@rangojs/router 0.0.0-experimental.f3c21dba → 0.0.0-experimental.f4a8e8de

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

@@ -1,62 +1,4 @@
-/**
- * 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);
-  }
-}
+export { flattenLeafEntries } from "../../build/prefix-tree-utils.js";
 
 /**
  * Wrap a value as `JSON.parse('...')` instead of a JS object literal.

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

@@ -1,57 +1,29 @@
-/**
- * Package Resolution Utilities
- *
- * Handles detection of workspace vs npm install context and generates
- * appropriate aliases and exclude lists for Vite configuration.
- */
-
 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)
  */
 const VIRTUAL_PACKAGE_NAME = "@rangojs/router";
 
-/**
- * Get the published package name (e.g., "@rangojs/router")
- */
 export function getPublishedPackageName(): string {
   return packageJson.name;
 }
 
-/**
- * Check if the package is installed from npm (scoped) vs workspace (unscoped)
- *
- * In workspace development:
- * - Package is installed as "@rangojs/router" via pnpm workspace alias
- * - The scoped name (@rangojs/router) doesn't exist in node_modules
- *
- * When installed from npm:
- * - Package is installed as "@rangojs/router"
- * - We need aliases to map "@rangojs/router/*" to "@rangojs/router/*"
- */
 export function isInstalledFromNpm(): boolean {
   const packageName = getPublishedPackageName();
   // Check if the scoped package exists in node_modules
   return existsSync(resolve(process.cwd(), "node_modules", packageName));
 }
 
-/**
- * Check if we're in a monorepo/workspace development context
- */
 export function isWorkspaceDevelopment(): boolean {
   return !isInstalledFromNpm();
 }
 
-/**
- * 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 SOURCE_EXPORT_SUBPATHS = Object.keys(packageJson.exports)
   .filter((key) => {
     const entry = (
@@ -67,12 +39,6 @@ const SOURCE_EXPORT_SUBPATHS = Object.keys(packageJson.exports)
   })
   .map((key) => key.replace(/^\./, ""));
 
-/**
- * Generate the list of modules to exclude from Vite's dependency optimization.
- *
- * We include both the published name and the virtual name because
- * Vite's optimizer runs before alias resolution.
- */
 export function getExcludeDeps(): string[] {
   const packageName = getPublishedPackageName();
   const excludes: string[] = [];
@@ -89,24 +55,10 @@ export function getExcludeDeps(): string[] {
   return excludes;
 }
 
-/**
- * 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 = SOURCE_EXPORT_SUBPATHS;
 
-/**
- * Generate aliases to map virtual package paths to the actual published package.
- *
- * Only needed when installed from npm, where the package is under @rangojs/router
- * but virtual entries import from rsc-router/*.
- *
- * Returns empty object in workspace development where rsc-router resolves directly.
- */
 export function getPackageAliases(): Record<string, string> {
   if (isWorkspaceDevelopment()) {
-    // No aliases needed - rsc-router resolves directly
     return {};
   }
 
@@ -119,3 +71,20 @@ export function getPackageAliases(): Record<string, string> {
 
   return aliases;
 }
+
+export function getVendorAliases(): Record<string, string> {
+  const specs = [
+    "@vitejs/plugin-rsc/vendor/react-server-dom/client.browser",
+    "@vitejs/plugin-rsc/vendor/react-server-dom/client.edge",
+    "@vitejs/plugin-rsc/vendor/react-server-dom/server.edge",
+  ];
+  const aliases: Record<string, string> = {};
+  for (const spec of specs) {
+    try {
+      aliases[spec] = require.resolve(spec);
+    } catch {
+      // Non-fatal; Vite will warn if it cannot resolve the spec
+    }
+  }
+  return aliases;
+}

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

@@ -9,50 +9,67 @@ import {
 } 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, "\\$&");
-}
+import { escapeRegExp } from "../../regex-escape.js";
+import { encodePathRemainder } from "../../router/url-params.js";
 
-/**
- * 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("/");
+  return encodePathRemainder(String(value), encodeURIComponent);
 }
 
-/**
- * Substitute route params into a pattern, stripping constraint and optional
- * syntax (:param(a|b)? -> value). Also handles wildcard params (*key).
- */
 export function substituteRouteParams(
   pattern: string,
   params: Record<string, string>,
   encode: (value: string) => string = encodeURIComponent,
 ): string {
   let result = pattern;
+  let hadOmittedOptional = false;
+
   for (const [key, value] of Object.entries(params)) {
     const escaped = escapeRegExp(key);
-    result = result.replace(
-      new RegExp(`:${escaped}(\\([^)]*\\))?\\??`),
-      encode(value),
-    );
-    result = result.replace(`*${key}`, encode(value));
+    // Named catch-all `:key+` / `:key*` (issue #634). Like the runtime reverse,
+    // the value is multi-segment: encode each segment and keep the `/` separators
+    // (a whole-value encode would turn `a/b` into `a%2Fb`), and consume the
+    // trailing modifier so it does not leak into the URL. `*` (zero-or-more)
+    // absent collapses via the trailing cleanup below.
+    const catchAllRe = new RegExp(`:${escaped}[+*]`);
+    if (catchAllRe.test(result)) {
+      if (value === "") {
+        result = result.replace(catchAllRe, "");
+        hadOmittedOptional = true;
+      } else {
+        result = result.replace(catchAllRe, encodePathRemainder(value, encode));
+      }
+      continue;
+    }
+    if (value === "") {
+      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));
+    }
+  }
+
+  result = result.replace(/:([a-zA-Z_][a-zA-Z0-9_]*)(\([^)]*\))?\?/g, () => {
+    hadOmittedOptional = true;
+    return "";
+  });
+
+  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,
@@ -64,19 +81,30 @@ export async function runWithConcurrency<T>(
     return;
   }
   let nextIndex = 0;
