@sigil-dev/grimoire 0.7.6 → 0.8.0

package/src/routing/manifest-gen.ts

@@ -1,39 +1,42 @@
-import type { RouteFile } from "./scanner";
-
-/**
- * Generates a manifest module that re-exports page route components keyed
- * by route path. Emits plain JS so the same output is valid as both `.ts`
- * and `.js`.
- *
- * If `fileMap` is provided, original `filePath`s are remapped to compiled
- * `.js` paths (used after pre-transforming routes to plain JS).
- */
-export function generateManifest(
-	routes: RouteFile[],
-	fileMap?: Map<string, string>,
-): string {
-	const pages = routes.filter((r) => r.type === "page" || r.type === "simple");
-	const layouts = routes.filter((r) => r.type === "layout");
-
-	const pageImports = pages
-		.map((r, i) => {
-			const path = fileMap?.get(r.filePath) ?? r.filePath;
-			return `import __Page${i} from ${JSON.stringify(path)};`;
-		})
-		.join("\n");
-	const layoutImports = layouts
-		.map((r, i) => {
-			const path = fileMap?.get(r.filePath) ?? r.filePath;
-			return `import __Layout${i} from ${JSON.stringify(path)};`;
-		})
-		.join("\n");
-
-	const map = pages
-		.map((r, i) => `  ${JSON.stringify(r.path)}: __Page${i},`)
-		.join("\n");
-	const layoutMap = layouts
-		.map((r, i) => `  { path: ${JSON.stringify(r.path)}, component: __Layout${i} },`)
-		.join("\n");
-
-	return `${pageImports}\n${layoutImports}\nexport const routes = {\n${map}\n};\nexport const layouts = [\n${layoutMap}\n];\n`;
-}
+import type { RouteFile } from "./scanner";
+
+/**
+ * Generates a manifest module that re-exports page route components keyed
+ * by route path. Emits plain JS so the same output is valid as both `.ts`
+ * and `.js`.
+ *
+ * If `fileMap` is provided, original `filePath`s are remapped to compiled
+ * `.js` paths (used after pre-transforming routes to plain JS).
+ */
+export function generateManifest(
+	routes: RouteFile[],
+	fileMap?: Map<string, string>,
+): string {
+	const pages = routes.filter((r) => r.type === "page" || r.type === "simple");
+	const layouts = routes.filter((r) => r.type === "layout");
+
+	const pageImports = pages
+		.map((r, i) => {
+			const path = fileMap?.get(r.filePath) ?? r.filePath;
+			return `import __Page${i} from ${JSON.stringify(path)};`;
+		})
+		.join("\n");
+	const layoutImports = layouts
+		.map((r, i) => {
+			const path = fileMap?.get(r.filePath) ?? r.filePath;
+			return `import __Layout${i} from ${JSON.stringify(path)};`;
+		})
+		.join("\n");
+
+	const map = pages
+		.map((r, i) => `  ${JSON.stringify(r.path)}: __Page${i},`)
+		.join("\n");
+	const layoutMap = layouts
+		.map(
+			(r, i) =>
+				`  { path: ${JSON.stringify(r.path)}, component: __Layout${i}, load: __Layout${i}.load },`,
+		)
+		.join("\n");
+
+	return `${pageImports}\n${layoutImports}\nexport const routes = {\n${map}\n};\nexport const layouts = [\n${layoutMap}\n];\n`;
+}

package/src/routing/router.ts

