@markless/router 0.5.0 → 0.6.0

package/dist/route-manifest-DMizh42B.js

@@ -0,0 +1,456 @@
+import { basename, extname, join, normalize, relative } from "pathe";
+import { joinURL, withLeadingSlash, withoutLeadingSlash, withoutTrailingSlash } from "ufo";
+const MIDDLEWARE_DIR = "middleware";
+const HTTP_METHODS = /* @__PURE__ */ new Set([
+	"connect",
+	"delete",
+	"get",
+	"head",
+	"options",
+	"patch",
+	"post",
+	"put",
+	"trace"
+]);
+function parseRequestFile(fileId, sourceText) {
+	const file = normalizeRequestFileId(fileId);
+	const apiFile = apiRelativeFile(file);
+	if (apiFile) return parseApiRequestFile(file, apiFile, sourceText);
+	if (middlewareRelativeFile(file)) return parseMiddlewareRequestFile(file, sourceText);
+	return {
+		diagnostics: [],
+		file,
+		kind: "none"
+	};
+}
+function normalizeRequestFileId(fileId) {
+	return withoutLeadingSlash(normalize(fileId));
+}
+function transformRequestFileSource(fileId, sourceText) {
+	const requestFile = parseRequestFile(fileId, sourceText);
+	if (requestFile.kind === "none" || requestFile.diagnostics.length > 0 || !requestFile.defaultExport) return;
+	const handler = localizeDefaultExport(sourceText);
+	if (!handler) return;
+	return {
+		code: requestFileWrapperSource(requestFile, handler.code, handler.name),
+		file: requestFile.file,
+		kind: requestFile.kind
+	};
+}
+function parseApiRequestFile(file, apiFile, sourceText) {
+	const defaultExport = findDefaultFunctionExport(sourceText);
+	const cache = parseCacheMetadata(sourceText);
+	const diagnostics = [
+		...missingDefaultFunctionDiagnostics("api", defaultExport),
+		...httpMethodExportDiagnostics(sourceText),
+		...cacheMetadataDiagnostics(sourceText, cache)
+	];
+	return {
+		...cache ? { cache } : {},
+		...defaultExport ? { defaultExport } : {},
+		diagnostics,
+		file,
+		kind: "api",
+		...apiRouteFromFile(apiFile)
+	};
+}
+function parseMiddlewareRequestFile(file, sourceText) {
+	const defaultExport = findDefaultFunctionExport(sourceText);
+	const diagnostics = missingDefaultFunctionDiagnostics("middleware", defaultExport);
+	return {
+		...defaultExport ? { defaultExport } : {},
+		diagnostics,
+		file,
+		kind: "middleware"
+	};
+}
+function apiRouteFromFile(apiFile) {
+	const withoutExtension = apiFile.slice(0, -3);
+	const rawSegments = normalize(join(withoutExtension)).split("/");
+	const finalSegment = rawSegments.at(-1);
+	const method = methodSuffix(finalSegment);
+	if (method !== "all") rawSegments[rawSegments.length - 1] = finalSegment.slice(0, -(method.length + 1));
+	if (rawSegments.at(-1) === "index") rawSegments.pop();
+	const normalizedSegments = rawSegments.filter(Boolean).map(normalizeRouteSegment);
+	const pathnameSegments = normalizedSegments.map((segment) => segment.pathname);
+	const patternSegments = normalizedSegments.map((segment) => segment.pattern);
+	return {
+		method,
+		route: {
+			params: normalizedSegments.flatMap((segment) => segment.params),
+			pathname: requestPathname(["api", ...pathnameSegments]),
+			pattern: requestPathname(["api", ...patternSegments])
+		}
+	};
+}
+function normalizeRouteSegment(segment) {
+	const catchAll = segment.match(/^\[\.\.\.([A-Za-z_$][\w$]*)\]$/);
+	if (catchAll) return {
+		params: [{
+			kind: "catch-all",
+			name: catchAll[1]
+		}],
+		pathname: "**",
+		pattern: `[...${catchAll[1]}]`
+	};
+	const dynamic = segment.match(/^\[([A-Za-z_$][\w$]*)\]$/);
+	if (dynamic) return {
+		params: [{
+			kind: "dynamic",
+			name: dynamic[1]
+		}],
+		pathname: `:${dynamic[1]}`,
+		pattern: `[${dynamic[1]}]`
+	};
+	return {
+		params: [],
+		pathname: segment,
+		pattern: segment
+	};
+}
+function requestPathname(segments) {
+	if (segments.length === 0) return "/";
+	const [base, ...rest] = segments;
+	return withLeadingSlash(joinURL(base, ...rest));
+}
+function methodSuffix(finalSegment) {
+	const suffix = finalSegment.split(".").at(-1);
+	return suffix && HTTP_METHODS.has(suffix) ? suffix : "all";
+}
+function findDefaultFunctionExport(sourceText) {
+	const directFunction = sourceText.match(/\bexport\s+default\s+(?:async\s+)?function(?:\s+[A-Za-z_$][\w$]*)?\s*\(\s*([A-Za-z_$][\w$]*)?/);
+	if (directFunction) return {
+		kind: "function",
+		parameterName: directFunction[1]
+	};
+	const directArrow = sourceText.match(/\bexport\s+default\s+(?:async\s+)?(?:\(\s*([A-Za-z_$][\w$]*)?\s*\)|([A-Za-z_$][\w$]*))\s*=>/);
+	if (directArrow) return {
+		kind: "function",
+		parameterName: directArrow[1] ?? directArrow[2]
+	};
+	const defaultIdentifier = sourceText.match(/\bexport\s+default\s+([A-Za-z_$][\w$]*)\s*;/)?.[1];
+	if (!defaultIdentifier) return;
+	const escapedIdentifier = escapeRegExp(defaultIdentifier);
+	const constArrow = sourceText.match(new RegExp(`\\bconst\\s+${escapedIdentifier}\\s*=\\s*(?:async\\s+)?(?:\\(\\s*([A-Za-z_$][\\w$]*)?\\s*\\)|([A-Za-z_$][\\w$]*))\\s*=>`));
+	if (constArrow) return {
+		kind: "function",
+		parameterName: constArrow[1] ?? constArrow[2]
+	};
+	const functionDeclaration = sourceText.match(new RegExp(`\\b(?:async\\s+)?function\\s+${escapedIdentifier}\\s*\\(\\s*([A-Za-z_$][\\w$]*)?`));
+	if (functionDeclaration) return {
+		kind: "function",
+		parameterName: functionDeclaration[1]
+	};
+}
+function parseCacheMetadata(sourceText) {
+	const objectLiteral = sourceText.match(/\bexport\s+const\s+cache\s*=\s*(\{[\s\S]*?\})\s*;?/)?.[1];
+	if (!objectLiteral) return;
+	const maxAge = objectLiteral.match(/^\{\s*maxAge\s*:\s*(\d+(?:\.\d+)?)\s*,?\s*\}$/)?.[1];
+	return maxAge ? { maxAge: Number(maxAge) } : void 0;
+}
+function missingDefaultFunctionDiagnostics(kind, defaultExport) {
+	if (defaultExport) return [];
+	return [{
+		code: "missing-default-function",
+		message: kind === "api" ? "API files must default export a function." : "Middleware files must default export a function."
+	}];
+}
+function httpMethodExportDiagnostics(sourceText) {
+	const exportedMethods = /* @__PURE__ */ new Set();
+	for (const pattern of [
+		/\bexport\s+(?:async\s+)?function\s+([A-Z]+)\b/g,
+		/\bexport\s+const\s+([A-Z]+)\b/g,
+		/\bexport\s*\{([^}]+)\}/g
+	]) for (const match of sourceText.matchAll(pattern)) {
+		const exportClause = match[1];
+		if (!exportClause) continue;
+		if (exportClause.includes(",")) {
+			for (const exportName of exportClause.split(",")) addHttpMethodExport(exportedMethods, exportName);
+			continue;
+		}
+		addHttpMethodExport(exportedMethods, exportClause);
+	}
+	return Array.from(exportedMethods).toSorted().map((method) => ({
+		code: "http-method-export",
+		message: `Do not export ${method}; the HTTP method comes from the filename.`
+	}));
+}
+function addHttpMethodExport(methods, exportName) {
+	const method = exportName.trim().split(/\s+as\s+/i).at(-1)?.trim();
+	if (method && HTTP_METHODS.has(method.toLowerCase())) methods.add(method.toUpperCase());
+}
+function cacheMetadataDiagnostics(sourceText, cache) {
+	if (!/\bexport\s+const\s+cache\b/.test(sourceText) || cache) return [];
+	return [{
+		code: "invalid-cache-metadata",
+		message: "Use export const cache for endpoint cache metadata."
+	}];
+}
+function apiRelativeFile(file) {
+	if (!isRequestModuleFile(file) || file === "api" || !file.startsWith(`api/`)) return;
+	return relative("api", file);
+}
+function middlewareRelativeFile(file) {
+	if (!isRequestModuleFile(file) || file === MIDDLEWARE_DIR || !file.startsWith(`${MIDDLEWARE_DIR}/`)) return;
+	return relative(MIDDLEWARE_DIR, file);
+}
+function localizeDefaultExport(sourceText) {
+	const defaultIdentifierMatch = sourceText.match(/\bexport\s+default\s+([A-Za-z_$][\w$]*)\s*;/);
+	if (defaultIdentifierMatch) return {
+		code: sourceText.replace(defaultIdentifierMatch[0], ""),
+		name: defaultIdentifierMatch[1]
+	};
+	const directDefaultMatch = sourceText.match(/\bexport\s+default\b/);
+	if (!directDefaultMatch || directDefaultMatch.index === void 0) return;
+	return {
+		code: `${sourceText.slice(0, directDefaultMatch.index)}const __markless_request_handler__ =${sourceText.slice(directDefaultMatch.index + directDefaultMatch[0].length)}`,
+		name: "__markless_request_handler__"
+	};
+}
+function requestFileWrapperSource(requestFile, sourceText, handlerName) {
+	const defineImport = requestFile.kind === "api" && requestFile.cache ? "import { defineCachedHandler as __markless_define_handler__ } from \"nitro/cache\";" : "import { defineHandler as __markless_define_handler__ } from \"nitro\";";
+	const wrappedHandler = `(event) =>
+	${handlerName}(__markless_create_http_context__(event))`;
+	const wrappedDefault = requestFile.kind === "api" && requestFile.cache ? `__markless_define_handler__(${wrappedHandler}, cache)` : `__markless_define_handler__(${wrappedHandler})`;
+	return `${defineImport}
+import { __marklessCreateHttpContext as __markless_create_http_context__ } from "@markless/router";
+
+${sourceText.trimEnd()}
+
+export default ${wrappedDefault};
+`;
+}
+function isRequestModuleFile(file) {
+	return extname(file) === ".ts" && basename(file) !== ".ts";
+}
+function escapeRegExp(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+//#endregion
+//#region src/route-manifest.ts
+const PAGES_DIR = "pages";
+const PAGE_EXTENSIONS = /* @__PURE__ */ new Set([".tsrx", ".mdx"]);
+function buildRouteManifestFromFileIds(fileIds) {
+	const pages = unique(fileIds.map(normalizeRouteFileId)).filter(isPageModuleFile).toSorted(compareCodeUnits).map(normalizePage);
+	const routes = pages.flatMap((page) => page.kind === "route" ? [page.route] : []);
+	assertNoRouteConflicts(routes);
+	const statusPages = {};
+	for (const page of pages) if (page.kind === "status") statusPages[page.status] = page.file;
+	return {
+		routes: routes.map(toPublicRoute).toSorted(compareRoutes),
+		statusPages
+	};
+}
+function normalizeRequestPathname(pathname) {
+	const normalizedPathname = withoutTrailingSlash(withLeadingSlash(pathname));
+	return normalizedPathname === "" ? "/" : normalizedPathname;
+}
+function normalizeRouteFileId(fileId) {
+	return withoutLeadingSlash(normalize(fileId));
+}
+function matchRouteManifest(pathname, manifest) {
+	const requestPathname = normalizeRequestPathname(pathname);
+	for (const route of manifest.routes) {
+		const params = matchRoutePathname(route, requestPathname);
+		if (params) return {
+			route,
+			params
+		};
+	}
+}
+function isPageModuleFile(file) {
+	const pageFile = pageRelativeFile(file);
+	return pageFile !== void 0 && PAGE_EXTENSIONS.has(extname(pageFile));
+}
+function normalizePage(file) {
+	const relativeFile = file;
+	const pageFile = pageRelativeFile(file);
+	const extension = extname(pageFile);
+	const withoutExtension = pageFile.slice(0, -extension.length);
+	const routeFile = normalize(join(withoutExtension));
+	const rawSegments = routeFile === "." ? [] : routeFile.split("/");
+	if (rawSegments.length === 1 && rawSegments[0] === "404") return {
+		kind: "status",
+		status: "notFound",
+		file: relativeFile
+	};
+	if (rawSegments.length === 1 && rawSegments[0] === "500") return {
+		kind: "status",
+		status: "error",
+		file: relativeFile
+	};
+	if (rawSegments.length > 1 && ["404", "500"].includes(rawSegments.at(-1))) throw new Error(`Nested status pages are not supported in v0: ${relativeFile}`);
+	if (rawSegments.at(-1) === "index") rawSegments.pop();
+	const pattern = routePathname(rawSegments);
+	const segments = rawSegments.map((segment, index) => normalizeSegment(segment, index, rawSegments, relativeFile));
+	const pathnameSegments = segments.map((segment) => segment.pathname);
+	const identitySegments = segments.map((segment) => segment.identity);
+	const params = segments.flatMap((segment) => segment.params);
+	return {
+		kind: "route",
+		route: {
+			pathname: routePathname(pathnameSegments),
+			pattern,
+			identity: routePathname(identitySegments),
+			params,
+			file: relativeFile,
+			relativeFile
+		}
+	};
+}
+function pageRelativeFile(file) {
+	if (file === PAGES_DIR || !file.startsWith(`${PAGES_DIR}/`)) return;
+	return relative(PAGES_DIR, file);
+}
+function normalizeSegment(segment, index, segments, relativeFile) {
+	const catchAll = segment.match(/^\[\.\.\.([A-Za-z_$][\w$]*)\]$/);
+	if (catchAll) {
+		if (index !== segments.length - 1) throw new Error(`Catch-all route segments must be final: ${relativeFile}`);
+		return {
+			pathname: "**",
+			identity: "**",
+			params: [{
+				name: catchAll[1],
+				kind: "catch-all"
+			}]
+		};
+	}
+	const dynamic = segment.match(/^\[([A-Za-z_$][\w$]*)\]$/);
+	if (dynamic) return {
+		pathname: `:${dynamic[1]}`,
+		identity: ":param",
+		params: [{
+			name: dynamic[1],
+			kind: "dynamic"
+		}]
+	};
+	if (segment.includes("[") || segment.includes("]")) throw new Error(`Unsupported route segment pattern: ${relativeFile}`);
+	return {
+		pathname: segment,
+		identity: segment,
+		params: []
+	};
+}
+function assertNoRouteConflicts(routes) {
+	const routesByIdentity = /* @__PURE__ */ new Map();
+	for (const route of routes) {
+		const existingRoutes = routesByIdentity.get(route.identity) ?? [];
+		existingRoutes.push(route);
+		routesByIdentity.set(route.identity, existingRoutes);
+	}
+	for (const [identity, conflictingRoutes] of routesByIdentity) {
+		if (conflictingRoutes.length < 2) continue;
+		const files = conflictingRoutes.map((route) => route.relativeFile).toSorted(compareCodeUnits);
+		throw new Error([`Route conflict: ${identity} is defined by both:`, ...files.map((file) => `- ${file}`)].join("\n"));
+	}
+}
+const PAGE_METHODS = /* @__PURE__ */ new Set([
+	"all",
+	"get",
+	"head"
+]);
+/**
+* Page files may live under pages/api/ beside the endpoints in api/; the build fails only when one
+* address is answered by both, since the endpoint would always win and the page could never be served.
+*/
+function assertNoEndpointConflicts(manifest, endpointFileIds) {
+	for (const fileId of endpointFileIds) {
+		const endpoint = parseRequestFile(fileId, "");
+		if (endpoint.kind !== "api" || !PAGE_METHODS.has(endpoint.method)) continue;
+		const segments = pathSegments(endpoint.route.pathname);
+		for (const route of manifest.routes) {
+			const address = sharedAddress(pathSegments(route.pathname), segments);
+			if (address === void 0) continue;
+			throw new Error([
+				`Route conflict: ${address} is answered by both a page and an endpoint:`,
+				`- ${route.file}`,
+				`- ${endpoint.file}`
+			].join("\n"));
+		}
+	}
+}
+const pathSegments = (pathname) => pathname.split("/").filter(Boolean);
+function sharedAddress(left, right) {
+	const address = [];
+	for (let index = 0;; index++) {
+		const a = left[index];
+		const b = right[index];
+		if (a === "**" || b === "**") {
+			const other = a === "**" ? right : left;
+			return other.length > index ? `/${[...address, ...other.slice(index)].join("/")}` : void 0;
+		}
+		if (a === void 0 || b === void 0) return a === b ? `/${address.join("/")}` : void 0;
+		if (a.startsWith(":")) address.push(b);
+		else if (b.startsWith(":") || a === b) address.push(a);
+		else return void 0;
+	}
+}
+function toPublicRoute(route) {
+	return {
+		pathname: route.pathname,
+		pattern: route.pattern,
+		params: route.params,
+		file: route.file
+	};
+}
+function compareRoutes(left, right) {
+	const leftSegments = splitRoutePathname(left.pathname);
+	const rightSegments = splitRoutePathname(right.pathname);
+	const length = Math.max(leftSegments.length, rightSegments.length);
+	for (let index = 0; index < length; index += 1) {
+		const leftSegment = leftSegments[index];
+		const rightSegment = rightSegments[index];
+		if (leftSegment === void 0) return -1;
+		if (rightSegment === void 0) return 1;
+		const rankDifference = segmentRank(leftSegment) - segmentRank(rightSegment);
+		if (rankDifference !== 0) return rankDifference;
+		if (segmentRank(leftSegment) === 0 && leftSegment !== rightSegment) return compareCodeUnits(leftSegment, rightSegment);
+	}
+	return compareCodeUnits(left.pathname, right.pathname);
+}
+function splitRoutePathname(pathname) {
+	const route = withoutLeadingSlash(pathname);
+	return route === "" ? [] : route.split("/");
+}
+function matchRoutePathname(route, requestPathname) {
+	const routeSegments = splitRoutePathname(route.pathname);
+	const requestSegments = splitRoutePathname(requestPathname);
+	const catchAllIndex = routeSegments.indexOf("**");
+	if (catchAllIndex === -1 && routeSegments.length !== requestSegments.length) return;
+	if (catchAllIndex !== -1 && requestSegments.length <= catchAllIndex) return;
+	const params = {};
+	for (let index = 0; index < routeSegments.length; index += 1) {
+		const routeSegment = routeSegments[index];
+		const requestSegment = requestSegments[index];
+		if (routeSegment === "**") {
+			const catchAllParam = route.params.find((param) => param.kind === "catch-all");
+			if (!catchAllParam) return void 0;
+			params[catchAllParam.name] = joinURL(requestSegment, ...requestSegments.slice(index + 1));
+			return params;
+		}
+		if (routeSegment.startsWith(":")) {
+			params[routeSegment.slice(1)] = requestSegment;
+			continue;
+		}
+		if (routeSegment !== requestSegment) return;
+	}
+	return params;
+}
+function segmentRank(segment) {
+	if (segment === "**") return 2;
+	if (segment.startsWith(":")) return 1;
+	return 0;
+}
+function compareCodeUnits(left, right) {
+	return left < right ? -1 : left > right ? 1 : 0;
+}
+function unique(values) {
+	return [...new Set(values)];
+}
+function routePathname(segments) {
+	if (segments.length === 0) return "/";
+	const [base, ...rest] = segments;
+	return withLeadingSlash(joinURL(base, ...rest));
+}
+//#endregion
+export { normalizeRequestPathname as a, parseRequestFile as c, matchRouteManifest as i, transformRequestFileSource as l, buildRouteManifestFromFileIds as n, normalizeRouteFileId as o, isPageModuleFile as r, normalizeRequestFileId as s, assertNoEndpointConflicts as t };

package/dist/typescript-plugin.cjs

@@ -168,7 +168,7 @@ function isReservedOrUnsupportedPage(fileId) {
 	const withoutExtension = fileId.slice(0, -extension.length);
 	const routeFile = (0, pathe.normalize)(withoutExtension);
 	const segments = routeFile === "." ? [] : routeFile.split("/").filter(Boolean);
-	return segments[0] === "api" || segments.length === 1 && (segments[0] === "404" || segments[0] === "500");
+	return segments.length === 1 && (segments[0] === "404" || segments[0] === "500");
 }
 function routeFromFileId(fileId) {
 	const extension = (0, pathe.extname)(fileId);

package/dist/typescript-plugin.js

@@ -168,7 +168,7 @@ function isReservedOrUnsupportedPage(fileId) {
 	const withoutExtension = fileId.slice(0, -extension.length);
 	const routeFile = normalize(withoutExtension);
 	const segments = routeFile === "." ? [] : routeFile.split("/").filter(Boolean);
-	return segments[0] === "api" || segments.length === 1 && (segments[0] === "404" || segments[0] === "500");
+	return segments.length === 1 && (segments[0] === "404" || segments[0] === "500");
 }
 function routeFromFileId(fileId) {
 	const extension = extname(fileId);

package/dist/vite/runtime/create-route-discovery.js

@@ -1,4 +1,4 @@
-import { a as normalizeRouteFileId } from "../../route-manifest-Bw_nFohL.js";
+import { o as normalizeRouteFileId } from "../../route-manifest-DMizh42B.js";
 //#region src/vite/runtime/create-route-discovery.ts
 function createRouteDiscovery(discoveredPageModuleLoaders) {
 	const pageModuleLoaders = Object.fromEntries(Object.entries(discoveredPageModuleLoaders).map(([file, loader]) => [normalizeRouteFileId(file), loader]));

package/dist/vite/runtime/create-server-entry.d.ts

@@ -1,3 +1,4 @@
+import { z as RouteManifest } from "../../index-BjxpxRL7.js";
 import { ModulePreloadInput } from "@markless/web/render-to-string";
 //#region src/vite/runtime/create-server-entry.d.ts
 export interface ServerEntryOptions {
@@ -19,9 +20,24 @@ export interface ServerEntryOptions {
   readonly render?: 'streaming' | 'blocking';
   readonly navigation?: 'fragment' | 'render';
   readonly fragmentEntryPath?: string;
+  readonly fragmentEntryImports?: readonly string[];
   readonly fragmentNavigationSource?: string;
+  readonly fragmentNavigationRunSource?: string;
+  readonly linkBridgePaths?: readonly [withoutHashLinks: string, withHashLinks: string];
 }
+export type LinkBridgeOptions = Pick<ServerEntryOptions, 'base' | 'navigationEntryPath' | 'prefetch' | 'documentNavigation' | 'navigation' | 'fragmentEntryPath' | 'fragmentEntryImports' | 'fragmentNavigationSource' | 'fragmentNavigationRunSource' | 'routeFileIds'> & {
+  readonly debug?: boolean;
+};
+/** The link bridge modules a built app's pages import; the build writes them as static client files. */
+export declare function routerLinkBridgeModules(options: LinkBridgeOptions, manifest?: RouteManifest): LinkBridgeFiles | undefined;
 export declare function createServerEntry(options: ServerEntryOptions): {
   fetch: (request: Request) => Promise<Response>;
+  linkBridgeModules: LinkBridgeFiles | undefined;
 };
+export interface LinkBridgeModule {
+  readonly path: string;
+  readonly source: string;
+}
+/** The two page-imported bridges (without and with '#/' links), then any file they load later. */
+export type LinkBridgeFiles = readonly [withoutHashLinks: LinkBridgeModule, withHashLinks: LinkBridgeModule, ...later: LinkBridgeModule[]];
 //#endregion