@qwik.dev/router 2.0.0-beta.4 → 2.0.0-beta.40

package/lib/chunks/http-error.qwik.mjs

@@ -0,0 +1,27 @@
+import { useHttpStatus } from "../index.qwik.mjs";
+import { _fnSignal, _jsxSorted, componentQrl, inlinedQrl } from "@qwik.dev/core";
+var _hf0 = (p0) => p0.status || 500;
+var _hf0_str = "p0.status||500";
+var _hf1 = (p0) => p0.message || "";
+var _hf1_str = "p0.message||\"\"";
+/** Cache error pages per status code so all 404s (or 500s) share one cache entry. */ var cacheKey = (ev) => String(ev.status);
+var COLOR_400 = "#006ce9";
+var COLOR_500 = "#713fc2";
+var DisplayHttpStatus = /*#__PURE__*/ componentQrl(/*#__PURE__*/ inlinedQrl(() => {
+	const httpstatus = useHttpStatus();
+	const width = httpstatus.message ? "600px" : "300px";
+	const color = httpstatus.status < 500 ? COLOR_400 : COLOR_500;
+	const style = `
+			body { color: ${color}; background-color: #fafafa; padding: 30px; font-family: ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, Roboto, sans-serif; }
+			p { max-width: ${width}; margin: 60px auto 30px auto; background: white; border-radius: 4px; box-shadow: 0px 0px 50px -20px ${color}; overflow: hidden; }
+			strong { display: inline-block; padding: 15px; background: ${color}; color: white; }
+			span { display: inline-block; padding: 15px; }
+	`;
+	return /*#__PURE__*/ _jsxSorted("p", null, null, [
+		/*#__PURE__*/ _jsxSorted("style", { dangerouslySetInnerHTML: style }, null, null, 3, null),
+		/*#__PURE__*/ _jsxSorted("strong", null, null, _fnSignal(_hf0, [httpstatus], _hf0_str), 3, null),
+		" ",
+		/*#__PURE__*/ _jsxSorted("span", null, null, _fnSignal(_hf1, [httpstatus], _hf1_str), 3, null)
+	], 1, "vY_0");
+}, "DisplayHttpStatus_component_PJf4K4PL7Oc"));
+export { cacheKey, DisplayHttpStatus as default };

package/lib/chunks/pathname.mjs

@@ -0,0 +1,57 @@
+/** Ensures the pathname ends with a slash */ var ensureSlash = (pathname) => pathname.endsWith("/") ? pathname : pathname + "/";
+function normalizePathname(pathname, basePathname) {
+	if (typeof pathname === "string") {
+		pathname = pathname.trim();
+		if (pathname !== "") try {
+			pathname = pathname.replace(/\/+/g, "/");
+			if (pathname.startsWith("/")) pathname = pathname.slice(1);
+			pathname = new URL(basePathname + pathname, `https://qwik.dev`).pathname;
+			if (pathname !== basePathname) {
+				if (!globalThis.__NO_TRAILING_SLASH__) {
+					if (!pathname.endsWith("/")) {
+						const segments = pathname.split("/");
+						if (!segments[segments.length - 1].includes(".")) pathname = ensureSlash(pathname);
+					}
+				} else if (pathname.endsWith("/")) pathname = pathname.slice(0, pathname.length - 1);
+			}
+			return pathname;
+		} catch (e) {
+			console.error(e);
+		}
+	}
+	return null;
+}
+function getPathnameForDynamicRoute(originalPathname, paramNames, params) {
+	let pathname = originalPathname;
+	if (paramNames && params) for (const paramName of paramNames) {
+		const paramKey = `[${paramName}]`;
+		const restParamKey = `[...${paramName}]`;
+		const paramValue = params[paramName];
+		pathname = pathname.replace(restParamKey, paramValue);
+		pathname = pathname.replace(paramKey, paramValue);
+	}
+	return pathname;
+}
+var PROTOCOLS = {
+	https: true,
+	http: true,
+	about: true,
+	javascript: true,
+	file: true
+};
+function isSameOriginUrl(url) {
+	if (typeof url === "string") {
+		url = url.trim();
+		if (url !== "") {
+			const firstChar = url.charAt(0);
+			if (firstChar !== "/" && firstChar !== ".") {
+				if (firstChar === "#") return false;
+				const i = url.indexOf(":");
+				if (i > -1) return !PROTOCOLS[url.slice(0, i).toLowerCase()];
+			}
+			return true;
+		}
+	}
+	return false;
+}
+export { normalizePathname as i, getPathnameForDynamicRoute as n, isSameOriginUrl as r, ensureSlash as t };