@@ -1,106 +1,109 @@
-import type { RouteFile, RouteTree } from "./scanner";
-
-export interface MatchedRoute {
-    route: RouteFile;
-    params: Record<string, string>;
-    layouts: RouteFile[];        // was: layout?: RouteFile
-    layoutServers: RouteFile[];       // was: layoutServer?: RouteFile
-    pageServer?: RouteFile;
-}
-
-export function matchRoute(tree: RouteTree, url: URL): MatchedRoute | null {
-    const pathname = url.pathname;
-
-    // check server routes first
-    for (const server of tree.servers) {
-        const params = matchPattern(server.path, pathname);
-        if (params !== null) return {
-          route: server,
-          params,
-          layouts: [],
-          layoutServers: []
-        };
-    }
-
-    // then pages
-    for (const route of tree.routes) {
-        if (route.type === "pageServer") continue;
-        const params = matchPattern(route.path, pathname);
-        if (params === null) continue;
-
-        // find applicable layouts by matching route pattern prefix, not URL pathname.
-        // pathname.startsWith(l.path) would fail for parameterized layouts like /w/:workspace.
-        const layoutMatches = (l: RouteFile) =>
-            l.path === "/" || route.path === l.path || route.path.startsWith(l.path + "/");
-
-        const layouts = tree.layouts
-          .filter((l) => l.type === "layout" && layoutMatches(l))
-          .sort((a, b) => a.path.length - b.path.length); // root first, innermost last
-
-        const layoutServers = tree.layouts
-          .filter((l) => l.type === "layoutServer" && layoutMatches(l))
-          .sort((a, b) => a.path.length - b.path.length); // root first, innermost last
-
-        const pageServer = tree.routes.find(
-          (r) => r.type === "pageServer" && r.path === route.path,
-        );
-
-        return { route, params, layouts, layoutServers, pageServer };
-    }
-
-    return null;
-}
-
-export function findClosestError(
-    errors: RouteFile[],
-    pathname: string,
-): RouteFile | null {
-    const segments = pathname.split("/").filter(Boolean);
-
-    // walk from most specific to root
-    while (segments.length >= 0) {
-        const prefix = `/${segments.join("/")}`;
-        const error = errors.find(
-            (e) => e.path === prefix || e.path === prefix + "/",
-        );
-        if (error) return error;
-        if (segments.length === 0) break;
-        segments.pop();
-    }
-    return null;
-}
-
-function matchPattern(
-    pattern: string,
-    pathname: string,
-): Record<string, string> | null {
-    const patternParts = pattern.split("/").filter(Boolean);
-    const pathParts = pathname.split("/").filter(Boolean);
-
-    const params: Record<string, string> = {};
-    let pi = 0;
-    let pj = 0;
-    while (pi < patternParts.length) {
-        const patternPart = patternParts[pi]!;
-
-        if (patternPart.startsWith("*")) {
-            // Rest param — captures zero or more remaining path segments joined by "/".
-            // Rest must be the last segment in the pattern.
-            params[patternPart.slice(1)] = pathParts.slice(pj).join("/");
-            return params;
-        }
-
-        if (pj >= pathParts.length) return null;
-        const pathPart = pathParts[pj]!;
-
-        if (patternPart.startsWith(":")) {
-            params[patternPart.slice(1)] = pathPart;
-        } else if (patternPart !== pathPart) {
-            return null;
-        }
-        pi++;
-        pj++;
-    }
-    if (pj < pathParts.length) return null;
-    return params;
-}
+import type { RouteFile, RouteTree } from "./scanner";
+
+export interface MatchedRoute {
+	route: RouteFile;
+	params: Record<string, string>;
+	layouts: RouteFile[]; // was: layout?: RouteFile
+	layoutServers: RouteFile[]; // was: layoutServer?: RouteFile
+	pageServer?: RouteFile;
+}
+
+export function matchRoute(tree: RouteTree, url: URL): MatchedRoute | null {
+	const pathname = url.pathname;
+
+	// check server routes first
+	for (const server of tree.servers) {
+		const params = matchPattern(server.path, pathname);
+		if (params !== null)
+			return {
+				route: server,
+				params,
+				layouts: [],
+				layoutServers: [],
+			};
+	}
+
+	// then pages
+	for (const route of tree.routes) {
+		if (route.type === "pageServer") continue;
+		const params = matchPattern(route.path, pathname);
+		if (params === null) continue;
+
+		// find applicable layouts by matching route pattern prefix, not URL pathname.
+		// pathname.startsWith(l.path) would fail for parameterized layouts like /w/:workspace.
+		const layoutMatches = (l: RouteFile) =>
+			l.path === "/" ||
+			route.path === l.path ||
+			route.path.startsWith(l.path + "/");
+
+		const layouts = tree.layouts
+			.filter((l) => l.type === "layout" && layoutMatches(l))
+			.sort((a, b) => a.path.length - b.path.length); // root first, innermost last
+
+		const layoutServers = tree.layouts
+			.filter((l) => l.type === "layoutServer" && layoutMatches(l))
+			.sort((a, b) => a.path.length - b.path.length); // root first, innermost last
+
+		const pageServer = tree.routes.find(
+			(r) => r.type === "pageServer" && r.path === route.path,
+		);
+
+		return { route, params, layouts, layoutServers, pageServer };
+	}
+
+	return null;
+}
+
+export function findClosestError(
+	errors: RouteFile[],
+	pathname: string,
+): RouteFile | null {
+	const segments = pathname.split("/").filter(Boolean);
+
+	// walk from most specific to root
+	while (segments.length >= 0) {
+		const prefix = `/${segments.join("/")}`;
+		const error = errors.find(
+			(e) => e.path === prefix || e.path === prefix + "/",
+		);
+		if (error) return error;
+		if (segments.length === 0) break;
+		segments.pop();
+	}
+	return null;
+}
+
+function matchPattern(
+	pattern: string,
+	pathname: string,
+): Record<string, string> | null {
+	const patternParts = pattern.split("/").filter(Boolean);
+	const pathParts = pathname.split("/").filter(Boolean);
+
+	const params: Record<string, string> = {};
+	let pi = 0;
+	let pj = 0;
+	while (pi < patternParts.length) {
+		const patternPart = patternParts[pi]!;
+
+		if (patternPart.startsWith("*")) {
+			// Rest param — captures zero or more remaining path segments joined by "/".
+			// Rest must be the last segment in the pattern.
+			params[patternPart.slice(1)] = pathParts.slice(pj).join("/");
+			return params;
+		}
+
+		if (pj >= pathParts.length) return null;
+		const pathPart = pathParts[pj]!;
+
+		if (patternPart.startsWith(":")) {
+			params[patternPart.slice(1)] = pathPart;
+		} else if (patternPart !== pathPart) {
+			return null;
+		}
+		pi++;
+		pj++;
+	}
+	if (pj < pathParts.length) return null;
+	return params;
+}

