@rangojs/router 0.10.1 → 0.12.0

package/src/vite/plugins/use-cache-transform.ts

@@ -17,6 +17,7 @@
  */
 
 import type { Plugin } from "vite";
+import type { ModuleExportMeta } from "@vitejs/plugin-rsc/transforms";
 import path from "node:path";
 import MagicString from "magic-string";
 import { normalizePath, hashId } from "./expose-id-utils.js";
@@ -89,6 +90,13 @@ export function useCacheTransform(): Plugin {
           return;
         }
 
+        // plugin-rsc 0.5.34 `matchDirective` does `stmt.directive.match(...)`
+        // after `"directive" in node`. Vite/oxc parseAst now emits
+        // `directive: null` on ordinary ExpressionStatements, so a file that
+        // mixes a `"use cache"` function with a sibling handler whose first
+        // statement is an expression throws and the wrap is dropped.
+        stripNullDirectiveFields(ast);
+
         const filePath = normalizePath(path.relative(projectRoot, id));
         const isLayoutOrTemplate = LAYOUT_TEMPLATE_PATTERN.test(id);
 
@@ -101,6 +109,7 @@ export function useCacheTransform(): Plugin {
             isBuild,
             isLayoutOrTemplate,
             transformWrapExport,
+            hasDirective,
           );
         }
 
