vite-plugin-react-server 0.3.4 → 0.3.6

package/plugin/worker/rsc/rsc-worker.tsx

@@ -0,0 +1,128 @@
+import { createWriteStream } from "node:fs";
+import { mkdir } from "node:fs/promises";
+import { dirname } from "node:path";
+import type { Writable } from "node:stream";
+import { parentPort } from "node:worker_threads";
+import {
+  registerClientReference,
+  registerServerReference
+  // @ts-ignore
+} from "react-server-dom-esm/server.node";
+
+import type { 
+  RscRenderState, 
+  RscWorkerMessage,
+  RscWorkerResponse 
+} from "../types.js";
+import { createRscStream } from "./createRscStream.js";
+
+if (!parentPort) {
+  throw new Error("This module must be run as a worker");
+}
+
+// Track active renders
+const activeRenders = new Map<string, RscRenderState>();
+const activeStreams = new Map<string, ReturnType<typeof createRscStream>>();
+const activeWrites = new Map<string, Writable>();
+
+async function shutdown() {
+  console.log("[RSC Worker] Shutting down forcefully");
+  for (const stream of activeStreams.values()) {
+    stream.abort();
+  }
+  for (const writeStream of activeWrites.values()) {
+    writeStream.destroy();
+  }
+  process.exit(0);
+}
+
+function sendMessage(message: RscWorkerResponse) {
+  parentPort?.postMessage(message);
+}
+
+// Handle incoming messages
+parentPort.on("message", async (message: RscWorkerMessage) => {
+  if (message.type === "SHUTDOWN") {
+    await shutdown();
+    return;
+  }
+
+  try {
+    switch (message.type) {
+      case "RSC_RENDER": {
+        const { id, pageImport, propsImport, outDir, moduleRootPath, moduleBaseURL, pipableStreamOptions } = message;
+        
+        // Skip if already rendered
+        if (activeRenders.has(id)) return;
+
+        // Create render state
+        const renderState: RscRenderState = {
+          id,
+          outDir,
+          moduleRootPath,
+          moduleBaseURL,
+          rscOutputPath: `${outDir}/${id}.rsc`,
+          componentImport: pageImport,
+          propsImport,
+          pipableStreamOptions
+        };
+
+        // Ensure output directory exists
+        await mkdir(dirname(renderState.rscOutputPath), { recursive: true });
+        const writeStream = createWriteStream(renderState.rscOutputPath);
+
+        // Create stream
+        const stream = createRscStream(renderState, writeStream, parentPort);
+
+        // Track active streams
+        activeRenders.set(id, renderState);
+        activeStreams.set(id, stream);
+        activeWrites.set(id, writeStream);
+        break;
+      }
+
+      case "RSC_END": {
+        const { id } = message;
+        activeRenders.delete(id);
+        activeStreams.delete(id);
+        activeWrites.delete(id);
+        break;
+      }
+
+      case "CLIENT_REFERENCE": {
+        const { id, location, key } = message;
+        const ref = registerClientReference(id, location, key);
+        sendMessage({
+          type: "CLIENT_REFERENCE",
+          id,
+          location,
+          key,
+          ref
+        });
+        break;
+      }
+
+      case "SERVER_REFERENCE": {
+        const { id, location, key } = message;
+        const ref = registerServerReference(id, location, key);
+        sendMessage({
+          type: "SERVER_REFERENCE",
+          id,
+          location,
+          key,
+          ref
+        });
+        break;
+      }
+    }
+  } catch (error) {
+    sendMessage({
+      type: "ERROR",
+      id: message.type === "RSC_RENDER" ? message.id : "",
+      error: error instanceof Error ? error.message : String(error)
+    });
+  }
+});
+
+// Signal ready
+parentPort.postMessage({ type: "READY" });

package/plugin/worker/types.ts

@@ -0,0 +1,124 @@
+interface PipeableStreamOptions {
+  bootstrapModules?: string[];
+  bootstrapScripts?: string[];
+  bootstrapScriptContent?: string;
+  signal?: AbortSignal;
+  identifierPrefix?: string;
+  namespaceURI?: string;
+  nonce?: string;
+  progressiveChunkSize?: number;
+  onShellReady?: () => void;
+  onAllReady?: () => void;
+  onError?: (error: unknown) => void;
+  importMap?: {
+    imports?: Record<string, string>;
+  };
+}
+
+export interface HtmlRenderState {
+  chunks: string[];
+  complete: boolean;
+  rendered: boolean;
+  outDir: string;
+  moduleRootPath: string;
+  moduleBaseURL: string;
+  htmlOutputPath: string;
+  id: string;
+  pipableStreamOptions: PipeableStreamOptions;
+}
+
+export interface RscRenderState {
+  id: string;
+  pipableStreamOptions: PipeableStreamOptions;
+  outDir: string;
+  moduleRootPath: string;
+  moduleBaseURL: string;
+  rscOutputPath: string;
+  componentImport: string;
+  propsImport: string;
+}
+
+export interface WorkerRscChunkMessage {
+  type: "RSC_CHUNK";
+  id: string;
+  chunk: string;
+  moduleRootPath: string;
+  moduleBaseURL: string;
+  outDir: string;
+  htmlOutputPath: string;
+  pipableStreamOptions: PipeableStreamOptions;
+}
+
+export interface ShutdownMessage {
+  type: "SHUTDOWN";
+  id: string;
+}
+
+export interface RscRenderMessage {
+  type: "RSC_RENDER";
+  id: string;
+  pageImport: string;
+  propsImport: string;
+  outDir: string;
+  moduleRootPath: string;
+  moduleBaseURL: string;
+  pipableStreamOptions: PipeableStreamOptions;
+}
+
+export interface RscCompleteMessage {
+  type: "RSC_COMPLETE";
+  id: string;
+  outputPath: string;
+}
+
+export interface RscErrorMessage {
+  type: "ERROR";
+  id: string;
+  error: string;
+}
+
+export interface RscWroteFileMessage {
+  type: "WROTE_FILE";
+  id: string;
+  outputPath: string;
+}
+
+export interface RscEndMessage {
+  type: "RSC_END";
+  id: string;
+}
+
+export interface ClientReferenceMessage {
+  type: "CLIENT_REFERENCE";
+  id: string;
+  location: string;
+  key: string;
+  ref: unknown;
+}
+
+export interface ServerReferenceMessage {
+  type: "SERVER_REFERENCE";
+  id: string;
+  location: string;
+  key: string;
+  ref: unknown;
+}
+
+export type HtmlWorkerMessage =
+  | WorkerRscChunkMessage
+  | RscEndMessage
+  | ShutdownMessage;
+
+export type RscWorkerMessage =
+  | RscRenderMessage
+  | RscEndMessage
+  | ShutdownMessage
+  | ClientReferenceMessage
+  | ServerReferenceMessage;
+
+export type RscWorkerResponse = 
+  | RscCompleteMessage
+  | RscErrorMessage
+  | RscWroteFileMessage
+  | ClientReferenceMessage
+  | ServerReferenceMessage;

