vite-plugin-react-server 1.1.17 → 1.1.18

package/plugin/transformer/plugin.server.ts

@@ -36,19 +36,22 @@ import { logError } from "../error/toError.js";
  * });
  * ```
  */
-let isBuild = true;
-let isSSR = false;
 
 export function reactTransformPlugin<
   T extends PagePropOpt = PagePropOpt,
   InlineCSS extends InlineCssOpt = InlineCssOpt
 >(options: StreamPluginOptions<T, InlineCSS>): Plugin {
   let userOptions: ResolvedUserOptions<T, InlineCSS>;
+
   const resolvedOptionsResult = resolveOptions(options);
+
   if (resolvedOptionsResult.type === "error") throw resolvedOptionsResult.error;
+
   userOptions = resolvedOptionsResult.userOptions;
 
-  let staticManifest: Manifest;
+  let staticManifest: Manifest = {};
+  let isBuild = true;
+  let isSSR = false;
 
   return {
     name: "vite:react-server-transform",
@@ -56,16 +59,21 @@ export function reactTransformPlugin<
     async configResolved(config) {
       isBuild = config.command === "build";
       isSSR = config.build?.ssr === true;
+
       if (isBuild && isSSR) {
         const staticManifestResult = await tryManifest({
           root: userOptions.projectRoot,
           ssrManifest: false,
           outDir: join(userOptions.build.outDir, userOptions.build.static),
+          manifestPath: config.build.manifest,
         });
+
         if (staticManifestResult.type === "error") {
           throw staticManifestResult.error;
         }
-        staticManifest = staticManifestResult.manifest;
+        if (staticManifestResult.type === "success") {
+          staticManifest = staticManifestResult.manifest;
+        }
       }
     },
     async resolveId(
@@ -100,27 +108,28 @@ export function reactTransformPlugin<
       if (!options?.ssr || !userOptions.autoDiscover.modulePattern(id)) {
         return null;
       }
-      const [, value] = userOptions.normalizer(id);
-      let moduleID = value;
+      const isServerFunctionCode = userOptions.autoDiscover.isServerFunctionCode(code);
+      const isClientComponentCode = userOptions.autoDiscover.isClientComponentCode(code);
+      if(!isServerFunctionCode && !isClientComponentCode) {
+        return null;
+      }
+      let [, moduleID] = userOptions.normalizer(id);
       if (isBuild) {
         if (staticManifest) {
-          if (value in staticManifest) {
-            moduleID = staticManifest[value].file;
+          if (moduleID in staticManifest) {
+            moduleID = staticManifest[moduleID].file;
           }
         } else {
           throw new Error(`Static manifest not found during dev build.`);
         }
-      } else {
-        // For non-SSR builds, just use the normalized path
-        moduleID = join(userOptions.moduleBasePath, value);
       }
       let finalID = userOptions.moduleID(moduleID);
       // Always transform in server context
       const transformed = transformModuleIfNeeded(
         code,
         finalID,
-        userOptions.autoDiscover.isServerFunctionCode(code),
-        userOptions.autoDiscover.isClientComponentCode(code),
+        isServerFunctionCode,
+        isClientComponentCode,
         true
       );
       if (userOptions.verbose)
@@ -145,14 +154,12 @@ export function reactTransformPlugin<
         }
       if (!transformed) {
         return {
-          id: finalID,
           code: "",
           map: null,
         };
       }
 
       return {
-        id: finalID,
         code: transformed,
         map: null,
       };

package/plugin/types.ts

@@ -19,6 +19,8 @@ import type {
   ViteDevServer,
 } from "vite";
 import type { ReactServerDomEsmOptions } from "./worker/types.js";
+import type { FragmentProps } from "react";
+import type { ExoticComponent } from "react";
 
 export type OnEvent = (event: PluginEvent) => void;
 
@@ -457,7 +459,7 @@ export interface StreamPluginOptions<
   // Auto-discovery (zero-config)
   autoDiscover?:
     | {
-      // default: /\.(m|c)?(j|t)sx?$/
+        // default: /\.(m|c)?(j|t)sx?$/
         moduleExtension?: RegExp;
         // default: /^"use server"[\s;]*\n?/m
         serverDirective?: RegExp;
@@ -561,12 +563,13 @@ export type CreateHandlerOptions<
   | "moduleRootPath"
   | "moduleBasePath"
   | "moduleBaseURL"
+  | "publicOrigin"
   | "pipeableStreamOptions"
   | "onEvent"
   | "onMetrics"
   | "projectRoot"
   | "normalizer"
-  | "moduleID"  
+  | "moduleID"
 > & {
   logger: Logger;
   loader: ModuleLoader;
@@ -778,10 +781,9 @@ export type InlineCssOpt = undefined | boolean;
 export type PagePropOpt = Record<string, unknown> | undefined;
 export type RegExpOpt = RegExp | string | ((path: string) => boolean);
 
-export type AsOpt = Exclude<
-  keyof React.JSX.IntrinsicElements,
-  "symbol" | "object"
->;
+export type AsOpt =
+  | ExoticComponent<FragmentProps>
+  | Exclude<keyof React.JSX.IntrinsicElements, "symbol" | "object">;
 export type PageComponentType<T extends PagePropOpt = PagePropOpt> =
   React.ComponentType<T & React.PropsWithChildren<{}>>;
 

package/plugin/worker/rsc/state.ts

@@ -4,7 +4,6 @@ import type { CssContent, ResolvedUserOptions, HmrState } from "../../types.js";
 import type { PassThrough } from "node:stream";
 import { relative } from "node:path";
 
-
 // Track active RSC streams
 export const activeStreams = new Map<string, PassThrough>();
 
@@ -16,40 +15,66 @@ export const moduleIds = new Map<string, string>();
 
 export const hmrState = new Map<string, HmrState>();
 
-if(workerData) {
-  if(workerData.hmrPort) {
-    workerData.hmrPort.on('message', (msg: { type: string; path: string; routes?: string[] }) => {
-      if(msg.type === 'HMR_UPDATE') {
-        // Normalize the path relative to project root
-        const normalizedPath = relative(workerData.userOptions.projectRoot, msg.path);
-        hmrState.set(normalizedPath, { 
-          timestamp: Date.now(), 
-          invalidated: true,
-          routes: msg.routes || []
-        });
-      } else if(msg.type === 'HMR_ACCEPT') {
-        // Normalize the path relative to project root
-        const normalizedPath = relative(workerData.userOptions.projectRoot, msg.path);
-        hmrState.delete(normalizedPath);
+if (workerData) {
+  if (workerData.hmrPort) {
+    workerData.hmrPort.on(
+      "message",
+      (msg: { type: string; path: string; routes?: string[] }) => {
+        if (msg.type === "HMR_UPDATE") {
+          // Normalize the path relative to project root
+          const normalizedPath = relative(
+            workerData.userOptions.projectRoot,
+            msg.path
+          );
+          hmrState.set(normalizedPath, {
+            timestamp: Date.now(),
+            invalidated: true,
+            routes: msg.routes || [],
+          });
+        } else if (msg.type === "HMR_ACCEPT") {
+          // Normalize the path relative to project root
+          const normalizedPath = relative(
+            workerData.userOptions.projectRoot,
+            msg.path
+          );
+          hmrState.delete(normalizedPath);
+        }
       }
-    });
+    );
   }
 } else {
   throw new Error("This module must be run with workerData");
 }
 
-
-export function addCssFileContent(id: string, code: string, userOptions: Pick<ResolvedUserOptions, "projectRoot" | "moduleBaseURL" | "moduleBasePath" | "moduleRootPath" | "css" | "normalizer" | "moduleID">) {
-  if(typeof code !== "string"){
-    throw new Error(`Expected css to be loaded as a string, but got ${typeof code}`);
+export function addCssFileContent(
+  id: string,
+  code: string,
+  userOptions: Pick<
+    ResolvedUserOptions,
+    | "projectRoot"
+    | "moduleBaseURL"
+    | "moduleBasePath"
+    | "moduleRootPath"
+    | "css"
+    | "normalizer"
+    | "moduleID"
+    | "publicOrigin"
+  >
+) {
+  if (typeof code !== "string") {
+    throw new Error(
+      `Expected css to be loaded as a string, but got ${typeof code}`
+    );
   }
-  cssFiles.set(id, createCssProps({
+  cssFiles.set(
     id,
-    code,
-    userOptions
-  }));
-} 
-
+    createCssProps({
+      id,
+      code,
+      userOptions,
+    })
+  );
+}
 
 // Helper to check if a module is invalidated
 export function isModuleInvalidated(path: string): boolean {
@@ -75,4 +100,4 @@ export function addModuleId(id: string, url: string) {
 
 export function getModuleId(id: string): string | undefined {
   return moduleIds.get(id);
-} 
+}