@rangojs/router 0.0.0-experimental.2 → 0.0.0-experimental.20dbba0c

package/src/vite/utils/manifest-utils.ts

@@ -0,0 +1,70 @@
+/**
+ * Flatten prefix tree leaf nodes into precomputed route entries.
+ * Leaf nodes have no children (no nested includes), so their routes can be
+ * used directly by evaluateLazyEntry() without running the handler.
+ * Non-leaf nodes are skipped because they have nested lazy includes that
+ * require the handler to run for discovery.
+ */
+export function flattenLeafEntries(
+  prefixTree: Record<string, any>,
+  routeManifest: Record<string, string>,
+  result: Array<{ staticPrefix: string; routes: Record<string, string> }>,
+): void {
+  function visit(node: any): void {
+    const children = node.children || {};
+    if (
+      Object.keys(children).length === 0 &&
+      node.routes &&
+      node.routes.length > 0
+    ) {
+      // Leaf node: collect its routes from the manifest
+      const routes: Record<string, string> = {};
+      for (const name of node.routes) {
+        if (name in routeManifest) {
+          routes[name] = routeManifest[name];
+        }
+      }
+      result.push({ staticPrefix: node.staticPrefix, routes });
+    } else {
+      // Non-leaf: recurse into children
+      for (const child of Object.values(children)) {
+        visit(child);
+      }
+    }
+  }
+  for (const node of Object.values(prefixTree)) {
+    visit(node);
+  }
+}
+
+/**
+ * Walk prefix tree to map each route name to its scope's staticPrefix.
+ */
+export function buildRouteToStaticPrefix(
+  prefixTree: Record<string, any>,
+  result: Record<string, string>,
+): void {
+  function visit(node: any): void {
+    const sp = node.staticPrefix || "";
+    for (const name of node.routes || []) {
+      result[name] = sp;
+    }
+    for (const child of Object.values(node.children || {})) {
+      visit(child);
+    }
+  }
+  for (const node of Object.values(prefixTree)) {
+    visit(node);
+  }
+}
+
+/**
+ * Wrap a value as `JSON.parse('...')` instead of a JS object literal.
+ * V8's JSON parser is significantly faster than its full JS parser for large
+ * objects, so this improves startup time for big route manifests.
+ */
+export function jsonParseExpression(value: unknown): string {
+  const json = JSON.stringify(value);
+  const escaped = json.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+  return `JSON.parse('${escaped}')`;
+}

package/src/vite/{package-resolution.ts → utils/package-resolution.ts}

@@ -6,8 +6,11 @@
  */
 
 import { existsSync } from "node:fs";
+import { createRequire } from "node:module";
 import { resolve } from "node:path";
-import packageJson from "../../package.json" with { type: "json" };
+import packageJson from "../../../package.json";
+
+const require = createRequire(import.meta.url);
 
 /**
  * The canonical name used in virtual entries (without scope)
@@ -46,21 +49,26 @@ export function isWorkspaceDevelopment(): boolean {
 }
 
 /**
- * Subpaths that need to be excluded from Vite's dependency optimization
- * and potentially aliased
+ * Subpaths derived from package.json exports that use TypeScript source.
+ * These must be excluded from Vite's dependency optimization (they ship
+ * as .ts/.tsx, not compiled JS) and aliased when installed from npm.
+ *
+ * Derived automatically from the exports field to prevent drift.
  */
