vite-plugin-react-server 0.3.3 → 0.3.5

package/src/worker/createHtmlStream.ts

@@ -1,76 +0,0 @@
-import { createWriteStream } from "node:fs";
-import { Readable, Writable } from "node:stream";
-import { parentPort } from "node:worker_threads";
-import { renderToPipeableStream } from "react-dom/server";
-import { createFromNodeStream } from "react-server-dom-esm/client.node";
-import type { RenderState } from "./types.js";
-
-const concatter = (chunk: string) => {
-  if (Array.isArray(chunk)) {
-    return Buffer.from(chunk);
-  }
-  return Buffer.from(chunk);
-};
-
-export function createHtmlStream(
-  renderState: RenderState,
-  writeStream: Writable
-) {
-  const outputPath = renderState.htmlOutputPath;
-
-  // Create readable stream from RSC content
-  const rscStream = Readable.from(renderState.chunks.map(concatter));
-
-  // Create RSC node stream
-  const reactElements = createFromNodeStream(
-    rscStream,
-    renderState.moduleBasePath,
-    renderState.moduleBaseURL
-  );
-  // rsc file destination follows the same path as the html file, but with a .rsc extension
-  const rscOutputPath = renderState.htmlOutputPath.endsWith(".html")
-    ? renderState.htmlOutputPath.slice(0, -5) + ".rsc"
-    : renderState.htmlOutputPath.endsWith("/")
-    ? renderState.htmlOutputPath + "index.rsc"
-    : renderState.htmlOutputPath.endsWith(".")
-    ? renderState.htmlOutputPath + "rsc"
-    : renderState.htmlOutputPath + ".rsc";
-
-  const writeRscEntry = createWriteStream(rscOutputPath);
-  rscStream.on("data", (chunk) => {
-    writeRscEntry.write(chunk);
-  });
-  rscStream.on("end", () => {
-    writeRscEntry.end();
-  });
-  const stream = renderToPipeableStream(reactElements as React.ReactNode, {
-    ...renderState.pipableStreamOptions,
-    onAllReady() {
-      writeStream.on("finish", () => {
-        parentPort?.postMessage({
-          type: "HTML",
-          outputPath,
-          route: renderState.id,
-        });
-      });
-      writeStream.on("error", (error) => {
-        console.error("[Worker] Write error at", error);
-        stream.abort();
-      });
-    },
-    onShellReady() {
-      stream.pipe(writeStream);
-    },
-    onError(error) {
-      console.error("[Worker] Render error at", error);
-      stream.abort();
-      writeStream.destroy();
-    },
-    onShellError(error) {
-      console.error("[Worker] Shell error at", error);
-      stream.abort();
-      writeStream.destroy();
-    },
-  });
-  return { stream, writeStream };
-}

package/src/worker/createWorker.ts

@@ -1,44 +0,0 @@
-import { join } from "node:path";
-import { Worker } from "node:worker_threads";
-
-type CreateWorkerOptions = {
-  workerPath: string;
-  nodePath: string;
-  mode: "production" | "development";
-  workerOptions?: WorkerOptions;
-};
-
-export async function createWorker(
-  options: CreateWorkerOptions
-) {
-  const { workerPath, nodePath, mode, workerOptions } = options;
-  console.log("[Worker] Creating worker...");
-  console.log("[Worker] Worker path:", workerPath);
-
-  try {
-    const worker = new Worker(workerPath, {
-      env: {
-        NODE_OPTIONS: "",
-        NODE_ENV: mode,
-        NODE_PATH: nodePath,
-      },
-      ...workerOptions,
-    });
-    worker.setMaxListeners(1000);
-
-    // Wait for worker to be ready
-    await new Promise<void>((resolve, reject) => {
-      worker.once("message", (message) => {
-        if (message.type === "READY") {
-          resolve();
-        }
-      });
-      worker.once("error", reject);
-    });
-
-    return worker;
-  } catch (error) {
-    console.error("[Worker] Startup error:", error);
-    throw error;
-  }
-}

package/src/worker/renderPages.ts

