vite-plugin-react-server 1.2.0-alpha.0 → 1.2.0

package/dist/plugin/react-static/fileWriter.js

@@ -4,66 +4,257 @@
  * MIT License
  */
 import { join } from 'node:path';
-import { createWriteStream } from 'node:fs';
-import { mkdir } from 'node:fs/promises';
-import { Transform } from 'node:stream';
+import { mkdirSync, createWriteStream } from 'node:fs';
+import { PassThrough, Transform } from 'node:stream';
+import { getNodeEnv } from '../config/getNodeEnv.js';
+import { handleError } from '../error/handleError.js';
 
-async function fileWriter(stream, fileType, options) {
-  const { onEvent } = options;
+class ContentCollectorStream extends Transform {
+  chunks = [];
+  _isFinished = false;
+  _onAllChunksCollected;
+  constructor(options = {}) {
+    super({
+      ...options,
+      objectMode: false
+    });
+  }
+  _transform(chunk, _encoding, callback) {
+    if (this._isFinished) {
+      callback();
+      return;
+    }
+    const buffer = Buffer.from(chunk);
+    this.chunks.push(buffer);
+    this.push(chunk);
+    callback();
+  }
+  _flush(callback) {
+    this._isFinished = true;
+    if (this._onAllChunksCollected) {
+      this._onAllChunksCollected();
+    }
+    callback();
+  }
+  getAllChunks() {
+    return this.chunks;
+  }
+  getContent() {
+    return Buffer.concat(this.chunks).toString("utf8");
+  }
+  hasContent() {
+    return this.chunks.length > 0;
+  }
+  onAllChunksCollected(callback) {
+    if (this._isFinished) {
+      callback();
+    } else {
+      this._onAllChunksCollected = callback;
+    }
+  }
+}
+const fileWriter = function _fileWriter(stream, fileType, options, signal) {
   if (!stream) {
     throw new Error(`Missing stream for route: ${options.route}`);
   }
+  const isStreamWrapper = stream.pipe && typeof stream.pipe === "function";
+  const routePath = options.route === "/" ? "" : options.route.replace(/^\//, "");
+  const baseDir = join(options.build.outDir, options.build.static);
   const outputPath = join(
-    options.build.outDir,
-    options.build.static,
-    options.route,
+    baseDir,
+    routePath,
     fileType === "html" ? options.build.htmlOutputPath : options.build.rscOutputPath
   );
   try {
-    await mkdir(join(options.build.outDir, options.build.static, options.route), { recursive: true });
+    mkdirSync(join(baseDir, routePath), { recursive: true });
   } catch (error) {
-    console.error(`Error creating directory: ${error}`);
-  }
-  const writeStream = createWriteStream(outputPath);
-  const contentCapture = new Transform({
-    transform(chunk, _encoding, callback) {
-      callback(null, chunk);
+    const panicError = handleError({
+      error,
+      logger: options.logger,
+      mode: getNodeEnv(),
+      panicThreshold: options.panicThreshold,
+      critical: false});
+    if (panicError != null) {
+      throw panicError;
     }
+  }
+  if (options.verbose) {
+    options.logger?.info(
+      `[fileWriter] Starting file write for ${fileType} on route ${options.route}`
+    );
+  }
+  if (signal?.aborted) {
+    const abortReason = signal?.reason || new Error("File write aborted");
+    throw abortReason;
+  }
+  const contentCollector = new ContentCollectorStream({
+    highWaterMark: 64 * 1024
+    // 64KB buffer
   });
-  const chunks = [];
-  contentCapture.on("data", (chunk) => {
-    chunks.push(Buffer.from(chunk));
+  const writeStream = createWriteStream(outputPath, {
+    highWaterMark: 64 * 1024
+    // 64KB buffer
   });
-  if (onEvent) {
-    onEvent({
-      type: "file.write",
-      data: {
-        fileType,
-        route: options.route,
-        stream,
-        path: outputPath,
-        onComplete: async () => {
-        }
-      }
-    });
+  let sourceStream;
+  if (isStreamWrapper) {
+    sourceStream = new PassThrough();
+    try {
+      stream.pipe(sourceStream);
+    } catch (error) {
+      throw new Error(`Failed to pipe stream wrapper: ${error}`);
+    }
+  } else {
+    sourceStream = stream;
   }
-  return new Promise((resolve, reject) => {
-    stream.pipe(contentCapture).pipe(writeStream).on("finish", () => {
-      const content = Buffer.concat(chunks).toString("utf-8");
-      if (onEvent) {
-        onEvent({
-          type: "file.write.done",
+  if (options.onEvent) {
+    try {
+      options.onEvent({
+        type: "file.write",
+        data: {
+          path: outputPath,
+          route: options.route,
+          fileType,
+          stream: contentCollector,
+          onComplete: () => new Promise((resolveComplete) => {
+            resolveComplete();
+          })
+        }
+      });
+    } catch (error) {
+      if (options.onEvent) {
+        options.onEvent({
+          type: "route.error",
           data: {
-            fileType,
+            error,
             route: options.route,
-            content
+            panicThreshold: options.panicThreshold
           }
         });
       }
-      resolve();
-    }).on("error", reject);
+      throw error;
+    }
+  }
+  return new Promise((resolve, reject) => {
+    const abortHandler = () => {
+      writeStream.destroy();
+      contentCollector.destroy();
+      sourceStream.destroy?.();
+      const abortReason = signal?.reason || new Error("File write aborted");
+      reject(abortReason);
+    };
+    if (signal) {
+      signal.addEventListener("abort", abortHandler);
+    }
+    sourceStream.pipe(contentCollector).pipe(writeStream);
+    const handleError2 = (error) => {
+      if (signal) {
+        signal.removeEventListener("abort", abortHandler);
+      }
+      if (options.verbose) {
+        options.logger?.error(
+          `[fileWriter] Error writing ${fileType} file for route ${options.route}: ${error.message}`
+        );
+      }
+      reject(error);
+    };
+    sourceStream.on("error", handleError2);
+    contentCollector.on("error", handleError2);
+    writeStream.on("error", handleError2);
+    writeStream.on("finish", () => {
+      if (signal) {
+        signal.removeEventListener("abort", abortHandler);
+      }
+      if (options.verbose) {
+        options.logger?.info(
+          `[fileWriter] Completed file write for ${fileType} on route ${options.route}`
+        );
+      }
+      contentCollector.onAllChunksCollected(() => {
+        if (options.onEvent) {
+          if (contentCollector.hasContent()) {
+            const content = contentCollector.getContent();
+            const chunks = contentCollector.getAllChunks();
+            if (options.verbose) {
+              options.logger?.info(
+                `[fileWriter:${fileType}] Emitting file.write.done with content length: ${content.length} bytes, chunks: ${chunks.length}`
+              );
+              if (content.length > 0) {
+                options.logger?.info(
+                  `[fileWriter:${fileType}] Content preview: ${content.substring(0, 200)}...`
+                );
+              }
+            }
+            const fileName = fileType === "html" ? options.build.htmlOutputPath : options.build.rscOutputPath;
+            try {
+              options.onEvent({
+                type: "file.write.done",
+                data: {
+                  route: options.route,
+                  fileType,
+                  content,
+                  chunks: chunks.length,
+                  path: outputPath,
+                  fileName,
+                  baseDir,
+                  routePath
+                }
+              });
+            } catch (error) {
+              if (options.onEvent) {
+                options.onEvent({
+                  type: "route.error",
+                  data: {
+                    error,
+                    route: options.route,
+                    panicThreshold: options.panicThreshold
+                  }
+                });
+              }
+              reject(error);
+              return;
+            }
+          } else {
+            if (options.verbose) {
+              options.logger?.warn(
+                `[fileWriter] No content chunks collected for ${fileType} file: ${outputPath}. This may be normal for empty files.`
+              );
+            }
+            const fileName = fileType === "html" ? options.build.htmlOutputPath : options.build.rscOutputPath;
+            try {
+              options.onEvent({
+                type: "file.write.done",
+                data: {
+                  route: options.route,
+                  fileType,
+                  content: "",
+                  chunks: 0,
+                  path: outputPath,
+                  fileName,
+                  baseDir,
+                  routePath
+                }
+              });
+            } catch (error) {
+              if (options.onEvent) {
+                options.onEvent({
+                  type: "route.error",
+                  data: {
+                    error,
+                    route: options.route,
+                    panicThreshold: options.panicThreshold
+                  }
+                });
+              }
+              reject(error);
+              return;
+            }
+          }
+        }
+        resolve();
+      });
+    });
   });
-}
+};
 
 export { fileWriter };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"fileWriter.js","sources":["../../../plugin/react-static/fileWriter.ts"],"sourcesContent":["/**\n * fileWriter.ts\n *\n * PURPOSE: Handles file writing operations for React Server Components (RSC) rendering\n *\n * This module:\n * 1. Writes HTML and RSC files to the filesystem using streams\n * 2. Creates necessary directories\n * 3. Handles file path construction\n * 4. Provides a clean interface for file operations\n */\nimport { join } from \"node:path\";\nimport { createWriteStream, mkdirSync } from \"node:fs\";\nimport { Transform, PassThrough } from \"node:stream\";\nimport type { FileWriterFn } from \"./types.js\";\nimport { getNodeEnv } from \"../config/getNodeEnv.js\";\nimport { handleError } from \"../error/handleError.js\";\n\n/**\n * A robust content collecting transform stream that handles race conditions\n */\nclass ContentCollectorStream extends Transform {\n  private chunks: Buffer[] = [];\n  private _isFinished = false;\n  private _onAllChunksCollected?: () => void;\n\n  constructor(options: any = {}) {\n    super({\n      ...options,\n      objectMode: false,\n    });\n  }\n\n  _transform(chunk: any, _encoding: any, callback: any) {\n    if (this._isFinished) {\n      callback();\n      return;\n    }\n\n    const buffer = Buffer.from(chunk);\n    this.chunks.push(buffer);\n    this.push(chunk);\n    callback();\n  }\n\n  _flush(callback: any) {\n    this._isFinished = true;\n    if (this._onAllChunksCollected) {\n      this._onAllChunksCollected();\n    }\n    callback();\n  }\n\n  getAllChunks(): Buffer[] {\n    return this.chunks;\n  }\n\n  getContent(): string {\n    return Buffer.concat(this.chunks).toString('utf8');\n  }\n\n  hasContent(): boolean {\n    return this.chunks.length > 0;\n  }\n\n  onAllChunksCollected(callback: () => void) {\n    if (this._isFinished) {\n      // Already finished, call immediately\n      callback();\n    } else {\n      this._onAllChunksCollected = callback;\n    }\n  }\n}\n\n/**\n * Writes HTML and RSC files for a route using streams\n *\n * @param stream The readable stream containing the content\n * @param fileType The type of file being written (\"html\" or \"rsc\")\n * @param options The file writer options\n * @param signal Optional AbortSignal to cancel the file write operation\n * @returns A promise that resolves when the file is written\n */\nexport const fileWriter: FileWriterFn = function _fileWriter(\n  stream,\n  fileType,\n  options,\n  signal\n) {\n  // Validate stream or stream wrapper\n  if (!stream) {\n    throw new Error(`Missing stream for route: ${options.route}`);\n  }\n\n  // Handle stream wrapper objects (from renderPage.server.ts)\n  const isStreamWrapper =\n    (stream as any).pipe && typeof (stream as any).pipe === \"function\";\n\n  // Remove leading slash from route for file path construction\n  const routePath =\n    options.route === \"/\" ? \"\" : options.route.replace(/^\\//, \"\");\n  const baseDir = join(options.build.outDir, options.build.static);\n  const outputPath = join(\n    baseDir,\n    routePath,\n    fileType === \"html\"\n      ? options.build.htmlOutputPath\n      : options.build.rscOutputPath\n  );\n\n  // Ensure directory exists\n  try {\n    mkdirSync(join(baseDir, routePath), { recursive: true });\n  } catch (error) {\n    const panicError = handleError({\n      error,\n      logger: options.logger,\n      mode: getNodeEnv(),\n      panicThreshold: options.panicThreshold,\n      critical: false,\n      context: \"fileWriter\",\n    });\n    if (panicError != null) {\n      throw panicError;\n    }\n  }\n\n  if (options.verbose) {\n    options.logger?.info(\n      `[fileWriter] Starting file write for ${fileType} on route ${options.route}`\n    );\n  }\n\n  // Handle abort signal early\n  if (signal?.aborted) {\n    const abortReason = signal?.reason || new Error(\"File write aborted\");\n    throw abortReason;\n  }\n\n  // Create streams with proper error handling\n  const contentCollector = new ContentCollectorStream({\n    highWaterMark: 64 * 1024, // 64KB buffer\n  });\n\n  const writeStream = createWriteStream(outputPath, {\n    highWaterMark: 64 * 1024, // 64KB buffer\n  });\n\n  // Create a robust source stream that handles wrappers properly\n  let sourceStream: any;\n  if (isStreamWrapper) {\n    // Create a PassThrough stream to normalize the wrapper\n    sourceStream = new PassThrough();\n    try {\n      (stream as any).pipe(sourceStream);\n    } catch (error) {\n      throw new Error(`Failed to pipe stream wrapper: ${error}`);\n    }\n  } else {\n    sourceStream = stream;\n  }\n\n  // Emit file.write event if onEvent is provided\n  if (options.onEvent) {\n    try {\n      options.onEvent({\n        type: \"file.write\",\n        data: {\n          path: outputPath,\n          route: options.route,\n          fileType,\n          stream: contentCollector,\n          onComplete: () =>\n            new Promise<void>((resolveComplete) => {\n              resolveComplete();\n            }),\n        },\n      });\n    } catch (error) {\n      // For file.write events, we need to emit a route.error event\n      if (options.onEvent) {\n        options.onEvent({\n          type: \"route.error\",\n          data: {\n            error: error,\n            route: options.route,\n            panicThreshold: options.panicThreshold\n          }\n        });\n      }\n      throw error;\n    }\n  }\n\n  return new Promise<void>((resolve, reject) => {\n    // Handle abort signal\n    const abortHandler = () => {\n      writeStream.destroy();\n      contentCollector.destroy();\n      sourceStream.destroy?.();\n      const abortReason = signal?.reason || new Error(\"File write aborted\");\n      reject(abortReason);\n    };\n\n    if (signal) {\n      signal.addEventListener(\"abort\", abortHandler);\n    }\n\n    // Set up the stream pipeline manually for better control\n    sourceStream.pipe(contentCollector).pipe(writeStream);\n\n    // Handle errors from any part of the pipeline\n    const handleError = (error: Error) => {\n      if (signal) {\n        signal.removeEventListener(\"abort\", abortHandler);\n      }\n      if (options.verbose) {\n        options.logger?.error(\n          `[fileWriter] Error writing ${fileType} file for route ${options.route}: ${error.message}`\n        );\n      }\n      reject(error);\n    };\n\n    sourceStream.on('error', handleError);\n    contentCollector.on('error', handleError);\n    writeStream.on('error', handleError);\n\n    // Handle successful completion\n    writeStream.on(\"finish\", () => {\n      if (signal) {\n        signal.removeEventListener(\"abort\", abortHandler);\n      }\n\n      if (options.verbose) {\n        options.logger?.info(\n          `[fileWriter] Completed file write for ${fileType} on route ${options.route}`\n        );\n      }\n\n      // Wait for content collector to finish processing all chunks\n      contentCollector.onAllChunksCollected(() => {\n        // Emit file.write.done event if onEvent is provided\n        if (options.onEvent) {\n          if (contentCollector.hasContent()) {\n            const content = contentCollector.getContent();\n            const chunks = contentCollector.getAllChunks();\n            \n            if (options.verbose) {\n              options.logger?.info(\n                `[fileWriter:${fileType}] Emitting file.write.done with content length: ${content.length} bytes, chunks: ${chunks.length}`\n              );\n              if (content.length > 0) {\n                options.logger?.info(\n                  `[fileWriter:${fileType}] Content preview: ${content.substring(0, 200)}...`\n                );\n              }\n            }\n\n            // Extract file name from the output path\n            const fileName =\n              fileType === \"html\"\n                ? options.build.htmlOutputPath\n                : options.build.rscOutputPath;\n\n            try {\n              options.onEvent({\n                type: \"file.write.done\",\n                data: {\n                  route: options.route,\n                  fileType,\n                  content,\n                  chunks: chunks.length,\n                  path: outputPath,\n                  fileName,\n                  baseDir: baseDir,\n                  routePath: routePath,\n                },\n              });\n            } catch (error) {\n              // For file.write.done events, we need to emit a route.error event\n              if (options.onEvent) {\n                options.onEvent({\n                  type: \"route.error\",\n                  data: {\n                    error: error,\n                    route: options.route,\n                    panicThreshold: options.panicThreshold\n                  }\n                });\n              }\n              reject(error);\n              return;\n            }\n          } else {\n            // Instead of rejecting, let's be more lenient about empty content\n            // This can happen legitimately with empty files or fast builds\n            if (options.verbose) {\n              options.logger?.warn(\n                `[fileWriter] No content chunks collected for ${fileType} file: ${outputPath}. This may be normal for empty files.`\n              );\n            }\n            \n            // Still emit the done event, but with empty content\n            const fileName =\n              fileType === \"html\"\n                ? options.build.htmlOutputPath\n                : options.build.rscOutputPath;\n\n            try {\n              options.onEvent({\n                type: \"file.write.done\",\n                data: {\n                  route: options.route,\n                  fileType,\n                  content: \"\",\n                  chunks: 0,\n                  path: outputPath,\n                  fileName,\n                  baseDir: baseDir,\n                  routePath: routePath,\n                },\n              });\n            } catch (error) {\n              if (options.onEvent) {\n                options.onEvent({\n                  type: \"route.error\",\n                  data: {\n                    error: error,\n                    route: options.route,\n                    panicThreshold: options.panicThreshold\n                  }\n                });\n              }\n              reject(error);\n              return;\n            }\n          }\n        }\n\n        resolve();\n      });\n    });\n  });\n};\n"],"names":["handleError"],"mappings":"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"}

package/dist/plugin/react-static/index.client.d.ts

@@ -0,0 +1,7 @@
+export { reactStaticPlugin } from "./plugin.client.js";
+export { renderPage } from "./renderPage.client.js";
+export { collectRscContent } from "./collectRscContent.js";
+export { temporaryReferences } from "./temporaryReferences.client.js";
+export { createBuildLoader } from "./createBuildLoader.client.js";
+export { createRscToHtmlStream } from "./rscToHtmlStream.client.js";
+//# sourceMappingURL=index.client.d.ts.map

package/dist/plugin/react-static/index.client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.client.d.ts","sourceRoot":"","sources":["../../../plugin/react-static/index.client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AACpD,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,EAAE,mBAAmB,EAAE,MAAM,iCAAiC,CAAC;AACtE,OAAO,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AAClE,OAAO,EAAE,qBAAqB,EAAE,MAAM,6BAA6B,CAAC"}

package/dist/plugin/react-static/index.client.js

@@ -0,0 +1,6 @@
+export { reactStaticPlugin } from "./plugin.client.js";
+export { renderPage } from "./renderPage.client.js";
+export { collectRscContent } from "./collectRscContent.js";
+export { temporaryReferences } from "./temporaryReferences.client.js";
+export { createBuildLoader } from "./createBuildLoader.client.js";
+export { createRscToHtmlStream } from "./rscToHtmlStream.client.js";

package/dist/plugin/react-static/index.d.ts

@@ -1,2 +1,8 @@
-export { reactStaticPlugin } from "./plugin.js";
+import type { VitePluginFn } from "../types.js";
+import type { CreateBuildLoaderFn, RscToHtmlStreamFn, RenderPageFn } from "./types.js";
+export declare const reactStaticPlugin: VitePluginFn, renderPage: RenderPageFn, temporaryReferences: WeakMap<any, any> | Set<any>, createBuildLoader: CreateBuildLoaderFn, rscToHtmlStream: RscToHtmlStreamFn;
+export { fileWriter } from "./fileWriter.js";
+export { renderPages } from "./renderPages.js";
+export { configurePreviewServer } from "./configurePreviewServer.js";
+export { collectRscContent } from "./collectRscContent.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/plugin/react-static/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../plugin/react-static/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../plugin/react-static/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,KAAK,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAKvF,eAAO,MACL,iBAAiB,gBACjB,UAAU,gBACV,mBAAmB,gCACnB,iBAAiB,uBACjB,eAAe,mBAOhB,CAAA;AAED,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AACrE,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC"}

package/dist/plugin/react-static/index.js

@@ -1 +1,19 @@
-export { reactStaticPlugin } from "./plugin.js";
+/**
+ * vite-plugin-react-server
+ * Copyright (c) Nico Brinkkemper
+ * MIT License
+ */
+import { getCondition } from '../config/getCondition.js';
+
+const condition = getCondition("");
+const dir = new URL("./", import.meta.url);
+const {
+  reactStaticPlugin,
+  renderPage,
+  temporaryReferences,
+  createBuildLoader,
+  rscToHtmlStream
+} = await import(`${dir}/index.${condition}.js`);
+
+export { createBuildLoader, reactStaticPlugin, renderPage, rscToHtmlStream, temporaryReferences };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3BsdWdpbi9yZWFjdC1zdGF0aWMvaW5kZXgudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgZ2V0Q29uZGl0aW9uIH0gZnJvbSBcIi4uL2NvbmZpZy9nZXRDb25kaXRpb24uanNcIjtcbmltcG9ydCB0eXBlIHsgVml0ZVBsdWdpbkZuIH0gZnJvbSBcIi4uL3R5cGVzLmpzXCI7XG5pbXBvcnQgdHlwZSB7IENyZWF0ZUJ1aWxkTG9hZGVyRm4sIFJzY1RvSHRtbFN0cmVhbUZuLCBSZW5kZXJQYWdlRm4gfSBmcm9tIFwiLi90eXBlcy5qc1wiO1xuXG5jb25zdCBjb25kaXRpb24gPSBnZXRDb25kaXRpb24oXCJcIik7XG5jb25zdCBkaXIgPSBuZXcgVVJMKFwiLi9cIiwgaW1wb3J0Lm1ldGEudXJsKTtcblxuZXhwb3J0IGNvbnN0IHtcbiAgcmVhY3RTdGF0aWNQbHVnaW4sXG4gIHJlbmRlclBhZ2UsXG4gIHRlbXBvcmFyeVJlZmVyZW5jZXMsXG4gIGNyZWF0ZUJ1aWxkTG9hZGVyLFxuICByc2NUb0h0bWxTdHJlYW1cbn0gPSBhd2FpdCBpbXBvcnQoYCR7ZGlyfS9pbmRleC4ke2NvbmRpdGlvbn0uanNgKSBhcyB7XG4gIHJlYWN0U3RhdGljUGx1Z2luOiBWaXRlUGx1Z2luRm47XG4gIHJlbmRlclBhZ2U6IFJlbmRlclBhZ2VGbjtcbiAgdGVtcG9yYXJ5UmVmZXJlbmNlczogV2Vha01hcDxhbnksIGFueT4gfCBTZXQ8YW55PjtcbiAgY3JlYXRlQnVpbGRMb2FkZXI6IENyZWF0ZUJ1aWxkTG9hZGVyRm47XG4gIHJzY1RvSHRtbFN0cmVhbTogUnNjVG9IdG1sU3RyZWFtRm47XG59XG5cbmV4cG9ydCB7IGZpbGVXcml0ZXIgfSBmcm9tIFwiLi9maWxlV3JpdGVyLmpzXCI7XG5leHBvcnQgeyByZW5kZXJQYWdlcyB9IGZyb20gXCIuL3JlbmRlclBhZ2VzLmpzXCI7XG5leHBvcnQgeyBjb25maWd1cmVQcmV2aWV3U2VydmVyIH0gZnJvbSBcIi4vY29uZmlndXJlUHJldmlld1NlcnZlci5qc1wiO1xuZXhwb3J0IHsgY29sbGVjdFJzY0NvbnRlbnQgfSBmcm9tIFwiLi9jb2xsZWN0UnNjQ29udGVudC5qc1wiOyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7O0FBSUEsTUFBTSxTQUFBLEdBQVksYUFBYSxFQUFFLENBQUE7QUFDakMsTUFBTSxHQUFNLEdBQUEsSUFBSSxHQUFJLENBQUEsSUFBQSxFQUFNLFlBQVksR0FBRyxDQUFBO0FBRTVCLE1BQUE7QUFBQSxFQUNYLGlCQUFBO0FBQUEsRUFDQSxVQUFBO0FBQUEsRUFDQSxtQkFBQTtBQUFBLEVBQ0EsaUJBQUE7QUFBQSxFQUNBO0FBQ0YsQ0FBQSxHQUFJLE1BQU0sT0FBTyxDQUFHLEVBQUEsR0FBRyxVQUFVLFNBQVMsQ0FBQSxHQUFBLENBQUE7Ozs7In0=

package/dist/plugin/react-static/index.server.d.ts

@@ -0,0 +1,7 @@
+export { reactStaticPlugin } from "./plugin.server.js";
+export { renderPage } from "./renderPage.server.js";
+export { temporaryReferences } from "./temporaryReferences.server.js";
+export { createBuildLoader } from "./createBuildLoader.server.js";
+export { createRscToHtmlStream } from "./rscToHtmlStream.server.js";
+export { collectHtmlContent } from "./collectHtmlContent.js";
+//# sourceMappingURL=index.server.d.ts.map

package/dist/plugin/react-static/index.server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.server.d.ts","sourceRoot":"","sources":["../../../plugin/react-static/index.server.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AACpD,OAAO,EAAE,mBAAmB,EAAE,MAAM,iCAAiC,CAAC;AACtE,OAAO,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AAClE,OAAO,EAAE,qBAAqB,EAAE,MAAM,6BAA6B,CAAC;AACpE,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC"}

package/dist/plugin/react-static/index.server.js

@@ -0,0 +1,6 @@
+export { reactStaticPlugin } from "./plugin.server.js";
+export { renderPage } from "./renderPage.server.js";
+export { temporaryReferences } from "./temporaryReferences.server.js";
+export { createBuildLoader } from "./createBuildLoader.server.js";
+export { createRscToHtmlStream } from "./rscToHtmlStream.server.js";
+export { collectHtmlContent } from "./collectHtmlContent.js";

package/dist/plugin/react-static/plugin.client.d.ts

@@ -0,0 +1,32 @@
+/**
+ * plugin.client.ts
+ *
+ * PURPOSE: Client-side static plugin for React Server Components
+ *
+ * This module:
+ * 1. Handles static site generation in the client environment
+ * 2. Uses RSC worker for RSC rendering and main-thread for HTML rendering
+ * 3. Generates both RSC and HTML files for static pages
+ * 4. Integrates with Vite's build process
+ *
+ * Feature parity with main react-static plugin, but in reverse. Uses rsc-worker to render rsc, and main thread for html.
+ * This is not the default behavior, but is supported for testing and custom app development purposes.
+ * Additionally, this can make it easier to use the --app flag to build all the modules + static generation at once.
+ */
+import type { VitePluginFn } from "../types.js";
+/**
+ * plugin.client.ts
+ *
+ * PURPOSE: Client-side static plugin for React Server Components
+ *
+ * This module:
+ * 1. Handles static site generation in the client environment
+ * 2. Uses RSC worker for RSC rendering and main-thread for HTML rendering
+ * 3. Generates both RSC and HTML files for static pages
+ * 4. Integrates with Vite's build process
+ *
+ * @param options
+ * @returns
+ */
+export declare const reactStaticPlugin: VitePluginFn;
+//# sourceMappingURL=plugin.client.d.ts.map

package/dist/plugin/react-static/plugin.client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.client.d.ts","sourceRoot":"","sources":["../../../plugin/react-static/plugin.client.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AASH,OAAO,KAAK,EAEV,YAAY,EAEb,MAAM,aAAa,CAAC;AAuCrB;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,iBAAiB,EAAE,YAm1B/B,CAAC"}