-const PACKAGE_SUBPATHS = [
-  "",
-  "/browser",
-  "/client",
-  "/server",
-  "/rsc",
-  "/ssr",
-  "/internal/deps/browser",
-  "/internal/deps/html-stream-client",
-  "/internal/deps/ssr",
-  "/internal/deps/rsc",
-] as const;
+const SOURCE_EXPORT_SUBPATHS = Object.keys(packageJson.exports)
+  .filter((key) => {
+    const entry = (
+      packageJson.exports as Record<string, Record<string, string>>
+    )[key];
+    // Include if any non-types condition points to TypeScript source
+    return Object.entries(entry).some(
+      ([condition, path]) =>
+        condition !== "types" &&
+        typeof path === "string" &&
+        /\.tsx?$/.test(path),
+    );
+  })
+  .map((key) => key.replace(/^\./, ""));
 
 /**
  * Generate the list of modules to exclude from Vite's dependency optimization.
@@ -72,7 +80,7 @@ export function getExcludeDeps(): string[] {
   const packageName = getPublishedPackageName();
   const excludes: string[] = [];
 
-  for (const subpath of PACKAGE_SUBPATHS) {
+  for (const subpath of SOURCE_EXPORT_SUBPATHS) {
     // Add scoped package paths
     excludes.push(`${packageName}${subpath}`);
     // Add virtual/aliased paths (before alias resolution)
@@ -85,20 +93,11 @@ export function getExcludeDeps(): string[] {
 }
 
 /**
- * Subpaths that need aliasing (subset of PACKAGE_SUBPATHS)
+ * Subpaths that need aliasing — same as SOURCE_EXPORT_SUBPATHS.
+ * When installed from npm, virtual entries may use a different package name
+ * than the published one; aliases bridge them.
  */
-const ALIAS_SUBPATHS = [
-  "/internal/deps/browser",
-  "/internal/deps/ssr",
-  "/internal/deps/rsc",
-  "/internal/deps/html-stream-client",
-  "/internal/deps/html-stream-server",
-  "/browser",
-  "/client",
-  "/server",
-  "/rsc",
-  "/ssr",
-] as const;
+const ALIAS_SUBPATHS = SOURCE_EXPORT_SUBPATHS;
 
 /**
  * Generate aliases to map virtual package paths to the actual published package.
@@ -123,3 +122,33 @@ export function getPackageAliases(): Record<string, string> {
 
   return aliases;
 }
+
+/**
+ * Plugin-rsc pushes bare specs like
+ * `@vitejs/plugin-rsc/vendor/react-server-dom/client.edge` into
+ * `optimizeDeps.include` for the ssr and rsc environments. In strict pnpm
+ * consumer apps, `@vitejs/plugin-rsc` is only reachable from @rangojs/router's
+ * node_modules, so Vite's optimizer — which resolves from the project root —
+ * can't find them and emits "Failed to resolve dependency" warnings.
+ *
+ * We resolve those specs from this plugin's location (where plugin-rsc is
+ * guaranteed to be installed as our dep) and expose them as `resolve.alias`
+ * entries. The optimizer's resolver honors aliases, so the bare specs map to
+ * absolute paths and resolve cleanly.
+ */
+export function getVendorAliases(): Record<string, string> {
+  const specs = [
+    "@vitejs/plugin-rsc/vendor/react-server-dom/client.edge",
+    "@vitejs/plugin-rsc/vendor/react-server-dom/server.edge",
+    "@vitejs/plugin-rsc/vendor/react-server-dom/client.browser",
+  ];
+  const aliases: Record<string, string> = {};
+  for (const spec of specs) {
+    try {
+      aliases[spec] = require.resolve(spec);
+    } catch {
+      // Spec unresolvable (unexpected but non-fatal — Vite will warn as before).
+    }
+  }
+  return aliases;
+}

package/src/vite/utils/prerender-utils.ts