+  // On first failure (the default prerender.onError: "fail" re-throws), stop
+  // scheduling new work so the remaining workers don't keep running full RSC
+  // renders before the build aborts. The first error is surfaced after all
+  // in-flight workers settle, preserving the throw-to-fail-build behavior.
+  let firstError: unknown;
+  let failed = false;
   async function worker() {
-    while (nextIndex < items.length) {
+    while (nextIndex < items.length && !failed) {
       const idx = nextIndex++;
-      await fn(items[idx]);
+      try {
+        await fn(items[idx]);
+      } catch (err) {
+        if (!failed) {
+          failed = true;
+          firstError = err;
+        }
+        return;
+      }
     }
   }
   await Promise.all(Array.from({ length: limit }, () => worker()));
+  if (failed) throw firstError;
 }
 
-/**
- * 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[] }[] {
@@ -96,10 +124,6 @@ export function groupByConcurrency<T extends { concurrency: number }>(
   }));
 }
 
-/**
- * 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,
@@ -139,6 +163,42 @@ export function notifyOnError(
   }
 }
 
+/**
+ * Resolve a thrown build-time render error into the prerender build's policy and
+ * log a per-entry line. A `Skip` (or any render error under `prerender.onError:
+ * "warn"`) logs and returns so the caller skips the entry; a render error under
+ * the default "fail" logs FAIL, notifies `onError`, and re-throws to fail the
+ * build. Shared by `expandPrerenderRoutes` (prerender) and `renderStaticHandlers`
+ * (static) so the Skip/warn/fail policy lives in one place. `label` is the padded
+ * URL / handler name for the log line; `elapsed` is the per-entry duration string.
+ */
+export function resolvePrerenderError(
+  registry: Map<string, any>,
+  error: any,
+  onError: "fail" | "warn",
+  label: string,
+  elapsed: string,
+  phase: "prerender" | "static",
+  routeKey?: string,
+  pathname?: string,
+): void {
+  const isSkip = error?.name === "Skip";
+  if (isSkip || onError === "warn") {
+    if (isSkip) {
+      console.log(`[rango]   SKIP ${label} (${elapsed}ms) - ${error.message}`);
+    } else {
+      console.warn(
+        `[rango]   WARN ${label} (${elapsed}ms) - render error, not pre-rendered (prerender.onError: "warn"): ${error.message}`,
+      );
+    }
+    notifyOnError(registry, error, phase, routeKey, pathname, true);
+    return;
+  }
+  console.error(`[rango]   FAIL ${label} (${elapsed}ms) - ${error.message}`);
+  notifyOnError(registry, error, phase, routeKey, pathname);
+  throw error;
+}
+
 function getStagedAssetDir(projectRoot: string): string {
   return resolve(projectRoot, "node_modules/.rangojs-router-build/rsc-assets");
 }
@@ -147,20 +207,27 @@ export function resetStagedBuildAssets(projectRoot: string): void {
   rmSync(getStagedAssetDir(projectRoot), { recursive: true, force: true });
 }
 
-export function stageBuildAssetModule(
-  projectRoot: string,
-  prefix: "__pr" | "__st",
+/**
+ * Write one content-hashed `export default <value>;` asset module into `dir`
+ * (created if needed) and return its file name. Identical payloads dedupe to
+ * one file (the hash is the content). Shared by the staged prerender/static
+ * flow (stageBuildAssetModule below) and the shell prerender phase, which
+ * writes directly into the final RSC assets dir — it runs after buildApp,
+ * past the staging/copy window.
+ */
+export function writeBuildAssetModule(
+  dir: string,
+  prefix: "__pr" | "__st" | "__ps",
   exportValue: string,
 ): string {
-  const stagedDir = getStagedAssetDir(projectRoot);
-  mkdirSync(stagedDir, { recursive: true });
+  mkdirSync(dir, { recursive: true });
 
   const contentHash = createHash("sha256")
     .update(exportValue)
     .digest("hex")
     .slice(0, 8);
   const fileName = `${prefix}-${contentHash}.js`;
-  const filePath = resolve(stagedDir, fileName);
+  const filePath = resolve(dir, fileName);
 
   if (!existsSync(filePath)) {
     writeFileSync(filePath, `export default ${exportValue};\n`);
@@ -169,6 +236,18 @@ export function stageBuildAssetModule(
   return fileName;
 }
 
+export function stageBuildAssetModule(
+  projectRoot: string,
+  prefix: "__pr" | "__st",
+  exportValue: string,
+): string {
+  return writeBuildAssetModule(
+    getStagedAssetDir(projectRoot),
+    prefix,
+    exportValue,
+  );
+}
+
 export function copyStagedBuildAssets(
   projectRoot: string,
   fileNames: Iterable<string>,