@sigil-dev/grimoire 0.7.5 → 0.7.6

package/src/routing/manifest-gen.ts

@@ -1,26 +1,39 @@
-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 imports = pages
-		.map((r, i) => {
-			const path = fileMap?.get(r.filePath) ?? r.filePath;
-			return `import __Page${i} from ${JSON.stringify(path)};`;
-		})
-		.join("\n");
-	const map = pages
-		.map((r, i) => `  ${JSON.stringify(r.path)}: __Page${i},`)
-		.join("\n");
-	return `${imports}\nexport const routes = {\n${map}\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} },`)
+		.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,98 +1,106 @@
-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 layout (longest matching prefix wins)
-        const layouts = tree.layouts
-          .filter(
-            (l) =>
-              l.type === "layout" &&
-              pathname.startsWith(l.path === "/" ? "/" : l.path),
-          )
-          .sort((a, b) => a.path.length - b.path.length); // root first, innermost last
-
-        const layoutServers = tree.layouts
-          .filter(
-            (l) =>
-              l.type === "layoutServer" &&
-              pathname.startsWith(l.path === "/" ? "/" : l.path),
-          )
-          .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);
-
-    if (patternParts.length !== pathParts.length) return null;
-
-    const params: Record<string, string> = {};
-    for (let i = 0; i < patternParts.length; i++) {
-        const patternPart = patternParts[i]!;
-        const pathPart = pathParts[i]!;
-
-        if (patternPart.startsWith(":")) {
-            params[patternPart.slice(1)] = pathPart;
-        } else if (patternPart !== pathPart) {
-            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,129 +1,135 @@
-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
-}
-
-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[] } {
-	const rel = relative(routesDir, filePath)
-		.replace(/\\/g, "/") // windows
-		.replace(/\.(tsx?|jsx?)$/, "");
-
-	const params: string[] = [];
-	const pattern =
-		rel
-			.replace(/\/?(\+\w+(\.\w+)?|index)$/, "") // index/+page → directory
-			.replace(/\[([^\]]+)\]/g, (_, p) => {
-				// [param] → :param
-				params.push(p);
-				return `:${p}`;
-			})
-			.replace(/^\/?/, "/") || // ensure leading slash
-		"/";
-
-	return { pattern, params };
-}
-
-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 } = 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,
-		};
-
-		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
-	routes.sort((a, b) => {
-		const aScore = a.paramNames.length;
-		const bScore = b.paramNames.length;
-		return aScore - bScore;
-	});
-
-	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, "/") // 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);
+	}
+}