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

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

@@ -8,16 +8,18 @@
  * 2. Returns the complete HTML content when the stream is done
  * 3. Provides a clean interface for HTML handling
  */
-import { PassThrough } from "node:stream";
-import type { CreateHandlerOptions, StreamMetrics, PagePropOpt, InlineCssOpt } from "../types.js";
+import type { PassThrough } from "node:stream";
+import type { CreateHandlerOptions, StreamMetrics } from "../types.js";
+export type CollectHtmlWorkerContentReturn = Promise<{
+    stream: PassThrough;
+    metrics: StreamMetrics;
+}>;
+export type CollectHtmlWorkerContentFn = <Opt extends CreateHandlerOptions = CreateHandlerOptions>(rscStream: PassThrough, handlerOptions: Opt) => CollectHtmlWorkerContentReturn;
 /**
  * Collects RSC content from the rscFull stream
  *
  * @param rscFull The stream containing the RSC content
  * @returns A promise that resolves with the complete RSC content
  */
-export declare function collectHtmlWorkerContent<T extends PagePropOpt = PagePropOpt, InlineCSS extends InlineCssOpt = InlineCssOpt>(rscStream: PassThrough, handlerOptions: CreateHandlerOptions<T, InlineCSS>): Promise<{
-    stream: PassThrough;
-    metrics: StreamMetrics;
-}>;
+export declare const collectHtmlWorkerContent: CollectHtmlWorkerContentFn;
 //# sourceMappingURL=collectHtmlWorkerContent.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"collectHtmlWorkerContent.d.ts","sourceRoot":"","sources":["../../../plugin/react-static/collectHtmlWorkerContent.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,WAAW,EAAa,MAAM,aAAa,CAAC;AACrD,OAAO,KAAK,EACV,oBAAoB,EACpB,aAAa,EACb,WAAW,EACX,YAAY,EACb,MAAM,aAAa,CAAC;AAKrB;;;;;GAKG;AACH,wBAAsB,wBAAwB,CAC5C,CAAC,SAAS,WAAW,GAAG,WAAW,EACnC,SAAS,SAAS,YAAY,GAAG,YAAY,EAE7C,SAAS,EAAE,WAAW,EACtB,cAAc,EAAE,oBAAoB,CAAC,CAAC,EAAE,SAAS,CAAC,GACjD,OAAO,CAAC;IAAE,MAAM,EAAE,WAAW,CAAC;IAAC,OAAO,EAAE,aAAa,CAAA;CAAE,CAAC,CAyG1D"}
