@rangojs/router 0.0.0-experimental.002d056c

package/src/bin/rango.ts

@@ -0,0 +1,321 @@
+import { resolve, dirname } from "node:path";
+import { readFileSync, statSync, existsSync } from "node:fs";
+import {
+  findTsFiles,
+  writePerModuleRouteTypesForFile,
+  writeCombinedRouteTypes,
+  detectUnresolvableIncludes,
+  detectUnresolvableIncludesForUrlsFile,
+  findNestedRouterConflict,
+  formatNestedRouterConflictError,
+  type UnresolvableInclude,
+} from "../build/generate-route-types.ts";
+
+const [command, ...rawArgs] = process.argv.slice(2);
+
+if (command === "generate") {
+  // Parse flags
+  let mode: "default" | "runtime" | "static" = "default";
+  let configFile: string | undefined;
+  const positionalArgs: string[] = [];
+
+  for (let i = 0; i < rawArgs.length; i++) {
+    const arg = rawArgs[i];
+    if (arg === "--runtime") {
+      mode = "runtime";
+    } else if (arg === "--static") {
+      mode = "static";
+    } else if (arg === "--config") {
+      configFile = rawArgs[++i];
+      if (!configFile) {
+        console.error("[rango] --config requires a path argument");
+        process.exit(1);
+      }
+    } else if (arg.startsWith("--")) {
+      console.error(`[rango] Unknown flag: ${arg}`);
+      process.exit(1);
+    } else {
+      positionalArgs.push(arg);
+    }
+  }
+
+  if (positionalArgs.length === 0) {
+    console.error(
+      "[rango] Usage: rango generate <file|dir> [file2 ...] [--runtime|--static] [--config <path>]",
+    );
+    process.exit(1);
+  }
+
+  if (configFile && mode !== "runtime") {
+    console.warn("[rango] --config is only used with --runtime, ignoring");
+  }
+
+  if (mode === "runtime") {
+    // Runtime discovery: dynamically import to avoid loading Vite for static-only usage
+    runRuntimeDiscovery(positionalArgs, configFile).catch((err) => {
+      console.error(`[rango] Runtime discovery failed: ${err.message}`);
+      process.exit(1);
+    });
+  } else {
+    runStaticGeneration(positionalArgs, mode);
+  }
+} else {
+  if (
+    command &&
+    command !== "help" &&
+    command !== "--help" &&
+    command !== "-h"
+  ) {
+    console.error(`[rango] Unknown command: ${command}\n`);
+  }
+  console.log(`Usage: rango generate <file|dir> [file2 ...] [--runtime|--static] [--config <path>]
+
+  Auto-detects file type (createRouter, urls) and generates
+  the appropriate .gen.ts route type files.
+
+Modes:
+  (default)   Static parser with error on unresolvable includes
+  --runtime   Vite-based runtime discovery (100% coverage)
+              Requires vite and @vitejs/plugin-rsc
+  --static    Static parser, accept partial output with warnings
+
+Options:
+  --config <path>  Path to vite.config.ts (--runtime only, auto-detected if omitted)
+
+Examples:
+  rango generate src/router.tsx
+  rango generate src/router.tsx --runtime
+  rango generate src/ --static`);
+  process.exit(
+    command && command !== "help" && command !== "--help" && command !== "-h"
+      ? 1
+      : 0,
+  );
+}
+
+/**
+ * Walk up from a file path to find the project root (directory containing
+ * package.json or vite.config.ts).
+ */
+function findProjectRoot(fromPath: string): string {
+  let dir = dirname(resolve(fromPath));
+  while (dir !== dirname(dir)) {
+    if (
+      existsSync(resolve(dir, "package.json")) ||
+      existsSync(resolve(dir, "vite.config.ts")) ||
+      existsSync(resolve(dir, "vite.config.js"))
+    ) {
+      return dir;
+    }
+    dir = dirname(dir);
+  }
+  // Fallback to cwd if no project root found
+  return process.cwd();
+}
+
+function runStaticGeneration(args: string[], mode: "default" | "static") {
+  // Expand args: files are used directly, directories are scanned
+  const files: string[] = [];
+  for (const arg of args) {
+    const resolved = resolve(arg);
+    try {
+      if (statSync(resolved).isDirectory()) {
+        files.push(...findTsFiles(resolved));
+      } else {
+        files.push(resolved);
+      }
+    } catch {
+      console.warn(`[rango] Skipping ${arg}: not found`);
+    }
+  }
+
+  if (files.length === 0) {
+    console.log("[rango] No files to process");
+    process.exit(0);
+  }
+
+  // Phase 1: Classify files
+  const routerFiles: string[] = [];
+  const urlsFiles: string[] = [];
+
+  for (const filePath of files) {
+    try {
+      const source = readFileSync(filePath, "utf-8");
+      if (/\bcreateRouter\s*[<(]/.test(source)) {
+        routerFiles.push(filePath);
+      }
+      if (source.includes("urls(")) {
+        urlsFiles.push(filePath);
+      }
+    } catch (err) {
+      console.warn(
+        `[rango] Failed to process ${filePath}: ${(err as Error).message}`,
+      );
+    }
+  }
+
+  // Phase 2: Collect diagnostics from all files BEFORE writing anything
+  const allDiagnostics: Array<UnresolvableInclude & { routerFile: string }> =
+    [];
+
+  for (const routerFile of routerFiles) {
+    const diagnostics = detectUnresolvableIncludes(routerFile);
+    for (const d of diagnostics) {
+      allDiagnostics.push({ ...d, routerFile });
+    }
+  }
+
+  // Also check standalone urls files not covered by router-level detection
+  const routerFileSet = new Set(routerFiles);
+  for (const urlsFile of urlsFiles) {
+    if (routerFileSet.has(urlsFile)) continue;
+    const diagnostics = detectUnresolvableIncludesForUrlsFile(urlsFile);
+    for (const d of diagnostics) {
+      allDiagnostics.push({ ...d, routerFile: urlsFile });
+    }
+  }
+
+  // Deduplicate diagnostics (router and urls detection may find the same issue)
+  const seen = new Set<string>();
+  const uniqueDiagnostics = allDiagnostics.filter((d) => {
+    const key = `${d.sourceFile}:${d.pathPrefix}:${d.reason}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+
+  if (uniqueDiagnostics.length > 0 && mode === "default") {
+    // Hard error: no files written
+    console.error("\n[rango] Unresolvable includes detected:\n");
+    formatDiagnostics(uniqueDiagnostics);
+    console.error(
+      "\nThe static parser cannot resolve these includes because they use " +
+        "factory functions or dynamic expressions.\n\n" +
+        "Options:\n" +
+        "  rango generate <path> --runtime   Use Vite-based discovery (requires vite)\n" +
+        "  rango generate <path> --static    Accept partial output (missing routes above)\n",
+    );
+    process.exit(1);
+  }
+
+  if (uniqueDiagnostics.length > 0 && mode === "static") {
+    // Warning: partial output accepted
+    console.warn(
+      "\n[rango] Warning: partial output (unresolvable includes):\n",
+    );
+    formatDiagnostics(uniqueDiagnostics);
+    console.warn("");
+  }
+
+  const nestedRouterConflict = findNestedRouterConflict(routerFiles);
+  if (nestedRouterConflict) {
+    console.error(
+      `\n${formatNestedRouterConflictError(nestedRouterConflict, "[rango]")}\n`,
+    );
+    process.exit(1);
+  }
+
+  // Phase 3: Write all outputs (only reached if diagnostics pass or --static)
+  for (const urlsFile of urlsFiles) {
+    writePerModuleRouteTypesForFile(urlsFile);
+  }
+
+  for (const routerFile of routerFiles) {
+    const projectRoot = findProjectRoot(routerFile);
+    writeCombinedRouteTypes(projectRoot, [routerFile]);
+  }
+
+  console.log(
+    `[rango] Processed ${files.length} file(s)${routerFiles.length ? ` (${routerFiles.length} router)` : ""}`,
+  );
+  process.exit(0);
+}
+
+async function runRuntimeDiscovery(args: string[], configFile?: string) {
+  // Resolve the entry: find the router file from the arguments
+  const files: string[] = [];
+  for (const arg of args) {
+    const resolved = resolve(arg);
+    try {
+      if (statSync(resolved).isDirectory()) {
+        files.push(...findTsFiles(resolved));
+      } else {
+        files.push(resolved);
+      }
+    } catch {
+      console.warn(`[rango] Skipping ${arg}: not found`);
+    }
+  }
+
+  // Find router files among the inputs
+  const routerEntries: string[] = [];
+  for (const filePath of files) {
+    try {
+      const source = readFileSync(filePath, "utf-8");
+      if (/\bcreateRouter\s*[<(]/.test(source)) {
+        routerEntries.push(filePath);
+      }
+      // Also generate per-module types for urls files
+      if (source.includes("urls(")) {
+        writePerModuleRouteTypesForFile(filePath);
+      }
+    } catch {
+      // Skip unreadable files
+    }
+  }
+
+  if (routerEntries.length === 0) {
+    console.error("[rango] No router files found in the provided paths");
+    process.exit(1);
+  }
+
+  const nestedRouterConflict = findNestedRouterConflict(routerEntries);
+  if (nestedRouterConflict) {
+    console.error(
+      `\n${formatNestedRouterConflictError(nestedRouterConflict, "[rango]")}\n`,
+    );
+    process.exit(1);
+  }
+
+  let discoverAndWriteRouteTypes: typeof import("../build/runtime-discovery.ts").discoverAndWriteRouteTypes;
+  try {
+    const mod = await import("../build/runtime-discovery.ts");
+    discoverAndWriteRouteTypes = mod.discoverAndWriteRouteTypes;
+  } catch (err: any) {
+    if (
+      err.code === "ERR_MODULE_NOT_FOUND" ||
+      err.code === "MODULE_NOT_FOUND"
+    ) {
+      console.error(
+        "[rango] Runtime discovery requires 'vite' and '@vitejs/plugin-rsc'.\n" +
+          "Install them with: pnpm add -D vite @vitejs/plugin-rsc",
+      );
+    } else {
+      console.error(`[rango] Failed to load runtime discovery: ${err.message}`);
+    }
+    process.exit(1);
+  }
+
+  for (const entry of routerEntries) {
+    const projectRoot = findProjectRoot(entry);
+    const result = await discoverAndWriteRouteTypes({
+      root: projectRoot,
+      configFile,
+      entry,
+    });
+    console.log(
+      `[rango] Runtime discovery: ${result.routerCount} router(s), ${result.routeCount} route(s)`,
+    );
+  }
+}
+
+function formatDiagnostics(
+  diagnostics: Array<UnresolvableInclude & { routerFile: string }>,
+) {
+  for (const d of diagnostics) {
+    const prefix = d.namePrefix ? `${d.namePrefix}.*` : `${d.pathPrefix}*`;
+    console.error(`  ${prefix}`);
+    console.error(`    Reason:  ${d.reason} -- ${d.detail}`);
+    console.error(`    Source:  ${d.sourceFile}`);
+  }
+}

package/src/browser/action-coordinator.ts

@@ -0,0 +1,97 @@
+import {
+  classifyActionResponse,
+  type ActionScenario,
+} from "./action-response-classifier.js";
+import type { ActionEntry } from "./event-controller.js";
+
+/**
+ * Plain data inputs for classifying a post-reconciliation action outcome.
+ * No browser objects or controller references — all values are snapshots.
+ */
+export interface ActionOutcomeInput {
+  /** This action's unique instance ID */
+  handleId: string;
+  /** All in-flight action entries (snapshot from event controller) */
+  inflightActions: Map<string, ActionEntry>;
+  /** Whether any concurrent actions occurred (controller-level shared flag) */
+  hadAnyConcurrentActions: boolean;
+  /** Segments revalidated by concurrent actions (from tracking set) */
+  revalidatedSegments: Set<string>;
+  /** window.location.pathname captured at action start */
+  actionStartPathname: string;
+  /** window.location.pathname at classification time */
+  currentPathname: string;
+  /** window.history.state?.key captured at action start */
+  actionStartLocationKey: string | undefined;
+  /** window.history.state?.key at classification time */
+  currentLocationKey: string | undefined;
+  /** Number of segments after reconciliation */
+  reconciledSegmentCount: number;
+  /** Number of matched segment IDs from server */
+  matchedCount: number;
+  /** Current intercept source URL (null when not on intercept route) */
+  currentInterceptSource: string | null;
+}
+
+/**
+ * Compute consolidation segments from concurrent action state.
+ *
+ * Returns segment IDs that need re-fetching when concurrent actions
+ * have each revalidated different parts of the tree, or null if
+ * consolidation is not needed.
+ */
+function computeConsolidationSegments(
+  input: ActionOutcomeInput,
+): string[] | null {
+  if (!input.hadAnyConcurrentActions) return null;
+  if (input.revalidatedSegments.size === 0) return null;
+
+  // Can't consolidate while any action is still waiting for a server response
+  const stillFetchingCount = [...input.inflightActions.values()].filter(
+    (a) => a.phase === "fetching",
+  ).length;
+  if (stillFetchingCount > 0) return null;
+
+  return Array.from(input.revalidatedSegments);
+}
+
+/**
+ * Count other actions still in "fetching" phase (excluding this handle).
+ */
+function countOtherFetchingActions(input: ActionOutcomeInput): number {
+  let count = 0;
+  for (const [, a] of input.inflightActions) {
+    if (a.phase === "fetching" && a.id !== input.handleId) {
+      count++;
+    }
+  }
+  return count;
+}
+
+/**
+ * Classify a post-reconciliation action outcome into one of 5 scenarios.
+ *
+ * This is the single entry point for post-action decision logic.
+ * It gathers consolidation and concurrency data from the plain inputs,
+ * then delegates to the pure classifyActionResponse function.
+ *
+ * The server-action-bridge calls this after reconciliation to decide
+ * whether to render, skip, consolidate, or refetch.
+ */
+export function classifyActionOutcome(
+  input: ActionOutcomeInput,
+): ActionScenario {
+  return classifyActionResponse({
+    actionStartPathname: input.actionStartPathname,
+    currentPathname: input.currentPathname,
+    actionStartLocationKey: input.actionStartLocationKey,
+    currentLocationKey: input.currentLocationKey,
+    reconciledSegmentCount: input.reconciledSegmentCount,
+    matchedCount: input.matchedCount,
+    currentInterceptSource: input.currentInterceptSource,
+    consolidationSegments: computeConsolidationSegments(input),
+    otherFetchingActionCount: countOtherFetchingActions(input),
+  });
+}
+
+export type { ActionScenario };

package/src/browser/action-response-classifier.ts

@@ -0,0 +1,99 @@
+/**
+ * Discriminated union of post-reconciliation action response scenarios.
+ *
+ * Error and full-update-unsupported are handled inline in the bridge
+ * before reconciliation. This classifier only runs for partial responses
+ * that have been successfully reconciled.
+ */
+export type ActionScenario =
+  | {
+      type: "navigated-away";
+      historyKeyChanged: boolean;
+      onInterceptRoute: boolean;
+    }
+  | { type: "hmr-missing" }
+  | { type: "consolidation-needed"; segmentIds: string[] }
+  | { type: "concurrent-skip"; otherFetchingCount: number }
+  | { type: "normal" };
+
+/**
+ * Pure data inputs for classifying a partial action response.
+ * All values come from the bridge but no browser APIs or side effects.
+ */
+export interface ClassifierInput {
+  /** window.location.pathname captured at action start */
+  actionStartPathname: string;
+  /** window.location.pathname at classification time */
+  currentPathname: string;
+  /** window.history.state?.key captured at action start */
+  actionStartLocationKey: string | undefined;
+  /** window.history.state?.key at classification time */
+  currentLocationKey: string | undefined;
+  /** Number of segments after reconciliation */
+  reconciledSegmentCount: number;
+  /** Number of matched segment IDs from server */
+  matchedCount: number;
+  /** Segment IDs needing consolidation (from concurrent action tracking) */
+  consolidationSegments: string[] | null;
+  /** Number of other actions still in "fetching" phase */
+  otherFetchingActionCount: number;
+  /** Current intercept source URL (null when not on intercept route) */
+  currentInterceptSource: string | null;
+}
+
+/**
+ * Classify a partial action response into one of 5 post-reconciliation
+ * scenarios.
+ *
+ * Called after error and full-update cases are handled inline by the bridge.
+ * The classification order matches the priority chain:
+ * 1. User navigated away during action
+ * 2. HMR missing segments (fewer reconciled than matched)
+ * 3. Consolidation needed (concurrent actions finished)
+ * 4. Concurrent skip (other actions still fetching)
+ * 5. Normal (single action, no issues)
+ *
+ * This is a pure function with no side effects - the bridge handles
+ * all UI updates, store mutations, and network requests based on the
+ * returned scenario.
+ */
+export function classifyActionResponse(input: ClassifierInput): ActionScenario {
+  // Check if user navigated away during the action
+  const userNavigatedAway =
+    input.currentPathname !== input.actionStartPathname ||
+    input.currentLocationKey !== input.actionStartLocationKey;
+
+  if (userNavigatedAway) {
+    const historyKeyChanged =
+      input.currentLocationKey !== input.actionStartLocationKey;
+    return {
+      type: "navigated-away",
+      historyKeyChanged,
+      onInterceptRoute: input.currentInterceptSource !== null,
+    };
+  }
+
+  // HMR resilience: segments missing after reconciliation
+  if (input.reconciledSegmentCount < input.matchedCount) {
+    return { type: "hmr-missing" };
+  }
+
+  // Consolidation needed for concurrent actions
+  if (input.consolidationSegments && input.consolidationSegments.length > 0) {
+    return {
+      type: "consolidation-needed",
+      segmentIds: input.consolidationSegments,
+    };
+  }
+
+  // Other actions still fetching - skip UI update
+  if (input.otherFetchingActionCount > 0) {
+    return {
+      type: "concurrent-skip",
+      otherFetchingCount: input.otherFetchingActionCount,
+    };
+  }
+
+  // Normal single-action completion
+  return { type: "normal" };
+}