package/scripts/check-react-version.mjs

@@ -5,44 +5,62 @@ import { fileURLToPath } from 'node:url'
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url))
 
-const PATCH_RECONCILER_VERSION = '19.1.0-experimental-b3a95caf-20250113'
-const ALTERNATIVE_REACT_VERSION = '0.0.0-experimental-b3a95caf-20250113'
-const STUB_ESM_VERSION = `0.0.1`
-const PATCH_FILE = `react-server-dom-esm+${STUB_ESM_VERSION}.patch`
+const TEMPLATE_VERSION = '0.0.0-experimental-b3a95caf-20250113'
+const STUB_VERSION = '0.0.1'
 
 async function main() {
-  try {
     // Read installed React version
     const reactPkgPath = path.resolve(process.cwd(), 'node_modules/react/package.json')
     const reactPkg = JSON.parse(await fs.readFile(reactPkgPath, 'utf-8'))
-    const installedVersion = reactPkg.version
-
-    // Get our patch file from our package
-    const ourPatchPath = path.resolve(__dirname, `../patches/${PATCH_FILE}`)
-    let patchContent = await fs.readFile(ourPatchPath, 'utf-8')
-
-    // Replace the version in the patch content
-    patchContent = patchContent.replace(
-      new RegExp(PATCH_RECONCILER_VERSION, 'g'),
-      installedVersion
-    ).replace(
-      new RegExp(ALTERNATIVE_REACT_VERSION, 'g'),
-      installedVersion
-    )
-
-    // Create patches dir in user's project
+    const userPkg = JSON.parse(await fs.readFile(path.resolve(process.cwd(), 'package.json'), 'utf-8'))
+    const patchVersion = reactPkg.version
+    let userVersion = userPkg.dependencies?.react ?? userPkg.devDependencies?.react ?? userPkg.peerDependencies?.react
+    if(!userVersion) {
+        throw new Error('React version not found in package.json')
+    } else {
+      userVersion = userVersion.replace('^', '')
+    }
+    // Define patches to process
+    const patches = [
+      {
+        template: path.resolve(__dirname, `react-server-dom-esm+${TEMPLATE_VERSION}.patch`),
+        output: `react-server-dom-esm+${STUB_VERSION}.patch`
+      },
+      {
+        template: path.resolve(__dirname, `react+${TEMPLATE_VERSION}.patch`),
+        output: `react+${userVersion}.patch`
+      },
+      {
+        template: path.resolve(__dirname, `react-dom+${TEMPLATE_VERSION}.patch`),
+        output: `react-dom+${userVersion}.patch`
+      }
+    ]
+
+    // Create patches dir
     const userPatchesDir = path.resolve(process.cwd(), 'patches')
     await fs.mkdir(userPatchesDir, { recursive: true })
 
-    // Write the patch file - use stub version for filename
-    const newFileName = `react-server-dom-esm+${STUB_ESM_VERSION}.patch`
-    const newPatchPath = path.resolve(userPatchesDir, newFileName)
-    await fs.writeFile(newPatchPath, patchContent)
+    // Process each patch
+    for (const {template, output} of patches) {
+      let patchContent = await fs.readFile(template, 'utf-8')
+      
+      // Replace versions
+      patchContent = patchContent
+        .replace(new RegExp(TEMPLATE_VERSION, 'g'), patchVersion)
+
+      // Write patched file
+      const outputPath = path.resolve(userPatchesDir, output)
+      await fs.writeFile(outputPath, patchContent)
+      console.log(`Wrote patch file to ${outputPath}`)
+    }
 
-    console.log(`Updated patch to match React version ${installedVersion}`)
-  } catch (error) {
-    
-  }
+    console.log(`Updated patches to match React version ${userVersion} (actual version: ${patchVersion})`)
 }
 
-main() 
+const PATCH = ``
+
+try {
+main()   
+} catch (error) {
+  console.error('error applying patch', error)
+}