@@ -131,6 +140,7 @@ function transformFileLevelUseCache(
   isBuild: boolean,
   isLayoutOrTemplate: boolean,
   transformWrapExport: (typeof import("@vitejs/plugin-rsc/transforms"))["transformWrapExport"],
+  hasDirective: (typeof import("@vitejs/plugin-rsc/transforms"))["hasDirective"],
 ) {
   const unconfirmedExports: string[] = [];
 
@@ -140,8 +150,18 @@ function transformFileLevelUseCache(
       return `__rango_registerCachedFunction(${value}, ${JSON.stringify(funcId)}, "default")`;
     },
     rejectNonAsyncFunction: false,
-    filter: (name: string, meta: { isFunction?: boolean }) => {
+    filter: (name: string, meta: ModuleExportMeta) => {
       if (name === "default" && isLayoutOrTemplate) return false;
+      // plugin-rsc 0.5.34 hoists mixed inline `"use server"` out of a
+      // file-level `"use cache"` module as `$$hoist_*` exports and rebinds the
+      // original name to `registerServerReference($$hoist_*, ...)`. Both are
+      // server references, not cached functions. The directive check covers
+      // the pre-hoist shape (this plugin seeing the source first).
+      if (name.startsWith("$$hoist_")) return false;
+      if (isHoistedServerReferenceRebind(meta.valueNode)) return false;
+      if (functionHasUseServerDirective(meta.valueNode, hasDirective)) {
+        return false;
+      }
       // isFunction is boolean | undefined: true = confirmed function, false =
       // confirmed non-function, undefined = cannot tell statically (e.g. a
       // factory/HOF initializer `const x = makeCached(fn)`). Deliberate policy:
@@ -250,6 +270,50 @@ function transformFunctionLevelUseCache(
   }
 }
 
+function stripNullDirectiveFields(node: unknown): void {
+  if (!node || typeof node !== "object") return;
+  const rec = node as Record<string, unknown>;
+  if (rec.type === "ExpressionStatement" && typeof rec.directive !== "string") {
+    delete rec.directive;
+  }
+  for (const value of Object.values(rec)) {
+    if (Array.isArray(value)) {
+      for (const item of value) stripNullDirectiveFields(item);
+    } else if (value && typeof value === "object" && "type" in value) {
+      stripNullDirectiveFields(value);
+    }
+  }
+}
+
+function isHoistedServerReferenceRebind(
+  valueNode: ModuleExportMeta["valueNode"],
+): boolean {
+  if (!valueNode || valueNode.type !== "CallExpression") return false;
+  const first = valueNode.arguments[0];
+  return (
+    first !== undefined &&
+    first.type === "Identifier" &&
+    first.name.startsWith("$$hoist_")
+  );
+}
+
+function functionHasUseServerDirective(
+  valueNode: ModuleExportMeta["valueNode"],
+  hasDirective: (typeof import("@vitejs/plugin-rsc/transforms"))["hasDirective"],
+): boolean {
+  if (!valueNode || !("body" in valueNode)) return false;
+  const { body } = valueNode;
+  if (!body || Array.isArray(body) || body.type !== "BlockStatement") {
+    return false;
+  }
+  // plugin-rsc types valueNode with plain estree nodes but hasDirective with
+  // its oxc-flavored AST; the flavors differ only in position/extra fields.
+  return hasDirective(
+    body.body as Parameters<typeof hasDirective>[0],
+    "use server",
+  );
+}
+
 function findFileLevelDirective(
   ast: any,
 ): { start: number; end: number } | null {

package/src/vite/plugins/virtual-entries.ts

@@ -63,18 +63,20 @@ function emitProgressiveChunkSize(value: number): string {
 /**
  * Generate the virtual SSR entry. `headScripts` mirrors the rango() plugin
  * option: "preinit" (default) installs the client-reference preinit hook and
- * lets the SSR handlers convert the bootstrap to `bootstrapModules`;
- * "preload" omits the hook and pins the handlers to the hint-only strategy.
+ * threads `getClientEntryUrl` so Fizz emits `bootstrapModules`;
+ * "preload" omits the hook and uses the deprecated inline
+ * `loadBootstrapScriptContent` bootstrap.
  */
 export function getVirtualEntrySSR(
   headScripts: HeadScriptsOption = "preinit",
   progressiveChunkSize?: number,
 ): string {
   const preinit = headScripts !== "preload";
-  // The preload variant drops exactly three preinit-only lines, all built
-  // here so the template below stays a single unconditional shape.
+  // The preload variant drops the preinit-only imports/install and swaps the
+  // bootstrap dep, all built here so the template below stays a single
+  // unconditional shape.
   const depsImportNames = preinit
-    ? "createFromReadableStream,\n  setOnClientReference,"
+    ? "createFromReadableStream,\n  setOnClientReference,\n  getClientEntryUrl,"
     : "createFromReadableStream,";
   const ssrImportNames = preinit ? "\n  installClientReferencePreinit," : "";
   const install = preinit
@@ -85,6 +87,10 @@ export function getVirtualEntrySSR(
 installClientReferencePreinit(setOnClientReference);
 `
     : "";
+  const bootstrapDep = preinit
+    ? "getClientEntryUrl,"
+    : `loadBootstrapScriptContent: () =>
+    import.meta.viteRsc.loadBootstrapScriptContent("index"),`;
   const hs = JSON.stringify(headScripts);
   // Emitted into all three handlers: live SSR and shell capture consume it
   // directly; the resume handler receives it for dep-shape uniformity (resume()
@@ -114,8 +120,7 @@ export const renderHTML = createSSRHandler({
   renderToReadableStream,
   injectRSCPayload,
   headScripts: ${hs},${pcs}
-  loadBootstrapScriptContent: () =>
-    import.meta.viteRsc.loadBootstrapScriptContent("index"),
+  ${bootstrapDep}
 });
 
 export const captureShellHTML = createShellCaptureHandler({
@@ -125,8 +130,7 @@ export const captureShellHTML = createShellCaptureHandler({
   prerender,
   resume,
   headScripts: ${hs},${pcs}
-  loadBootstrapScriptContent: () =>
-    import.meta.viteRsc.loadBootstrapScriptContent("index"),
+  ${bootstrapDep}
 });
 
 export const resumeShellHTML = createShellResumeHandler({
@@ -136,8 +140,7 @@ export const resumeShellHTML = createShellResumeHandler({
   prerender,
   resume,
   headScripts: ${hs},${pcs}
-  loadBootstrapScriptContent: () =>
-    import.meta.viteRsc.loadBootstrapScriptContent("index"),
+  ${bootstrapDep}
 });
 `.trim();
 }