@@ -0,0 +1,221 @@
+import { createHash } from "node:crypto";
+import {
+  copyFileSync,
+  existsSync,
+  mkdirSync,
+  rmSync,
+  statSync,
+  writeFileSync,
+} from "node:fs";
+import { resolve } from "node:path";
+
+/**
+ * Escape special RegExp characters in a string for safe interpolation
+ * into new RegExp() patterns.
+ */
+export function escapeRegExp(str: string): string {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+/**
+ * Encode route param values for path interpolation while preserving path
+ * separators for wildcard params (splat-style values can include `/`).
+ */
+export function encodePathParam(value: unknown): string {
+  return String(value)
+    .split("/")
+    .map((segment) => encodeURIComponent(segment))
+    .join("/");
+}
+
+/**
+ * Substitute route params into a pattern, stripping constraint and optional
+ * syntax (:param(a|b)? -> value). Also handles wildcard params (*key).
+ * Optional params not present in `params` are removed from the output.
+ */
+export function substituteRouteParams(
+  pattern: string,
+  params: Record<string, string>,
+  encode: (value: string) => string = encodeURIComponent,
+): string {
+  let result = pattern;
+  let hadOmittedOptional = false;
+
+  // First pass: substitute provided params.
+  // Empty string on an optional placeholder is treated as omitted (the trie
+  // matcher fills unmatched optionals with "" — letting the second pass
+  // strip them keeps slash cleanup consistent). Empty string on required
+  // `:key` or wildcard `*key` still substitutes, matching prior behaviour.
+  for (const [key, value] of Object.entries(params)) {
+    const escaped = escapeRegExp(key);
+    if (value === "") {
+      // Only replace required placeholders (negative lookahead for `?`);
+      // leave `:key?` for the second pass.
+      result = result.replace(
+        new RegExp(`:${escaped}(\\([^)]*\\))?(?!\\?)`),
+        "",
+      );
+      result = result.replace(`*${key}`, "");
+    } else {
+      result = result.replace(
+        new RegExp(`:${escaped}(\\([^)]*\\))?\\??`),
+        encode(value),
+      );
+      result = result.replace(`*${key}`, encode(value));
+    }
+  }
+
+  // Second pass: strip remaining optional param placeholders not in params
+  result = result.replace(/:([a-zA-Z_][a-zA-Z0-9_]*)(\([^)]*\))?\?/g, () => {
+    hadOmittedOptional = true;
+    return "";
+  });
+
+  // Clean up slashes from omitted optional segments
+  if (hadOmittedOptional) {
+    const hadTrailingSlash = pattern.length > 1 && pattern.endsWith("/");
+    result = result.replace(/\/\/+/g, "/").replace(/\/+$/, "") || "/";
+    if (hadTrailingSlash && !result.endsWith("/")) result += "/";
+  }
+
+  return result;
+}
+
+/**
+ * Run an async function over items with bounded concurrency.
+ * Errors propagate immediately and abort remaining work.
+ */
+export async function runWithConcurrency<T>(
+  items: T[],
+  concurrency: number,
+  fn: (item: T) => Promise<void>,
+): Promise<void> {
+  const limit = Math.max(1, Math.min(concurrency, items.length));
+  if (limit <= 1) {
+    for (const item of items) await fn(item);
+    return;
+  }
+  let nextIndex = 0;
+  async function worker() {
+    while (nextIndex < items.length) {
+      const idx = nextIndex++;
+      await fn(items[idx]);
+    }
+  }
+  await Promise.all(Array.from({ length: limit }, () => worker()));
+}
+
+/**
+ * Group prerender entries by their concurrency setting so each group
+ * can be rendered with the appropriate parallelism.
+ */
+export function groupByConcurrency<T extends { concurrency: number }>(
+  entries: T[],
+): { concurrency: number; entries: T[] }[] {
+  const map = new Map<number, T[]>();
+  for (const entry of entries) {
+    const key = entry.concurrency;
+    let group = map.get(key);
+    if (!group) {
+      group = [];
+      map.set(key, group);
+    }
+    group.push(entry);
+  }
+  return Array.from(map.entries(), ([concurrency, items]) => ({
+    concurrency,
+    entries: items,
+  }));
+}
+
+/**
+ * Notify all routers' onError callbacks about a build-time error.
+ * Uses a synthetic request since there is no real request during build.
+ */
+export function notifyOnError(
+  registry: Map<string, any>,
+  error: unknown,
+  phase: "prerender" | "static",
+  routeKey?: string,
+  pathname?: string,
+  skipped?: boolean,
+): void {
+  for (const [, routerInstance] of registry) {
+    const onError = routerInstance.onError;
+    if (!onError) continue;
+
+    const errorObj = error instanceof Error ? error : new Error(String(error));
+    const syntheticUrl = new URL("http://prerender" + (pathname || "/"));
+    const context = {
+      error: errorObj,
+      phase,
+      request: new Request(syntheticUrl),
+      url: syntheticUrl,
+      pathname: syntheticUrl.pathname,
+      method: "GET",
+      routeKey,
+      metadata: skipped ? { skipped: true } : undefined,
+    };
+
+    try {
+      const result = onError(context);
+      if (result instanceof Promise) {
+        result.catch((cbErr: unknown) => {
+          console.error(`[Build.onError] Callback error:`, cbErr);
+        });
+      }
+    } catch (cbErr) {
+      console.error(`[Build.onError] Callback error:`, cbErr);
+    }
+    break; // Only notify the first router with onError
+  }
+}
+
+function getStagedAssetDir(projectRoot: string): string {
+  return resolve(projectRoot, "node_modules/.rangojs-router-build/rsc-assets");
+}
+
+export function resetStagedBuildAssets(projectRoot: string): void {
+  rmSync(getStagedAssetDir(projectRoot), { recursive: true, force: true });
+}
+
+export function stageBuildAssetModule(
+  projectRoot: string,
+  prefix: "__pr" | "__st",
+  exportValue: string,
+): string {
+  const stagedDir = getStagedAssetDir(projectRoot);
+  mkdirSync(stagedDir, { recursive: true });
+
+  const contentHash = createHash("sha256")
+    .update(exportValue)
+    .digest("hex")
+    .slice(0, 8);
+  const fileName = `${prefix}-${contentHash}.js`;
+  const filePath = resolve(stagedDir, fileName);
+
+  if (!existsSync(filePath)) {
+    writeFileSync(filePath, `export default ${exportValue};\n`);
+  }
+
+  return fileName;
+}
+
+export function copyStagedBuildAssets(
+  projectRoot: string,
+  fileNames: Iterable<string>,
+): number {
+  const stagedDir = getStagedAssetDir(projectRoot);
+  const distAssetsDir = resolve(projectRoot, "dist/rsc/assets");
+  mkdirSync(distAssetsDir, { recursive: true });
+
+  let totalBytes = 0;
+  for (const fileName of new Set(fileNames)) {
+    const stagedPath = resolve(stagedDir, fileName);
+    const distPath = resolve(distAssetsDir, fileName);
+    copyFileSync(stagedPath, distPath);
+    totalBytes += statSync(stagedPath).size;
+  }
+
+  return totalBytes;
+}