+{"version":3,"file":"collectHtmlWorkerContent.d.ts","sourceRoot":"","sources":["../../../plugin/react-static/collectHtmlWorkerContent.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE/C,OAAO,KAAK,EACV,oBAAoB,EACpB,aAAa,EACd,MAAM,aAAa,CAAC;AAMrB,MAAM,MAAM,8BAA8B,GAAG,OAAO,CAAC;IACnD,MAAM,EAAE,WAAW,CAAC;IACpB,OAAO,EAAE,aAAa,CAAC;CACxB,CAAC,CAAC;AAEH,MAAM,MAAM,0BAA0B,GAAG,CACvC,GAAG,SAAS,oBAAoB,GAAG,oBAAoB,EAEvD,SAAS,EAAE,WAAW,EACtB,cAAc,EAAE,GAAG,KAChB,8BAA8B,CAAC;AAEpC;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB,EAAE,0BA0GpC,CAAC"}

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

@@ -4,11 +4,11 @@
  * MIT License
  */
 import { Transform } from 'node:stream';
-import { createStreamMetrics } from '../helpers/metrics.js';
+import { createStreamMetrics } from '../metrics/createStreamMetrics.js';
 import { createRscToHtmlStream } from './rscToHtmlStream.js';
 import { fileWriter } from './fileWriter.js';
 
-async function collectHtmlWorkerContent(rscStream, handlerOptions) {
+const collectHtmlWorkerContent = async function _collectHtmlWorkerContent(rscStream, handlerOptions) {
   if (!handlerOptions.worker) {
     throw new Error("Worker is not a valid worker");
   }
@@ -88,7 +88,7 @@ async function collectHtmlWorkerContent(rscStream, handlerOptions) {
     rscToHtmlStream.destroy();
     throw error;
   }
-}
+};
 
 export { collectHtmlWorkerContent };
-//# sourceMappingURL=collectHtmlWorkerContent.js.map
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"collectHtmlWorkerContent.js","sources":["../../../plugin/react-static/collectHtmlWorkerContent.ts"],"sourcesContent":["/**\n * rscHandler.ts\n *\n * PURPOSE: Handles collecting HTML content from the htmlCompact stream\n *\n * This module:\n * 1. Collects HTML content from the rscFull stream (which includes <html> and <body> tags)\n * 2. Returns the complete HTML content when the stream is done\n * 3. Provides a clean interface for HTML handling\n */\n\nimport type { PassThrough } from \"node:stream\";\nimport { Transform } from \"node:stream\";\nimport type {\n  CreateHandlerOptions,\n  StreamMetrics,  \n} from \"../types.js\";\nimport { createStreamMetrics } from \"../metrics/createStreamMetrics.js\";\nimport { createRscToHtmlStream } from \"./rscToHtmlStream.js\";\nimport { fileWriter } from \"./fileWriter.js\";\nimport type { HtmlWorkerOutputMessage } from \"../worker/html/types.js\";\n\nexport type CollectHtmlWorkerContentReturn = Promise<{\n  stream: PassThrough;\n  metrics: StreamMetrics;\n}>;\n\nexport type CollectHtmlWorkerContentFn = <\n  Opt extends CreateHandlerOptions = CreateHandlerOptions\n>(\n  rscStream: PassThrough,\n  handlerOptions: Opt\n) => CollectHtmlWorkerContentReturn;\n\n/**\n * Collects RSC content from the rscFull stream\n *\n * @param rscFull The stream containing the RSC content\n * @returns A promise that resolves with the complete RSC content\n */\nexport const collectHtmlWorkerContent: CollectHtmlWorkerContentFn =\n  async function _collectHtmlWorkerContent(rscStream, handlerOptions) {\n    if (!handlerOptions.worker) {\n      throw new Error(\"Worker is not a valid worker\");\n    }\n    const metrics = createStreamMetrics();\n    const startTime = performance.now();\n\n    // Create RSC to HTML transform stream\n    const rscToHtmlStream = createRscToHtmlStream({\n      worker: handlerOptions.worker,\n      route: handlerOptions.route,\n      moduleRootPath: handlerOptions.moduleRootPath,\n      moduleBaseURL: handlerOptions.moduleBaseURL,\n      pipeableStreamOptions: handlerOptions.pipeableStreamOptions,\n      build: handlerOptions.build,\n      cssFiles: handlerOptions.cssFiles,\n      projectRoot: handlerOptions.projectRoot,\n    });\n\n    // Create transform stream to handle HTML chunks and file writing\n    const htmlTransform = new Transform({\n      transform(chunk, _encoding, callback) {\n        metrics.chunks++;\n        callback(null, chunk);\n      },\n      flush(callback) {\n        metrics.duration = performance.now() - startTime;\n        callback();\n      },\n    });\n\n    let isComplete = false;\n\n    // Create a promise that resolves when the route is complete\n    const routeComplete = new Promise<void>((resolve, reject) => {\n      if (!handlerOptions.worker) {\n        throw new Error(\"Worker is not a valid worker\");\n      }\n      const messageHandler = (msg: HtmlWorkerOutputMessage) => {\n        if (!handlerOptions.worker) {\n          throw new Error(\"Worker is not a valid worker\");\n        }\n        switch (msg.type) {\n          case \"HTML_CHUNK\":\n            if (!isComplete) {\n              htmlTransform.write(msg.chunk);\n            }\n            break;\n          case \"HTML_COMPLETE\":\n            isComplete = true;\n            // End the transform stream\n            htmlTransform.end();\n            // Send cleanup message to worker\n            handlerOptions.worker.postMessage({\n              type: \"CLEANUP\",\n              id: handlerOptions.route,\n            });\n            break;\n          case \"CLEANUP_COMPLETE\":\n            resolve();\n            break;\n          case \"ERROR\":\n            handlerOptions.worker.removeListener(\"message\", messageHandler);\n            reject(msg.error);\n            break;\n        }\n      };\n      handlerOptions.worker.on(\"message\", messageHandler);\n    });\n\n    try {\n      // Set up event handler to capture content length\n      if (handlerOptions.onEvent) {\n        const originalOnEvent = handlerOptions.onEvent;\n        handlerOptions.onEvent = (event) => {\n          if (\n            event.type === \"file.write.done\" &&\n            event.data.fileType === \"html\"\n          ) {\n            metrics.bytes = event.data.content.length;\n          }\n          originalOnEvent(event);\n        };\n      }\n\n      // Pipe RSC through transform to HTML\n      rscStream.pipe(rscToHtmlStream);\n\n      // Set up file writing using fileWriter\n      const writePromise = fileWriter(htmlTransform, \"html\", handlerOptions);\n\n      // Wait for route to complete\n      await routeComplete;\n\n      // Wait for file writing to complete\n      await writePromise;\n\n      rscToHtmlStream.destroy();\n\n      return { stream: rscStream, metrics };\n    } catch (error) {\n      // Clean up streams on error\n      rscToHtmlStream.destroy();\n      throw error;\n    }\n  };\n"],"names":[],"mappings":"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"}

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

@@ -8,8 +8,13 @@
  * 2. Returns the complete RSC content when the stream is done
  * 3. Provides a clean interface for RSC handling
  */
-import { PassThrough } from "node:stream";
-import type { CreateHandlerOptions, StreamMetrics, PagePropOpt, InlineCssOpt } from "../types.js";
+import type { PassThrough } from "node:stream";
+import type { CreateHandlerOptions, StreamMetrics } from "../types.js";
+export type CollectRscContentReturn = Promise<{
+    stream: PassThrough;
+    metrics: StreamMetrics;
+}>;
+export type CollectRscContentFn = (rscStream: PassThrough, handlerOptions: CreateHandlerOptions) => CollectRscContentReturn;
 /**
  * Collects RSC content from the rscHeadless stream
  *
@@ -17,8 +22,5 @@ import type { CreateHandlerOptions, StreamMetrics, PagePropOpt, InlineCssOpt } f
  * @param handlerOptions The options for the handler
  * @returns A promise that resolves with the complete RSC content and metrics
  */
-export declare function collectRscContent<T extends PagePropOpt = PagePropOpt, InlineCSS extends InlineCssOpt = InlineCssOpt>(rscStream: PassThrough, handlerOptions: CreateHandlerOptions<T, InlineCSS>): Promise<{
-    stream: PassThrough;
-    metrics: StreamMetrics;
-}>;
+export declare const collectRscContent: CollectRscContentFn;
 //# sourceMappingURL=collectRscContent.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"collectRscContent.d.ts","sourceRoot":"","sources":["../../../plugin/react-static/collectRscContent.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,WAAW,EAAa,MAAM,aAAa,CAAC;AAGrD,OAAO,KAAK,EACV,oBAAoB,EACpB,aAAa,EACb,WAAW,EACX,YAAY,EACb,MAAM,aAAa,CAAC;AAIrB;;;;;;GAMG;AACH,wBAAsB,iBAAiB,CACrC,CAAC,SAAS,WAAW,GAAG,WAAW,EACnC,SAAS,SAAS,YAAY,GAAG,YAAY,EAE7C,SAAS,EAAE,WAAW,EACtB,cAAc,EAAE,oBAAoB,CAAC,CAAC,EAAE,SAAS,CAAC,GACjD,OAAO,CAAC;IAAE,MAAM,EAAE,WAAW,CAAC;IAAC,OAAO,EAAE,aAAa,CAAA;CAAE,CAAC,CAgD1D"}
