bosia 0.2.2 → 0.3.0

package/src/core/matcher.ts

@@ -1,4 +1,4 @@
-import type { RouteMatch } from "./types.ts";
+import type { RouteMatch, TrailingSlash } from "./types.ts";
 
 // ─── Route Matcher ───────────────────────────────────────
 // Single shared matcher used by both client and server at runtime.
@@ -12,57 +12,55 @@ import type { RouteMatch } from "./types.ts";
 // ─── Compiled Route Types ────────────────────────────────
 
 interface CompiledRoute {
-    regex: RegExp;
-    paramNames: string[];
-    isExact: boolean;
+	regex: RegExp;
+	paramNames: string[];
+	isExact: boolean;
 }
 
 // ─── Pattern Compiler ────────────────────────────────────
 
 /** Escape regex special chars in a literal string segment. */
 function escapeRegex(s: string): string {
-    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
 /**
  * Pre-compile a route pattern into a RegExp for fast matching.
  */
 function compilePattern(pattern: string): CompiledRoute {
-    // No dynamic segments — exact match via ===
-    if (!pattern.includes("[")) {
-        return { regex: null!, paramNames: [], isExact: true };
-    }
-
-    const paramNames: string[] = [];
-
-    // Catch-all: /prefix/[...name]
-    const catchallMatch = pattern.match(/^(.*?)\/\[\.\.\.(\w+)\]$/);
-    if (catchallMatch) {
-        const prefix = catchallMatch[1] || "";
-        paramNames.push(catchallMatch[2]!);
-        const escaped = prefix ? escapeRegex(prefix) : "";
-        // Root catch-all /[...rest] must have at least one char after /
-        const regex = prefix
-            ? new RegExp(`^${escaped}\\/(.+)$`)
-            : new RegExp(`^\\/(.+)$`);
-        return { regex, paramNames, isExact: false };
-    }
-
-    // Dynamic segments: /blog/[slug]/comments → ^\/blog\/([^/]+)\/comments$
-    const segments = pattern.split("/").filter(Boolean);
-    let regexStr = "^";
-    for (const seg of segments) {
-        regexStr += "\\/";
-        if (seg.startsWith("[") && seg.endsWith("]")) {
-            paramNames.push(seg.slice(1, -1));
-            regexStr += "([^/]+)";
-        } else {
-            regexStr += escapeRegex(seg);
-        }
-    }
-    regexStr += "$";
-
-    return { regex: new RegExp(regexStr), paramNames, isExact: false };
+	// No dynamic segments — exact match via ===
+	if (!pattern.includes("[")) {
+		return { regex: null!, paramNames: [], isExact: true };
+	}
+
+	const paramNames: string[] = [];
+
+	// Catch-all: /prefix/[...name]
+	const catchallMatch = pattern.match(/^(.*?)\/\[\.\.\.(\w+)\]$/);
+	if (catchallMatch) {
+		const prefix = catchallMatch[1] || "";
+		paramNames.push(catchallMatch[2]!);
+		const escaped = prefix ? escapeRegex(prefix) : "";
+		// Root catch-all /[...rest] must have at least one char after /
+		const regex = prefix ? new RegExp(`^${escaped}\\/(.+)$`) : new RegExp(`^\\/(.+)$`);
+		return { regex, paramNames, isExact: false };
+	}
+
+	// Dynamic segments: /blog/[slug]/comments → ^\/blog\/([^/]+)\/comments$
+	const segments = pattern.split("/").filter(Boolean);
+	let regexStr = "^";
+	for (const seg of segments) {
+		regexStr += "\\/";
+		if (seg.startsWith("[") && seg.endsWith("]")) {
+			paramNames.push(seg.slice(1, -1));
+			regexStr += "([^/]+)";
+		} else {
+			regexStr += escapeRegex(seg);
+		}
+	}
+	regexStr += "$";
+
+	return { regex: new RegExp(regexStr), paramNames, isExact: false };
 }
 
 /**
@@ -71,12 +69,12 @@ function compilePattern(pattern: string): CompiledRoute {
  * Call once at startup — all modules sharing the same route array see the result.
  */
 export function compileRoutes<T extends { pattern: string }>(
-    routes: T[],
+	routes: T[],
 ): (T & { _compiled: CompiledRoute })[] {
-    for (const route of routes) {
-        (route as any)._compiled = compilePattern(route.pattern);
-    }
-    return routes as (T & { _compiled: CompiledRoute })[];
+	for (const route of routes) {
+		(route as any)._compiled = compilePattern(route.pattern);
+	}
+	return routes as (T & { _compiled: CompiledRoute })[];
 }
 
 // ─── Legacy Pattern Matcher (fallback for uncompiled routes) ─
@@ -85,51 +83,48 @@ export function compileRoutes<T extends { pattern: string }>(
  * Match a URL pathname against a single route pattern.
  * Returns extracted params if matched, null otherwise.
  */
-function matchPattern(
-    pattern: string,
-    pathname: string,
-): Record<string, string> | null {
-    // Strip trailing slash (but keep "/" as-is)
-    if (pathname.length > 1 && pathname.endsWith("/")) {
-        pathname = pathname.slice(0, -1);
-    }
-
-    // Exact match
-    if (pattern === pathname) return {};
-
-    // Catch-all pattern: /[...name] or /prefix/[...name]
-    const catchallMatch = pattern.match(/^(.*?)\/\[\.\.\.(\w+)\]$/);
-    if (catchallMatch) {
-        const prefix = catchallMatch[1] || "";
-        const paramName = catchallMatch[2]!;
-        if (prefix === "" || pathname.startsWith(prefix + "/") || pathname === prefix) {
-            const rest = prefix ? pathname.slice(prefix.length + 1) : pathname.slice(1);
-            // Don't let a root catch-all match "/" with an empty slug.
-            // If you want the catch-all to also serve "/", add an explicit +page.svelte at the root.
-            if (!prefix && rest === "") return null;
-            return { [paramName]: rest };
-        }
-        return null;
-    }
-
-    // Dynamic segments: must have same segment count
-    if (!pattern.includes("[")) return null;
-
-    const patParts = pattern.split("/").filter(Boolean);
-    const pathParts = pathname.split("/").filter(Boolean);
-    if (patParts.length !== pathParts.length) return null;
-
-    const params: Record<string, string> = {};
-    for (let i = 0; i < patParts.length; i++) {
-        const pp = patParts[i]!;
-        const val = pathParts[i]!;
-        if (pp.startsWith("[") && pp.endsWith("]")) {
-            params[pp.slice(1, -1)] = val;
-        } else if (pp !== val) {
-            return null;
-        }
-    }
-    return params;
+function matchPattern(pattern: string, pathname: string): Record<string, string> | null {
+	// Strip trailing slash (but keep "/" as-is)
+	if (pathname.length > 1 && pathname.endsWith("/")) {
+		pathname = pathname.slice(0, -1);
+	}
+
+	// Exact match
+	if (pattern === pathname) return {};
+
+	// Catch-all pattern: /[...name] or /prefix/[...name]
+	const catchallMatch = pattern.match(/^(.*?)\/\[\.\.\.(\w+)\]$/);
+	if (catchallMatch) {
+		const prefix = catchallMatch[1] || "";
+		const paramName = catchallMatch[2]!;
+		if (prefix === "" || pathname.startsWith(prefix + "/") || pathname === prefix) {
+			const rest = prefix ? pathname.slice(prefix.length + 1) : pathname.slice(1);
+			// Don't let a root catch-all match "/" with an empty slug.
+			// If you want the catch-all to also serve "/", add an explicit +page.svelte at the root.
+			if (!prefix && rest === "") return null;
+			return { [paramName]: rest };
+		}
+		return null;
+	}
+
+	// Dynamic segments: must have same segment count
+	if (!pattern.includes("[")) return null;
+
+	const patParts = pattern.split("/").filter(Boolean);
+	const pathParts = pathname.split("/").filter(Boolean);
+	if (patParts.length !== pathParts.length) return null;
+
+	const params: Record<string, string> = {};
+	for (let i = 0; i < patParts.length; i++) {
+		const pp = patParts[i]!;
+		const val = pathParts[i]!;
+		if (pp.startsWith("[") && pp.endsWith("]")) {
+			params[pp.slice(1, -1)] = val;
+		} else if (pp !== val) {
+			return null;
+		}
+	}
+	return params;
 }
 
 // ─── Route Matching ──────────────────────────────────────
@@ -139,22 +134,22 @@ function matchPattern(
  * Returns extracted params if matched, null otherwise.
  */
 function matchCompiled(
-    compiled: CompiledRoute,
-    pattern: string,
-    pathname: string,
+	compiled: CompiledRoute,
+	pattern: string,
+	pathname: string,
 ): Record<string, string> | null {
-    if (compiled.isExact) {
-        return pattern === pathname ? {} : null;
-    }
-
-    const m = compiled.regex.exec(pathname);
-    if (!m) return null;
-
-    const params: Record<string, string> = {};
-    for (let i = 0; i < compiled.paramNames.length; i++) {
-        params[compiled.paramNames[i]!] = m[i + 1]!;
-    }
-    return params;
+	if (compiled.isExact) {
+		return pattern === pathname ? {} : null;
+	}
+
+	const m = compiled.regex.exec(pathname);
+	if (!m) return null;
+
+	const params: Record<string, string> = {};
+	for (let i = 0; i < compiled.paramNames.length; i++) {
+		params[compiled.paramNames[i]!] = m[i + 1]!;
+	}
+	return params;
 }
 
 /**
@@ -163,21 +158,35 @@ function matchCompiled(
  * Single pass — first match wins.
  */
 export function findMatch<T extends { pattern: string }>(
-    routes: T[],
-    pathname: string,
+	routes: T[],
+	pathname: string,
 ): RouteMatch<T> | null {
-    // Strip trailing slash (but keep "/" as-is)
-    if (pathname.length > 1 && pathname.endsWith("/")) {
-        pathname = pathname.slice(0, -1);
-    }
-
-    for (const route of routes) {
-        const compiled = (route as any)._compiled as CompiledRoute | undefined;
-        const params = compiled
-            ? matchCompiled(compiled, route.pattern, pathname)
-            : matchPattern(route.pattern, pathname);
-        if (params !== null) return { route, params };
-    }
-
-    return null;
+	// Strip trailing slash (but keep "/" as-is)
+	if (pathname.length > 1 && pathname.endsWith("/")) {
+		pathname = pathname.slice(0, -1);
+	}
+
+	for (const route of routes) {
+		const compiled = (route as any)._compiled as CompiledRoute | undefined;
+		const params = compiled
+			? matchCompiled(compiled, route.pattern, pathname)
+			: matchPattern(route.pattern, pathname);
+		if (params !== null) return { route, params };
+	}
+
+	return null;
+}
+
+// ─── Trailing-Slash Canonicalization ──────────────────────
+// Returns the canonical pathname for a given mode, or null if pathname is
+// already canonical. Root "/" is never modified. Caller decides whether to
+// 308-redirect (server) or replaceState (client).
+
+export function canonicalPathname(pathname: string, mode: TrailingSlash): string | null {
+	if (mode === "ignore") return null;
+	if (pathname === "/") return null;
+	const endsWithSlash = pathname.endsWith("/");
+	if (mode === "never" && endsWithSlash) return pathname.slice(0, -1);
+	if (mode === "always" && !endsWithSlash) return pathname + "/";
+	return null;
 }

package/src/core/paths.ts

@@ -16,17 +16,15 @@ const isInstalledAsDep = parentDir.endsWith("node_modules");
 const HOISTED_NM = isInstalledAsDep ? parentDir : null;
 
 /** NODE_PATH value covering both nested and hoisted dependency locations */
-export const BOSIA_NODE_PATH = HOISTED_NM
-    ? [NESTED_NM, HOISTED_NM].join(":")
-    : NESTED_NM;
+export const BOSIA_NODE_PATH = HOISTED_NM ? [NESTED_NM, HOISTED_NM].join(":") : NESTED_NM;
 
 /** Find a binary from bosia's dependencies (handles hoisting) */
 export function resolveBosiaBin(name: string): string {
-    const nested = join(NESTED_NM, ".bin", name);
-    if (existsSync(nested)) return nested;
-    if (HOISTED_NM) {
-        const hoisted = join(HOISTED_NM, ".bin", name);
-        if (existsSync(hoisted)) return hoisted;
-    }
-    return nested; // fallback — will produce a clear ENOENT
+	const nested = join(NESTED_NM, ".bin", name);
+	if (existsSync(nested)) return nested;
+	if (HOISTED_NM) {
+		const hoisted = join(HOISTED_NM, ".bin", name);
+		if (existsSync(hoisted)) return hoisted;
+	}
+	return nested; // fallback — will produce a clear ENOENT
 }

package/src/core/plugin.ts

@@ -8,126 +8,132 @@ import { join, dirname } from "path";
 
 let cachedTsconfigPaths: Record<string, string[]> | null = null;
 async function getTsconfigPaths() {
-    if (cachedTsconfigPaths !== null) return cachedTsconfigPaths;
-    try {
-        const tsconfig = await Bun.file(join(process.cwd(), "tsconfig.json")).json();
-        cachedTsconfigPaths = tsconfig?.compilerOptions?.paths || {};
-    } catch {
-        cachedTsconfigPaths = {};
-    }
-    return cachedTsconfigPaths!;
+	if (cachedTsconfigPaths !== null) return cachedTsconfigPaths;
+	try {
+		const tsconfig = await Bun.file(join(process.cwd(), "tsconfig.json")).json();
+		cachedTsconfigPaths = tsconfig?.compilerOptions?.paths || {};
+	} catch {
+		cachedTsconfigPaths = {};
+	}
+	return cachedTsconfigPaths!;
 }
 
 export function makeBosiaPlugin(target: "browser" | "bun" = "bun") {
-    return {
-        name: "bosia-resolver",
-        setup(build: import("bun").PluginBuilder) {
-            // bosia:routes → .bosia/routes.client.ts (browser) or .bosia/routes.ts (server)
-            // Client-only file excludes serverRoutes/apiRoutes to prevent the browser
-            // bundler from following server-side dynamic imports into Node builtins.
-            build.onResolve({ filter: /^bosia:routes$/ }, () => ({
-                path: join(process.cwd(), ".bosia", target === "browser" ? "routes.client.ts" : "routes.ts"),
-            }));
+	return {
+		name: "bosia-resolver",
+		setup(build: import("bun").PluginBuilder) {
+			// bosia:routes → .bosia/routes.client.ts (browser) or .bosia/routes.ts (server)
+			// Client-only file excludes serverRoutes/apiRoutes to prevent the browser
+			// bundler from following server-side dynamic imports into Node builtins.
+			build.onResolve({ filter: /^bosia:routes$/ }, () => ({
+				path: join(
+					process.cwd(),
+					".bosia",
+					target === "browser" ? "routes.client.ts" : "routes.ts",
+				),
+			}));
 
-            // $env → .bosia/env.client.ts (browser) or .bosia/env.server.ts (bun)
-            build.onResolve({ filter: /^\$env$/ }, () => ({
-                path: join(
-                    process.cwd(),
-                    ".bosia",
-                    target === "browser" ? "env.client.ts" : "env.server.ts",
-                ),
-            }));
+			// $env → .bosia/env.client.ts (browser) or .bosia/env.server.ts (bun)
+			build.onResolve({ filter: /^\$env$/ }, () => ({
+				path: join(
+					process.cwd(),
+					".bosia",
+					target === "browser" ? "env.client.ts" : "env.server.ts",
+				),
+			}));
 
-            // Handle all $ aliases using tsconfig.json paths (e.g. $lib, $registry)
-            build.onResolve({ filter: /^\$/ }, async (args) => {
-                if (args.path === "$env") return undefined; // Handled above
+			// Handle all $ aliases using tsconfig.json paths (e.g. $lib, $registry)
+			build.onResolve({ filter: /^\$/ }, async (args) => {
+				if (args.path === "$env") return undefined; // Handled above
 
-                const paths = await getTsconfigPaths();
-                let longestMatch = "";
-                let targetPattern = "";
+				const paths = await getTsconfigPaths();
+				let longestMatch = "";
+				let targetPattern = "";
 
-                for (const [pattern, targets] of Object.entries(paths)) {
-                    const prefix = pattern.replace(/\*$/, "");
-                    if (args.path.startsWith(prefix) && prefix.length > longestMatch.length) {
-                        longestMatch = prefix;
-                        targetPattern = (targets as string[])[0];
-                    }
-                }
+				for (const [pattern, targets] of Object.entries(paths)) {
+					const prefix = pattern.replace(/\*$/, "");
+					if (args.path.startsWith(prefix) && prefix.length > longestMatch.length) {
+						longestMatch = prefix;
+						targetPattern = (targets as string[])[0];
+					}
+				}
 
-                if (longestMatch && targetPattern) {
-                    const suffix = args.path.slice(longestMatch.length);
-                    const targetDir = targetPattern.replace(/\*$/, "");
-                    const resolved = join(process.cwd(), targetDir, suffix);
-                    return { path: await resolveWithExts(resolved) };
-                }
+				if (longestMatch && targetPattern) {
+					const suffix = args.path.slice(longestMatch.length);
+					const targetDir = targetPattern.replace(/\*$/, "");
+					const resolved = join(process.cwd(), targetDir, suffix);
+					return { path: await resolveWithExts(resolved) };
+				}
 
-                // Fallback for $lib/* if not in tsconfig
-                if (args.path.startsWith("$lib/")) {
-                    const rel = args.path.slice(5);
-                    const base = join(process.cwd(), "src", "lib", rel);
-                    return { path: await resolveWithExts(base) };
-                }
+				// Fallback for $lib/* if not in tsconfig
+				if (args.path.startsWith("$lib/")) {
+					const rel = args.path.slice(5);
+					const base = join(process.cwd(), "src", "lib", rel);
+					return { path: await resolveWithExts(base) };
+				}
 
-                return undefined;
-            });
+				return undefined;
+			});
 
-            // Force svelte imports to resolve from the app's node_modules.
-            // Without this, when bosia is symlinked (bun link / workspace),
-            // hydrate.ts resolves "svelte" from the framework's location while
-            // compiled components resolve "svelte/internal/client" from the app's.
-            // Two different Svelte copies = duplicate runtime state = broken hydration.
-            //
-            // require.resolve uses the "default" export condition, which for
-            // bare "svelte" returns index-server.js. For browser builds we need
-            // index-client.js, so we read the "browser" condition from package.json.
-            const appDir = process.cwd();
-            let svelteBrowserEntry: string | null = null;
-            if (target === "browser") {
-                try {
-                    const svelteDir = dirname(require.resolve("svelte/package.json", { paths: [appDir] }));
-                    const pkg = require(join(svelteDir, "package.json"));
-                    const dotExport = pkg.exports?.["."];
-                    const browserPath = typeof dotExport === "object" ? dotExport.browser : null;
-                    if (browserPath) {
-                        svelteBrowserEntry = join(svelteDir, browserPath);
-                    }
-                } catch { }
-            }
-            build.onResolve({ filter: /^svelte(\/.*)?$/ }, (args) => {
-                try {
-                    // Bare "svelte" in browser build: use the "browser" export condition
-                    if (args.path === "svelte" && svelteBrowserEntry) {
-                        return { path: svelteBrowserEntry };
-                    }
-                    return { path: require.resolve(args.path, { paths: [appDir] }) };
-                } catch {
-                    return undefined; // fall through to default resolution
-                }
-            });
+			// Force svelte imports to resolve from the app's node_modules.
+			// Without this, when bosia is symlinked (bun link / workspace),
+			// hydrate.ts resolves "svelte" from the framework's location while
+			// compiled components resolve "svelte/internal/client" from the app's.
+			// Two different Svelte copies = duplicate runtime state = broken hydration.
+			//
+			// require.resolve uses the "default" export condition, which for
+			// bare "svelte" returns index-server.js. For browser builds we need
+			// index-client.js, so we read the "browser" condition from package.json.
+			const appDir = process.cwd();
+			let svelteBrowserEntry: string | null = null;
+			if (target === "browser") {
+				try {
+					const svelteDir = dirname(
+						require.resolve("svelte/package.json", { paths: [appDir] }),
+					);
+					const pkg = require(join(svelteDir, "package.json"));
+					const dotExport = pkg.exports?.["."];
+					const browserPath = typeof dotExport === "object" ? dotExport.browser : null;
+					if (browserPath) {
+						svelteBrowserEntry = join(svelteDir, browserPath);
+					}
+				} catch {}
+			}
+			build.onResolve({ filter: /^svelte(\/.*)?$/ }, (args) => {
+				try {
+					// Bare "svelte" in browser build: use the "browser" export condition
+					if (args.path === "svelte" && svelteBrowserEntry) {
+						return { path: svelteBrowserEntry };
+					}
+					return { path: require.resolve(args.path, { paths: [appDir] }) };
+				} catch {
+					return undefined; // fall through to default resolution
+				}
+			});
 
-            // "tailwindcss" inside app.css is a Tailwind CLI directive —
-            // it's already compiled to public/bosia-tw.css by the CLI step.
-            // Return an empty CSS module so Bun's CSS bundler doesn't choke on it.
-            build.onResolve({ filter: /^tailwindcss$/ }, () => ({
-                path: "tailwindcss",
-                namespace: "bosia-empty-css",
-            }));
-            build.onLoad({ filter: /.*/, namespace: "bosia-empty-css" }, () => ({
-                contents: "",
-                loader: "css",
-            }));
-        },
-    };
+			// "tailwindcss" inside app.css is a Tailwind CLI directive —
+			// it's already compiled to public/bosia-tw.css by the CLI step.
+			// Return an empty CSS module so Bun's CSS bundler doesn't choke on it.
+			build.onResolve({ filter: /^tailwindcss$/ }, () => ({
+				path: "tailwindcss",
+				namespace: "bosia-empty-css",
+			}));
+			build.onLoad({ filter: /.*/, namespace: "bosia-empty-css" }, () => ({
+				contents: "",
+				loader: "css",
+			}));
+		},
+	};
 }
 
 async function resolveWithExts(base: string): Promise<string> {
-    if (await Bun.file(base).exists()) return base;
-    for (const ext of [".ts", ".svelte", ".js"]) {
-        if (await Bun.file(base + ext).exists()) return base + ext;
-    }
-    for (const idx of ["index.ts", "index.svelte", "index.js"]) {
-        const p = join(base, idx);
-        if (await Bun.file(p).exists()) return p;
-    }
-    return base;
+	if (await Bun.file(base).exists()) return base;
+	for (const ext of [".ts", ".svelte", ".js"]) {
+		if (await Bun.file(base + ext).exists()) return base + ext;
+	}
+	for (const idx of ["index.ts", "index.svelte", "index.js"]) {
+		const p = join(base, idx);
+		if (await Bun.file(p).exists()) return p;
+	}
+	return base;
 }