package/lib/chunks/request-body-limit.mjs

@@ -0,0 +1,27 @@
+import { t as ServerError } from "./server-error.mjs";
+var DEFAULT_REQUEST_BODY_LIMIT = 10485760;
+var RequestBodyLimitError = class extends ServerError {
+	code = "QWIK_REQUEST_BODY_LIMIT";
+	statusCode = 413;
+	constructor(limit) {
+		super(413, `Request body exceeds ${limit} bytes`);
+	}
+};
+var validateRequestBodyLimit = (requestBodyLimit) => {
+	if (!Number.isSafeInteger(requestBodyLimit) || requestBodyLimit <= 0) throw new TypeError("requestBodyLimit must be a positive safe integer");
+};
+var limitRequestBody = (request, requestBodyLimit = DEFAULT_REQUEST_BODY_LIMIT) => {
+	validateRequestBodyLimit(requestBodyLimit);
+	if (!request.body) return request;
+	let received = 0;
+	const body = request.body.pipeThrough(new TransformStream({ transform(chunk, controller) {
+		if (chunk.byteLength > requestBodyLimit - received) throw new RequestBodyLimitError(requestBodyLimit);
+		received += chunk.byteLength;
+		controller.enqueue(chunk);
+	} }));
+	return new Request(request, {
+		body,
+		duplex: "half"
+	});
+};
+export { validateRequestBodyLimit as i, RequestBodyLimitError as n, limitRequestBody as r, DEFAULT_REQUEST_BODY_LIMIT as t };

package/lib/chunks/request-path.mjs

@@ -0,0 +1,49 @@
+import { t as ensureSlash } from "./pathname.mjs";
+var IsQLoader = "@isQLoader";
+var IsQAction = "@isQAction";
+var QLoaderId = "@loaderId";
+var QActionId = "@actionId";
+/** Matches the final `/q-loader-{loaderId}.{manifestHash}.json` path segment. */ var LOADER_REGEX = /\/(q-loader-([^/.]+)\.([^/.]+)\.json)$/;
+var getLoaderName = (loaderId, manifestHash) => `q-loader-${loaderId}.${manifestHash}.json`;
+/**
+* Recognize internal request types from the URL pathname.
+*
+* Returns the request type, how many characters to trim from the pathname, and any extracted data
+* (e.g. loaderId for loader requests).
+*/ function recognizeRequest(pathname) {
+	if (pathname.length < 10) return null;
+	const loaderMatch = pathname.match(LOADER_REGEX);
+	if (loaderMatch) return {
+		type: IsQLoader,
+		trimLength: loaderMatch[1].length + 1,
+		data: {
+			loaderId: loaderMatch[2],
+			manifestHash: loaderMatch[3]
+		}
+	};
+	return null;
+}
+/** Trim a recognized internal URL suffix from a pathname, returning the clean route pathname. */ function trimRecognizedInternalPathname(pathname, recognized) {
+	let trimmed = pathname.slice(0, pathname.length - recognized.trimLength) || "/";
+	if (!globalThis.__NO_TRAILING_SLASH__ && !trimmed.endsWith("/")) trimmed = ensureSlash(trimmed);
+	return trimmed;
+}
+/** Trim any recognized internal URL suffix from a pathname, returning the clean route pathname. */ function trimInternalPathname(pathname) {
+	const recognized = recognizeRequest(pathname);
+	if (recognized) return trimRecognizedInternalPathname(pathname, recognized);
+	return pathname;
+}
+function resolveValidInternalFullPathname(loaderPathname, fullPath) {
+	if (!fullPath || !fullPath.startsWith("/") || fullPath.startsWith("//")) return;
+	try {
+		const pageUrl = new URL(fullPath, "http://qwik.internal");
+		if (pageUrl.origin !== "http://qwik.internal") return;
+		const pagePathname = pageUrl.pathname;
+		if (pagePathname === loaderPathname) return;
+		const loaderPrefix = ensureSlash(loaderPathname);
+		return pagePathname.startsWith(loaderPrefix) ? pagePathname : void 0;
+	} catch {
+		return;
+	}
+}
+export { QLoaderId as a, resolveValidInternalFullPathname as c, QActionId as i, trimInternalPathname as l, IsQLoader as n, getLoaderName as o, LOADER_REGEX as r, recognizeRequest as s, IsQAction as t, trimRecognizedInternalPathname as u };