package/src/routing/scanner.ts

@@ -1,135 +1,141 @@
-import { basename, join, relative } from "node:path";
-
-export interface RouteFile {
-	path: string; // URL (ie /blog/:slug)
-	filePath: string; // absolute disk path;
-	clientPath: string; // Relative path (/src/routes/spells/+page.tsx)
-	type:
-		| "page"
-		| "pageServer"
-		| "layout"
-		| "layoutServer"
-		| "server"
-		| "error"
-		| "simple";
-	paramNames: string[]; // ["slug"] in /blog/:slug
-	restParamNames: string[]; // ["rest"] in /blog/*rest
-}
-
-export interface RouteTree {
-	routes: RouteFile[];
-	layouts: RouteFile[]; // layout + layout.server
-	servers: RouteFile[]; // +server.ts API routes
-	errors: RouteFile[]; // +error.tsx
-}
-
-export function filePathToRoutePath(
-	filePath: string,
-	routesDir: string,
-): { pattern: string; params: string[]; restParams: string[] } {
-	const rel = relative(routesDir, filePath)
-		.replace(/\\/g, "/") // windows
-		.replace(/\.(tsx?|jsx?)$/, "");
-
-	const params: string[] = [];
-	const restParams: string[] = [];
-	const pattern =
-		rel
-			.replace(/\/?(\+\w+(\.\w+)?|index)$/, "") // index/+page → directory
-			.replace(/\[(\.\.\.)?([^\]]+)\]/g, (_, dots, name) => {
-				// [...rest] → *rest (captures zero or more remaining path segments)
-				if (dots) {
-					restParams.push(name);
-					return `*${name}`;
-				}
-				// [param] → :param
-				params.push(name);
-				return `:${name}`;
-			})
-			.replace(/^\/?/, "/") || // ensure leading slash
-		"/";
-
-	return { pattern, params, restParams };
-}
-
-export async function scanRoutes(
-	routesDir: string,
-	viteRoot: string = routesDir,
-): Promise<RouteTree> {
-	const glob = new Bun.Glob("**/*.{tsx,ts,jsx,js}");
-	const routes: RouteFile[] = [];
-	const layouts: RouteFile[] = [];
-	const servers: RouteFile[] = [];
-	const errors: RouteFile[] = [];
-
-	for await (const file of glob.scan(routesDir)) {
-		const filePath = join(routesDir, file);
-		const name = basename(file).replace(/\.(tsx?|jsx?)$/, "");
-		const { pattern, params, restParams } = filePathToRoutePath(filePath, routesDir);
-
-		let type: RouteFile["type"];
-		if (name === "+page") type = "page";
-		else if (name === "+page.server") type = "pageServer";
-		else if (name === "+layout") type = "layout";
-		else if (name === "+layout.server") type = "layoutServer";
-		else if (name === "+server") type = "server";
-		else if (name === "+error") type = "error";
-		else type = "simple";
-
-		const clientPath = "/" + relative(viteRoot, filePath).replace(/\\/g, "/");
-
-		const routeFile: RouteFile = {
-			path: pattern,
-			filePath,
-			clientPath, // add this
-			type,
-			paramNames: params,
-			restParamNames: restParams,
-		};
-
-		if (type === "simple" || type === "page" || type === "pageServer")
-			routes.push(routeFile);
-		if (type === "layout" || type === "layoutServer") layouts.push(routeFile);
-		if (type === "server") servers.push(routeFile);
-		if (type === "error") errors.push(routeFile);
-	}
-
-	// sort so static routes match before dynamic ones, rest params last
-	const scoreRoute = (r: RouteFile) => r.paramNames.length + r.restParamNames.length * 1000;
-	routes.sort((a, b) => scoreRoute(a) - scoreRoute(b));
-	servers.sort((a, b) => scoreRoute(a) - scoreRoute(b));
-
-	assertNoDuplicatePaths(
-		routes.filter((r) => r.type === "page" || r.type === "simple"),
-		"page",
-	);
-	assertNoDuplicatePaths(
-		routes.filter((r) => r.type === "pageServer"),
-		"page server",
-	);
-	assertNoDuplicatePaths(
-		layouts.filter((l) => l.type === "layout"),
-		"layout",
-	);
-	assertNoDuplicatePaths(
-		layouts.filter((l) => l.type === "layoutServer"),
-		"layout server",
-	);
-	assertNoDuplicatePaths(servers, "API route");
-	assertNoDuplicatePaths(errors, "error page");
-
-	return { routes, layouts, servers, errors };
-}
-
-function assertNoDuplicatePaths(files: RouteFile[], label: string): void {
-	const seen = new Map<string, string>();
-	for (const file of files) {
-		const existing = seen.get(file.path);
-		if (existing) {
-			throw new Error(
-				`Duplicate ${label} at "${file.path}": "${existing}" and "${file.clientPath}"`,
-			);
-		}
-		seen.set(file.path, file.clientPath);
-	}
-}
+import { basename, join, relative } from "node:path";
+
+export interface RouteFile {
+	path: string; // URL (ie /blog/:slug)
+	filePath: string; // absolute disk path;
+	clientPath: string; // Relative path (/src/routes/spells/+page.tsx)
+	type:
+		| "page"
+		| "pageServer"
+		| "layout"
+		| "layoutServer"
+		| "server"
+		| "error"
+		| "simple";
+	paramNames: string[]; // ["slug"] in /blog/:slug
+	restParamNames: string[]; // ["rest"] in /blog/*rest
+}
+
+export interface RouteTree {
+	routes: RouteFile[];
+	layouts: RouteFile[]; // layout + layout.server
+	servers: RouteFile[]; // +server.ts API routes
+	errors: RouteFile[]; // +error.tsx
+}
+
+export function filePathToRoutePath(
+	filePath: string,
+	routesDir: string,
+): { pattern: string; params: string[]; restParams: string[] } {
+	const rel = relative(routesDir, filePath)
+		.replace(/\\/g, "/")
+		.replace(/\.(tsx?|jsx?)$/, "")
+		.replace(/(?:^|\/)(\([^)]+\))(?=\/|$)/g, "") // strip (groupName) anywhere
+		.replace(/\/+/g, "/"); // collapse double slashes
+
+	const params: string[] = [];
+	const restParams: string[] = [];
+	const pattern =
+		rel
+			.replace(/\/?(\+\w+(\.\w+)?|index)$/, "") // index/+page → directory
+			.replace(/\[(\.\.\.)?([^\]]+)\]/g, (_, dots, name) => {
+				// [...rest] → *rest (captures zero or more remaining path segments)
+				if (dots) {
+					restParams.push(name);
+					return `*${name}`;
+				}
+				// [param] → :param
+				params.push(name);
+				return `:${name}`;
+			})
+			.replace(/^\/?/, "/") || // ensure leading slash
+		"/";
+
+	return { pattern, params, restParams };
+}
+
+export async function scanRoutes(
+	routesDir: string,
+	viteRoot: string = routesDir,
+): Promise<RouteTree> {
+	const glob = new Bun.Glob("**/*.{tsx,ts,jsx,js}");
+	const routes: RouteFile[] = [];
+	const layouts: RouteFile[] = [];
+	const servers: RouteFile[] = [];
+	const errors: RouteFile[] = [];
+
+	for await (const file of glob.scan(routesDir)) {
+		const filePath = join(routesDir, file);
+		const name = basename(file).replace(/\.(tsx?|jsx?)$/, "");
+		const { pattern, params, restParams } = filePathToRoutePath(
+			filePath,
+			routesDir,
+		);
+
+		let type: RouteFile["type"];
+		if (name === "+page") type = "page";
+		else if (name === "+page.server") type = "pageServer";
+		else if (name === "+layout") type = "layout";
+		else if (name === "+layout.server") type = "layoutServer";
+		else if (name === "+server") type = "server";
+		else if (name === "+error") type = "error";
+		else type = "simple";
+
+		const clientPath = "/" + relative(viteRoot, filePath).replace(/\\/g, "/");
+
+		const routeFile: RouteFile = {
+			path: pattern,
+			filePath,
+			clientPath, // add this
+			type,
+			paramNames: params,
+			restParamNames: restParams,
+		};
+
+		if (type === "simple" || type === "page" || type === "pageServer")
+			routes.push(routeFile);
+		if (type === "layout" || type === "layoutServer") layouts.push(routeFile);
+		if (type === "server") servers.push(routeFile);
+		if (type === "error") errors.push(routeFile);
+	}
+
+	// sort so static routes match before dynamic ones, rest params last
+	const scoreRoute = (r: RouteFile) =>
+		r.paramNames.length + r.restParamNames.length * 1000;
+	routes.sort((a, b) => scoreRoute(a) - scoreRoute(b));
+	servers.sort((a, b) => scoreRoute(a) - scoreRoute(b));
+
+	assertNoDuplicatePaths(
+		routes.filter((r) => r.type === "page" || r.type === "simple"),
+		"page",
+	);
+	assertNoDuplicatePaths(
+		routes.filter((r) => r.type === "pageServer"),
+		"page server",
+	);
+	assertNoDuplicatePaths(
+		layouts.filter((l) => l.type === "layout"),
+		"layout",
+	);
+	assertNoDuplicatePaths(
+		layouts.filter((l) => l.type === "layoutServer"),
+		"layout server",
+	);
+	assertNoDuplicatePaths(servers, "API route");
+	assertNoDuplicatePaths(errors, "error page");
+
+	return { routes, layouts, servers, errors };
+}
+
+function assertNoDuplicatePaths(files: RouteFile[], label: string): void {
+	const seen = new Map<string, string>();
+	for (const file of files) {
+		const existing = seen.get(file.path);
+		if (existing) {
+			throw new Error(
+				`Duplicate ${label} at "${file.path}": "${existing}" and "${file.clientPath}"`,
+			);
+		}
+		seen.set(file.path, file.clientPath);
+	}
+}