vite-plugin-react-server 1.2.2 → 1.2.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vite-plugin-react-server",
-  "version": "1.2.2",
+  "version": "1.2.4",
   "description": "Vite plugin for React Server Components (RSC)",
   "type": "module",
   "main": "./dist/plugin/index.js",

package/plugin/helpers/createSharedLoader.ts

@@ -38,7 +38,7 @@ export async function createSharedLoader({
   buildServerDir,
   // Direct import options
   isBuildMode = false,
-  isServeMode = false,
+  isServeMode: _isServeMode = false,
   effectiveProjectRoot,
   build,
 }: {
@@ -99,66 +99,32 @@ export async function createSharedLoader({
     });
 
     if (manifestResolution.manifestEntry && manifestResolution.resolvedPath) {
-      // Found in manifest - use the resolved path (it's already a full absolute path)
       resolvedModuleID = manifestResolution.resolvedPath;
-      if (verbose) {
-        logger?.info(
-          `[createSharedLoader] Build mode: resolved via manifest to: ${resolvedModuleID}`
-        );
-      }
     } else {
-      // Not in manifest - use the builtModuleId from resolution
       resolvedModuleID = manifestResolution.builtModuleId;
-      if (verbose) {
-        logger?.info(
-          `[createSharedLoader] Build mode: not in manifest, using builtModuleId: ${resolvedModuleID}`
-        );
-      }
       
-      // Check if we need to prefix with build directory
-      // A source path starts with moduleBase (e.g., "src/"), a built path doesn't
-      // Also check if it's already an absolute path or starts with file://
+      // Prefix non-source, non-absolute paths with server build directory
       const isSourcePath = moduleId.startsWith(moduleBase + "/") || 
                           moduleId.startsWith("./" + moduleBase + "/") ||
                           (isAbsolute(moduleId) && moduleId.includes(moduleBase));
       
-      // If it's not a source path and not already absolute, prefix with server build directory
       if (!isSourcePath && !isAbsolute(resolvedModuleID) && effectiveProjectRoot && build) {
-        const serverBuildPath = join(
+        resolvedModuleID = join(
           effectiveProjectRoot,
           build.outDir || "dist",
-          build.server || "server"
-        );
-        resolvedModuleID = join(serverBuildPath, resolvedModuleID);
-        if (verbose) {
-          logger?.info(
-            `[createSharedLoader] Build mode: prefixing with ${serverBuildPath}: ${resolvedModuleID}`
-          );
-        }
-      }
-    }
-  } else if (isServeMode) {
-    // Dev mode: load directly from source files, no build path prefixing
-    if (verbose) {
-      logger?.info(
-        `[createSharedLoader] Dev mode: loading directly from source`
-      );
-    }
-  } else if (isBuildMode && effectiveProjectRoot && build) {
-    // Build mode fallback: prefix with server build directory even without manifest/normalizer
-    if (!isAbsolute(resolvedModuleID)) {
-      const serverBuildPath = join(
-        effectiveProjectRoot,
-        build.outDir || "dist",
-        build.server || "server"
-      );
-      resolvedModuleID = join(serverBuildPath, resolvedModuleID);
-      if (verbose) {
-        logger?.info(
-          `[createSharedLoader] Build mode fallback: prefixing with ${serverBuildPath}: ${resolvedModuleID}`
+          build.server || "server",
+          resolvedModuleID
         );
       }
     }
+  } else if (isBuildMode && effectiveProjectRoot && build && !isAbsolute(resolvedModuleID)) {
+    // Build mode fallback without manifest
+    resolvedModuleID = join(
+      effectiveProjectRoot,
+      build.outDir || "dist",
+      build.server || "server",
+      resolvedModuleID
+    );
   }
 
   // Step 3: Construct the full path and import
@@ -168,40 +134,21 @@ export async function createSharedLoader({
       ? join(effectiveProjectRoot, resolvedModuleID)
       : resolvedModuleID;
 
-  if (verbose) {
-    logger?.info(`[createSharedLoader] Importing from: ${fullPath}`);
-  }
-
-  // Step 4: Import the module
+  // Import the module
   const fileUrl = isAbsolute(fullPath) ? pathToFileURL(fullPath).href : fullPath;
   const result = await import(fileUrl);
 
-  // Step 5: Validate exports
+  // Validate exports
   if (result == null) {
     throw new Error(`Module "${moduleId}" does not have any exports`);
   }
-
   if (!Object.keys(result).length && exportName?.length) {
-    throw new Error(
-      `Module "${moduleId}" is a module, but does not have any exports so it can't find ${exportName}`
-    );
+    throw new Error(`Module "${moduleId}" has no exports, can't find ${exportName}`);
   }
-
   if (exportName && !(exportName in result)) {
-    throw new Error(
-      `Module "${moduleId}" exists, but does not export "${exportName}"`
-    );
-  }
-
-  if (verbose) {
-    logger?.info(
-      `[createSharedLoader] Module loaded successfully, exports: ${Object.keys(
-        result
-      ).join(", ")}`
-    );
+    throw new Error(`Module "${moduleId}" does not export "${exportName}"`);
   }
 
-  // Import always returns a module object (not a Promise), so return it directly
   return result;
 }
 

package/plugin/loader/directives/analyzeDirectives.ts

@@ -67,11 +67,15 @@ export function analyzeDirectives(
       ? optionsOrMatches.logger ?? _logger ?? createLogger()
       : _logger ?? createLogger();
   // Check if this looks like Vite-injected code
+  // During build, Vite may prepend imports (e.g., __vitePreload for dynamic imports)
+  // before "use client"/"use server" directives
   const isViteInjectedCode =
     source.includes("__vite__createHotContext") ||
     source.includes("import.meta.hot") ||
     source.includes("import.meta.env") ||
-    source.includes("/@vite/client");
+    source.includes("/@vite/client") ||
+    source.includes("__vitePreload") ||
+    source.includes("\0vite/");
 
   for (const node of ast.body) {
     // Debug logging

package/plugin/loader/react-loader.ts

@@ -119,30 +119,11 @@ export const load: LoadHook = async (url, context, nextLoad) => {
     });
   }
   const verbose = userOptions?.verbose ?? false;
-  if (verbose) {
-    logger.info(`Attempting to load: ${url}`);
-    logger.info(`Context: ${JSON.stringify({
-      format: context.format,
-      conditions: context.conditions,
-    })}`);
-  }
 
   const { format } = context;
   if (format === "module" || format === "module-typescript") {
-    if (verbose) {
-      logger.info(`Loading module: ${url}`);
-    }
-    
     // Load the URL normally
     const result = await nextLoad(url, context);
-    
-    if (verbose) {
-      logger.info(`Next load result: ${JSON.stringify({
-        format: result.format,
-        shortCircuit: result.shortCircuit,
-        source: typeof result.source,
-      })}`);
-    }
 
     let source =
       typeof result.source === "string"
@@ -187,45 +168,18 @@ export const load: LoadHook = async (url, context, nextLoad) => {
         ? isClientComponent(source, url)
         : false);
 
-    if (verbose) {
-      let startPreviewIndex = 0;
-      let startLine = 0;
-      const lines = source.split("\n");
-      while (
-        lines[startLine].trim() === "" || lines[startLine].trim() === "\r" ||
-        // comment lines
-        lines[startLine].trim().startsWith("//")
-        || lines[startLine].trim().startsWith("/**")
-        || lines[startLine].trim().startsWith("*")
-      ) {
-        startPreviewIndex += lines[startLine].length;
-        startLine++;
-      }
-      logger.info(`Module analysis: ${JSON.stringify({
-        url,
-        isServer,
-        isClient,
-        hasFileLevelServerDirective,
-        hasFileLevelClientDirective,
-        sourceLength: source.length,
-        sourcePreview: source.slice(startPreviewIndex, startPreviewIndex + 100) + "...",
-      })}`);
-    }
-
     if (!isServer && !isClient) {
-      if (verbose) {
-        logger.info(`Skipping non-server/non-client module: ${url}`);
-      }
       // Return modified source if CJS React imports were rewritten
       return { ...result, source };
     }
 
-    // Handle file URLs
-    const filePath = url.startsWith("file://") ? fileURLToPath(url) : url;
     if (verbose) {
-      logger.info(`File path: ${filePath}`);
+      logger.info(`[react-loader] ${isServer ? 'server' : 'client'} module: ${url}`);
     }
 
+    // Handle file URLs
+    const filePath = url.startsWith("file://") ? fileURLToPath(url) : url;
+
     if(typeof userOptions.moduleID !== "function") {
       // Ensure we have proper build context for RSC worker
       // If configEnv is not available or doesn't indicate build mode, create a build-compatible configEnv
@@ -249,27 +203,11 @@ export const load: LoadHook = async (url, context, nextLoad) => {
       const [, value] = userOptions.normalizer(filePath);
       moduleID = join(userOptions.moduleBasePath, value);
       finalID = userOptions.moduleID?.(moduleID) || moduleID;
-      if (verbose) {
-        logger.info(`Normalized IDs: ${moduleID} -> ${finalID}`);
-        logger.info(`userOptions: ${JSON.stringify(userOptions)}`);
-      }
     }
 
     const { code: transformed, map } = await transformer(source, moduleID, finalID);
 
-    if (verbose) {
-      logger.info(`Transformation result: ${JSON.stringify({
-        originalLength: source.length,
-        transformedLength: transformed.length,
-        wasTransformed: source !== transformed,
-        hasSourceMap: !!map,
-      })}`);
-    }
-
     if (loaderPort) {
-      if (verbose) {
-        logger.info("Sending SERVER_MODULE message");
-      }
       loaderPort.postMessage({
         type: "SERVER_MODULE",
         id: finalID,
@@ -285,21 +223,9 @@ export const load: LoadHook = async (url, context, nextLoad) => {
     };
   }
 
-  if (verbose) {
-    logger.info(`Skipping non-module format: ${format}`);
-  }
   return nextLoad(url, context);
 };
 
 export const resolve: ResolveHook = async (specifier, context, nextResolve) => {
-  verbose = userOptions?.verbose ?? false;
-  if (verbose) {
-    logger.info(`Resolving: ${specifier}`);
-    logger.info(`Resolve context: ${JSON.stringify(context)}`);
-  }
-  const result = await nextResolve(specifier, context);
-  if (verbose) {
-    logger.info(`Resolve result: ${JSON.stringify(result)}`);
-  }
-  return result;
+  return nextResolve(specifier, context);
 };

package/plugin/worker/rsc/createRscWorkerLoader.ts

@@ -4,15 +4,11 @@ import type { GenericModuleLoader } from "../../types.js";
 import { createSharedLoader } from "../../helpers/createSharedLoader.js";
 
 /**
- * Creates a simple GenericModuleLoader for the RSC worker
- *
- * This follows the same pattern as the main thread server version:
- * - Simple dynamic import-based loading
- * - Proper export name resolution
- * - Works in both dev and build scenarios
+ * Creates a GenericModuleLoader for the RSC worker.
+ * Uses createSharedLoader for virtual modules, manifest resolution, and imports.
  */
 export const createRscWorkerLoader = ({
-  verbose = false, // Disable verbose for performance
+  verbose = false,
   logger = createLogger(workerData.resolvedConfig?.logLevel ?? "info", {
     prefix: "vite:plugin-react-server/worker/rsc",
   }),
@@ -31,57 +27,14 @@ export const createRscWorkerLoader = ({
   };
   manifest?: Record<string, any>;
 } = {}): GenericModuleLoader => {
-  // Debug log the build config
-  if (verbose) {
-    logger.info(`[createRscWorkerLoader] build config: ${JSON.stringify(build)}`);
-  }
-  
-  // Determine projectRoot based on configEnv if not provided
-  // In dev mode, configEnv.command should be "serve", but if it's undefined,
-  // we can detect dev mode by checking if we're in a dev server environment
   const isBuildMode = workerData.configEnv?.command === "build";
-  const isServeMode = !isBuildMode
+  const isServeMode = !isBuildMode;
   const effectiveProjectRoot =
     projectRoot || workerData.userOptions?.projectRoot || process.cwd();
 
-  // Log build config for debugging
-  if (verbose) {
-    logger.info(
-      `[createRscWorkerLoader] build config: ${JSON.stringify(build)}`
-    );
-    logger.info(
-      `[createRscWorkerLoader] manifest: ${JSON.stringify(manifest)}`
-    );
-  }
-  
-  if (verbose) {
-    logger.info(
-      `[createRscWorkerLoader] configEnv: ${JSON.stringify(
-        workerData.configEnv
-      )}`
-    );
-    logger.info(
-      `[createRscWorkerLoader] config.env: ${JSON.stringify(
-        workerData.resolvedConfig?.env
-      )}`
-    );
-    logger.info(
-      `[createRscWorkerLoader] mode: ${workerData.resolvedConfig?.mode}`
-    );
-    logger.info(`[createRscWorkerLoader] NODE_ENV: ${process.env.NODE_ENV}`);
-    logger.info(`[createRscWorkerLoader] isServeMode: ${isServeMode}`);
-    logger.info(`[createRscWorkerLoader] projectRoot: ${effectiveProjectRoot}`);
-  }
-
-  // Simple GenericModuleLoader using shared loader utility
   return async (id: string) => {
-    if (verbose) {
-      logger.info(`[RSC Worker Loader] Loading module: ${id}`);
-    }
-
     const [moduleID, exportName] = id.split("#");
 
-    // Use shared loader utility - it handles virtual modules, manifest resolution, and imports
     return await createSharedLoader({
       moduleId: moduleID,
       exportName,