package/lib/chunks/routes.mjs

@@ -0,0 +1,26 @@
+function routeToRegExp(rule) {
+	let transformedRule;
+	if (rule === "/" || rule === "/*") transformedRule = rule;
+	else if (rule.endsWith("/*")) transformedRule = `${rule.substring(0, rule.length - 2)}(/*)?`;
+	else if (rule.endsWith("/")) transformedRule = `${rule.substring(0, rule.length - 1)}(/)?`;
+	else if (rule.endsWith("*")) transformedRule = rule;
+	else transformedRule = `${rule}(/)?`;
+	transformedRule = `^${transformedRule.replace(/\*/g, ".*")}$`;
+	return new RegExp(transformedRule);
+}
+function routesToRegExps(routes) {
+	if (!Array.isArray(routes)) return [];
+	return routes.filter((r) => typeof r === "string").map(routeToRegExp);
+}
+function createRouteTester(basePathname, includeRoutes, excludeRoutes) {
+	const includes = routesToRegExps(includeRoutes);
+	const excludes = routesToRegExps(excludeRoutes);
+	return (pathname) => {
+		if (basePathname !== "/") pathname = pathname.slice(basePathname.length - 1);
+		for (const exclude of excludes) if (exclude.test(pathname)) return false;
+		if (pathname.endsWith("/404.html")) return true;
+		for (const include of includes) if (include.test(pathname)) return true;
+		return false;
+	};
+}
+export { createRouteTester as t };

package/lib/chunks/server-error.mjs

@@ -0,0 +1,16 @@
+/** @public */ var AbortMessage = class {};
+/** @public */ var RedirectMessage = class extends AbortMessage {};
+/** @public */ var ServerError = class extends Error {
+	status;
+	data;
+	constructor(status, data) {
+		super(typeof data === "string" ? data : void 0), this.status = status, this.data = data;
+	}
+};
+/**
+* `ev.redirect()`, `ev.error()`, etc. return a control-flow signal meant to be thrown. Throw it for
+* the user when they return it instead, so returning and throwing behave the same.
+*/ var throwIfControlFlowSignal = (value) => {
+	if (value instanceof AbortMessage || value instanceof ServerError) throw value;
+};
+export { RedirectMessage as i, throwIfControlFlowSignal as n, AbortMessage as r, ServerError as t };

package/lib/chunks/system.mjs

