vite-plugin-react-server 0.3.7 → 0.3.8

package/plugin/react-server/plugin.ts

@@ -18,7 +18,7 @@ import { resolvePages } from "../config/resolvePages.js";
 import { resolveUserConfig } from "../config/resolveUserConfig.js";
 import { getModuleManifest } from "../helpers/getModuleManifest.js";
 import { tryManifest } from "../helpers/tryManifest.js";
-import { createBuildLoader } from '../loader/createBuildLoader.js';
+import { createBuildLoader } from "../loader/createBuildLoader.js";
 import type {
   BuildTiming,
   CheckFilesExistReturn,
@@ -33,7 +33,10 @@ import { createHandler } from "./createHandler.js";
 
 export function reactServerPlugin(
   options: StreamPluginOptions
-): import("vite").Plugin<{ meta: ReactStreamPluginMeta,  addCssFile: (path: string) => void } > {
+): import("vite").Plugin<{
+  meta: ReactStreamPluginMeta;
+  addCssFile: (path: string) => void;
+}> {
   const timing: BuildTiming = {
     start: performance.now(),
   };
@@ -195,12 +198,7 @@ export function reactServerPlugin(
       });
     },
     async config(config, configEnv): Promise<UserConfig> {
-      if (typeof config.root === "string" && config.root !== root) {
-        console.log(
-          "[vite-plugin-react-server] Root dir changed",
-          config.root,
-          root
-        );
+      if (typeof config.root === "string" && config.root !== root && config.root !== process.cwd() && config.root !== "") {
         root = config.root;
       }
       const resolvedPages = await resolvePages(userOptions.build.pages);
@@ -253,7 +251,7 @@ export function reactServerPlugin(
         let htmlWorkerPath = serverManifest["html-worker"]?.file;
 
         if (options.htmlWorkerPath) {
-          htmlWorkerPath = join(root, options.htmlWorkerPath);
+          htmlWorkerPath = options.htmlWorkerPath;
         } else {
           htmlWorkerPath = join(
             getPluginRoot(),
@@ -261,16 +259,9 @@ export function reactServerPlugin(
           );
         }
 
-        // Initialize worker with path from server directory
-        const workerPath = resolve(
-          root,
-          userOptions.build.server,
-          htmlWorkerPath
-        );
-
         worker = await createWorker({
-          projectRoot: userOptions.projectRoot,
-          workerPath,
+          projectRoot: root,
+          workerPath: htmlWorkerPath,
           condition: "react-server",
           reverseCondition: true,
           mode: finalConfig.mode as "production" | "development",
@@ -283,7 +274,6 @@ export function reactServerPlugin(
           throw resolvedPages.error;
         }
         const routes = resolvedPages.pages;
-        console.log("[plugin] Routes to render:", routes);
 
         const entries = Object.values(serverManifest).filter(
           (entry) => entry.isEntry
@@ -297,11 +287,16 @@ export function reactServerPlugin(
 
         const { failedRoutes, completedRoutes } = await renderPages(routes, {
           pipableStreamOptions: {
-            bootstrapModules: entries.map((entry) => "/" + entry.file),
+            bootstrapModules: entries
+              .filter((entry) =>
+                userOptions.autoDiscover.clientComponents.test(entry.file)
+              )
+              .filter((t)=> typeof t === "object" && t != null && "file" in t)
+              .map((entry) => "/" + entry.file.replace(userOptions.moduleBasePath, "")),
           },
           moduleBasePath: userOptions.moduleBasePath,
           moduleBaseURL: userOptions.moduleBaseURL,
-          clientCss: css?.map((css) => "/" + css) ?? [],
+          clientCss: css?.filter((css) => typeof css === "string").map((css) => "/" + css.replace(userOptions.moduleBasePath, "")) ?? [],
           userConfig,
           pluginOptions: userOptions,
           worker: worker,
@@ -309,25 +304,17 @@ export function reactServerPlugin(
           loader,
           onCssFile: (path: string) => {
             if (buildCssFiles && path.endsWith(".css")) {
-              buildCssFiles.add(path);
+              buildCssFiles.add(path.replace(userOptions.moduleBasePath, ""));
             }
           },
         });
 
-        // Debug render results
-        console.log("[vite-plugin-react-server] Render results:", {
-          failedRoutes,
-          completedRoutes,
-        });
-
         if (failedRoutes.size) {
           console.error(
             "[vite-plugin-react-server] Failed to render routes:",
             failedRoutes
           );
         }
-        console.log("[vite-plugin-react-server] Render complete");
-        console.log("[vite-plugin-react-server] Terminating worker");
         if (worker) await worker.terminate();
 
         timing.renderEnd = performance.now();
@@ -438,15 +425,7 @@ export function reactServerPlugin(
       };
 
       if (chunk.fileName.includes("html-worker")) {
-        const workerPath = resolve(
-          root,
-          userOptions.build.server,
-          chunk.fileName
-        );
-        console.log("Files in output dir:", {
-          files: readdirSync(resolve(root, userOptions.build.server)),
-          workerPath,
-        });
+        const workerPath = resolve(root, chunk.fileName);
 
         // Don't initialize worker during build phase
         if (finalConfig.command === "build") {

package/plugin/resolveProps.ts

@@ -44,7 +44,6 @@ export async function resolveProps({
   if (found) {
     let value = propsModule[found];
     try {
-      console.log("[resolveProps] Found:", found, value);
       // If it's a function, call it with the URL
       if (isFunction(value)) {
         const props = await value(url);

package/plugin/worker/createWorker.ts

@@ -1,7 +1,7 @@
 import { Worker, type ResourceLimits } from "node:worker_threads";
 import { getMode, getNodePath } from "../config/getPaths.js";
 import { getCondition } from "../config/getCondition.js";
-
+import { join } from "node:path";
 type CreateWorkerOptions = {
   projectRoot?: string;
   condition?: "react-server" | "react-client";
@@ -45,7 +45,7 @@ export async function createWorker(options: CreateWorkerOptions) {
   const maxRetries = 3;
   for (let tries = 0; tries < maxRetries; tries++) {
     try {
-      const worker = new Worker(workerPath, {
+      const worker = new Worker(workerPath.startsWith('/') ? workerPath : join(projectRoot, workerPath), {
         env,
         // Increase resource limits for stream handling
         resourceLimits: resourceLimits

package/plugin/worker/html/renderPages.ts

@@ -1,10 +1,10 @@
+import { mkdirSync } from "node:fs";
+import { mkdir, writeFile } from "node:fs/promises";
 import { dirname, join, resolve as resolvePath } from "node:path";
 import { Transform } from "node:stream";
 import type { Worker } from "node:worker_threads";
 import { createHandler } from "../../react-server/createHandler.js";
 import type { ResolvedUserConfig, StreamPluginOptions } from "../../types.js";
-import { mkdir, writeFile } from "node:fs/promises";
-import { mkdirSync } from "node:fs";
 
 interface PipeableStreamOptions {
   bootstrapModules?: string[];
@@ -57,10 +57,8 @@ export async function renderPages(
   const moduleBaseURL = options.moduleBaseURL;
   const htmlRoot = join(
     options.userConfig.root,
-    options.pluginOptions.build?.client ?? options.userConfig.build.outDir.replace('server', 'client')
+    options.userConfig.build.outDir
   );
-  console.log("[renderPages] HTML root:", htmlRoot);
-
   const streamStarted = new Set<string>();
   const completedRoutes = new Set<string>();
   const htmlContent = new Map<string, string>();
@@ -68,9 +66,7 @@ export async function renderPages(
 
   // Create a promise that resolves when all routes are complete
   const allRoutesComplete = new Promise<void>((resolve, reject) => {
-    const timeout = setTimeout(() => {
-      reject(new Error(`Render timeout - Started: ${streamStarted.size}, Completed: ${completedRoutes.size}`));
-    }, 5000);
+
 
     options.worker.on("message", function messageHandler(msg: any) {
       switch (msg.type) {
@@ -87,7 +83,6 @@ export async function renderPages(
           
           if (completedRoutes.size === routes.length) {
             options.worker.removeListener("message", messageHandler);
-            clearTimeout(timeout);
             
             // Write all HTML files
             for (const [route, html] of htmlContent) {
@@ -124,7 +119,6 @@ export async function renderPages(
     await mkdir(htmlRoot, { recursive: true });
 
     const renderPromises = routes.map(async (route) => {
-      console.log("[renderPages] Processing route:", route);
       
       try {
         const result = await createHandler(route, options.pluginOptions, {