@rangojs/router 0.0.0-experimental.12 → 0.0.0-experimental.121

package/src/vite/rango.ts

@@ -0,0 +1,549 @@
+import type { PluginOption } from "vite";
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { exposeActionId } from "./plugins/expose-action-id.js";
+import {
+  exposeInternalIds,
+  exposeRouterId,
+} from "./plugins/expose-internal-ids.js";
+import { useCacheTransform } from "./plugins/use-cache-transform.js";
+import { clientRefDedup } from "./plugins/client-ref-dedup.js";
+import { VIRTUAL_IDS } from "./plugins/virtual-entries.js";
+import {
+  getExcludeDeps,
+  getPackageAliases,
+  getPublishedPackageName,
+  getVendorAliases,
+} from "./utils/package-resolution.js";
+import { findRouterFiles } from "../build/generate-route-types.js";
+import { createVersionPlugin } from "./plugins/version-plugin.js";
+import {
+  sharedRolldownOptions,
+  createVirtualEntriesPlugin,
+  onwarn,
+  getManualChunks,
+} from "./utils/shared-utils.js";
+import {
+  resolveClientChunks,
+  type ClientChunkContext,
+} from "./utils/client-chunks.js";
+import type { RangoOptions } from "./plugin-types.js";
+import { printBanner, rangoVersion } from "./utils/banner.js";
+import { createVersionInjectorPlugin } from "./plugins/version-injector.js";
+import { createCjsToEsmPlugin } from "./plugins/cjs-to-esm.js";
+import { createRouterDiscoveryPlugin } from "./router-discovery.js";
+import { performanceTracksPlugin } from "./plugins/performance-tracks.js";
+import { createRangoDebugger, NS } from "./debug.js";
+
+const debugConfig = createRangoDebugger(NS.config);
+
+/**
+ * Vite plugin for @rangojs/router.
+ *
+ * Includes @vitejs/plugin-rsc and all necessary transforms for the router
+ * to function correctly with React Server Components.
+ *
+ * @example Node.js (default)
+ * ```ts
+ * export default defineConfig({
+ *   plugins: [react(), rango()],
+ * });
+ * ```
+ *
+ * @example Cloudflare Workers
+ * ```ts
+ * export default defineConfig({
+ *   plugins: [
+ *     react(),
+ *     rango({ preset: 'cloudflare' }),
+ *     cloudflare({ viteEnvironment: { name: 'rsc' } }),
+ *   ],
+ * });
+ * ```
+ */
+export async function rango(options?: RangoOptions): Promise<PluginOption[]> {
+  const rangoStart = performance.now();
+  const resolvedOptions: RangoOptions = options ?? { preset: "node" };
+  const preset = resolvedOptions.preset ?? "node";
+  const showBanner = resolvedOptions.banner ?? true;
+  // Client-chunking strategy (per-route/per-feature splitting of the browser
+  // bundle). Defaults to the built-in directory strategy (`true`) pre-1.0; pass
+  // `clientChunks: false` to opt out. Resolved once and forwarded to
+  // @vitejs/plugin-rsc in both presets. The built-in strategy only splits where it
+  // recognizes a route structure, so this default is a no-op for flat / host-split
+  // apps and never duplicates the shared runtime.
+  const clientChunksOption = resolvedOptions.clientChunks ?? true;
+  // Shared context the built-in strategy reads at build time: the production
+  // hashes of registered error/notFound fallback modules (-> app-fallback).
+  // Populated by the discovery plugin in buildStart, before the client build
+  // invokes the strategy. Only wired when the built-in strategy is active; a
+  // custom function owns its own grouping.
+  const useBuiltInClientChunks = clientChunksOption === true;
+  const clientChunkCtx: ClientChunkContext | undefined = useBuiltInClientChunks
+    ? { fallbackRefs: new Set<string>() }
+    : undefined;
+  const clientChunks = resolveClientChunks(clientChunksOption, clientChunkCtx);
+  debugConfig?.("rango(%s) setup start", preset);
+
+  const plugins: PluginOption[] = [];
+
+  // Get package resolution info (workspace vs npm install).
+  // Vendor aliases redirect the bare plugin-rsc vendor specs (which plugin-rsc
+  // itself injects into optimizeDeps.include) to absolute paths resolved from
+  // this package — so strict-pnpm consumers don't hit "Failed to resolve
+  // dependency" warnings when those deps aren't hoisted to their app root.
+  const rangoAliases = { ...getPackageAliases(), ...getVendorAliases() };
+  const excludeDeps = [
+    ...getExcludeDeps(),
+    // plugin-rsc itself injects these into the client env's
+    // optimizeDeps.include, which overrides exclude for the dep's own
+    // pre-bundle entry. What exclude still controls is how *other*
+    // pre-bundled deps treat imports of these specs (external vs inlined)
+    // via esbuildCjsExternalPlugin. The cjs-to-esm transform in
+    // plugins/cjs-to-esm.ts is the fallback for strict-pnpm consumers,
+    // where client.browser's bare include fails to resolve and Vite ends up
+    // serving the raw CJS file at dev-serve time.
+    "@vitejs/plugin-rsc/browser",
+    "@vitejs/plugin-rsc/vendor/react-server-dom/client.browser",
+  ];
+
+  // Vite supports a nested `A > B` syntax in optimizeDeps.include that resolves
+  // B from A's location. We anchor transitive deps (rsc-html-stream,
+  // @vitejs/plugin-rsc/vendor/*) to @rangojs/router so pnpm consumers — where
+  // these aren't visible at the app root — can still pre-bundle them.
+  const pkg = getPublishedPackageName();
+  const nested = (spec: string) => `${pkg} > ${spec}`;
+
+  // Mutable ref for router path (node preset only).
+  // Set immediately when user-specified, or populated by the auto-discover
+  // config() hook using Vite's resolved root.
+  const routerRef: { path: string | undefined } = { path: undefined };
+
+  // Build-time prerendering is enabled for both presets.
+  // Collection runs in-process via the RSC dev environment runner during discoverRouters().
+  const prerenderEnabled = true;
+
+  if (preset === "cloudflare") {
+    // Cloudflare preset: configure entries for cloudflare worker setup
+    // Router is not needed here - worker.rsc.tsx imports it directly
+
+    // Dynamically import @vitejs/plugin-rsc
+    const { default: rsc } = await import("@vitejs/plugin-rsc");
+
+    // Only client and ssr entries - rsc entry is handled by cloudflare plugin
+    // Always use virtual modules for cloudflare preset
+    const finalEntries: { client: string; ssr: string } = {
+      client: VIRTUAL_IDS.browser,
+      ssr: VIRTUAL_IDS.ssr,
+    };
+
+    plugins.push({
+      name: "@rangojs/router:cloudflare-integration",
+      enforce: "pre",
+
+      config() {
+        // Configure environments for cloudflare deployment
+        return {
+          // Exclude rsc-router modules from optimization to prevent module duplication
+          // This ensures the same Context instance is used by both browser entry and RSC proxy modules
+          optimizeDeps: {
+            exclude: excludeDeps,
+            rolldownOptions: sharedRolldownOptions,
+          },
+          resolve: {
+            alias: rangoAliases,
+            // Force a single React/React-DOM copy across all three RSC
+            // environments. RSC requires exactly one react/react-dom instance
+            // per environment runtime; consumer install topologies (pnpm
+            // strict layout, experimental React pins, third-party "use client"
+            // packages) can otherwise resolve duplicate copies, causing
+            // "Invalid hook call" / lost context. Child environments inherit
+            // this root dedupe, and Vite merges it with any consumer dedupe.
+            dedupe: ["react", "react-dom"],
+          },
+          build: {
+            rollupOptions: { onwarn },
+          },
+          environments: {
+            client: {
+              build: {
+                rollupOptions: {
+                  // FILE_NAME_CONFLICT (and any other client-build warning) is
+                  // emitted by the CLIENT environment build, which consults THIS
+                  // env's onwarn -- Vite 8's environment builds do NOT propagate
+                  // the top-level build.rollupOptions.onwarn into the client env.
+                  // Wire it here so the suppression runs where the conflicts
+                  // originate (the top-level handler is invoked 0x for these; the
+                  // client-env handler is invoked for all of them).
+                  onwarn,
+                  output: {
+                    manualChunks: getManualChunks,
+                  },
+                },
+              },
+              // Pre-bundle rsc-html-stream to prevent discovery during first request
+              // Exclude rsc-router modules to ensure same Context instance
+              optimizeDeps: {
+                include: [nested("rsc-html-stream/client")],
+                exclude: excludeDeps,
+                rolldownOptions: sharedRolldownOptions,
+              },
+            },
+            ssr: {
+              // Build SSR inside RSC directory so wrangler can deploy self-contained dist/rsc
+              build: {
+                outDir: "./dist/rsc/ssr",
+              },
+              // Pre-bundle SSR entry and React for proper module linking with childEnvironments
+              // All deps must be listed to avoid late discovery triggering ERR_OUTDATED_OPTIMIZED_DEP
+              optimizeDeps: {
+                entries: [finalEntries.ssr],
+                include: [
+                  "react",
+                  "react-dom",
+                  "react-dom/server.edge",
+                  "react-dom/static.edge",
+                  "react/jsx-runtime",
+                  "react/jsx-dev-runtime",
+                  nested("rsc-html-stream/server"),
+                  nested(
+                    "@vitejs/plugin-rsc/vendor/react-server-dom/client.edge",
+                  ),
+                ],
+                exclude: excludeDeps,
+                rolldownOptions: sharedRolldownOptions,
+              },
+            },
+            rsc: {
+              // RSC environment needs exclude list and esbuild options
+              // Exclude rsc-router modules to prevent createContext in RSC environment
+              optimizeDeps: {
+                // Pre-bundle all RSC deps to prevent late discovery triggering ERR_OUTDATED_OPTIMIZED_DEP
+                include: [
+                  "react",
+                  "react/jsx-runtime",
+                  "react/jsx-dev-runtime",
+                  nested(
+                    "@vitejs/plugin-rsc/vendor/react-server-dom/server.edge",
+                  ),
+                ],
+                exclude: excludeDeps,
+                rolldownOptions: sharedRolldownOptions,
+              },
+            },
+          },
+        };
+      },
+
+      configResolved(config) {
+        if (showBanner) {
+          const mode =
+            config.command === "serve"
+              ? process.argv.includes("preview")
+                ? "preview"
+                : "dev"
+              : "build";
+          printBanner(mode, "cloudflare", rangoVersion);
+        }
+      },
+    });
+
+    plugins.push(createVirtualEntriesPlugin(finalEntries));
+
+    // Dev-only: RSDW client patch for React Performance Tracks
+    plugins.push(performanceTracksPlugin());
+
+    // Add RSC plugin with cloudflare-specific options
+    // Note: loadModuleDevProxy should NOT be used with childEnvironments
+    // since SSR runs in workerd alongside RSC
+    plugins.push(
+      rsc({
+        entries: finalEntries,
+        serverHandler: false,
+        clientChunks,
+      }) as PluginOption,
+    );
+
+    // Deduplicate client references from third-party packages in dev mode.
+    // Prevents module duplication when server components import "use client"
+    // packages that are also imported directly by client components.
+    plugins.push(clientRefDedup());
+  } else {
+    // Auto-discover router using Vite's resolved root (not process.cwd())
+    plugins.push({
+      name: "@rangojs/router:auto-discover",
+      config(userConfig) {
+        if (routerRef.path) return;
+        const root = userConfig.root
+          ? resolve(process.cwd(), userConfig.root)
+          : process.cwd();
+        const candidates = findRouterFiles(root);
+        if (candidates.length === 1) {
+          const abs = candidates[0];
+          routerRef.path = (
+            abs.startsWith(root) ? "./" + abs.slice(root.length + 1) : abs
+          ).replaceAll("\\", "/");
+        } else if (candidates.length > 1) {
+          const list = candidates
+            .map(
+              (f) =>
+                "  - " + (f.startsWith(root) ? f.slice(root.length + 1) : f),
+            )
+            .join("\n");
+          throw new Error(`[rango] Multiple routers found:\n${list}`);
+        }
+        // 0 found: routerRef.path stays undefined, warn at startup via discovery plugin
+      },
+    });
+
+    // Always use virtual entries for client, ssr, and rsc
+    const finalEntries = {
+      client: VIRTUAL_IDS.browser,
+      ssr: VIRTUAL_IDS.ssr,
+      rsc: VIRTUAL_IDS.rsc,
+    };
+
+    // Dynamically import @vitejs/plugin-rsc
+    const { default: rsc } = await import("@vitejs/plugin-rsc");
+
+    let hasWarnedDuplicate = false;
+
+    plugins.push({
+      name: "@rangojs/router:rsc-integration",
+      enforce: "pre",
+
+      config() {
+        return {
+          optimizeDeps: {
+            exclude: excludeDeps,
+            rolldownOptions: sharedRolldownOptions,
+          },
+          build: {
+            rollupOptions: { onwarn },
+          },
+          resolve: {
+            alias: rangoAliases,
+            // Force a single React/React-DOM copy across all three RSC
+            // environments. RSC requires exactly one react/react-dom instance
+            // per environment runtime; consumer install topologies (pnpm
+            // strict layout, experimental React pins, third-party "use client"
+            // packages) can otherwise resolve duplicate copies, causing
+            // "Invalid hook call" / lost context. Child environments inherit
+            // this root dedupe, and Vite merges it with any consumer dedupe.
+            dedupe: ["react", "react-dom"],
+          },
+          environments: {
+            client: {
+              build: {
+                rollupOptions: {
+                  // FILE_NAME_CONFLICT (and any other client-build warning) is
+                  // emitted by the CLIENT environment build, which consults THIS
+                  // env's onwarn -- Vite 8's environment builds do NOT propagate
+                  // the top-level build.rollupOptions.onwarn into the client env.
+                  // Wire it here so the suppression runs where the conflicts
+                  // originate (the top-level handler is invoked 0x for these; the
+                  // client-env handler is invoked for all of them).
+                  onwarn,
+                  output: {
+                    manualChunks: getManualChunks,
+                  },
+                },
+              },
+              optimizeDeps: {
+                include: [
+                  "react",
+                  "react-dom",
+                  "react/jsx-runtime",
+                  "react/jsx-dev-runtime",
+                  nested("rsc-html-stream/client"),
+                ],
+                exclude: excludeDeps,
+                rolldownOptions: sharedRolldownOptions,
+                entries: [VIRTUAL_IDS.browser],
+              },
+            },
+            ssr: {
+              optimizeDeps: {
+                entries: [VIRTUAL_IDS.ssr],
+                include: [
+                  "react",
+                  "react-dom",
+                  "react-dom/server.edge",
+                  "react-dom/static.edge",
+                  "react/jsx-runtime",
+                  "react/jsx-dev-runtime",
+                  nested(
+                    "@vitejs/plugin-rsc/vendor/react-server-dom/client.edge",
+                  ),
+                ],
+                exclude: excludeDeps,
+                rolldownOptions: sharedRolldownOptions,
+              },
+            },
+            rsc: {
+              optimizeDeps: {
+                entries: [VIRTUAL_IDS.rsc],
+                include: [
+                  "react",
+                  "react/jsx-runtime",
+                  "react/jsx-dev-runtime",
+                  nested(
+                    "@vitejs/plugin-rsc/vendor/react-server-dom/server.edge",
+                  ),
+                ],
+                rolldownOptions: sharedRolldownOptions,
+              },
+            },
+          },
+        };
+      },
+
+      configResolved(config) {
+        if (showBanner) {
+          const mode =
+            config.command === "serve"
+              ? process.argv.includes("preview")
+                ? "preview"
+                : "dev"
+              : "build";
+          printBanner(mode, "node", rangoVersion);
+        }
+
+        const rscMinimalCount = config.plugins.filter(
+          (p) => p.name === "rsc:minimal",
+        ).length;
+
+        if (rscMinimalCount > 1 && !hasWarnedDuplicate) {
+          hasWarnedDuplicate = true;
+          console.warn(
+            "[rango] Duplicate @vitejs/plugin-rsc detected. " +
+              "Remove rsc() from your vite config — rango() includes it automatically.",
+          );
+        }
+      },
+    });
+
+    // Add virtual entries plugin (RSC entry generated lazily from routerRef)
+    plugins.push(createVirtualEntriesPlugin(finalEntries, routerRef));
+
+    // Dev-only: RSDW client patch for React Performance Tracks
+    plugins.push(performanceTracksPlugin());
+
+    plugins.push(
+      rsc({
+        entries: finalEntries,
+        clientChunks,
+      }) as PluginOption,
+    );
+
+    // Deduplicate client references from third-party packages in dev mode.
+    // Prevents module duplication when server components import "use client"
+    // packages that are also imported directly by client components.
+    plugins.push(clientRefDedup());
+  }
+
+  // Fix HMR for "use client" components.
+  //
+  // @vitejs/plugin-rsc's hotUpdate returns undefined for "use client" files
+  // in the RSC environment. Vite then tries to propagate through the RSC
+  // module graph, but the proxy module has no import.meta.hot.accept()
+  // boundary, causing a full page reload. The client env would handle it
+  // fine via React Refresh, but the RSC env's full-reload arrives first.
+  //
+  // Fix: in the RSC env, return [] for "use client" files to signal
+  // "handled, nothing to propagate". The client env is left alone so
+  // React Refresh processes the update normally.
+  plugins.push({
+    name: "@rangojs/router:client-component-hmr",
+    hotUpdate(ctx) {
+      const envName = this.environment?.name;
+      if (envName !== "rsc" && envName !== "ssr") return;
+
+      // Check if the changed file is a "use client" module
+      const file = ctx.file;
+      if (
+        !file.endsWith(".tsx") &&
+        !file.endsWith(".ts") &&
+        !file.endsWith(".jsx") &&
+        !file.endsWith(".js")
+      )
+        return;
+
+      try {
+        const source = readFileSync(file, "utf-8");
+        const trimmed = source.trimStart();
+        if (
+          trimmed.startsWith('"use client"') ||
+          trimmed.startsWith("'use client'")
+        ) {
+          // Consume the update in RSC/SSR envs. The proxy module was already
+          // re-transformed by the RSC plugin's hotUpdate. Without this, Vite
+          // tries to propagate through the RSC/SSR module graph where the proxy
+          // has no import.meta.hot.accept() boundary, triggering a full reload.
+          // The actual component update is handled by React Refresh in the
+          // client environment.
+          return [];
+        }
+      } catch {
+        // File deleted/moved during HMR, let default handling proceed
+      }
+    },
+  });
+
+  plugins.push(exposeActionId());
+
+  // "use cache" directive transform (enforce: "post"):
+  // Wraps exports with registerCachedFunction() for function-level caching.
+  plugins.push(useCacheTransform());
+
+  // Consolidated plugin for create* ID injection (enforce: "post"):
+  // loaders, handles, location state, and prerender handlers.
+  plugins.push(exposeInternalIds());
+
+  // Router ID injection runs at normal priority (no enforce) to avoid
+  // changing Vite's dep optimization timing.
+  plugins.push(exposeRouterId());
+
+  // Add version virtual module plugin for cache invalidation
+  plugins.push(createVersionPlugin());
+
+  // Entry path for discovery: user-specified value (if any) or undefined.
+  // Auto-discovered path is passed separately via routerRef.
+  // Cloudflare preset: deferred to configResolved (read from resolved Vite env config).
+  const discoveryEntryPath =
+    preset !== "cloudflare" ? routerRef.path : undefined;
+  // Ref for deferred auto-discovery (node preset only, undefined for cloudflare)
+  const discoveryRouterRef = preset !== "cloudflare" ? routerRef : undefined;
+
+  // Version injector: auto-injects VERSION and routes-manifest into the RSC entry.
+  // For cloudflare preset, the entry is resolved lazily in configResolved.
+  // For node preset, the virtual entry already includes these imports.
+  if (preset === "cloudflare") {
+    plugins.push(createVersionInjectorPlugin(undefined));
+  }
+
+  // Transform CJS vendor files to ESM for browser compatibility
+  // optimizeDeps.include doesn't work because the file is loaded after initial optimization
+  plugins.push(createCjsToEsmPlugin());
+
+  // Router discovery plugin for build-time manifest generation.
+  // For cloudflare, the entry is resolved lazily in configResolved from the RSC environment.
+  // For node, discoveryRouterRef provides the auto-discovered path when not user-specified.
+  plugins.push(
+    createRouterDiscoveryPlugin(discoveryEntryPath, {
+      routerPathRef: discoveryRouterRef,
+      enableBuildPrerender: prerenderEnabled,
+      buildEnv: options?.buildEnv,
+      preset,
+      clientChunkCtx,
+    }),
+  );
+
+  debugConfig?.(
+    "rango(%s) setup done: %d plugin(s) (%sms)",
+    preset,
+    plugins.length,
+    (performance.now() - rangoStart).toFixed(1),
+  );
+  return plugins;
+}