@@ -0,0 +1,265 @@
+import { t as ensureSlash } from "./pathname.mjs";
+import { o as getLoaderName } from "./request-path.mjs";
+import { _ as normalizePath } from "./fs.mjs";
+import fs from "node:fs";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { cpus } from "node:os";
+import { Worker } from "node:worker_threads";
+function ssgWorkerCompare(a, b) {
+	if (a.activeTasks < b.activeTasks) return -1;
+	if (a.activeTasks > b.activeTasks) return 1;
+	return a.totalTasks < b.totalTasks ? -1 : 1;
+}
+async function createWorkerPool(sys, opts) {
+	const log = await sys.createLogger();
+	const ssgWorkers = [];
+	const sitemapBuffer = [];
+	let sitemapStream = null;
+	opts = { ...opts };
+	let outDir = opts.outDir;
+	if (typeof outDir !== "string") throw new Error(`Missing "outDir" option`);
+	if (!isAbsolute(outDir)) throw new Error(`"outDir" must be an absolute file path, received: ${outDir}`);
+	outDir = normalizePath(outDir);
+	let maxWorkers = cpus().length;
+	if (typeof opts.maxWorkers === "number") maxWorkers = Math.max(1, Math.min(opts.maxWorkers, maxWorkers));
+	let maxTasksPerWorker = 20;
+	if (typeof opts.maxTasksPerWorker === "number") maxTasksPerWorker = Math.max(1, Math.min(opts.maxTasksPerWorker, 50));
+	let sitemapOutFile = opts.sitemapOutFile;
+	if (sitemapOutFile !== null) {
+		if (typeof sitemapOutFile !== "string") sitemapOutFile = "sitemap.xml";
+		if (!isAbsolute(sitemapOutFile)) sitemapOutFile = resolve(outDir, sitemapOutFile);
+	}
+	if (!opts.workerFilePath) throw new Error("Missing \"workerFilePath\" option for SSG worker creation");
+	const workerFilePath = typeof opts.workerFilePath === "string" && opts.workerFilePath.startsWith("file://") ? new URL(opts.workerFilePath) : opts.workerFilePath;
+	const { render: _r, qwikRouterConfig: _c, workerFilePath: _w, ...workerData } = opts;
+	const createWorker = () => {
+		let terminateResolve = null;
+		const mainTasks = /* @__PURE__ */ new Map();
+		let terminateTimeout = null;
+		const nodeWorker = new Worker(workerFilePath, { workerData });
+		nodeWorker.unref();
+		const ssgWorker = {
+			activeTasks: 0,
+			totalTasks: 0,
+			render: (staticRoute) => {
+				return new Promise((resolve, reject) => {
+					try {
+						ssgWorker.activeTasks++;
+						ssgWorker.totalTasks++;
+						mainTasks.set(staticRoute.pathname, resolve);
+						nodeWorker.postMessage(staticRoute);
+					} catch (e) {
+						ssgWorker.activeTasks--;
+						mainTasks.delete(staticRoute.pathname);
+						reject(e);
+					}
+				});
+			},
+			terminate: async () => {
+				mainTasks.clear();
+				const msg = { type: "close" };
+				await new Promise((resolve) => {
+					terminateResolve = () => {
+						resolve();
+					};
+					terminateTimeout = setTimeout(async () => {
+						terminateTimeout = null;
+						terminateResolve = null;
+						await nodeWorker.terminate();
+						resolve();
+					}, 1e3);
+					nodeWorker.postMessage(msg);
+				});
+				if (terminateTimeout) {
+					clearTimeout(terminateTimeout);
+					terminateTimeout = null;
+				}
+			}
+		};
+		nodeWorker.on("message", (msg) => {
+			switch (msg.type) {
+				case "render": {
+					const mainTask = mainTasks.get(msg.pathname);
+					if (mainTask) {
+						mainTasks.delete(msg.pathname);
+						ssgWorker.activeTasks--;
+						mainTask(msg);
+					}
+					break;
+				}
+				case "close": if (terminateResolve) {
+					terminateResolve();
+					terminateResolve = null;
+				}
+			}
+		});
+		nodeWorker.on("error", (e) => {
+			log.error(`worker error`, e);
+		});
+		nodeWorker.on("exit", (code) => {
+			log.debug(`worker exit code=${code}`);
+			if (terminateTimeout) {
+				clearTimeout(terminateTimeout);
+				terminateTimeout = null;
+			}
+			if (mainTasks.size > 0) {
+				for (const [pathname, resolve] of mainTasks) {
+					ssgWorker.activeTasks--;
+					resolve({
+						type: "render",
+						pathname,
+						url: "",
+						ok: false,
+						error: {
+							message: `Worker exited with code ${code}`,
+							stack: void 0
+						},
+						filePath: null,
+						contentType: null,
+						resourceType: null
+					});
+				}
+				mainTasks.clear();
+			}
+			if (terminateResolve) {
+				terminateResolve();
+				terminateResolve = null;
+			}
+			if (code !== 0) console.error(`worker exit ${code}`);
+		});
+		return ssgWorker;
+	};
+	const getNextWorker = () => ssgWorkers.sort(ssgWorkerCompare)[0];
+	const hasAvailableWorker = () => {
+		return getNextWorker().activeTasks < maxTasksPerWorker;
+	};
+	const render = async (ssgRoute) => {
+		const result = await getNextWorker().render(ssgRoute);
+		const isNotFoundPage = result.pathname.endsWith("/404.html");
+		if (sitemapOutFile && result.ok && result.resourceType === "page" && !isNotFoundPage) {
+			sitemapBuffer.push(`<url><loc>${result.url}</loc></url>`);
+			if (sitemapBuffer.length > 50) {
+				const siteMapUrls = sitemapBuffer.join("\n") + "\n";
+				sitemapBuffer.length = 0;
+				if (sitemapStream) sitemapStream.write(siteMapUrls);
+			}
+		}
+		return result;
+	};
+	const close = async () => {
+		const promises = [];
+		if (sitemapStream) {
+			sitemapBuffer.push(`</urlset>`);
+			sitemapStream.write(sitemapBuffer.join("\n"));
+			sitemapBuffer.length = 0;
+			await new Promise((resolve, reject) => {
+				if (sitemapStream) sitemapStream.end((err) => {
+					if (err) reject(err);
+					else resolve();
+				});
+				else resolve();
+			});
+			sitemapStream = null;
+		}
+		for (const ssgWorker of ssgWorkers) try {
+			promises.push(ssgWorker.terminate());
+		} catch (e) {
+			console.error(e);
+		}
+		await Promise.all(promises);
+		ssgWorkers.length = 0;
+		if (process.platform === "win32") await new Promise((resolve) => setTimeout(resolve, 300));
+	};
+	if (sitemapOutFile) {
+		await sys.ensureDir(sitemapOutFile);
+		sitemapStream = fs.createWriteStream(sitemapOutFile, { flags: "w" });
+		sitemapStream.write(`<?xml version="1.0" encoding="UTF-8"?>\n<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">\n`);
+	}
+	log.debug(`creating ${maxWorkers} workers, ${maxTasksPerWorker} tasks each`);
+	for (let i = 0; i < maxWorkers; i++) {
+		ssgWorkers.push(createWorker());
+		if (process.platform === "win32" && i < maxWorkers - 1) await new Promise((resolve) => setTimeout(resolve, 100));
+	}
+	return {
+		hasAvailableWorker,
+		render,
+		close
+	};
+}
+var ensureDir = async (filePath) => {
+	await fs.promises.mkdir(dirname(filePath), { recursive: true });
+};
+var access = async (path) => {
+	try {
+		await fs.promises.access(path);
+		return true;
+	} catch {
+		return false;
+	}
+};
+/** @public */ async function createSystem(opts, threadId) {
+	const createWriteStream = (filePath) => {
+		return fs.createWriteStream(filePath, { flags: "w" });
+	};
+	const NS_PER_SEC = 1e9;
+	const MS_PER_NS = 1e-6;
+	const createTimer = () => {
+		const start = process.hrtime();
+		return () => {
+			const diff = process.hrtime(start);
+			return (diff[0] * NS_PER_SEC + diff[1]) * MS_PER_NS;
+		};
+	};
+	const noop = () => {};
+	const createLogger = async () => {
+		const isQuiet = opts.log === "quiet";
+		const isDebug = opts.log === "debug";
+		if (threadId !== void 0) return {
+			debug: isDebug ? console.debug.bind(console, `[${threadId}]`) : noop,
+			error: console.error.bind(console, `[${threadId}]`),
+			info: isQuiet ? noop : console.info.bind(console, `[${threadId}]`)
+		};
+		return {
+			debug: isDebug ? console.debug.bind(console) : noop,
+			error: console.error.bind(console),
+			info: isQuiet ? noop : console.info.bind(console)
+		};
+	};
+	const outDir = normalizePath(opts.outDir);
+	const basenameLen = (opts.basePathname || "/").length;
+	const getRouteFilePath = (pathname, isHtml) => {
+		pathname = decodeURIComponent(pathname.slice(basenameLen));
+		if (isHtml) {
+			if (!pathname.endsWith(".html")) {
+				if (pathname.endsWith("/")) pathname += "index.html";
+				else pathname += "/index.html";
+			}
+		} else if (pathname.endsWith("/")) pathname = pathname.slice(0, -1);
+		return join(outDir, pathname);
+	};
+	const getLoaderFilePath = (pathname, loaderId, manifestHash) => {
+		pathname = decodeURIComponent(pathname.slice(basenameLen));
+		const suffix = getLoaderName(loaderId, manifestHash);
+		pathname = ensureSlash(pathname) + suffix;
+		return join(outDir, pathname);
+	};
+	const sys = {
+		createMainProcess: null,
+		createLogger,
+		getOptions: () => opts,
+		ensureDir,
+		createWriteStream,
+		createTimer,
+		access,
+		getRouteFilePath,
+		getLoaderFilePath,
+		getEnv: (key) => process.env[key],
+		platform: {
+			static: true,
+			node: process.versions.node
+		}
+	};
+	sys.createMainProcess = () => createWorkerPool(sys, opts);
+	return sys;
+}
+export { createSystem };

