275 lines
9.8 KiB
TypeScript
275 lines
9.8 KiB
TypeScript
// Kleine preview-server voor dist/client, voor Lighthouse en de browsertests.
|
|
//
|
|
// Waarom een eigen server (D10): `vite preview` kent geen echte 404 en geen
|
|
// afbeelding van /over-mij naar over-mij.html, en productie draait geen
|
|
// Node-server. Hier krijgt een onbekend pad 404.html met status 404, en een
|
|
// pad zonder punt het bijbehorende paginabestand, zoals de host dat straks
|
|
// ook moet doen (BR-SRV-01 tot 08).
|
|
import { createReadStream, statSync } from 'node:fs';
|
|
import {
|
|
createServer,
|
|
type IncomingMessage,
|
|
type Server,
|
|
type ServerResponse,
|
|
} from 'node:http';
|
|
import { extname, join, resolve, sep, win32 } from 'node:path';
|
|
import { fileURLToPath } from 'node:url';
|
|
import { createGzip } from 'node:zlib';
|
|
import { NOT_FOUND_FILE, pageFile } from './pageFiles.ts';
|
|
import { securityHeaders } from './securityHeaders.ts';
|
|
|
|
export interface ResolvedRequest {
|
|
// Relatief aan clientDir, met voorwaartse slashes en zonder voorste slash
|
|
file: string;
|
|
status: 200 | 404;
|
|
}
|
|
|
|
const NOT_FOUND: ResolvedRequest = { file: NOT_FOUND_FILE, status: 404 };
|
|
|
|
// Een segment van alleen punten en spaties ('.', '..', '...', '.. ') wordt door
|
|
// Windows tot een puntsegment teruggebracht, dus het mag nooit door
|
|
const DOT_SEGMENT = /^[. ]+$/;
|
|
|
|
// Het verzoekpad (zonder query of hash) naar het bestand dat erbij hoort.
|
|
// Eerst één keer decoderen en dán pas op segmenten controleren, zodat
|
|
// '%2e%2e' en '..%2f' niet langs de controle komen (BR-SRV-06). Een
|
|
// dubbel gecodeerd pad blijft na één keer decoderen een gewone bestandsnaam.
|
|
export function resolveRequest(
|
|
path: string,
|
|
fileExists: (file: string) => boolean,
|
|
): ResolvedRequest {
|
|
let decoded: string;
|
|
try {
|
|
decoded = decodeURIComponent(path);
|
|
} catch {
|
|
return NOT_FOUND;
|
|
}
|
|
if (
|
|
!decoded.startsWith('/') ||
|
|
decoded.includes('\0') ||
|
|
decoded.includes('\\')
|
|
) {
|
|
return NOT_FOUND;
|
|
}
|
|
if (decoded === '/') return { file: pageFile('/'), status: 200 };
|
|
|
|
// Lege segmenten (dubbele slash, slash aan het eind) en puntsegmenten:
|
|
// geen redirect, maar een 404 (BR-SRV-07)
|
|
const segments = decoded.slice(1).split('/');
|
|
if (
|
|
segments.some((segment) => segment === '' || DOT_SEGMENT.test(segment))
|
|
) {
|
|
return NOT_FOUND;
|
|
}
|
|
|
|
const isFileRequest = segments[segments.length - 1].includes('.');
|
|
const file = isFileRequest ? segments.join('/') : pageFile(decoded);
|
|
// Een stationsletter ('c:/x') is op Windows een absoluut pad
|
|
if (win32.isAbsolute(file)) return NOT_FOUND;
|
|
// Het pagina-pad /404 antwoordt met 404, niet met 200. Het bestandsverzoek /404.html is
|
|
// gewoon een bestand (BR-SRV-04) en geeft 200: Lighthouse weigert een
|
|
// pagina met een 404-status te auditen en gebruikt dit pad als terugval.
|
|
if (!isFileRequest && file === NOT_FOUND_FILE) return NOT_FOUND;
|
|
return fileExists(file) ? { file, status: 200 } : NOT_FOUND;
|
|
}
|
|
|
|
const CONTENT_TYPES: Record<string, string> = {
|
|
'.html': 'text/html; charset=utf-8',
|
|
'.js': 'text/javascript; charset=utf-8',
|
|
'.css': 'text/css; charset=utf-8',
|
|
'.svg': 'image/svg+xml',
|
|
'.png': 'image/png',
|
|
'.jpg': 'image/jpeg',
|
|
'.webp': 'image/webp',
|
|
'.woff2': 'font/woff2',
|
|
'.ico': 'image/x-icon',
|
|
'.xml': 'application/xml; charset=utf-8',
|
|
'.txt': 'text/plain; charset=utf-8',
|
|
'.json': 'application/json; charset=utf-8',
|
|
};
|
|
|
|
export const contentTypeOf = (file: string): string =>
|
|
CONTENT_TYPES[extname(file).toLowerCase()] ?? 'application/octet-stream';
|
|
|
|
// Tekst wordt gecomprimeerd, afbeeldingen en lettertypen niet (die zijn het al).
|
|
// Waarom: de nulmeting draaide op `vite preview`, dat comprimeert; zonder dit
|
|
// zijn de Lighthouse-metingen niet te vergelijken (scripts: 667 kB tegen
|
|
// 202 kB). Productie comprimeert op de host (BR-SRV-08).
|
|
const COMPRESSIBLE = new Set([
|
|
'.html',
|
|
'.js',
|
|
'.css',
|
|
'.svg',
|
|
'.json',
|
|
'.xml',
|
|
'.txt',
|
|
]);
|
|
|
|
export const isCompressible = (file: string): boolean =>
|
|
COMPRESSIBLE.has(extname(file).toLowerCase());
|
|
|
|
// Staat gzip in Accept-Encoding? 'gzip;q=0' weigert het, '*' staat het toe,
|
|
// tenzij gzip zelf genoemd is
|
|
export function acceptsGzip(header: string | undefined): boolean {
|
|
if (!header) return false;
|
|
let gzip: number | undefined;
|
|
let star: number | undefined;
|
|
for (const part of header.split(',')) {
|
|
const [name, ...params] = part.trim().toLowerCase().split(';');
|
|
const q = params
|
|
.map((param) => /^\s*q\s*=\s*([0-9.]+)\s*$/.exec(param))
|
|
.find(Boolean);
|
|
const weight = q ? Number(q[1]) : 1;
|
|
if (name === 'gzip') gzip = weight;
|
|
else if (name === '*') star = weight;
|
|
}
|
|
return (gzip ?? star ?? 0) > 0;
|
|
}
|
|
|
|
// Alleen het pad: query en hash horen niet bij het bestand. Bewust niet via
|
|
// `new URL`, want die haalt '..' al weg en dan ziet resolveRequest het niet.
|
|
const pathOf = (target: string) => target.split(/[?#]/, 1)[0];
|
|
|
|
function send(
|
|
response: ServerResponse,
|
|
status: number,
|
|
headers: Record<string, string | number>,
|
|
body: NodeJS.ReadableStream | string | null,
|
|
) {
|
|
response.writeHead(status, {
|
|
...securityHeaders('production'),
|
|
...headers,
|
|
});
|
|
if (body === null) response.end();
|
|
else if (typeof body === 'string') response.end(body);
|
|
else body.pipe(response);
|
|
}
|
|
|
|
export function startPreviewServer(
|
|
clientDir: string,
|
|
port: number,
|
|
): Promise<Server> {
|
|
const root = resolve(clientDir);
|
|
const isFile = (file: string) => {
|
|
try {
|
|
return statSync(join(root, file)).isFile();
|
|
} catch {
|
|
return false;
|
|
}
|
|
};
|
|
|
|
const handle = (request: IncomingMessage, response: ServerResponse) => {
|
|
if (request.method !== 'GET' && request.method !== 'HEAD') {
|
|
send(
|
|
response,
|
|
405,
|
|
{ Allow: 'GET, HEAD', 'Content-Type': 'text/plain' },
|
|
'Method Not Allowed',
|
|
);
|
|
return;
|
|
}
|
|
const { file, status } = resolveRequest(
|
|
pathOf(request.url ?? '/'),
|
|
isFile,
|
|
);
|
|
const target = join(root, file);
|
|
// Tweede slot naast resolveRequest: nooit buiten clientDir lezen
|
|
if (!target.startsWith(root + sep) || !isFile(file)) {
|
|
send(
|
|
response,
|
|
404,
|
|
{ 'Content-Type': 'text/plain' },
|
|
request.method === 'HEAD' ? null : 'Not Found',
|
|
);
|
|
return;
|
|
}
|
|
const headers: Record<string, string | number> = {
|
|
'Content-Type': contentTypeOf(file),
|
|
};
|
|
if (file.endsWith('.html')) headers['Cache-Control'] = 'no-cache';
|
|
// Gzip als stroom: de lengte is vooraf niet bekend, dus dan geen
|
|
// Content-Length (chunked); ook niet bij HEAD, dat geen inhoud stuurt
|
|
const compressible = isCompressible(file);
|
|
const gzip =
|
|
compressible && acceptsGzip(request.headers['accept-encoding']);
|
|
if (compressible) headers['Vary'] = 'Accept-Encoding';
|
|
if (gzip) headers['Content-Encoding'] = 'gzip';
|
|
else headers['Content-Length'] = statSync(target).size;
|
|
let body: NodeJS.ReadableStream | null = null;
|
|
if (request.method !== 'HEAD') {
|
|
body = createReadStream(target);
|
|
if (gzip) body = body.pipe(createGzip());
|
|
}
|
|
send(response, status, headers, body);
|
|
};
|
|
|
|
return new Promise((resolvePromise, reject) => {
|
|
const server = createServer(handle);
|
|
server.once('error', reject);
|
|
server.listen(port, '127.0.0.1', () => {
|
|
server.off('error', reject);
|
|
resolvePromise(server);
|
|
});
|
|
});
|
|
}
|
|
|
|
// `--port 4173` en `--port=4173`; onbekende argumenten (die `vite preview`
|
|
// wel kent) worden genegeerd
|
|
function parseArguments(args: string[]) {
|
|
const options = { port: 4173, strictPort: false, dir: 'dist/client' };
|
|
for (let i = 0; i < args.length; i++) {
|
|
const [name, inline] = args[i].split('=', 2);
|
|
const value = () => inline ?? args[++i];
|
|
if (name === '--port') options.port = Number(value());
|
|
else if (name === '--dir') options.dir = value();
|
|
else if (name === '--strictPort') options.strictPort = true;
|
|
}
|
|
return options;
|
|
}
|
|
|
|
const MAX_PORT_TRIES = 10;
|
|
|
|
async function main(args: string[]) {
|
|
const { port, strictPort, dir } = parseArguments(args);
|
|
if (!Number.isInteger(port) || port < 0 || port > 65535) {
|
|
console.error(`Ongeldige poort: ${port}`);
|
|
process.exitCode = 1;
|
|
return;
|
|
}
|
|
// Zonder --strictPort schuift de poort op als hij bezet is, zoals vite
|
|
// preview; poort 0 (laat het systeem kiezen) schuift niet
|
|
const tries = strictPort || port === 0 ? 1 : MAX_PORT_TRIES;
|
|
for (let attempt = 0; attempt < tries; attempt++) {
|
|
try {
|
|
const server = await startPreviewServer(dir, port + attempt);
|
|
const address = server.address();
|
|
const actual =
|
|
typeof address === 'object' && address ? address.port : port;
|
|
// 'Local' moet erin staan: startServerReadyPattern van lighthouserc.cjs
|
|
console.log(` Local: http://127.0.0.1:${actual}/`);
|
|
return;
|
|
} catch (error) {
|
|
const inUse =
|
|
(error as NodeJS.ErrnoException).code === 'EADDRINUSE';
|
|
if (!inUse || attempt === tries - 1) {
|
|
console.error(
|
|
inUse
|
|
? `Poort ${port + attempt} is al in gebruik`
|
|
: String(error),
|
|
);
|
|
process.exitCode = 1;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Draait alleen als het bestand zelf wordt gestart (pnpm preview), niet als
|
|
// een test het importeert.
|
|
if (
|
|
process.argv[1] &&
|
|
resolve(process.argv[1]) === fileURLToPath(import.meta.url)
|
|
) {
|
|
await main(process.argv.slice(2));
|
|
}
|