@ilha/router 0.1.1

package/dist/vite.js

@@ -0,0 +1,205 @@
+import { wrapError, wrapLayout } from "./index.js";
+import { mkdir, readFile, readdir, writeFile } from "node:fs/promises";
+import { basename, dirname, extname, join, relative, resolve } from "node:path";
+//#region src/vite.ts
+/** Files that should never be treated as pages even if they match the ts/tsx extension. */
+const EXCLUDED_RE = /\.(test|spec|d)\.(ts|tsx)$/;
+function fileToSegment(name) {
+	if (name.startsWith("[...") && name.endsWith("]")) return `**:${name.slice(4, -1)}`;
+	if (name.startsWith("[") && name.endsWith("]")) return `:${name.slice(1, -1)}`;
+	return name;
+}
+function fileToPattern(pagesDir, file) {
+	const rel = relative(pagesDir, file);
+	const segments = rel.slice(0, -extname(rel).length).split("/").map(fileToSegment);
+	if (segments.at(-1) === "index") segments.pop();
+	return "/" + segments.filter(Boolean).join("/") || "/";
+}
+function patternToName(pattern) {
+	if (pattern === "/") return "index";
+	return pattern.replace(/^\//, "").replace(/\*\*:[^/]*/g, (m) => m.length > 3 ? m.slice(3) : "wildcard").replace(/:/g, "").replace(/\*\*/g, "wildcard").replace(/\//g, "-").replace(/[^a-zA-Z0-9-]/g, "") || "page";
+}
+function specificityScore(pattern) {
+	if (pattern === "/") return 3;
+	if (pattern.includes("**")) return 0;
+	if (pattern.includes(":")) return 1;
+	return 2;
+}
+/** Deterministic sort: by specificity desc, then by segment count desc, then alphabetical. */
+function sortEntries(entries) {
+	return [...entries].sort((a, b) => {
+		const specDiff = specificityScore(b.pattern) - specificityScore(a.pattern);
+		if (specDiff !== 0) return specDiff;
+		const segDiff = b.pattern.split("/").length - a.pattern.split("/").length;
+		if (segDiff !== 0) return segDiff;
+		return a.pattern.localeCompare(b.pattern);
+	});
+}
+function chainForFile(pagesDir, file, all, sentinel) {
+	const relDir = relative(pagesDir, dirname(file));
+	const parts = relDir === "" ? [] : relDir.split("/");
+	return [pagesDir, ...parts.map((_, i) => join(pagesDir, ...parts.slice(0, i + 1)))].map((dir) => join(dir, sentinel)).filter((candidate) => all.has(candidate));
+}
+const MAX_SCAN_DEPTH = 20;
+async function collectFiles(dir, depth = 0) {
+	if (depth > MAX_SCAN_DEPTH) {
+		console.warn(`[ilha:pages] Max scan depth (${MAX_SCAN_DEPTH}) reached at ${dir} — skipping`);
+		return [];
+	}
+	const results = [];
+	for (const entry of await readdir(dir, { withFileTypes: true })) {
+		const full = join(dir, entry.name);
+		if (entry.isDirectory()) results.push(...await collectFiles(full, depth + 1));
+		else if (entry.isFile() && /\.(ts|tsx)$/.test(entry.name) && !EXCLUDED_RE.test(entry.name)) results.push(full);
+	}
+	return results;
+}
+async function scanPages(pagesDir) {
+	const all = await collectFiles(pagesDir);
+	const allSet = new Set(all);
+	return all.filter((f) => !basename(f).startsWith("+")).map((file) => {
+		const pattern = fileToPattern(pagesDir, file);
+		return {
+			file,
+			pattern,
+			name: patternToName(pattern),
+			layouts: chainForFile(pagesDir, file, allSet, "+layout.ts"),
+			errors: chainForFile(pagesDir, file, allSet, "+error.ts")
+		};
+	});
+}
+function validateEntries(entries, pagesDir) {
+	if (entries.length === 0) {
+		console.warn(`[ilha:pages] No pages found in ${pagesDir}`);
+		return;
+	}
+	const seenPatterns = /* @__PURE__ */ new Map();
+	const seenNames = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		const existingPattern = seenPatterns.get(entry.pattern);
+		if (existingPattern) console.warn(`[ilha:pages] Duplicate route pattern "${entry.pattern}"\n  first:  ${existingPattern}\n  second: ${entry.file}\n  The first match wins — the second page will never be reached.`);
+		else seenPatterns.set(entry.pattern, entry.file);
+		const existingName = seenNames.get(entry.name);
+		if (existingName) console.warn(`[ilha:pages] Registry name collision: "${entry.name}" is used by both\n  ${existingName}\n  ${entry.file}\n  Hydration may not work correctly for one of these routes.`);
+		else seenNames.set(entry.name, entry.file);
+	}
+}
+async function generate(pagesDir, outFile) {
+	const entries = sortEntries(await scanPages(pagesDir));
+	validateEntries(entries, pagesDir);
+	const rel = (abs) => {
+		const r = relative(dirname(outFile), abs);
+		return r.startsWith(".") ? r : `./${r}`;
+	};
+	const imports = [`import { router, wrapLayout, wrapError } from "@ilha/router";`, `import type { Island }                    from "ilha";`];
+	const wrappedIslandLines = [];
+	const registryLines = [];
+	const routeLines = [];
+	for (const [i, entry] of entries.entries()) {
+		const pageId = `_page${i}`;
+		imports.push(`import { default as ${pageId} } from ${JSON.stringify(rel(entry.file))};`);
+		for (const [j, l] of entry.layouts.entries()) imports.push(`import { default as _layout${i}_${j} } from ${JSON.stringify(rel(l))};`);
+		for (const [j, e] of entry.errors.entries()) imports.push(`import { default as _error${i}_${j} } from ${JSON.stringify(rel(e))};`);
+		let expr = pageId;
+		for (let j = entry.errors.length - 1; j >= 0; j--) expr = `wrapError(_error${i}_${j}, ${expr})`;
+		for (let j = entry.layouts.length - 1; j >= 0; j--) expr = `wrapLayout(_layout${i}_${j}, ${expr})`;
+		const wrappedId = `_wrapped${i}`;
+		wrappedIslandLines.push(`const ${wrappedId} = ${expr};`);
+		registryLines.push(`  ${JSON.stringify(entry.name)}: ${wrappedId}` + (i < entries.length - 1 ? "," : ""));
+		routeLines.push(`  .route(${JSON.stringify(entry.pattern)}, ${wrappedId})`);
+	}
+	const code = [
+		`// @generated by @ilha/router — do not edit`,
+		``,
+		...imports,
+		``,
+		...wrappedIslandLines,
+		``,
+		`export const registry: Record<string, Island<any, any>> = {`,
+		...registryLines,
+		`};`,
+		``,
+		`export const pageRouter = router()`,
+		...routeLines,
+		`  ;`
+	].join("\n");
+	await mkdir(dirname(outFile), { recursive: true });
+	if (await writeIfChanged(outFile, code)) await generateTypes(outFile);
+}
+async function writeIfChanged(file, content) {
+	try {
+		if (await readFile(file, "utf8") === content) return false;
+	} catch {}
+	await writeFile(file, content, "utf8");
+	return true;
+}
+async function generateTypes(outFile) {
+	await writeIfChanged(outFile.replace(/\.ts$/, ".d.ts"), [
+		`// @generated by @ilha/router — do not edit`,
+		``,
+		`declare module "ilha:pages" {`,
+		`  import type { RouterBuilder } from "@ilha/router";`,
+		`  export const pageRouter: RouterBuilder;`,
+		`}`,
+		``,
+		`declare module "ilha:registry" {`,
+		`  import type { Island } from "ilha";`,
+		`  export const registry: Record<string, Island<any, any>>;`,
+		`}`,
+		``
+	].join("\n"));
+}
+const VIRTUAL_PAGES = "ilha:pages";
+const VIRTUAL_REGISTRY = "ilha:registry";
+const RESOLVED_PAGES = "\0ilha:pages";
+const RESOLVED_REGISTRY = "\0ilha:registry";
+function pages(options = {}) {
+	let pagesDir;
+	let outFile;
+	async function regen() {
+		try {
+			await generate(pagesDir, outFile);
+		} catch (e) {
+			console.error("[ilha:pages] codegen failed:", e);
+		}
+	}
+	return {
+		name: "ilha:pages",
+		configResolved(config) {
+			pagesDir = resolve(config.root, options.dir ?? "src/pages");
+			outFile = resolve(config.root, options.generated ?? ".ilha/routes.ts");
+		},
+		async buildStart() {
+			await regen();
+		},
+		configureServer(server) {
+			server.watcher.add(pagesDir);
+			const structuralInvalidate = async (file) => {
+				if (!file.startsWith(pagesDir)) return;
+				await regen();
+				for (const id of [RESOLVED_PAGES, RESOLVED_REGISTRY]) {
+					const mod = server.moduleGraph.getModuleById(id);
+					if (mod) server.moduleGraph.invalidateModule(mod);
+				}
+				server.hot.send({ type: "full-reload" });
+			};
+			server.watcher.on("add", structuralInvalidate);
+			server.watcher.on("addDir", structuralInvalidate);
+			server.watcher.on("unlink", structuralInvalidate);
+			server.watcher.on("change", async (file) => {
+				if (!file.startsWith(pagesDir)) return;
+				if (basename(file).startsWith("+")) await structuralInvalidate(file);
+			});
+		},
+		resolveId(id) {
+			if (id === VIRTUAL_PAGES) return RESOLVED_PAGES;
+			if (id === VIRTUAL_REGISTRY) return RESOLVED_REGISTRY;
+		},
+		load(id) {
+			if (id === RESOLVED_PAGES) return `export { pageRouter } from ${JSON.stringify(outFile)};`;
+			if (id === RESOLVED_REGISTRY) return `export { registry } from ${JSON.stringify(outFile)};`;
+		}
+	};
+}
+//#endregion
+export { pages, wrapError, wrapLayout };

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@ilha/router",
+  "version": "0.1.1",
+  "description": "A tiny SPA router for Ilha",
+  "license": "MIT",
+  "author": "Ryuz <ryuzer@proton.me>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ilhajs/ilha.git"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./vite": {
+      "types": "./dist/vite.d.ts",
+      "import": "./dist/vite.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc && tsdown",
+    "test": "bun test"
+  },
+  "dependencies": {
+    "ilha": "0.1.0",
+    "rou3": "0.8.1"
+  },
+  "devDependencies": {
+    "vite": "^8.0.7"
+  }
+}