package/src/vite/utils/shared-utils.ts

@@ -0,0 +1,170 @@
+import type { Plugin } from "vite";
+import * as Vite from "vite";
+import { getPublishedPackageName } from "./package-resolution.js";
+import { performanceTracksOptimizeDepsPlugin } from "../plugins/performance-tracks.js";
+import {
+  VIRTUAL_ENTRY_BROWSER,
+  VIRTUAL_ENTRY_SSR,
+  getVirtualEntryRSC,
+  VIRTUAL_IDS,
+} from "../plugins/virtual-entries.js";
+
+/**
+ * esbuild plugin to provide rsc-router:version virtual module during optimization.
+ * This is needed because esbuild runs during Vite's dependency optimization phase,
+ * before Vite's plugin system can handle virtual modules.
+ */
+const versionEsbuildPlugin = {
+  name: "@rangojs/router-version",
+  setup(build: any): void {
+    build.onResolve({ filter: /^rsc-router:version$/ }, (args: any) => ({
+      path: args.path,
+      namespace: "@rangojs/router-virtual",
+    }));
+    build.onLoad(
+      { filter: /.*/, namespace: "@rangojs/router-virtual" },
+      () => ({
+        contents: `export const VERSION = "dev";`,
+        loader: "js",
+      }),
+    );
+  },
+};
+
+/**
+ * Shared esbuild options for dependency optimization.
+ * Includes the version stub plugin for all environments.
+ */
+export const sharedEsbuildOptions: {
+  plugins: any[];
+} = {
+  plugins: [versionEsbuildPlugin, performanceTracksOptimizeDepsPlugin()],
+};
+
+/**
+ * Create a virtual modules plugin for default entry files.
+ * Provides virtual module content when entries use VIRTUAL_IDS (no custom entry configured).
+ */
+export function createVirtualEntriesPlugin(
+  entries: { client: string; ssr: string; rsc?: string },
+  routerPathRef?: { path?: string },
+): Plugin {
+  // Build virtual modules map based on which entries use virtual IDs
+  const virtualModules: Record<string, string> = {};
+
+  if (entries.client === VIRTUAL_IDS.browser) {
+    virtualModules[VIRTUAL_IDS.browser] = VIRTUAL_ENTRY_BROWSER;
+  }
+  if (entries.ssr === VIRTUAL_IDS.ssr) {
+    virtualModules[VIRTUAL_IDS.ssr] = VIRTUAL_ENTRY_SSR;
+  }
+
+  // RSC entry is resolved lazily in load() because routerPath may be
+  // set after plugin creation (e.g. by the auto-discover config() hook).
+  // Track all known virtual IDs for resolveId (content is separate).
+  const knownIds = new Set(Object.keys(virtualModules));
+  if (entries.rsc === VIRTUAL_IDS.rsc) {
+    knownIds.add(VIRTUAL_IDS.rsc);
+  }
+
+  return {
+    name: "@rangojs/router:virtual-entries",
+    enforce: "pre",
+
+    resolveId(id) {
+      if (knownIds.has(id)) {
+        return "\0" + id;
+      }
+      // Handle if the id already has the null prefix (RSC plugin wrapper imports)
+      if (id.startsWith("\0") && knownIds.has(id.slice(1))) {
+        return id;
+      }
+      return null;
+    },
+
+    load(id) {
+      if (id.startsWith("\0virtual:rsc-router/")) {
+        const virtualId = id.slice(1);
+        if (virtualId in virtualModules) {
+          return virtualModules[virtualId];
+        }
+        // Lazy RSC entry: routerPath may have been set by a config() hook
+        if (virtualId === VIRTUAL_IDS.rsc && routerPathRef?.path) {
+          const raw = routerPathRef.path.startsWith(".")
+            ? "/" + routerPathRef.path.slice(2) // ./src/router.tsx -> /src/router.tsx
+            : routerPathRef.path;
+          // Normalize backslashes for Windows (path.join/slice preserve native separators)
+          const absoluteRouterPath = raw.replaceAll("\\", "/");
+          return getVirtualEntryRSC(absoluteRouterPath);
+        }
+      }
+      return null;
+    },
+  };
+}
+
+/**
+ * Rollup onwarn handler that suppresses known harmless warnings:
+ * - "use client" directives: handled by the RSC plugin, not relevant to Rollup
+ * - sourcemap errors: caused by "use client" directive at line 1:0 confusing sourcemap resolution
+ * - sourcemap incomplete: plugins that transform without generating sourcemaps (router + RSC plugin)
+ * - dynamic/static mixed imports: expected for router internals (e.g. request-context, cache-scope)
+ * - empty bundle: @vitejs/plugin-rsc scan build (step 1/5) produces an empty "index" chunk
+ *   because the RSC entry is fully externalized during client-reference analysis
+ */
+export function onwarn(
+  warning: Vite.Rollup.RollupLog,
+  defaultHandler: (warning: Vite.Rollup.RollupLog) => void,
+): void {
+  if (
+    warning.code === "MODULE_LEVEL_DIRECTIVE" ||
+    warning.code === "SOURCEMAP_ERROR" ||
+    warning.code === "EMPTY_BUNDLE"
+  ) {
+    return;
+  }
+  // @vitejs/plugin-rsc@0.5.14: rsc:virtual:vite-rsc/assets-manifest renderChunk
+  // returns { code } without map, causing Rollup to warn about incorrect sourcemaps.
+  // This is harmless (simple string replacement). Remove this suppression if a
+  // future version of @vitejs/plugin-rsc fixes the missing sourcemap.
+  if (warning.message?.includes("Sourcemap is likely to be incorrect")) {
+    return;
+  }
+  if (
+    warning.plugin === "vite:reporter" &&
+    warning.message?.includes(
+      "dynamic import will not move module into another chunk",
+    )
+  ) {
+    return;
+  }
+  defaultHandler(warning);
+}
+
+/**
+ * Manual chunks configuration for client build.
+ * Splits React and router packages into separate chunks for better caching.
+ */
+export function getManualChunks(id: string): string | undefined {
+  const normalized = Vite.normalizePath(id);
+
+  if (
+    normalized.includes("node_modules/react/") ||
+    normalized.includes("node_modules/react-dom/") ||
+    normalized.includes("node_modules/react-server-dom-webpack/") ||
+    normalized.includes("node_modules/@vitejs/plugin-rsc/")
+  ) {
+    return "react";
+  }
+  // Use dynamic package name from package.json
+  // Check both npm install path and workspace symlink resolved path
+  const packageName = getPublishedPackageName();
+  if (
+    normalized.includes(`node_modules/${packageName}/`) ||
+    normalized.includes("packages/rsc-router/") ||
+    normalized.includes("packages/rangojs-router/")
+  ) {
+    return "router";
+  }
+  return undefined;
+}