package/lib/chunks/url.mjs

@@ -0,0 +1,59 @@
+/** Common mime types mapped to Content-Type headers */ var MIME_TYPES = {
+	"3gp": "video/3gpp",
+	"3gpp": "video/3gpp",
+	asf: "video/x-ms-asf",
+	asx: "video/x-ms-asf",
+	avi: "video/x-msvideo",
+	avif: "image/avif",
+	bmp: "image/x-ms-bmp",
+	css: "text/css",
+	flv: "video/x-flv",
+	gif: "image/gif",
+	htm: "text/html",
+	html: "text/html",
+	ico: "image/x-icon",
+	jng: "image/x-jng",
+	jpeg: "image/jpeg",
+	jpg: "image/jpeg",
+	js: "application/javascript",
+	json: "application/json",
+	kar: "audio/midi",
+	m4a: "audio/x-m4a",
+	m4v: "video/x-m4v",
+	mid: "audio/midi",
+	midi: "audio/midi",
+	mng: "video/x-mng",
+	mov: "video/quicktime",
+	mp3: "audio/mpeg",
+	mp4: "video/mp4",
+	mpeg: "video/mpeg",
+	mpg: "video/mpeg",
+	ogg: "audio/ogg",
+	pdf: "application/pdf",
+	png: "image/png",
+	rar: "application/x-rar-compressed",
+	shtml: "text/html",
+	svg: "image/svg+xml",
+	svgz: "image/svg+xml",
+	tif: "image/tiff",
+	tiff: "image/tiff",
+	ts: "video/mp2t",
+	txt: "text/plain",
+	wbmp: "image/vnd.wap.wbmp",
+	webm: "video/webm",
+	webp: "image/webp",
+	wmv: "video/x-ms-wmv",
+	woff: "font/woff",
+	woff2: "font/woff2",
+	xml: "text/xml",
+	zip: "application/zip"
+};
+var LEADING_DOUBLE_SLASH_REG = /^[\\/]{2,}/;
+function normalizeRequestUrl(url, base) {
+	const DOUBLE_SLASH_REG = /\/\/|\\\\/g;
+	const queryOrHashIndex = url.search(/[?#]/);
+	const path = queryOrHashIndex === -1 ? url : url.slice(0, queryOrHashIndex);
+	const suffix = queryOrHashIndex === -1 ? "" : url.slice(queryOrHashIndex);
+	return new URL(`${path.replace(LEADING_DOUBLE_SLASH_REG, "/").replace(DOUBLE_SLASH_REG, "/")}${suffix}`, base);
+}
+export { MIME_TYPES as n, normalizeRequestUrl as t };