@@ -1,144 +0,0 @@
-import { join, resolve as resolvePath } from "node:path";
-import { Transform } from "node:stream";
-import type { Worker } from "node:worker_threads";
-import type { PipeableStreamOptions } from "react-dom/server.node";
-import { createHandler } from "../react-server/createHandler.js";
-import type { StreamPluginOptions } from "../types.js";
-import type {
-  WorkerRscChunkMessage,
-  WorkerRscEndMessage,
-} from "./types.js";
-
-type RenderPagesOptions = {
-  pluginOptions: Required<
-    Pick<
-      StreamPluginOptions,
-      "moduleBase" | "moduleBasePath" | "moduleBaseURL" | "projectRoot"
-    >
-  > &
-    Pick<
-      StreamPluginOptions,
-      "Page" | "props" | "build" | "Html" | "pageExportName" | "propsExportName"
-    >;
-  outDir: string;
-  manifest: Record<string, { file: string }>;
-  worker: Worker;
-  pipableStreamOptions?: PipeableStreamOptions;
-  loader: (id: string) => Promise<Record<string, any>>;
-  onCssFile?: (path: string) => void;
-  clientCss?: string[];
-};
-
-export async function renderPages(
-  routes: string[],
-  options: RenderPagesOptions
-) {
-  const destinationRoot = resolvePath(
-    options.pluginOptions.projectRoot,
-    options.outDir
-  );
-  const failedRoutes = new Map<string, Error>();
-  const moduleBasePath = join(
-    destinationRoot,
-    options.pluginOptions.moduleBasePath
-  );
-  const moduleBaseURL = options.pluginOptions.moduleBaseURL;
-
-  const htmlRoot = resolvePath(
-    options.pluginOptions.projectRoot,
-    options.pluginOptions.build?.client ?? options.outDir
-  );
-  const filesOutputted: string[] = [];
-
-  options.worker.on("message", (msg) => {
-    switch (msg.type) {
-      case "ERROR":
-        console.error("[RenderPages] Worker error:", msg.error);
-        break;
-      case "HTML":
-        filesOutputted.push(msg.outputPath);
-        if (filesOutputted.length === routes.length) {
-          renderPromises.push(
-            new Promise<void>((resolve) => {
-              options.worker.removeAllListeners();
-              options.worker.terminate();
-              resolve();
-            })
-          );
-        }
-        break;
-      default:
-        break;
-    }
-  });
-  const pipableStreamOptions = options.pipableStreamOptions ?? {};
-
-  // Create promises for each route in the batch
-  const renderPromises = routes.map(async (route) => {
-    try {
-      // Wait for handler creation
-      const result = await createHandler(route, options.pluginOptions, {
-        loader: options.loader,
-        manifest: options.manifest,
-      });
-
-      if (result.type !== "success") {
-        return;
-      }
-      const htmlOutputPath = join(htmlRoot, route, "index.html");
-
-      // Create a promise that resolves when the worker completes
-      await new Promise<void>((resolve, reject) => {
-        // Pipe RSC stream to worker
-        const transform = new Transform({
-          transform(chunk, _encoding, callback) {
-            // Send raw chunk
-            options.worker.postMessage({
-              type: "RSC_CHUNK",
-              id: route,
-              chunk: chunk,
-              moduleBasePath,
-              moduleBaseURL,
-              htmlOutputPath: htmlOutputPath,
-              outDir: options.outDir,
-              pipableStreamOptions,
-            } satisfies WorkerRscChunkMessage);
-            callback();
-          },
-          flush(callback) {
-            options.worker.postMessage({
-              type: "RSC_END",
-              id: route,
-            } satisfies WorkerRscEndMessage);
-            callback();
-          },
-        });
-
-        // Listen for worker response for this route
-        const messageHandler = (msg: any) => {
-          if (msg.route === route) {
-            if (msg.type === "ERROR") {
-              options.worker.removeListener("message", messageHandler);
-              reject(new Error(msg.error));
-            } else if (msg.type === "HTML") {
-              options.worker.removeListener("message", messageHandler);
-              resolve();
-            }
-          }
-        };
-
-        options.worker.on("message", messageHandler);
-        result.stream?.pipe(transform);
-      });
-    } catch (error) {
-      failedRoutes.set(route, error as Error);
-    }
-  });
-
-  // Wait for all routes to complete
-  await Promise.all(renderPromises);
-
-  if (failedRoutes.size > 0) {
-    console.error("[vite-react-stream] Failed routes:", failedRoutes);
-  }
-}

package/src/worker/types.ts