package/CLAUDE.md

@@ -1,7 +0,0 @@
-# @rangojs/router
-
-Django-inspired RSC router with composable URL patterns. Read skills in `node_modules/@rangojs/router/skills/` for patterns:
-
-router-setup, route, layout, loader, middleware, intercept, caching, document-cache, theme, hooks, typesafety, parallel
-
-Read the relevant skill before implementing features.

package/src/__tests__/component-utils.test.ts

@@ -1,76 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { isClientComponent, assertClientComponent } from "../component-utils";
-
-describe("component-utils", () => {
-  describe("isClientComponent", () => {
-    it("should return false for regular functions", () => {
-      const ServerComponent = () => null;
-      expect(isClientComponent(ServerComponent)).toBe(false);
-    });
-
-    it("should return false for non-functions", () => {
-      expect(isClientComponent(null)).toBe(false);
-      expect(isClientComponent(undefined)).toBe(false);
-      expect(isClientComponent("string")).toBe(false);
-      expect(isClientComponent(123)).toBe(false);
-      expect(isClientComponent({})).toBe(false);
-    });
-
-    it("should return true for functions with client reference marker", () => {
-      const ClientComponent = () => null;
-      // Simulate what the bundler does for "use client" components
-      (ClientComponent as any).$$typeof = Symbol.for("react.client.reference");
-      (ClientComponent as any).$$id = "src/components/MyComponent.tsx#default";
-
-      expect(isClientComponent(ClientComponent)).toBe(true);
-    });
-
-    it("should return false for functions with wrong $$typeof symbol", () => {
-      const Component = () => null;
-      (Component as any).$$typeof = Symbol.for("react.element");
-
-      expect(isClientComponent(Component)).toBe(false);
-    });
-  });
-
-  describe("assertClientComponent", () => {
-    it("should throw for non-function values", () => {
-      expect(() => assertClientComponent(null, "document")).toThrow(
-        'document must be a client component function with "use client" directive'
-      );
-
-      expect(() => assertClientComponent({}, "document")).toThrow(
-        'document must be a client component function with "use client" directive'
-      );
-    });
-
-    it("should throw for server components (no client marker)", () => {
-      const ServerComponent = () => null;
-
-      expect(() => assertClientComponent(ServerComponent, "document")).toThrow(
-        'document must be a client component with "use client" directive'
-      );
-      expect(() => assertClientComponent(ServerComponent, "document")).toThrow(
-        "cannot be serialized in the RSC payload"
-      );
-    });
-
-    it("should not throw for client components", () => {
-      const ClientComponent = () => null;
-      (ClientComponent as any).$$typeof = Symbol.for("react.client.reference");
-      (ClientComponent as any).$$id = "src/document.tsx#default";
-
-      expect(() =>
-        assertClientComponent(ClientComponent, "document")
-      ).not.toThrow();
-    });
-
-    it("should include component name in error message", () => {
-      const ServerComponent = () => null;
-
-      expect(() => assertClientComponent(ServerComponent, "myLayout")).toThrow(
-        "myLayout must be a client component"
-      );
-    });
-  });
-});