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

package/src/build/route-types/router-processing.ts

@@ -15,10 +15,13 @@ import {
 import ts from "typescript";
 import { generateRouteTypesSource } from "./codegen.js";
 import type { ScanFilter } from "./scan-filter.js";
+import { firstCodeMatchIndex } from "./source-scan.js";
 import {
   resolveImportedVariable,
   resolveImportPath,
   buildCombinedRouteMapWithSearch,
+  createScanMemo,
+  type ScanMemo,
   type UnresolvableInclude,
 } from "./include-resolution.js";
 import { findUrlsVariableNames } from "./per-module-writer.js";
@@ -38,6 +41,8 @@ function countPublicRouteEntries(source: string): number {
 }
 
 const ROUTER_CALL_PATTERN = /\bcreateRouter\s*[<(]/;
+// Global variant for the code-region scan (firstCodeMatchIndex sets lastIndex).
+const ROUTER_CALL_PATTERN_G = /\bcreateRouter\s*[<(]/g;
 
 function isRoutableSourceFile(name: string): boolean {
   return (
@@ -51,8 +56,33 @@ function isRoutableSourceFile(name: string): boolean {
   );
 }
 
-function findRouterFilesRecursive(
+function isExcludedScanDir(name: string): boolean {
+  return (
+    name === "node_modules" ||
+    name === "dist" ||
+    name === "coverage" ||
+    name === "__tests__" ||
+    name === "__mocks__" ||
+    name.startsWith(".")
+  );
+}
+
+/**
+ * Recursively collect source files whose code contains `pattern` (a comment- or
+ * string-only mention is ignored via firstCodeMatchIndex). Shared by createRouter
+ * and createHostRouter discovery, which differ only in the call pattern and
+ * `stopAtMatchDir`: createRouter treats a directory containing a match as a router
+ * root and stops descending it; createHostRouter descends the whole tree (the host
+ * entry sits above the sub-app router roots).
+ *
+ * `pattern` is the non-global tester (no lastIndex state); `patternG` is its global
+ * twin for the code-region scan.
+ */
+function findCallSiteFilesRecursive(
   dir: string,
+  pattern: RegExp,
+  patternG: RegExp,
+  stopAtMatchDir: boolean,
   filter: ScanFilter | undefined,
   results: string[],
 ): void {
@@ -61,27 +91,18 @@ function findRouterFilesRecursive(
     entries = readdirSync(dir, { withFileTypes: true });
   } catch (err) {
     console.warn(
-      `[rsc-router] Failed to scan directory ${dir}: ${(err as Error).message}`,
+      `[rango] Failed to scan directory ${dir}: ${(err as Error).message}`,
     );
     return;
   }
 
   const childDirs: string[] = [];
-  const routerFilesInDir: string[] = [];
+  const matchesInDir: string[] = [];
 
   for (const entry of entries) {
     const fullPath = join(dir, entry.name);
     if (entry.isDirectory()) {
-      if (
-        entry.name === "node_modules" ||
-        entry.name === "dist" ||
-        entry.name === "coverage" ||
-        entry.name === "__tests__" ||
-        entry.name === "__mocks__" ||
-        entry.name.startsWith(".")
-      )
-        continue;
-      childDirs.push(fullPath);
+      if (!isExcludedScanDir(entry.name)) childDirs.push(fullPath);
       continue;
     }
 
@@ -90,23 +111,36 @@ function findRouterFilesRecursive(
 
     try {
       const source = readFileSync(fullPath, "utf-8");
-      if (ROUTER_CALL_PATTERN.test(source)) {
-        routerFilesInDir.push(fullPath);
+      // Fast path: most files contain no `createRouter(` at all, so the cheap
+      // raw regex short-circuits before the code-region scan. Only a file that
+      // mentions the token (real call OR a comment/string mention) is rescanned
+      // over code regions — allocation-free, never building a stripped copy —
+      // so a mention inside a comment or string is not mistaken for a real
+      // router file (which previously triggered a spurious "Multiple routers
+      // found" error).
+      if (pattern.test(source) && firstCodeMatchIndex(source, patternG) >= 0) {
+        matchesInDir.push(fullPath);
       }
     } catch {
       continue;
     }
   }
 
-  // A directory that contains a router file is treated as a router root.
-  // Once found, deeper directories are skipped to avoid redundant scans.
-  if (routerFilesInDir.length > 0) {
-    results.push(...routerFilesInDir);
-    return;
-  }
-
-  for (const childDir of childDirs) {
-    findRouterFilesRecursive(childDir, filter, results);
+  results.push(...matchesInDir);
+
+  // createRouter (stopAtMatchDir): a directory that contains a match is a router
+  // root, so deeper directories are skipped. createHostRouter: always descend.
+  if (!stopAtMatchDir || matchesInDir.length === 0) {
+    for (const childDir of childDirs) {
+      findCallSiteFilesRecursive(
+        childDir,
+        pattern,
+        patternG,
+        stopAtMatchDir,
+        filter,
+        results,
+      );
+    }
   }
 }
 
@@ -142,7 +176,7 @@ export function findNestedRouterConflict(
 
 export function formatNestedRouterConflictError(
   conflict: { ancestor: string; nested: string },
-  prefix = "[rsc-router]",
+  prefix = "[rango]",
 ): string {
   return (
     `${prefix} Nested router roots are not supported.\n` +
@@ -165,18 +199,43 @@ export type UrlsExtractionResult =
   | { kind: "variable"; name: string }
   | { kind: "inline"; block: string };
 
-/**
- * Extract the url patterns from a router file using AST.
- * Detects four patterns:
- *   1. createRouter(...).routes(variableName)
- *   2. createRouter({ urls: variableName, ... })
- *   3. createRouter(...).routes(({ path, ... }) => [...])
- *   4. createRouter({ urls: ({ path, ... }) => [...], ... })
- * Returns either a variable name or an inline code block.
- */
-export function extractUrlsFromRouter(
-  code: string,
+function isCreateRouterCall(node: ts.Node): boolean {
+  if (!ts.isCallExpression(node)) return false;
+  const callee = node.expression;
+  return ts.isIdentifier(callee) && callee.text === "createRouter";
+}
+
+function extractUrlsArgument(
+  node: ts.Expression,
+  sourceFile: ts.SourceFile,
 ): UrlsExtractionResult | null {
+  if (ts.isIdentifier(node)) {
+    return { kind: "variable", name: node.text };
+  }
+  if (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) {
+    return { kind: "inline", block: node.getText(sourceFile) };
+  }
+  return null;
+}
+
+/** Return a createRouter call chain in runtime registration order. */
+function collectCreateRouterCallChain(
+  endpoint: ts.CallExpression,
+): ts.CallExpression[] | null {
+  const calls: ts.CallExpression[] = [];
+  let current = endpoint;
+
+  while (true) {
+    calls.push(current);
+    if (isCreateRouterCall(current)) return calls.reverse();
+    if (!ts.isPropertyAccessExpression(current.expression)) return null;
+    const receiver = current.expression.expression;
+    if (!ts.isCallExpression(receiver)) return null;
+    current = receiver;
+  }
+}
+
+function extractAllUrlsFromRouter(code: string): UrlsExtractionResult[] {
   const sourceFile = ts.createSourceFile(
     "router.tsx",
     code,
@@ -184,85 +243,71 @@ export function extractUrlsFromRouter(
     true,
     ts.ScriptKind.TSX,
   );
-  let result: UrlsExtractionResult | null = null;
-
-  function isCreateRouterCall(node: ts.Node): boolean {
-    if (!ts.isCallExpression(node)) return false;
-    const callee = node.expression;
-    return ts.isIdentifier(callee) && callee.text === "createRouter";
-  }
-
-  /** Check if a node is an arrow/function expression (inline builder). */
-  function isInlineBuilder(node: ts.Node): boolean {
-    return ts.isArrowFunction(node) || ts.isFunctionExpression(node);
-  }
-
-  /** Check if a .routes() call chains from createRouter(). */
-  function isRoutesOnCreateRouter(node: ts.CallExpression): boolean {
-    if (
-      !ts.isPropertyAccessExpression(node.expression) ||
-      node.expression.name.text !== "routes"
-    )
-      return false;
-    let inner: ts.Expression = node.expression.expression;
-    while (
-      ts.isCallExpression(inner) &&
-      ts.isPropertyAccessExpression(inner.expression)
-    ) {
-      inner = inner.expression.expression;
-    }
-    return isCreateRouterCall(inner);
-  }
+  let result: UrlsExtractionResult[] | null = null;
 
   function visit(node: ts.Node) {
     if (result) return;
-
-    // Pattern 1 & 3: createRouter(...).routes(variableName | builder)
-    if (
-      ts.isCallExpression(node) &&
-      node.arguments.length >= 1 &&
-      isRoutesOnCreateRouter(node)
-    ) {
-      const arg = node.arguments[0];
-      if (ts.isIdentifier(arg)) {
-        result = { kind: "variable", name: arg.text };
-      } else if (isInlineBuilder(arg)) {
-        result = { kind: "inline", block: arg.getText(sourceFile) };
-      }
-      return;
-    }
-
-    // Pattern 2 & 4: createRouter({ urls: variableName | builder, ... })
-    if (isCreateRouterCall(node)) {
-      const callExpr = node as ts.CallExpression;
-      for (const callArg of callExpr.arguments) {
-        if (ts.isObjectLiteralExpression(callArg)) {
+    if (ts.isCallExpression(node)) {
+      const chain = collectCreateRouterCallChain(node);
+      if (chain) {
+        const extracted: UrlsExtractionResult[] = [];
+        const createRouterCall = chain[0];
+
+        for (const callArg of createRouterCall.arguments) {
+          if (!ts.isObjectLiteralExpression(callArg)) continue;
           for (const prop of callArg.properties) {
             if (
-              ts.isPropertyAssignment(prop) &&
-              ts.isIdentifier(prop.name) &&
-              prop.name.text === "urls"
+              !ts.isPropertyAssignment(prop) ||
+              !ts.isIdentifier(prop.name) ||
+              prop.name.text !== "urls"
             ) {
-              if (ts.isIdentifier(prop.initializer)) {
-                result = { kind: "variable", name: prop.initializer.text };
-              } else if (isInlineBuilder(prop.initializer)) {
-                result = {
-                  kind: "inline",
-                  block: prop.initializer.getText(sourceFile),
-                };
-              }
-              return;
+              continue;
             }
+            const urls = extractUrlsArgument(prop.initializer, sourceFile);
+            if (urls) extracted.push(urls);
+            break;
           }
         }
+
+        for (const call of chain.slice(1)) {
+          if (
+            !ts.isPropertyAccessExpression(call.expression) ||
+            call.expression.name.text !== "routes" ||
+            call.arguments.length === 0
+          ) {
+            continue;
+          }
+          const urls = extractUrlsArgument(call.arguments[0], sourceFile);
+          if (urls) extracted.push(urls);
+        }
+
+        if (extracted.length > 0) {
+          result = extracted;
+          return;
+        }
       }
     }
-
     ts.forEachChild(node, visit);
   }
 
   visit(sourceFile);
-  return result;
+  return result ?? [];
+}
+
+/**
+ * Extract the url patterns from a router file using AST.
+ * Detects four patterns:
+ *   1. createRouter(...).routes(variableName)
+ *   2. createRouter({ urls: variableName, ... })
+ *   3. createRouter(...).routes(({ path, ... }) => [...])
+ *   4. createRouter({ urls: ({ path, ... }) => [...], ... })
+ * Returns either a variable name or an inline code block.
+ */
+export function extractUrlsFromRouter(
+  code: string,
+): UrlsExtractionResult | null {
+  const extractions = extractAllUrlsFromRouter(code);
+  return extractions[extractions.length - 1] ?? null;
 }
 
 /**
@@ -309,12 +354,6 @@ export function extractBasenameFromRouter(code: string): string | undefined {
   return result;
 }
 
-/** @deprecated Use extractUrlsFromRouter instead */
-export function extractUrlsVariableFromRouter(code: string): string | null {
-  const result = extractUrlsFromRouter(code);
-  return result?.kind === "variable" ? result.name : null;
-}
-
 /** Apply a basename prefix to all route patterns in a result set. */
 function applyBasenameToRoutes(
   result: {
@@ -339,10 +378,110 @@ function applyBasenameToRoutes(
   return { routes: prefixed, searchSchemas: result.searchSchemas };
 }
 
+type RouteMapWithSearch = {
+  routes: Record<string, string>;
+  searchSchemas: Record<string, Record<string, string>>;
+};
+
+function resolveRouterUrlsExtraction(
+  routerFilePath: string,
+  routerSource: string,
+  extraction: UrlsExtractionResult,
+  diagnosticsOut: UnresolvableInclude[] | undefined,
+  memo: ScanMemo,
+): RouteMapWithSearch {
+  if (extraction.kind === "inline") {
+    return buildCombinedRouteMapWithSearch(
+      routerFilePath,
+      undefined,
+      new Set(),
+      diagnosticsOut,
+      extraction.block,
+      memo,
+    );
+  }
+
+  const imported = resolveImportedVariable(routerSource, extraction.name);
+  if (imported) {
+    const targetFile = resolveImportPath(imported.specifier, routerFilePath);
+    if (!targetFile) {
+      diagnosticsOut?.push({
+        pathPrefix: "/",
+        namePrefix: null,
+        reason: "file-not-found",
+        sourceFile: routerFilePath,
+        detail: `import "${imported.specifier}" resolved to no file`,
+      });
+      return { routes: {}, searchSchemas: {} };
+    }
+    return buildCombinedRouteMapWithSearch(
+      targetFile,
+      imported.exportedName,
+      new Set(),
+      diagnosticsOut,
+      undefined,
+      memo,
+    );
+  }
+
+  return buildCombinedRouteMapWithSearch(
+    routerFilePath,
+    extraction.name,
+    new Set(),
+    diagnosticsOut,
+    undefined,
+    memo,
+  );
+}
+
+function mergeRouteMaps(
+  target: RouteMapWithSearch,
+  source: RouteMapWithSearch,
+): void {
+  for (const [name, pattern] of Object.entries(source.routes)) {
+    target.routes[name] = pattern;
+    const search = source.searchSchemas[name];
+    if (search) {
+      target.searchSchemas[name] = search;
+    } else {
+      delete target.searchSchemas[name];
+    }
+  }
+}
+
+// Filesystem path of the generated route-types file for a router source file.
+// Native separators — matches the self-gen-tracking Map key the watcher compares.
+export function genFileTsPath(sourceFile: string): string {
+  const base = pathBasename(sourceFile).replace(/\.(tsx?|jsx?)$/, "");
+  return join(dirname(sourceFile), `${base}.named-routes.gen.ts`);
+}
+
+// Search schemas for the gen file: prefer the runtime manifest's; when it omits
+// them (some module-runner flows) fall back to static parsing filtered to the
+// public route-name set. Returns the runtime value unchanged otherwise.
+export function resolveSearchSchemas(
+  publicRouteNames: string[],
+  runtimeSchemas: Record<string, Record<string, string>> | undefined,
+  sourceFile: string,
+): Record<string, Record<string, string>> | undefined {
+  if (runtimeSchemas && Object.keys(runtimeSchemas).length > 0) {
+    return runtimeSchemas;
+  }
+  const staticParsed = buildCombinedRouteMapForRouterFile(sourceFile);
+  if (Object.keys(staticParsed.searchSchemas).length === 0) {
+    return runtimeSchemas;
+  }
+  const filtered: Record<string, Record<string, string>> = {};
+  for (const name of publicRouteNames) {
+    const schema = staticParsed.searchSchemas[name];
+    if (schema) filtered[name] = schema;
+  }
+  return Object.keys(filtered).length > 0 ? filtered : runtimeSchemas;
+}
+
 /**
- * Resolve routes and search schemas from a router source file by following the
- * variable passed to `.routes(...)` or `urls: ...` in createRouter options,
- * or by parsing an inline builder function directly.
+ * Resolve routes and search schemas from every direct mount in a createRouter
+ * chain. Registrations are merged in runtime order, with later mounts winning.
  */
 export function buildCombinedRouteMapForRouterFile(routerFilePath: string): {
   routes: Record<string, string>;
@@ -355,8 +494,8 @@ export function buildCombinedRouteMapForRouterFile(routerFilePath: string): {
     return { routes: {}, searchSchemas: {} };
   }
 
-  const extraction = extractUrlsFromRouter(routerSource);
-  if (!extraction) {
+  const extractions = extractAllUrlsFromRouter(routerSource);
+  if (extractions.length === 0) {
     return { routes: {}, searchSchemas: {} };
   }
 
@@ -366,40 +505,24 @@ export function buildCombinedRouteMapForRouterFile(routerFilePath: string): {
     ? ("/" + rawBasename.replace(/^\/+|\/+$/g, "")).replace(/^\/$/, "")
     : undefined;
 
-  let result: {
-    routes: Record<string, string>;
-    searchSchemas: Record<string, Record<string, string>>;
-  };
-
-  // Inline builder: extract routes directly from the function body
-  if (extraction.kind === "inline") {
-    result = buildCombinedRouteMapWithSearch(
-      routerFilePath,
-      undefined,
-      undefined,
-      undefined,
-      extraction.block,
+  const result: RouteMapWithSearch = { routes: {}, searchSchemas: {} };
+  const memo = createScanMemo();
+  for (const extraction of extractions) {
+    mergeRouteMaps(
+      result,
+      resolveRouterUrlsExtraction(
+        routerFilePath,
+        routerSource,
+        extraction,
+        undefined,
+        memo,
+      ),
     );
-  } else {
-    // Variable reference: follow imports or same-file declaration
-    const imported = resolveImportedVariable(routerSource, extraction.name);
-    if (imported) {
-      const targetFile = resolveImportPath(imported.specifier, routerFilePath);
-      if (!targetFile) {
-        return { routes: {}, searchSchemas: {} };
-      }
-      result = buildCombinedRouteMapWithSearch(
-        targetFile,
-        imported.exportedName,
-      );
-    } else {
-      result = buildCombinedRouteMapWithSearch(routerFilePath, extraction.name);
-    }
   }
 
   // Apply basename prefix to all extracted route patterns
   if (basename) {
-    result = applyBasenameToRoutes(result, basename);
+    return applyBasenameToRoutes(result, basename);
   }
 
   return result;
@@ -425,56 +548,20 @@ export function detectUnresolvableIncludes(
     return [];
   }
 
-  // Extract the urls source from the router file
-  const extraction = extractUrlsFromRouter(source);
-  if (!extraction) return [];
+  const extractions = extractAllUrlsFromRouter(source);
+  if (extractions.length === 0) return [];
 
   const diagnostics: UnresolvableInclude[] = [];
-
-  if (extraction.kind === "inline") {
-    // Inline builder: parse directly
-    buildCombinedRouteMapWithSearch(
+  const memo = createScanMemo();
+  for (const extraction of extractions) {
+    resolveRouterUrlsExtraction(
       realPath,
-      undefined,
-      new Set(),
+      source,
+      extraction,
       diagnostics,
-      extraction.block,
+      memo,
     );
-    return diagnostics;
   }
-
-  // Variable reference: resolve where it comes from
-  const imported = resolveImportedVariable(source, extraction.name);
-  let targetFile: string;
-  let exportedName: string | undefined;
-
-  if (imported) {
-    const resolved = resolveImportPath(imported.specifier, realPath);
-    if (!resolved) {
-      return [
-        {
-          pathPrefix: "/",
-          namePrefix: null,
-          reason: "file-not-found",
-          sourceFile: realPath,
-          detail: `import "${imported.specifier}" resolved to no file`,
-        },
-      ];
-    }
-    targetFile = resolved;
-    exportedName = imported.exportedName;
-  } else {
-    // Same-file urls() definition
-    targetFile = realPath;
-    exportedName = extraction.name;
-  }
-
-  buildCombinedRouteMapWithSearch(
-    targetFile,
-    exportedName,
-    new Set(),
-    diagnostics,
-  );
   return diagnostics;
 }
 
@@ -515,7 +602,38 @@ export function detectUnresolvableIncludesForUrlsFile(
  */
 export function findRouterFiles(root: string, filter?: ScanFilter): string[] {
   const result: string[] = [];
-  findRouterFilesRecursive(root, filter, result);
+  findCallSiteFilesRecursive(
+    root,
+    ROUTER_CALL_PATTERN,
+    ROUTER_CALL_PATTERN_G,
+    true,
+    filter,
+    result,
+  );
+  return result;
+}
+
+const HOST_ROUTER_CALL_PATTERN = /\bcreateHostRouter\s*[<(]/;
+const HOST_ROUTER_CALL_PATTERN_G = /\bcreateHostRouter\s*[<(]/g;
+
+/**
+ * Scan for files containing createHostRouter() and return their paths. Unlike
+ * findRouterFiles, this does NOT stop at the first router-root directory -- a host
+ * entry typically sits above the sub-app router roots, so the whole tree is scanned.
+ */
+export function findHostRouterFiles(
+  root: string,
+  filter?: ScanFilter,
+): string[] {
+  const result: string[] = [];
+  findCallSiteFilesRecursive(
+    root,
+    HOST_ROUTER_CALL_PATTERN,
+    HOST_ROUTER_CALL_PATTERN_G,
+    false,
+    filter,
+    result,
+  );
   return result;
 }
 
@@ -528,7 +646,10 @@ export function findRouterFiles(root: string, filter?: ScanFilter): string[] {
 export function writeCombinedRouteTypes(
   root: string,
   knownRouterFiles?: string[],
-  opts?: { preserveIfLarger?: boolean },
+  opts?: {
+    preserveIfLarger?: boolean;
+    onWrite?: (outPath: string, content: string) => void;
+  },
 ): void {
   // Delete old combined named-routes.gen.ts if it exists (stale from older versions)
   try {
@@ -536,7 +657,7 @@ export function writeCombinedRouteTypes(
     if (existsSync(oldCombinedPath)) {
       unlinkSync(oldCombinedPath);
       console.log(
-        `[rsc-router] Removed stale combined route types: ${oldCombinedPath}`,
+        `[rango] Removed stale combined route types: ${oldCombinedPath}`,
       );
     }
   } catch {}
@@ -566,24 +687,15 @@ export function writeCombinedRouteTypes(
       if (!extractUrlsFromRouter(routerSource)) continue;
     }
 
-    const routerBasename = pathBasename(routerFilePath).replace(
-      /\.(tsx?|jsx?)$/,
-      "",
-    );
-    const outPath = join(
-      dirname(routerFilePath),
-      `${routerBasename}.named-routes.gen.ts`,
-    );
+    const outPath = genFileTsPath(routerFilePath);
     const existing = existsSync(outPath)
       ? readFileSync(outPath, "utf-8")
       : null;
 
-    // When the static parser can't extract routes (e.g. callback-style urls()),
-    // write an empty placeholder so the build-time transform's injected import
-    // resolves. Runtime discovery will overwrite this with the real routes.
     if (Object.keys(result.routes).length === 0) {
       if (!existing) {
         const emptySource = generateRouteTypesSource({});
+        opts?.onWrite?.(outPath, emptySource);
         writeFileSync(outPath, emptySource);
       }
       continue;
@@ -595,11 +707,6 @@ export function writeCombinedRouteTypes(
       hasSearchSchemas ? result.searchSchemas : undefined,
     );
     if (existing !== source) {
-      // On initial dev startup, don't overwrite a file from runtime discovery
-      // (which has all dynamic routes) with a smaller set from the static
-      // parser. The static parser can't see routes generated by Array.from()
-      // or other dynamic code. During HMR (file watcher), always write so
-      // newly added routes appear immediately.
       if (opts?.preserveIfLarger && existing) {
         const existingCount = countPublicRouteEntries(existing);
         const newCount = Object.keys(result.routes).filter(
@@ -609,9 +716,10 @@ export function writeCombinedRouteTypes(
           continue;
         }
       }
+      opts?.onWrite?.(outPath, source);
       writeFileSync(outPath, source);
       console.log(
-        `[rsc-router] Generated route types (${Object.keys(result.routes).length} routes) -> ${outPath}`,
+        `[rango] Generated route types (${Object.keys(result.routes).length} routes) -> ${outPath}`,
       );
     }
   }