@@ -1,38 +0,0 @@
-import type { PipeableStreamOptions } from "react-dom/server.node";
-
-export interface RenderState {
-  chunks: string[];
-  complete: boolean;
-  rendered: boolean;
-  outDir: string;
-  moduleBasePath: string;
-  moduleBaseURL: string;
-  htmlOutputPath: string;
-  id: string;
-  pipableStreamOptions: PipeableStreamOptions;
-}
-
-export interface WorkerRscChunkMessage {
-  type: "RSC_CHUNK";
-  id: string;
-  chunk: string;
-  moduleBasePath: string;
-  moduleBaseURL: string;
-  outDir: string;
-  htmlOutputPath: string;
-  pipableStreamOptions: PipeableStreamOptions;
-}
-
-export interface WorkerRscEndMessage {
-  type: "RSC_END";
-  id: string;
-}
-
-export interface WorkerShutdownMessage {
-  type: "SHUTDOWN";
-}
-
-export type WorkerMessage =
-  | WorkerRscChunkMessage
-  | WorkerRscEndMessage
-  | WorkerShutdownMessage;

package/src/worker/worker.tsx

@@ -1,136 +0,0 @@
-import { createWriteStream } from "node:fs";
-import { mkdir } from "node:fs/promises";
-import { dirname } from "node:path";
-import { Writable } from "node:stream";
-import { parentPort } from "node:worker_threads";
-import type { PipeableStream } from "react-server-dom-esm/server.node";
-import { createHtmlStream } from "./createHtmlStream.js";
-import type { RenderState, WorkerMessage } from "./types.js";
-
-if (!parentPort) {
-  throw new Error("This module must be run as a worker");
-}
-
-declare global {
-  interface Window {
-    href: string;
-  }
-} 
-// Initialize happy-dom window
-(global as any).window = {
-  href: undefined,
-  pathname: undefined,
-}
-
-// Track active renders
-const activeRenders = new Map<string, RenderState>();
-const activeStreams = new Map<string, PipeableStream>();
-const activeWrites = new Map<string, Writable>();
-
-async function shutdown() {
-  console.log("[Worker] Shutting down forcefully");
-  while (activeRenders.size > 0) {
-    await new Promise((resolve) => setTimeout(resolve, 100));
-  }
-  for (const stream of activeStreams.values()) {
-    stream.abort();
-  }
-  for (const writeStream of activeWrites.values()) {
-    writeStream.destroy();
-  }
-  process.exit(0);
-}
-// Handle incoming messages
-parentPort.on("message", async (message: WorkerMessage) => {
-  if (message.type === "SHUTDOWN") {
-    await shutdown();
-  }
-  if (!parentPort) {
-    throw new Error("No parent port available");
-  }
-  try {
-    switch (message.type) {
-      case "RSC_CHUNK": {
-        const { chunk, id, ...rest } = message;
-        (global as any).window.pathname = id;
-        // Skip if already rendered
-        let renderState = activeRenders.get(id);
-        if (renderState?.rendered) {
-          return;
-        }
-        // Initialize render state
-        if (!renderState) {
-          renderState = {
-            chunks: [],
-            complete: false,
-            rendered: false,
-            id: id,
-            ...rest,
-          };
-          activeRenders.set(id, renderState);
-        }
-        // Add chunk
-        if (chunk) renderState.chunks.push(chunk);
-        break;
-      }
-
-      case "RSC_END": {
-        const { id } = message;
-        const render = activeRenders.get(id);
-
-        if (!render || !parentPort || render.rendered) return;
-        try {
-          const writeToFile = render.outDir && render.htmlOutputPath;
-          // Write RSC content
-          if (writeToFile) {
-            await mkdir(dirname(render.htmlOutputPath), { recursive: true });
-          }
-          const { stream, writeStream } = createHtmlStream(
-            render,
-            writeToFile
-              ? createWriteStream(render.htmlOutputPath)
-              : new Writable({
-                  write(chunk, _, callback) {
-                    parentPort?.postMessage({
-                      type: "HTML",
-                      route: render.id,
-                      content: chunk.toString(),
-                    });
-                    callback();
-                  },
-                })
-          );
-          activeStreams.set(id, stream);
-          activeWrites.set(id, writeStream);
-          writeStream.on("finish", () => {
-            activeStreams.delete(id);
-            activeWrites.delete(id);
-          });
-          writeStream.on("error", () => {
-            activeStreams.delete(id);
-            activeWrites.delete(id);
-            stream.abort();
-          });
-        } catch (error) {
-          activeRenders.delete(id);
-          activeStreams.delete(id);
-          activeWrites.delete(id);
-          throw error;
-        } finally {
-          activeRenders.delete(id);
-        }
-        break;
-      }
-    }
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    parentPort?.postMessage({
-      type: "ERROR",
-      error: errorMessage,
-    });
-  }
-});
-
-// Signal ready only after loader is registered
-parentPort.postMessage({ type: "READY" });
-