+{"version":3,"file":"collectRscContent.d.ts","sourceRoot":"","sources":["../../../plugin/react-static/collectRscContent.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAI/C,OAAO,KAAK,EACV,oBAAoB,EACpB,aAAa,EACd,MAAM,aAAa,CAAC;AAIrB,MAAM,MAAM,uBAAuB,GAAG,OAAO,CAAC;IAC5C,MAAM,EAAE,WAAW,CAAC;IACpB,OAAO,EAAE,aAAa,CAAC;CACxB,CAAC,CAAC;AAEH,MAAM,MAAM,mBAAmB,GAAG,CAChC,SAAS,EAAE,WAAW,EACtB,cAAc,EAAE,oBAAoB,KACjC,uBAAuB,CAAC;AAE7B;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,EAAE,mBAiD7B,CAAC"}

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

@@ -6,10 +6,10 @@
 import { Transform } from 'node:stream';
 import { join, dirname } from 'node:path';
 import { mkdir } from 'node:fs/promises';
-import { createStreamMetrics } from '../helpers/metrics.js';
+import { createStreamMetrics } from '../metrics/createStreamMetrics.js';
 import { fileWriter } from './fileWriter.js';
 
-async function collectRscContent(rscStream, handlerOptions) {
+const collectRscContent = async function _collectRscContent(rscStream, handlerOptions) {
   const metrics = createStreamMetrics();
   const startTime = performance.now();
   const outputPath = join(
@@ -43,7 +43,7 @@ async function collectRscContent(rscStream, handlerOptions) {
     metricsTransform.destroy();
     throw error;
   }
-}
+};
 
 export { collectRscContent };
-//# sourceMappingURL=collectRscContent.js.map
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

@@ -1,7 +1,9 @@
 import type { PreviewServer } from "vite";
-import type { ResolvedUserOptions, PagePropOpt, InlineCssOpt } from "../types.js";
-export declare function configurePreviewServer<T extends PagePropOpt = PagePropOpt, InlineCSS extends InlineCssOpt = InlineCssOpt>({ server, userOptions, }: {
+import type { ResolvedUserOptions } from "../types.js";
+export type ConfigurePreviewServerProps<Opt extends ResolvedUserOptions> = {
     server: PreviewServer;
-    userOptions: ResolvedUserOptions<T, InlineCSS>;
-}): Promise<void>;
+    userOptions: Opt;
+};
+export type ConfigurePreviewServerFn = <Opt extends ResolvedUserOptions>(props: ConfigurePreviewServerProps<Opt>) => Promise<void>;
+export declare const configurePreviewServer: ConfigurePreviewServerFn;
 //# sourceMappingURL=configurePreviewServer.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"configurePreviewServer.d.ts","sourceRoot":"","sources":["../../../plugin/react-static/configurePreviewServer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,MAAM,CAAC;AAC1C,OAAO,KAAK,EACV,mBAAmB,EACnB,WAAW,EACX,YAAY,EACb,MAAM,aAAa,CAAC;AAWrB,wBAAsB,sBAAsB,CAC1C,CAAC,SAAS,WAAW,GAAG,WAAW,EACnC,SAAS,SAAS,YAAY,GAAG,YAAY,EAC7C,EACA,MAAM,EACN,WAAW,GACZ,EAAE;IACD,MAAM,EAAE,aAAa,CAAC;IACtB,WAAW,EAAE,mBAAmB,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC;CAChD,iBAiGA"}
+{"version":3,"file":"configurePreviewServer.d.ts","sourceRoot":"","sources":["../../../plugin/react-static/configurePreviewServer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,MAAM,CAAC;AAC1C,OAAO,KAAK,EACV,mBAAmB,EAEpB,MAAM,aAAa,CAAC;AAOrB,MAAM,MAAM,2BAA2B,CAAC,GAAG,SAAS,mBAAmB,IAAI;IACzE,MAAM,EAAE,aAAa,CAAC;IACtB,WAAW,EAAE,GAAG,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,wBAAwB,GAAG,CAAC,GAAG,SAAS,mBAAmB,EACrE,KAAK,EAAE,2BAA2B,CAAC,GAAG,CAAC,KACpC,OAAO,CAAC,IAAI,CAAC,CAAC;AAEnB,eAAO,MAAM,sBAAsB,EAAE,wBAgHlC,CAAC"}

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

@@ -9,26 +9,24 @@ import { stat } from 'node:fs/promises';
 import { pipeline } from 'node:stream/promises';
 import { requestInfo } from '../helpers/requestInfo.js';
 
-async function configurePreviewServer({
-  server,
-  userOptions
-}) {
+const configurePreviewServer = async function _configurePreviewServer({ server, userOptions }) {
   const staticHostDir = join(
     userOptions.projectRoot,
     userOptions.build.outDir,
     userOptions.build.static
   );
+  console.log(userOptions.moduleBaseURL, userOptions.moduleBasePath);
   server.middlewares.use(async (req, res, next) => {
     if (!req.url) {
       return next();
     }
-    const { contentType, filePath } = requestInfo(
+    const { contentType, filePath, isRscRequest } = requestInfo(
       req,
       userOptions,
       staticHostDir,
       server.config.logger
     );
-    if (filePath && contentType.includes("text/x-component")) {
+    if (filePath && isRscRequest) {
       try {
         const stats = await stat(filePath);
         if (stats.isFile()) {
@@ -49,30 +47,33 @@ async function configurePreviewServer({
             });
             await pipeline(readStream, res, { signal });
           } catch (error) {
-            const streamError = error;
-            if (streamError.code === "ERR_STREAM_PREMATURE_CLOSE" || streamError.name === "AbortError") {
-              if (res.writable) {
-                res.statusCode = 499;
-                res.end("Client closed request");
-              }
-            } else if (streamError.code === "ENOENT") {
-              res.statusCode = 404;
-              server.config.logger.error(
-                `File not found: ${filePath}. ${streamError.message}`,
-                {
-                  error: streamError
-                }
-              );
-              res.end("File not found");
-            } else {
-              server.config.logger.error(
-                `Error loading file: ${filePath}. ${streamError.message}`,
-                {
-                  error: streamError
+            if (error != null && typeof error === "object" && "code" in error) {
+              const streamError = error;
+              if (streamError.code === "ERR_STREAM_PREMATURE_CLOSE" || streamError.name === "AbortError") {
+                if (res.writable) {
+                  res.statusCode = 499;
+                  res.end("Client closed request");
                 }
-              );
-              res.statusCode = 500;
-              res.end("Internal server error");
+              } else if (streamError.code === "ENOENT") {
+                res.statusCode = 404;
+                server.config.logger.error(
+                  `File not found: ${filePath}. ${streamError.message}`,
+                  {
+                    error: streamError
+                  }
+                );
+                console.log("File not found: ", filePath);
+                res.end("File not found");
+              } else {
+                server.config.logger.error(
+                  `Error loading file: ${filePath}. ${streamError.message}`,
+                  {
+                    error: streamError
+                  }
+                );
+                res.statusCode = 500;
+                res.end("Internal server error");
+              }
             }
             return;
           }
@@ -81,6 +82,12 @@ async function configurePreviewServer({
       } catch (error) {
         const err = error;
         if (err.code === "ENOENT") {
+          server.config.logger.error(
+            `File not found: ${filePath}. ${err.message}`,
+            {
+              error: err
+            }
+          );
           res.statusCode = 404;
           res.end("File not found");
         } else {
@@ -95,7 +102,7 @@ async function configurePreviewServer({
     }
     next();
   });
-}
+};
 
 export { configurePreviewServer };
-//# sourceMappingURL=configurePreviewServer.js.map
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"configurePreviewServer.js","sources":["../../../plugin/react-static/configurePreviewServer.ts"],"sourcesContent":["import type { PreviewServer } from \"vite\";\nimport type {\n  ResolvedUserOptions,\n  StreamError,\n} from \"../types.js\";\nimport { join } from \"node:path\";\nimport { createReadStream } from \"node:fs\";\nimport { stat } from \"node:fs/promises\";\nimport { pipeline } from \"node:stream/promises\";\nimport { requestInfo } from \"../helpers/requestInfo.js\";\n\nexport type ConfigurePreviewServerProps<Opt extends ResolvedUserOptions> = {\n  server: PreviewServer;\n  userOptions: Opt;\n};\n\nexport type ConfigurePreviewServerFn = <Opt extends ResolvedUserOptions>(\n  props: ConfigurePreviewServerProps<Opt>\n) => Promise<void>;\n\nexport const configurePreviewServer: ConfigurePreviewServerFn =\n  async function _configurePreviewServer({ server, userOptions }) {\n    const staticHostDir = join(\n      userOptions.projectRoot,\n      userOptions.build.outDir,\n      userOptions.build.static\n    );\n    console.log(userOptions.moduleBaseURL, userOptions.moduleBasePath);\n    server.middlewares.use(async (req, res, next) => {\n      if (!req.url) {\n        return next();\n      }\n      const { contentType, filePath, isRscRequest } = requestInfo(\n        req,\n        userOptions,\n        staticHostDir,\n        server.config.logger\n      );\n      // Handle static files including CSS\n      if (filePath && (isRscRequest)) {\n        try {\n          const stats = await stat(filePath);\n          if (stats.isFile()) {\n            res.setHeader(\"Content-Type\", contentType);\n\n            // Create abort controller for the stream\n            const controller = new AbortController();\n            const { signal } = controller;\n\n            // Check if response is still writable before streaming\n            if (!res.writable) {\n              res.statusCode = 499;\n              res.end(\"Client closed request\");\n              return;\n            }\n\n            try {\n              const readStream = createReadStream(filePath);\n              readStream.on(\"error\", () => {\n                if (!res.writable) {\n                  controller.abort();\n                }\n              });\n              await pipeline(readStream, res, { signal });\n            } catch (error) {\n              if (\n                error != null &&\n                typeof error === \"object\" &&\n                \"code\" in error\n              ) {\n                const streamError = error as StreamError;\n                // Handle different error cases\n                if (\n                  streamError.code === \"ERR_STREAM_PREMATURE_CLOSE\" ||\n                  streamError.name === \"AbortError\"\n                ) {\n                  // Client closed the connection\n                  if (res.writable) {\n                    res.statusCode = 499;\n                    res.end(\"Client closed request\");\n                  }\n                } else if (streamError.code === \"ENOENT\") {\n                  // File not found\n                  res.statusCode = 404;\n                  server.config.logger.error(\n                    `File not found: ${filePath}. ${streamError.message}`,\n                    {\n                      error: streamError,\n                    }\n                  );\n                  console.log(\"File not found: \", filePath);\n                  res.end(\"File not found\");\n                } else {\n                  // Server error\n                  server.config.logger.error(\n                    `Error loading file: ${filePath}. ${streamError.message}`,\n                    {\n                      error: streamError,\n                    }\n                  );\n                  res.statusCode = 500;\n                  res.end(\"Internal server error\");\n                }\n              }\n              return;\n            }\n            return;\n          }\n        } catch (error) {\n          const err = error as Error;\n          // Handle file system errors\n          if ((err as NodeJS.ErrnoException).code === \"ENOENT\") {\n            server.config.logger.error(\n              `File not found: ${filePath}. ${err.message}`,\n              {\n                error: err,\n              }\n            );\n            res.statusCode = 404;\n            res.end(\"File not found\");\n          } else {\n            server.config.logger.error(`Error loading file: ${filePath}.`, {\n              error: err,\n            });\n            res.statusCode = 500;\n            res.end(\"Internal server error\");\n          }\n          return;\n        }\n      }\n      next();\n    });\n  };\n"],"names":[],"mappings":"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"}

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

@@ -1,13 +1,13 @@
-import type { InlineCssOpt, PagePropOpt, ResolvedUserConfig, ResolvedUserOptions } from "../../server.js";
+import type { BuildModuleLoader, ResolvedUserConfig, ResolvedUserOptions } from "../../server.js";
 import type { Manifest } from "vite";
 import type { OutputBundle } from "rollup";
-export interface BuildLoaderOptions<T extends PagePropOpt = PagePropOpt, InlineCSS extends InlineCssOpt = InlineCssOpt> {
+export type CreateBuildLoaderFn = (props: {
     userConfig: ResolvedUserConfig;
-    userOptions: ResolvedUserOptions<T, InlineCSS>;
+    userOptions: ResolvedUserOptions;
     serverManifest: Manifest;
     clientManifest: Manifest;
     staticManifest: Manifest;
-}
+}, bundle: OutputBundle) => BuildModuleLoader;
 /**
  * Creates a loader function for handling module resolution during build.
  *
@@ -16,5 +16,5 @@ export interface BuildLoaderOptions<T extends PagePropOpt = PagePropOpt, InlineC
  *  - For server components: Use server manifest and server.js
  *  - For static assets: Use static manifest
  */
-export declare function createBuildLoader<T extends PagePropOpt = PagePropOpt, InlineCSS extends InlineCssOpt = InlineCssOpt>({ userOptions, serverManifest, clientManifest, staticManifest, }: BuildLoaderOptions<T, InlineCSS>, bundle: OutputBundle): Promise<(id: string) => Promise<any>>;
+export declare const createBuildLoader: CreateBuildLoaderFn;
 //# sourceMappingURL=createBuildLoader.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"createBuildLoader.d.ts","sourceRoot":"","sources":["../../../plugin/react-static/createBuildLoader.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,YAAY,EACZ,WAAW,EACX,kBAAkB,EAClB,mBAAmB,EACpB,MAAM,iBAAiB,CAAC;AACzB,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,MAAM,CAAC;AAErC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAI3C,MAAM,WAAW,kBAAkB,CACjC,CAAC,SAAS,WAAW,GAAG,WAAW,EACnC,SAAS,SAAS,YAAY,GAAG,YAAY;IAE7C,UAAU,EAAE,kBAAkB,CAAC;IAC/B,WAAW,EAAE,mBAAmB,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC;IAC/C,cAAc,EAAE,QAAQ,CAAC;IACzB,cAAc,EAAE,QAAQ,CAAC;IACzB,cAAc,EAAE,QAAQ,CAAC;CAC1B;AAED;;;;;;;GAOG;AACH,wBAAsB,iBAAiB,CACrC,CAAC,SAAS,WAAW,GAAG,WAAW,EACnC,SAAS,SAAS,YAAY,GAAG,YAAY,EAE7C,EACE,WAAW,EACX,cAAc,EACd,cAAc,EACd,cAAc,GACf,EAAE,kBAAkB,CAAC,CAAC,EAAE,SAAS,CAAC,EACnC,MAAM,EAAE,YAAY,gBAOkB,MAAM,mBAgJ7C"}
+{"version":3,"file":"createBuildLoader.d.ts","sourceRoot":"","sources":["../../../plugin/react-static/createBuildLoader.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,iBAAiB,EACjB,kBAAkB,EAClB,mBAAmB,EACpB,MAAM,iBAAiB,CAAC;AACzB,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,MAAM,CAAC;AAErC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAM3C,MAAM,MAAM,mBAAmB,GAAG,CAAC,KAAK,EAAE;IACxC,UAAU,EAAE,kBAAkB,CAAC;IAC/B,WAAW,EAAE,mBAAmB,CAAC;IACjC,cAAc,EAAE,QAAQ,CAAC;IACzB,cAAc,EAAE,QAAQ,CAAC;IACzB,cAAc,EAAE,QAAQ,CAAC;CAC1B,EAAE,MAAM,EAAE,YAAY,KAAK,iBAAiB,CAAC;AAE9C;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB,EAAE,mBA+Q/B,CAAA"}

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

@@ -7,8 +7,10 @@ import { join } from 'node:path';
 import { getModuleRef } from '../helpers/moduleRefs.js';
 import { temporaryReferences } from './temporaryReferences.js';
 import { toError } from '../error/toError.js';
+import { readFile, writeFile, unlink } from 'fs/promises';
+import { existsSync } from 'fs';
 
-async function createBuildLoader({
+const createBuildLoader = function _createBuildLoader({
   userOptions,
   serverManifest,
   clientManifest,
@@ -19,8 +21,12 @@ async function createBuildLoader({
     throw new Error("Server manifest is empty");
   }
   return async function buildLoader(id) {
+    if (userOptions.verbose) {
+      console.log("[buildLoader] id: ", id);
+    }
     const [withoutQuery, query] = id.split("?", 2);
-    const [normalizedKey, normalizedValue] = userOptions.normalizer(withoutQuery);
+    const [moduleId, exportName] = withoutQuery.split("#", 2);
+    const [normalizedKey, normalizedValue] = userOptions.normalizer(moduleId);
     const moduleRef = getModuleRef(id);
     if (temporaryReferences?.has(moduleRef)) {
       const mod = temporaryReferences.get(moduleRef);
@@ -38,12 +44,12 @@ async function createBuildLoader({
         )?.[1];
         if (serverChunk) {
           if (serverChunk.type === "asset") {
-            if (userOptions.autoDiscover.jsonPattern(normalizedValue)) {
+            if (userOptions.autoDiscover.jsonPattern.test(normalizedValue)) {
               const jsonContent = serverChunk.source;
               if (typeof jsonContent === "string") {
                 return { default: JSON.parse(jsonContent) };
               }
-            } else if (userOptions.autoDiscover.cssPattern(normalizedValue)) {
+            } else if (userOptions.autoDiscover.cssPattern.test(normalizedValue)) {
               const cssContent = serverChunk.source;
               if (typeof cssContent === "string") {
                 return { default: cssContent };
@@ -57,12 +63,12 @@ async function createBuildLoader({
         console.warn("Could not find inline module for: " + normalizedValue);
         return null;
       }
-      const isClientComponent = userOptions.autoDiscover.clientComponents(normalizedValue);
-      const isServerAction = userOptions.autoDiscover.serverFunctions(normalizedValue);
-      const isPage = userOptions.autoDiscover.pagePattern(normalizedValue);
-      const isProps = userOptions.autoDiscover.propsPattern(normalizedValue);
+      const isClientComponent = userOptions.autoDiscover.clientPattern.test(normalizedValue);
       if (isClientComponent) {
         const clientEntry = clientManifest[normalizedValue];
+        if (userOptions.verbose) {
+          console.log("clientEntry", clientEntry);
+        }
         if (clientEntry) {
           try {
             const module = await import(join(
@@ -81,26 +87,6 @@ async function createBuildLoader({
           }
         }
       }
-      if (isServerAction || isPage || isProps) {
-        const serverEntry = serverManifest[normalizedValue];
-        if (serverEntry) {
-          try {
-            const module = await import(join(
-              userOptions.projectRoot,
-              userOptions.build.outDir,
-              userOptions.build.server,
-              serverEntry.file
-            ));
-            temporaryReferences?.set(moduleRef, module);
-            return module;
-          } catch (error) {
-            const err = toError(error);
-            console.warn("Error loading server module:", err);
-            temporaryReferences?.delete(moduleRef);
-            throw err;
-          }
-        }
-      }
       const staticEntry = staticManifest[normalizedValue];
       if (staticEntry) {
         try {
@@ -111,6 +97,9 @@ async function createBuildLoader({
             staticEntry.file
           ));
           temporaryReferences?.set(moduleRef, module);
+          if (exportName && !(exportName in module)) {
+            throw new Error(`Export ${exportName} not found in module ${normalizedValue}`);
+          }
           return module;
         } catch (error) {
           const err = toError(error);
@@ -119,6 +108,109 @@ async function createBuildLoader({
           throw err;
         }
       }
+      const serverEntry = serverManifest[normalizedValue];
+      if (serverEntry) {
+        try {
+          const module = await import(join(
+            userOptions.projectRoot,
+            userOptions.build.outDir,
+            userOptions.build.server,
+            serverEntry.file
+          ));
+          temporaryReferences?.set(moduleRef, module);
+          if (exportName && !(exportName in module)) {
+            throw new Error(`Export ${exportName} not found in module ${normalizedValue}`);
+          }
+          return module;
+        } catch (error) {
+          const err = toError(error);
+          if (userOptions.panicThreshold === "critical_errors") {
+            console.warn("Error loading server module:", err);
+            temporaryReferences?.delete(moduleRef);
+          } else {
+            console.error("Error loading server module:", err);
+            throw err;
+          }
+        }
+      }
+      const sourceFilePath = join(userOptions.projectRoot, normalizedValue);
+      if (userOptions.verbose) {
+        console.log("[buildLoader] Checking source file:", sourceFilePath, "exists:", existsSync(sourceFilePath));
+      }
+      if (existsSync(sourceFilePath)) {
+        try {
+          if (userOptions.verbose) {
+            console.log("[buildLoader] Loading source file:", sourceFilePath);
+          }
+          if (sourceFilePath.endsWith(".tsx") || sourceFilePath.endsWith(".ts") || sourceFilePath.endsWith(".mts")) {
+            const relativePath = normalizedValue.replace(/^src\//, "");
+            const staticBuiltPath = join(
+              userOptions.projectRoot,
+              userOptions.build.outDir,
+              userOptions.build.static,
+              relativePath.replace(/\.(tsx?|mts)$/, ".js")
+            );
+            const serverBuiltPath = join(
+              userOptions.projectRoot,
+              userOptions.build.outDir,
+              userOptions.build.server,
+              relativePath.replace(/\.(tsx?|mts)$/, ".js")
+            );
+            let builtModulePath = null;
+            if (existsSync(staticBuiltPath)) {
+              builtModulePath = staticBuiltPath;
+            } else if (existsSync(serverBuiltPath)) {
+              builtModulePath = serverBuiltPath;
+            }
+            if (builtModulePath) {
+              if (userOptions.verbose) {
+                console.log("[buildLoader] Found built module:", builtModulePath);
+              }
+              const module = await import(builtModulePath);
+              temporaryReferences?.set(moduleRef, module);
+              if (exportName && !(exportName in module)) {
+                throw new Error(`Export ${exportName} not found in module ${normalizedValue}`);
+              }
+              return module;
+            }
+            if (userOptions.verbose) {
+              console.log("[buildLoader] No built module found, trying to compile source file");
+            }
+            const { transformWithEsbuild } = await import('vite');
+            const sourceCode = await readFile(sourceFilePath, "utf-8");
+            const result = await transformWithEsbuild(sourceCode, sourceFilePath, {
+              format: "esm",
+              sourcemap: false
+            });
+            const tempFilePath = sourceFilePath.replace(/\.(tsx?|mts)$/, ".temp.js");
+            await writeFile(tempFilePath, result.code);
+            try {
+              const module = await import(tempFilePath);
+              temporaryReferences?.set(moduleRef, module);
+              if (exportName && !(exportName in module)) {
+                throw new Error(`Export ${exportName} not found in module ${normalizedValue}`);
+              }
+              return module;
+            } finally {
+              try {
+                await unlink(tempFilePath);
+              } catch (cleanupError) {
+                if (userOptions.verbose) {
+                  console.warn("[buildLoader] Failed to cleanup temp file:", cleanupError);
+                }
+              }
+            }
+          } else {
+            const content = await readFile(sourceFilePath, "utf-8");
+            return { default: content };
+          }
+        } catch (error) {
+          const err = toError(error);
+          console.warn("Error loading source file:", err);
+          temporaryReferences?.delete(moduleRef);
+          throw err;
+        }
+      }
       throw new Error(`Module ${normalizedValue} not found during build`);
     } catch (error) {
       const emptyExports = {
@@ -129,7 +221,7 @@ async function createBuildLoader({
       return emptyExports;
     }
   };
-}
+};
 
 export { createBuildLoader };
-//# sourceMappingURL=createBuildLoader.js.map
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"createBuildLoader.js","sources":["../../../plugin/react-static/createBuildLoader.ts"],"sourcesContent":["import { join } from \"node:path\";\nimport type {\n  BuildModuleLoader,\n  ResolvedUserConfig,\n  ResolvedUserOptions,\n} from \"../../server.js\";\nimport type { Manifest } from \"vite\";\nimport { getModuleRef } from \"../helpers/moduleRefs.js\";\nimport type { OutputBundle } from \"rollup\";\nimport { temporaryReferences } from \"./temporaryReferences.js\";\nimport { toError } from \"../error/toError.js\";\nimport { readFile, writeFile, unlink } from \"fs/promises\";\nimport { existsSync } from \"fs\";\n\nexport type CreateBuildLoaderFn = (props: {\n  userConfig: ResolvedUserConfig;\n  userOptions: ResolvedUserOptions;\n  serverManifest: Manifest;\n  clientManifest: Manifest;\n  staticManifest: Manifest;\n}, bundle: OutputBundle) => BuildModuleLoader;\n\n/**\n * Creates a loader function for handling module resolution during build.\n *\n * The loader handles the following strategy:\n *  - For client components: Use client manifest and client.browser.js\n *  - For server components: Use server manifest and server.js\n *  - For static assets: Use static manifest\n */\nexport const createBuildLoader: CreateBuildLoaderFn = function _createBuildLoader(\n  {\n    userOptions,\n    serverManifest,\n    clientManifest,\n    staticManifest,\n  },\n  bundle\n) {\n  const manifestKeys = Object.keys(serverManifest);\n  if (!manifestKeys.length) {\n    throw new Error(\"Server manifest is empty\");\n  }\n\n  return async function buildLoader(id) {\n    if (userOptions.verbose) {\n      console.log(\"[buildLoader] id: \", id);\n    }\n    const [withoutQuery, query] = id.split(\"?\", 2);\n    const [moduleId, exportName] = withoutQuery.split(\"#\", 2);\n    const [normalizedKey, normalizedValue] = userOptions.normalizer(moduleId);\n    const moduleRef = getModuleRef(id);\n\n    // Check if we have a temporary reference (cached module)\n    if (temporaryReferences?.has(moduleRef)) {\n      const mod = temporaryReferences.get(moduleRef);\n      if (typeof mod === \"object\" && mod !== null && \"error\" in mod) {\n        // ignore it\n      } else {\n        return mod;\n      }\n    }\n\n    try {\n      // For inline modules, handle them directly\n      if (query === \"inline\") {\n        const startsWithMarker = normalizedKey.split(\"-\")[0];\n        const serverChunk =\n          bundle[serverManifest[normalizedValue]?.file] ??\n          bundle[staticManifest[normalizedValue]?.file] ??\n          bundle[clientManifest[normalizedValue]?.file] ??\n          bundle[withoutQuery] ??\n          bundle[normalizedValue] ??\n          Object.entries(bundle).find(\n            ([, value]) => value.name === normalizedValue\n          )?.[1] ??\n          Object.entries(bundle).find(([_key]) =>\n            _key.startsWith(startsWithMarker)\n          )?.[1];\n\n        if (serverChunk) {\n          if (serverChunk.type === \"asset\") {\n            // For CSS files, ensure we're in the React Server environment\n            if (userOptions.autoDiscover.jsonPattern.test(normalizedValue)) {\n              const jsonContent = serverChunk.source;\n              if (typeof jsonContent === \"string\") {\n                return { default: JSON.parse(jsonContent) };\n              }\n            } else if (\n              userOptions.autoDiscover.cssPattern.test(normalizedValue)\n            ) {\n              const cssContent = serverChunk.source;\n              if (typeof cssContent === \"string\") {\n                return { default: cssContent };\n              }\n            }\n            return { default: serverChunk.source };\n          } else if (\"code\" in serverChunk) {\n            return { default: serverChunk.code };\n          }\n        }\n        console.warn(\"Could not find inline module for: \" + normalizedValue);\n        return null;\n      }\n\n      // Determine if this is a client component\n      const isClientComponent =\n        userOptions.autoDiscover.clientPattern.test(normalizedValue);\n\n      // For client components, use client manifest\n      if (isClientComponent) {\n        const clientEntry = clientManifest[normalizedValue];\n        if (userOptions.verbose) {\n          console.log(\"clientEntry\", clientEntry);\n        }\n        if (clientEntry) {\n          try {\n            const module = await import(\n              join(\n                userOptions.projectRoot,\n                userOptions.build.outDir,\n                userOptions.build.client,\n                clientEntry.file\n              )\n            );\n            temporaryReferences?.set(moduleRef, module);\n            return module;\n          } catch (error) {\n            const err = toError(error);\n            console.warn(\"Error loading client module:\", err);\n            temporaryReferences?.delete(moduleRef);\n            throw err;\n          }\n        }\n      }\n\n      // For static assets, use static manifest\n      const staticEntry = staticManifest[normalizedValue];\n      if (staticEntry) {\n        try {\n          const module = await import(\n            join(\n              userOptions.projectRoot,\n              userOptions.build.outDir,\n              userOptions.build.static,\n              staticEntry.file\n            )\n          );\n          temporaryReferences?.set(moduleRef, module);\n          // If we have an export name, make sure it's a key\n          if (exportName && !(exportName in module)) {\n            throw new Error(`Export ${exportName} not found in module ${normalizedValue}`);\n          }\n          return module;\n        } catch (error) {\n          const err = toError(error);\n          console.warn(\"Error loading static module:\", err);\n          temporaryReferences?.delete(moduleRef);\n          throw err;\n        }\n      }\n\n      // Check server manifest for any remaining modules (including Html/Root components)\n      const serverEntry = serverManifest[normalizedValue];\n\n      if (serverEntry) {\n        try {\n          const module = await import(\n            join(\n              userOptions.projectRoot,\n              userOptions.build.outDir,\n              userOptions.build.server,\n              serverEntry.file\n            )\n          );\n          temporaryReferences?.set(moduleRef, module);\n          // If we have an export name, make sure it's a key\n          if (exportName && !(exportName in module)) {\n            throw new Error(`Export ${exportName} not found in module ${normalizedValue}`);\n          }\n          return module;\n        } catch (error) {\n          const err = toError(error);\n          if(userOptions.panicThreshold === \"critical_errors\") {\n            console.warn(\"Error loading server module:\", err);\n            temporaryReferences?.delete(moduleRef);\n          } else {\n            console.error(\"Error loading server module:\", err);\n            throw err;\n          }\n        }\n      }\n\n      // For source files (like custom Root/Html components), try to load directly from filesystem\n      const sourceFilePath = join(userOptions.projectRoot, normalizedValue);\n      if (userOptions.verbose) {\n        console.log(\"[buildLoader] Checking source file:\", sourceFilePath, \"exists:\", existsSync(sourceFilePath));\n      }\n      if (existsSync(sourceFilePath)) {\n        try {\n          if (userOptions.verbose) {\n            console.log(\"[buildLoader] Loading source file:\", sourceFilePath);\n          }\n\n          // For TypeScript/TSX files, first check if there's a built version in dist\n          if (sourceFilePath.endsWith('.tsx') || sourceFilePath.endsWith('.ts') || sourceFilePath.endsWith('.mts')) {\n            // Try to find the built module first - check both static and server directories\n            const relativePath = normalizedValue.replace(/^src\\//, '');\n            const staticBuiltPath = join(\n              userOptions.projectRoot,\n              userOptions.build.outDir,\n              userOptions.build.static,\n              relativePath.replace(/\\.(tsx?|mts)$/, '.js')\n            );\n            const serverBuiltPath = join(\n              userOptions.projectRoot,\n              userOptions.build.outDir,\n              userOptions.build.server,\n              relativePath.replace(/\\.(tsx?|mts)$/, '.js')\n            );\n\n            // Check static directory first, then server directory\n            let builtModulePath: string | null = null;\n            if (existsSync(staticBuiltPath)) {\n              builtModulePath = staticBuiltPath;\n            } else if (existsSync(serverBuiltPath)) {\n              builtModulePath = serverBuiltPath;\n            }\n\n            if (builtModulePath) {\n              if (userOptions.verbose) {\n                console.log(\"[buildLoader] Found built module:\", builtModulePath);\n              }\n              const module = await import(builtModulePath);\n              temporaryReferences?.set(moduleRef, module);\n              // If we have an export name, make sure it's a key\n              if (exportName && !(exportName in module)) {\n                throw new Error(`Export ${exportName} not found in module ${normalizedValue}`);\n              }\n              return module;\n            }\n\n            // If no built module found, try to compile the source file\n            if (userOptions.verbose) {\n              console.log(\"[buildLoader] No built module found, trying to compile source file\");\n            }\n\n            // Use esbuild to compile the TypeScript/TSX file\n            const { transformWithEsbuild } = await import('vite');\n            const sourceCode = await readFile(sourceFilePath, 'utf-8');\n            const result = await transformWithEsbuild(sourceCode, sourceFilePath, {\n              format: 'esm',\n              sourcemap: false,\n            });\n\n            // Create a temporary file with the compiled code\n            const tempFilePath = sourceFilePath.replace(/\\.(tsx?|mts)$/, '.temp.js');\n            await writeFile(tempFilePath, result.code);\n\n            try {\n              const module = await import(tempFilePath);\n              temporaryReferences?.set(moduleRef, module);\n              // If we have an export name, make sure it's a key\n              if (exportName && !(exportName in module)) {\n                throw new Error(`Export ${exportName} not found in module ${normalizedValue}`);\n              }\n              return module;\n            } finally {\n              // Clean up temporary file\n              try {\n                await unlink(tempFilePath);\n              } catch (cleanupError) {\n                // Ignore cleanup errors\n                if (userOptions.verbose) {\n                  console.warn(\"[buildLoader] Failed to cleanup temp file:\", cleanupError);\n                }\n              }\n            }\n          } else {\n            // For other files, read as text\n            const content = await readFile(sourceFilePath, 'utf-8');\n            return { default: content };\n          }\n        } catch (error) {\n          const err = toError(error);\n          console.warn(\"Error loading source file:\", err);\n          temporaryReferences?.delete(moduleRef);\n          throw err;\n        }\n      }\n\n      throw new Error(`Module ${normalizedValue} not found during build`);\n    } catch (error) {\n      const emptyExports = {\n        error: error instanceof Error ? error : new Error(String(error)),\n        id: id,\n      };\n      temporaryReferences?.delete(moduleRef);\n      return emptyExports;\n    }\n  };\n}\n\n"],"names":[],"mappings":"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"}

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

@@ -66,4 +66,4 @@ async function fileWriter(stream, fileType, options) {
 }
 
 export { fileWriter };
-//# sourceMappingURL=fileWriter.js.map
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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