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

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

@@ -1,11 +1,12 @@
-import type { ResolvedUserOptions } from "../../types.js";
+import type { SerializedUserOptions } from "../../types.js";
 import type { ViteDevServer } from "vite";
 import type { AutoDiscoveredFiles } from "../../types.js";
 import { MessageChannel, type Worker } from "node:worker_threads";
-export declare function restartWorker({ server, autoDiscoveredFiles, userOptions, hmrChannel, }: {
+export type RestartWorkerFn = (props: {
     server: ViteDevServer;
     autoDiscoveredFiles: AutoDiscoveredFiles;
-    userOptions: ResolvedUserOptions;
+    userOptions: SerializedUserOptions;
     hmrChannel: MessageChannel;
-}): Promise<Worker | null>;
+}) => Promise<Worker | null>;
+export declare const restartWorker: RestartWorkerFn;
 //# sourceMappingURL=restartWorker.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"restartWorker.d.ts","sourceRoot":"","sources":["../../../plugin/react-client/restartWorker.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAE1D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,MAAM,CAAC;AAC1C,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAI1D,OAAO,EAAE,cAAc,EAAE,KAAK,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAMlE,wBAAsB,aAAa,CAAC,EAChC,MAAM,EACN,mBAAmB,EACnB,WAAW,EACX,UAAU,GACX,EAAE;IACD,MAAM,EAAE,aAAa,CAAC;IACtB,mBAAmB,EAAE,mBAAmB,CAAC;IACzC,WAAW,EAAE,mBAAmB,CAAC;IACjC,UAAU,EAAE,cAAc,CAAC;CAC5B,0BA8DF"}
+{"version":3,"file":"restartWorker.d.ts","sourceRoot":"","sources":["../../../plugin/react-client/restartWorker.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,qBAAqB,EACtB,MAAM,gBAAgB,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,MAAM,CAAC;AAC1C,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAG1D,OAAO,EAAE,cAAc,EAAE,KAAK,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAOlE,MAAM,MAAM,eAAe,GAAG,CAAC,KAAK,EAAE;IACpC,MAAM,EAAE,aAAa,CAAC;IACtB,mBAAmB,EAAE,mBAAmB,CAAC;IACzC,WAAW,EAAE,qBAAqB,CAAC;IACnC,UAAU,EAAE,cAAc,CAAC;CAC5B,KAAK,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;AAE7B,eAAO,MAAM,aAAa,EAAE,eAoE3B,CAAC"}

package/dist/plugin/react-client/restartWorker.js

@@ -4,13 +4,14 @@
  * MIT License
  */
 import { createWorker } from '../worker/createWorker.js';
-import { serializedOptions, serializedDevServerConfig } from '../helpers/serializeUserOptions.js';
+import { serializedDevServerConfig } from '../helpers/serializeUserOptions.js';
 import { MessageChannel } from 'node:worker_threads';
 import { DEFAULT_CONFIG } from '../config/defaults.js';
+import React__default from 'react';
 
 let currentWorker = null;
 let isRestarting = false;
-async function restartWorker({
+const restartWorker = async function _restartWorker({
   server,
   autoDiscoveredFiles,
   userOptions,
@@ -40,18 +41,19 @@ async function restartWorker({
       maxListeners,
       envPrefix: typeof server.config.envPrefix === "string" ? server.config.envPrefix : Array.isArray(server.config.envPrefix) ? server.config.envPrefix[0] : DEFAULT_CONFIG.ENV_PREFIX,
       workerData: {
-        hmrPort: workerHmrChannel.port2,
+        userOptions,
         resolvedConfig: serializedDevServerConfig(server.config),
-        userOptions: serializedOptions(userOptions, autoDiscoveredFiles),
-        serverActions: autoDiscoveredFiles.serverActions
+        reactVersion: React__default.version,
+        id: "worker/rsc"
       },
       transferList: [workerHmrChannel.port2]
     });
     if (workerResult.type === "success") {
       currentWorker = workerResult.worker;
-      if (userOptions.verbose) server.config.logger.info(
-        `[react-client] Set max listeners to ${maxListeners} for ${routeCount} routes`
-      );
+      if (userOptions.verbose)
+        server.config.logger.info(
+          `[react-client] Set max listeners to ${maxListeners} for ${routeCount} routes`
+        );
     } else if (workerResult.type === "error") {
       server.config.logger.error("Failed to start rsc-worker", {
         error: workerResult.error
@@ -62,7 +64,7 @@ async function restartWorker({
     isRestarting = false;
   }
   return currentWorker;
-}
+};
 
 export { restartWorker };
-//# sourceMappingURL=restartWorker.js.map
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/plugin/react-server/configureReactServer.d.ts

@@ -1,9 +1,10 @@
 import type { Manifest, ViteDevServer } from "vite";
-import type { AutoDiscoveredFiles, InlineCssOpt, PagePropOpt, ResolvedUserOptions } from "../types.js";
-export declare function configureReactServer<T extends PagePropOpt = PagePropOpt, InlineCSS extends InlineCssOpt = InlineCssOpt>({ server, autoDiscoveredFiles, userOptions: _userOptions, serverManifest, }: {
+import type { AutoDiscoveredFiles, ResolvedUserOptions } from "../types.js";
+export type ConfigureReactServerFn = (options: {
     server: ViteDevServer;
     autoDiscoveredFiles: AutoDiscoveredFiles;
-    userOptions: ResolvedUserOptions<T, InlineCSS>;
+    userOptions: ResolvedUserOptions;
     serverManifest: Manifest;
-}): Promise<void>;
+}) => void;
+export declare const configureReactServer: ConfigureReactServerFn;
 //# sourceMappingURL=configureReactServer.d.ts.map

package/dist/plugin/react-server/configureReactServer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"configureReactServer.d.ts","sourceRoot":"","sources":["../../../plugin/react-server/configureReactServer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,MAAM,CAAC;AAEpD,OAAO,KAAK,EACV,mBAAmB,EACnB,YAAY,EACZ,WAAW,EACX,mBAAmB,EACpB,MAAM,aAAa,CAAC;AAWrB,wBAAsB,oBAAoB,CACxC,CAAC,SAAS,WAAW,GAAG,WAAW,EACnC,SAAS,SAAS,YAAY,GAAG,YAAY,EAC7C,EACA,MAAM,EACN,mBAAmB,EACnB,WAAW,EAAE,YAAY,EACzB,cAAc,GACf,EAAE;IACD,MAAM,EAAE,aAAa,CAAC;IACtB,mBAAmB,EAAE,mBAAmB,CAAC;IACzC,WAAW,EAAE,mBAAmB,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC;IAC/C,cAAc,EAAE,QAAQ,CAAC;CAC1B,iBA6IA"}
+{"version":3,"file":"configureReactServer.d.ts","sourceRoot":"","sources":["../../../plugin/react-server/configureReactServer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,MAAM,CAAC;AAEpD,OAAO,KAAK,EACV,mBAAmB,EACnB,mBAAmB,EACpB,MAAM,aAAa,CAAC;AAarB,MAAM,MAAM,sBAAsB,GAAG,CAAC,OAAO,EAAE;IAC7C,MAAM,EAAE,aAAa,CAAC;IACtB,mBAAmB,EAAE,mBAAmB,CAAC;IACzC,WAAW,EAAE,mBAAmB,CAAC;IACjC,cAAc,EAAE,QAAQ,CAAC;CAC1B,KAAK,IAAI,CAAC;AAEX,eAAO,MAAM,oBAAoB,EAAE,sBA6MhC,CAAC"}

package/dist/plugin/react-server/configureReactServer.js

@@ -5,15 +5,17 @@
  */
 import { createEventHandler } from '../helpers/createEventHandler.js';
 import { collectViteModuleGraphCss } from '../helpers/collectViteModuleGraphCss.js';
-import { resolvePageAndProps } from '../helpers/resolvePageAndProps.js';
+import { resolveComponents } from '../helpers/resolveComponents.js';
 import { createHandler } from '../helpers/createHandler.js';
-import React__default from 'react';
 import { requestInfo } from '../helpers/requestInfo.js';
 import { getRouteFiles } from '../helpers/getRouteFiles.js';
-import { logError } from '../error/toError.js';
+import { logError } from '../error/logError.js';
 import { handleServerAction } from './handleServerAction.js';
+import { ReactDOMServer } from '../vendor/vendor.server.js';
+import React__default from 'react';
+import { DEFAULT_CONFIG } from '../config/defaults.js';
 
-async function configureReactServer({
+const configureReactServer = function _configureReactServer({
   server,
   autoDiscoveredFiles,
   userOptions: _userOptions,
@@ -23,18 +25,12 @@ async function configureReactServer({
   const {
     Html: _UserHtmlComponent,
     onEvent,
-    // remove these
+    // loader config isn't important here, since that's used by the transformer
+    loader: _loaderConfig,
+    verbose,
+    // we can use these directly to create the handler
     ...handlerUserOptions
   } = _userOptions;
-  const handlerOptions = {
-    ...handlerUserOptions,
-    moduleBaseURL: server.config.base,
-    moduleBasePath: server.config.base,
-    projectRoot: server.config.root,
-    Html: React__default.Fragment,
-    onEvent: createEventHandler(onEvent),
-    css: handlerUserOptions.css
-  };
   const define = {
     ...server.config.define,
     "process.env.NODE_ENV": JSON.stringify(
@@ -61,10 +57,33 @@ async function configureReactServer({
     }
     activeStreams.clear();
   });
+  const loader = async (id) => {
+    const [moduleID, exportName] = id.split("#");
+    const result = await server.ssrLoadModule(moduleID);
+    if (!result) {
+      return {};
+    }
+    if (exportName && !(exportName in result)) {
+      throw new Error(
+        `Module ${moduleID} does not have export ${exportName}`
+      );
+    }
+    return result;
+  };
   server.middlewares.use(async (req, res, next) => {
     if (!req.url) {
       return next();
     }
+    const handlerOptions = {
+      ...handlerUserOptions,
+      moduleBaseURL: server.config.base,
+      moduleBasePath: handlerUserOptions.moduleBasePath,
+      projectRoot: server.config.root,
+      onEvent: createEventHandler(onEvent),
+      css: handlerUserOptions.css,
+      loader,
+      verbose
+    };
     const info = requestInfo(req, handlerOptions, "", server.config.logger);
     if (info.isServerActionRequest) {
       return handleServerAction(req, res, server, handlerOptions);
@@ -74,7 +93,7 @@ async function configureReactServer({
       const routeFiles = await getRouteFiles(
         info.route,
         autoDiscoveredFiles,
-        handlerOptions
+        _userOptions
       );
       if (routeFiles.type === "error") {
         server.config.logger.error(routeFiles.error.message);
@@ -82,30 +101,48 @@ async function configureReactServer({
       }
       const pagePath = routeFiles.page;
       const propsPath = routeFiles.props;
-      const pageAndPropsResult = await resolvePageAndProps({
+      const rootPath = routeFiles.root;
+      const htmlPath = routeFiles.html;
+      const componentsResult = await resolveComponents({
         pagePath,
         propsPath,
+        rootPath,
+        htmlPath,
+        pageExportName: handlerOptions.pageExportName ?? DEFAULT_CONFIG.PAGE_EXPORT_NAME,
+        propsExportName: handlerOptions.propsExportName ?? DEFAULT_CONFIG.PROPS_EXPORT_NAME,
+        rootExportName: handlerOptions.rootExportName ?? DEFAULT_CONFIG.ROOT_EXPORT_NAME,
+        htmlExportName: handlerOptions.htmlExportName ?? DEFAULT_CONFIG.HTML_EXPORT_NAME,
         route: info.route,
-        loader: server.ssrLoadModule,
-        pageExportName: handlerOptions.pageExportName ?? "default",
-        propsExportName: handlerOptions.propsExportName ?? "default"
+        loader,
+        verbose,
+        moduleBaseURL: server.config.base,
+        build: handlerOptions.build
       });
-      if (pageAndPropsResult.type === "error") {
-        throw pageAndPropsResult.error;
-      }
-      if (pageAndPropsResult.type === "skip") {
-        return next();
+      if (componentsResult.type === "error") {
+        throw componentsResult.error;
       }
+      const { PageComponent, pageProps, RootComponent } = componentsResult;
       const eventHandler = createEventHandler(onEvent);
+      const intermediateHandlerOptions = {
+        ...handlerOptions,
+        loader,
+        onEvent: eventHandler,
+        route: info.route,
+        pagePath,
+        propsPath,
+        logger: server.config.logger,
+        manifest: serverManifest,
+        server
+      };
       const cssFilesResult = await collectViteModuleGraphCss({
         moduleGraph: server.moduleGraph,
-        // by having loaded the page and props, we can get them from the module graph
         parentUrl: pagePath,
         handlerOptions: {
+          ...handlerOptions,
           pagePath,
-          loader: server.ssrLoadModule,
-          // explicitly set for development server
-          ...handlerOptions
+          moduleBaseURL: server.config.base,
+          moduleBasePath: handlerUserOptions.moduleBasePath,
+          projectRoot: server.config.root
         }
       });
       if (cssFilesResult.type === "skip") {
@@ -114,23 +151,15 @@ async function configureReactServer({
       if (cssFilesResult.type === "error") {
         throw cssFilesResult.error;
       }
-      const { PageComponent, pageProps } = pageAndPropsResult;
-      const rscResult = createHandler({
-        ...handlerOptions,
+      const finalHandlerOptions = Object.assign(intermediateHandlerOptions, {
         PageComponent,
         pageProps,
-        logger: server.config.logger,
-        loader: server.ssrLoadModule,
-        Html: React__default.Fragment,
-        onEvent: eventHandler,
-        manifest: serverManifest,
-        server,
-        route: info.route,
-        pagePath,
-        propsPath,
+        RootComponent,
+        HtmlComponent: React__default.Fragment,
         cssFiles: cssFilesResult.cssFiles ?? /* @__PURE__ */ new Map(),
         globalCss: /* @__PURE__ */ new Map()
       });
+      const rscResult = createHandler(finalHandlerOptions);
       if (rscResult.type === "success") {
         res.setHeader("Content-Type", "text/x-component; charset=utf-8");
         rscResult.stream.pipe(res);
@@ -141,10 +170,36 @@ async function configureReactServer({
       });
     } catch (error) {
       logError(error, server.config.logger);
-      res.end();
+      res.statusCode = 500;
+      res.setHeader("Content-Type", "text/x-component; charset=utf-8");
+      res.setHeader("Content-Length", "0");
+      const { pipe } = ReactDOMServer.renderToPipeableStream(
+        {
+          type: "error",
+          error: {
+            digest: error instanceof Error ? error.message : String(error),
+            name: error instanceof Error ? error.name : "Error"
+          }
+        },
+        handlerOptions.moduleBasePath,
+        {
+          onError(error2) {
+            logError(error2, server.config.logger);
+            res.statusCode = 500;
+            res.end();
+          },
+          onAllReady() {
+            const contentLength = res.getHeader("Content-Length");
+            if (contentLength) {
+              res.setHeader("Content-Length", contentLength);
+            }
+          }
+        }
+      );
+      pipe(res);
     }
   });
-}
+};
 
 export { configureReactServer };
-//# sourceMappingURL=configureReactServer.js.map
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"configureReactServer.js","sources":["../../../plugin/react-server/configureReactServer.ts"],"sourcesContent":["import type { Manifest, ViteDevServer } from \"vite\";\nimport type { ServerResponse } from \"http\";\nimport type {\n  AutoDiscoveredFiles,\n  ResolvedUserOptions,\n} from \"../types.js\";\nimport { createEventHandler } from \"../helpers/createEventHandler.js\";\nimport { collectViteModuleGraphCss } from \"../helpers/collectViteModuleGraphCss.js\";\nimport { resolveComponents } from \"../helpers/resolveComponents.js\";\nimport { createHandler } from \"../helpers/createHandler.js\";\nimport { requestInfo } from \"../helpers/requestInfo.js\";\nimport { getRouteFiles } from \"../helpers/getRouteFiles.js\";\nimport { logError } from \"../error/logError.js\";\nimport { handleServerAction } from \"./handleServerAction.js\";\nimport { ReactDOMServer } from \"../vendor/vendor.server.js\";\nimport React from \"react\";\nimport { DEFAULT_CONFIG } from \"../config/defaults.js\";\n\nexport type ConfigureReactServerFn = (options: {\n  server: ViteDevServer;\n  autoDiscoveredFiles: AutoDiscoveredFiles;\n  userOptions: ResolvedUserOptions;\n  serverManifest: Manifest;\n}) => void;\n\nexport const configureReactServer: ConfigureReactServerFn =\n  function _configureReactServer({\n    server,\n    autoDiscoveredFiles,\n    userOptions: _userOptions,\n    serverManifest,\n  }) {\n    const activeStreams = new Set<ServerResponse>();\n    const {\n      Html: _UserHtmlComponent,\n      onEvent,\n      // loader config isn't important here, since that's used by the transformer\n      loader: _loaderConfig,\n      verbose,\n      // we can use these directly to create the handler\n      ...handlerUserOptions\n    } = _userOptions;\n\n    // Set environment-specific configuration\n    const define = {\n      ...server.config.define,\n      \"process.env.NODE_ENV\": JSON.stringify(\n        process.env[\"NODE_ENV\"] || \"development\"\n      ),\n    };\n    server.config = {\n      ...server.config,\n      define,\n    };\n\n    // Handle Vite server restarts\n    server.ws.on(\"restart\", (path) => {\n      server.config.logger.info(\n        \"[vite-plugin-react-server] 🔧 Plugin changed, preparing for restart:\",\n        path\n      );\n\n      // Close streams with restart message\n      for (const res of activeStreams) {\n        res.writeHead(503, {\n          \"Content-Type\": \"text/x-component; charset=utf-8\",\n          \"Retry-After\": \"1\",\n        });\n        res.end(\n          `0:E{\"digest\":\"\",\"name\":\"Error\",\"message\":\"Server restarting...\",\"stack\":\"\",\"env\":\"Server\"}`\n        );\n      }\n      activeStreams.clear();\n    });\n    const loader = async (id: string) => {\n      const [moduleID, exportName] = id.split(\"#\");\n      const result = await server.ssrLoadModule(moduleID);\n      if (!result) {\n        return {};\n      }\n      if (exportName && !(exportName in result)) {\n        throw new Error(\n          `Module ${moduleID} does not have export ${exportName}`\n        );\n      }\n      return result;\n    };\n\n    server.middlewares.use(async (req, res, next) => {\n      if (!req.url) {\n        return next();\n      }\n      const handlerOptions = {\n        ...handlerUserOptions,\n        moduleBaseURL: server.config.base,\n        moduleBasePath: handlerUserOptions.moduleBasePath,\n        projectRoot: server.config.root,\n        onEvent: createEventHandler(onEvent),\n        css: handlerUserOptions.css,\n        loader: loader,\n        verbose,\n      };\n      const info = requestInfo(req, handlerOptions, \"\", server.config.logger);\n\n      // Handle server actions\n      if (info.isServerActionRequest) {\n        return handleServerAction(req, res, server, handlerOptions);\n      }\n      if (!info.isRscRequest) return next();\n      try {\n        const routeFiles = await getRouteFiles(\n          info.route,\n          autoDiscoveredFiles,\n          _userOptions\n        );\n        if (routeFiles.type === \"error\") {\n          server.config.logger.error(routeFiles.error.message);\n          return next();\n        }\n        const pagePath = routeFiles.page;\n        const propsPath = routeFiles.props;\n        const rootPath = routeFiles.root;\n        const htmlPath = routeFiles.html;\n\n        // Resolve all components together\n        const componentsResult = await resolveComponents({\n          pagePath,\n          propsPath,\n          rootPath,\n          htmlPath,\n          pageExportName: handlerOptions.pageExportName ?? DEFAULT_CONFIG.PAGE_EXPORT_NAME,\n          propsExportName: handlerOptions.propsExportName ?? DEFAULT_CONFIG.PROPS_EXPORT_NAME,\n          rootExportName: handlerOptions.rootExportName ?? DEFAULT_CONFIG.ROOT_EXPORT_NAME,\n          htmlExportName: handlerOptions.htmlExportName ?? DEFAULT_CONFIG.HTML_EXPORT_NAME,\n          route: info.route,\n          loader: loader,\n          verbose,\n          moduleBaseURL: server.config.base,\n          build: handlerOptions.build,\n        });\n        if (componentsResult.type === \"error\") {\n          throw componentsResult.error;\n        }\n\n        const { PageComponent, pageProps, RootComponent } = componentsResult;\n\n        const eventHandler = createEventHandler(onEvent);\n        const intermediateHandlerOptions = {\n          ...handlerOptions,\n          loader: loader,\n          onEvent: eventHandler,\n          route: info.route,\n          pagePath,\n          propsPath,\n          logger: server.config.logger,\n          manifest: serverManifest,\n          server,\n        };\n        const cssFilesResult = await collectViteModuleGraphCss({\n          moduleGraph: server.moduleGraph,\n          parentUrl: pagePath,\n          handlerOptions: {\n            ...handlerOptions,\n            pagePath,\n            moduleBaseURL: server.config.base,\n            moduleBasePath: handlerUserOptions.moduleBasePath,\n            projectRoot: server.config.root,\n          },\n        });\n        if (cssFilesResult.type === \"skip\") {\n          return next();\n        }\n        if (cssFilesResult.type === \"error\") {\n          throw cssFilesResult.error;\n        }\n\n        const finalHandlerOptions = Object.assign(intermediateHandlerOptions, {\n          PageComponent: PageComponent,\n          pageProps: pageProps,\n          RootComponent,\n          HtmlComponent: React.Fragment,\n          cssFiles: cssFilesResult.cssFiles ?? new Map(),\n          globalCss: new Map(),\n        });\n\n        // Create the headless RSC stream directly\n        const rscResult = createHandler(finalHandlerOptions);\n\n        if (rscResult.type === \"success\") {\n          // set headers\n          res.setHeader(\"Content-Type\", \"text/x-component; charset=utf-8\");\n          rscResult.stream!.pipe(res);\n        }\n        activeStreams.add(res);\n        res.on(\"close\", () => {\n          activeStreams.delete(res);\n        });\n      } catch (error) {\n        logError(error, server.config.logger);\n        res.statusCode = 500;\n        res.setHeader(\"Content-Type\", \"text/x-component; charset=utf-8\");\n        res.setHeader(\"Content-Length\", \"0\"); // Will be updated after streaming\n\n        const { pipe } = ReactDOMServer.renderToPipeableStream(\n          {\n            type: \"error\",\n            error: {\n              digest: error instanceof Error ? error.message : String(error),\n              name: error instanceof Error ? error.name : \"Error\",\n            },\n          },\n          handlerOptions.moduleBasePath,\n          {\n            onError(error: Error) {\n              logError(error, server.config.logger);\n              res.statusCode = 500;\n              res.end();\n            },\n            onAllReady() {\n              // Update content length after streaming is complete\n              const contentLength = res.getHeader(\"Content-Length\");\n              if (contentLength) {\n                res.setHeader(\"Content-Length\", contentLength);\n              }\n            },\n          }\n        );\n        pipe(res);\n      }\n    });\n  };\n"],"names":["React","error"],"mappings":"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"}

package/dist/plugin/react-server/handleServerAction.d.ts

@@ -1,5 +1,6 @@
 import type { ViteDevServer } from "vite";
-import type { InlineCssOpt, PagePropOpt, ResolvedUserOptions } from "../types.js";
+import type { CreateHandlerOptions } from "../types.js";
 import type { IncomingMessage, ServerResponse } from "http";
-export declare function handleServerAction<T extends PagePropOpt = PagePropOpt, InlineCss extends InlineCssOpt = InlineCssOpt>(req: IncomingMessage, res: ServerResponse, server: ViteDevServer, handlerOptions: ResolvedUserOptions<T, InlineCss>): Promise<void>;
+export type HandleServerActionFn = (req: IncomingMessage, res: ServerResponse, server: ViteDevServer, handlerOptions: Pick<CreateHandlerOptions, "verbose" | "moduleBasePath" | "projectRoot" | "loader">) => Promise<void>;
+export declare const handleServerAction: HandleServerActionFn;
 //# sourceMappingURL=handleServerAction.d.ts.map

package/dist/plugin/react-server/handleServerAction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"handleServerAction.d.ts","sourceRoot":"","sources":["../../../plugin/react-server/handleServerAction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,MAAM,CAAC;AAC1C,OAAO,KAAK,EACV,YAAY,EACZ,WAAW,EACX,mBAAmB,EACpB,MAAM,aAAa,CAAC;AAIrB,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,MAAM,CAAC;AAE5D,wBAAsB,kBAAkB,CACtC,CAAC,SAAS,WAAW,GAAG,WAAW,EACnC,SAAS,SAAS,YAAY,GAAG,YAAY,EAE7C,GAAG,EAAE,eAAe,EACpB,GAAG,EAAE,cAAc,EACnB,MAAM,EAAE,aAAa,EACrB,cAAc,EAAE,mBAAmB,CAAC,CAAC,EAAE,SAAS,CAAC,iBAiLlD"}
+{"version":3,"file":"handleServerAction.d.ts","sourceRoot":"","sources":["../../../plugin/react-server/handleServerAction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,MAAM,CAAC;AAC1C,OAAO,KAAK,EACV,oBAAoB,EACrB,MAAM,aAAa,CAAC;AAIrB,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,MAAM,CAAC;AAE5D,MAAM,MAAM,oBAAoB,GAAG,CACjC,GAAG,EAAE,eAAe,EACpB,GAAG,EAAE,cAAc,EACnB,MAAM,EAAE,aAAa,EACrB,cAAc,EAAE,IAAI,CAClB,oBAAoB,EACpB,SAAS,GAAG,gBAAgB,GAAG,aAAa,GAAG,QAAQ,CACxD,KACE,OAAO,CAAC,IAAI,CAAC,CAAC;AAEnB,eAAO,MAAM,kBAAkB,EAAE,oBA4K9B,CAAC"}

package/dist/plugin/react-server/handleServerAction.js

@@ -3,11 +3,12 @@
  * Copyright (c) Nico Brinkkemper
  * MIT License
  */
-import { toError, logError } from '../error/toError.js';
-import { join } from 'path';
+import { toError } from '../error/toError.js';
+import { logError } from '../error/logError.js';
+import { join } from 'node:path';
 import { ReactDOMServer } from '../vendor/vendor.server.js';
 
-async function handleServerAction(req, res, server, handlerOptions) {
+const handleServerAction = async function _handleServerAction(req, res, server, handlerOptions) {
   let id = req.url?.split("?")[0] ?? "";
   try {
     if (handlerOptions.verbose) {
@@ -41,7 +42,7 @@ async function handleServerAction(req, res, server, handlerOptions) {
       }
     } catch (error) {
       throw new Error(`Failed to parse server action request`, {
-        cause: toError(error)
+        cause: error
       });
     }
     if (!id) {
@@ -103,7 +104,8 @@ async function handleServerAction(req, res, server, handlerOptions) {
       );
     }
     res.setHeader("Content-Type", "text/x-component; charset=utf-8");
-    res.setHeader("Content-Length", "0");
+    res.setHeader("Transfer-Encoding", "chunked");
+    res.setHeader("Connection", "keep-alive");
     const { pipe } = ReactDOMServer.renderToPipeableStream(
       {
         type: "server-action-response",
@@ -118,10 +120,6 @@ async function handleServerAction(req, res, server, handlerOptions) {
           res.end();
         },
         onAllReady() {
-          const contentLength = res.getHeader("Content-Length");
-          if (contentLength) {
-            res.setHeader("Content-Length", contentLength);
-          }
         }
       }
     );
@@ -131,14 +129,14 @@ async function handleServerAction(req, res, server, handlerOptions) {
     logError(err, server.config.logger);
     res.statusCode = 500;
     res.setHeader("Content-Type", "text/x-component; charset=utf-8");
-    res.setHeader("Content-Length", "0");
+    res.setHeader("Transfer-Encoding", "chunked");
+    res.setHeader("Connection", "keep-alive");
     const { pipe } = ReactDOMServer.renderToPipeableStream(
       {
         type: "server-action-response",
-        returnValue: null,
-        error: {
-          digest: err.message || "",
-          name: err.name || "Error"
+        returnValue: {
+          success: false,
+          error: err.message
         },
         id
       },
@@ -150,16 +148,12 @@ async function handleServerAction(req, res, server, handlerOptions) {
           res.end();
         },
         onAllReady() {
-          const contentLength = res.getHeader("Content-Length");
-          if (contentLength) {
-            res.setHeader("Content-Length", contentLength);
-          }
         }
       }
     );
     pipe(res);
   }
-}
+};
 
 export { handleServerAction };
-//# sourceMappingURL=handleServerAction.js.map
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"handleServerAction.js","sources":["../../../plugin/react-server/handleServerAction.ts"],"sourcesContent":["import type { ViteDevServer } from \"vite\";\nimport type {\n  CreateHandlerOptions,\n} from \"../types.js\";\nimport { logError, toError } from \"../error/index.js\";\nimport { join } from \"node:path\";\nimport { ReactDOMServer } from \"../vendor/vendor.server.js\";\nimport type { IncomingMessage, ServerResponse } from \"http\";\n\nexport type HandleServerActionFn = (\n  req: IncomingMessage,\n  res: ServerResponse,\n  server: ViteDevServer,\n  handlerOptions: Pick<\n    CreateHandlerOptions,\n    \"verbose\" | \"moduleBasePath\" | \"projectRoot\" | \"loader\"\n  >\n) => Promise<void>;\n\nexport const handleServerAction: HandleServerActionFn =\n  async function _handleServerAction(req, res, server, handlerOptions) {\n    let id = req.url?.split(\"?\")[0] ?? \"\";\n    try {\n      if (handlerOptions.verbose) {\n        server.config.logger.info(\n          `[react-server] Handling server action request at ${req.url}`\n        );\n      }\n\n      // Parse the request body\n      let args: unknown[];\n      try {\n        const chunks: Buffer[] = [];\n        for await (const chunk of req) {\n          chunks.push(chunk);\n        }\n        const body = Buffer.concat(chunks).toString();\n        if (handlerOptions.verbose) {\n          server.config.logger.info(`[react-server] Request body: ${body}`);\n        }\n\n        const parsed = JSON.parse(body);\n        if (Array.isArray(parsed)) {\n          // Format 1: Direct args array\n          args = parsed;\n          // Get the action ID from the request URL\n          if (handlerOptions.verbose) {\n            server.config.logger.info(\n              `[react-server] Using action ID from URL: ${id}`\n            );\n          }\n        } else if (parsed && typeof parsed === \"object\" && \"id\" in parsed) {\n          // Format 2: Object with id and args\n          id = parsed.id;\n          args = parsed.args ?? [];\n        } else {\n          throw new Error(\"Invalid server action request format\");\n        }\n      } catch (error: unknown) {\n        throw new Error(`Failed to parse server action request`, {\n          cause: error,\n        });\n      }\n\n      if (!id) {\n        throw new Error(\"Server action ID is required\");\n      }\n\n      if (handlerOptions.verbose) {\n        server.config.logger.info(\n          `[react-server] Server action request for ${id} with args: ${JSON.stringify(\n            args\n          )}`\n        );\n      }\n\n      // Parse the server action ID to get the file path and export name\n      const [filePath, exportName] = id.split(\"#\");\n      if (!filePath || !exportName) {\n        throw new Error(\n          `Invalid server action ID format: ${id}. Expected format: \"path/to/file.ts#exportName\"`\n        );\n      }\n\n      // Convert the server action ID to a file path\n      const actionPath = filePath.startsWith(\"/\")\n        ? filePath.slice(1)\n        : filePath;\n      const fullPath = join(handlerOptions.projectRoot, actionPath);\n      if (handlerOptions.verbose) {\n        server.config.logger.info(\n          `[react-server] Resolved file path: id=${id}, actionPath=${actionPath}, projectRoot=${handlerOptions.projectRoot}, filePath=${fullPath}, exportName=${exportName}`\n        );\n      }\n\n      // Load the server action module\n      if (handlerOptions.verbose) {\n        server.config.logger.info(`[react-server] Loading module: ${fullPath}`);\n      }\n      const module = await server.ssrLoadModule(fullPath);\n      if (handlerOptions.verbose) {\n        server.config.logger.info(\n          `[react-server] Looking for action: ${exportName} in module with exports: ${Object.keys(\n            module\n          ).join(\", \")}`\n        );\n      }\n      const action = module[exportName];\n\n      if (typeof action !== \"function\") {\n        if (handlerOptions.verbose) {\n          server.config.logger.error(\n            `[react-server] Action not found: ${exportName} in module with exports: ${Object.keys(\n              module\n            ).join(\", \")}`\n          );\n        }\n        throw new Error(`Server action not found: ${id}`);\n      }\n\n      // Execute the server action\n      if (handlerOptions.verbose) {\n        server.config.logger.info(\n          `[react-server] Executing action with args: ${JSON.stringify(args)}`\n        );\n      }\n      const result = await action(...args);\n      if (handlerOptions.verbose) {\n        server.config.logger.info(\n          `[react-server] Action completed successfully with result: ${JSON.stringify(\n            result\n          )}`\n        );\n      }\n\n      // Send the response using RSC streaming\n      res.setHeader(\"Content-Type\", \"text/x-component; charset=utf-8\");\n      res.setHeader(\"Transfer-Encoding\", \"chunked\");\n      res.setHeader(\"Connection\", \"keep-alive\");\n\n      const { pipe } = ReactDOMServer.renderToPipeableStream(\n        {\n          type: \"server-action-response\",\n          returnValue: result,\n          id,\n        },\n        handlerOptions.moduleBasePath,\n        {\n          onError(error: Error) {\n            logError(error, server.config.logger);\n            res.statusCode = 500;\n            res.end();\n          },\n          onAllReady() {\n            // No need to update content length for chunked encoding\n          },\n        }\n      );\n\n      pipe(res);\n    } catch (error) {\n      const err = toError(error);\n      logError(err, server.config.logger);\n      res.statusCode = 500;\n      res.setHeader(\"Content-Type\", \"text/x-component; charset=utf-8\");\n      res.setHeader(\"Transfer-Encoding\", \"chunked\");\n      res.setHeader(\"Connection\", \"keep-alive\");\n\n      const { pipe } = ReactDOMServer.renderToPipeableStream(\n        {\n          type: \"server-action-response\",\n          returnValue: {\n            success: false,\n            error: err.message,\n          },\n          id,\n        },\n        handlerOptions.moduleBasePath,\n        {\n          onError(error: Error) {\n            logError(error, server.config.logger);\n            res.statusCode = 500;\n            res.end();\n          },\n          onAllReady() {\n            // No need to update content length for chunked encoding\n          },\n        }\n      );\n      pipe(res);\n    }\n  };\n"],"names":["error"],"mappings":"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"}

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

@@ -1,7 +1,6 @@
-import { type Plugin as VitePlugin } from "vite";
-import type { ReactStreamPluginMeta, PagePropOpt, InlineCssOpt } from "../types.js";
-import { type StreamPluginOptions } from "../types.js";
-export declare function reactServerPlugin<T extends PagePropOpt = PagePropOpt, InlineCSS extends InlineCssOpt = InlineCssOpt>(options: StreamPluginOptions<T, InlineCSS>): VitePlugin<{
+import type { ReactStreamPluginFn, ReactStreamPluginMeta } from "../types.js";
+export type ReactServerPluginFn = ReactStreamPluginFn<{
     meta: ReactStreamPluginMeta;
 }>;
+export declare const reactServerPlugin: ReactServerPluginFn;
 //# sourceMappingURL=plugin.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../../../plugin/react-server/plugin.ts"],"names":[],"mappings":"AACA,OAAO,EAKL,KAAK,MAAM,IAAI,UAAU,EAC1B,MAAM,MAAM,CAAC;AAGd,OAAO,KAAK,EAGV,qBAAqB,EAErB,WAAW,EACX,YAAY,EACb,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,KAAK,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAiBvD,wBAAgB,iBAAiB,CAC/B,CAAC,SAAS,WAAW,GAAG,WAAW,EACnC,SAAS,SAAS,YAAY,GAAG,YAAY,EAC7C,OAAO,EAAE,mBAAmB,CAAC,CAAC,EAAE,SAAS,CAAC,GAAG,UAAU,CAAC;IACxD,IAAI,EAAE,qBAAqB,CAAC;CAC7B,CAAC,CAuJD"}
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../../../plugin/react-server/plugin.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAGV,mBAAmB,EACnB,qBAAqB,EACtB,MAAM,aAAa,CAAC;AAWrB,MAAM,MAAM,mBAAmB,GAAG,mBAAmB,CAAC;IACpD,IAAI,EAAE,qBAAqB,CAAC;CAC7B,CAAC,CAAA;AAEF,eAAO,MAAM,iBAAiB,EAAC,mBA2J9B,CAAA"}

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

@@ -8,29 +8,23 @@ import 'vite';
 import { resolveOptions } from '../config/resolveOptions.js';
 import { resolveUserConfig } from '../config/resolveUserConfig.js';
 import { resolveAutoDiscover } from '../config/autoDiscover/resolveAutoDiscover.js';
-import { getCondition } from '../config/getCondition.js';
 import { configureReactServer } from './configureReactServer.js';
 import { configurePreviewServer } from '../react-static/configurePreviewServer.js';
 import { getBundleManifest } from '../helpers/getBundleManifest.js';
+import { createDefaultModuleID } from '../config/createModuleID.js';
 
 let resolvedConfig = null;
-if (getCondition() !== "react-server") {
-  throw new Error(
-    "Condition mismatch, should be react-server but got " + process.env["NODE_OPTIONS"]
-  );
-}
-function reactServerPlugin(options) {
+const reactServerPlugin = function _reactServerPlugin(options) {
   const timing = {
     start: performance.now()
   };
   let autoDiscoveredFiles;
-  let userOptions;
   let serverManifest = {};
   const resolvedOptions = resolveOptions(options);
   if (resolvedOptions.type === "error") {
     throw resolvedOptions.error;
   }
-  userOptions = resolvedOptions.userOptions;
+  const userOptions = resolvedOptions.userOptions;
   return {
     name: "vite:react-stream-server",
     enforce: "post",
@@ -47,16 +41,16 @@ function reactServerPlugin(options) {
       timing.configResolved = performance.now();
       const plugins = resolvedConfig.plugins;
       const transformerIndex = plugins.findIndex(
-        (p) => p.name === "vite:react-server-transform"
+        (p) => p.name.includes("vite-plugin-react-server:transform")
       );
       const preserverIndex = plugins.findIndex(
-        (p) => p.name === "vite-plugin-react-server:preserve-directives"
+        (p) => p.name.includes("vite-plugin-react-server:preserve-directives")
       );
       if (transformerIndex === -1) {
         throw new Error("Transformer plugin not installed");
       }
       if (preserverIndex < transformerIndex) {
-        throw new Error(
+        console.warn(
           "Transformer plugin isn't installed or isn't running before preserver"
         );
       }
@@ -76,6 +70,9 @@ function reactServerPlugin(options) {
       });
     },
     async config(config, configEnv) {
+      if (typeof userOptions.moduleID !== "function") {
+        userOptions.moduleID = createDefaultModuleID(userOptions, configEnv, userOptions.loader.mode);
+      }
       const autoDiscoverResult = await resolveAutoDiscover({
         config,
         configEnv,
@@ -127,15 +124,15 @@ function reactServerPlugin(options) {
         normalizer: userOptions.normalizer
       });
     },
-    async handleHotUpdate({ file, server, read, timestamp, ...ctx }) {
+    async handleHotUpdate({ file, server, timestamp, ...ctx }) {
       try {
         if (server.moduleGraph) {
           const mod = server.moduleGraph.getModuleById(file);
           if (mod) {
-            server.moduleGraph.invalidateModule(mod, void 0, void 0, true);
+            server.moduleGraph.invalidateModule(mod, void 0, timestamp, true);
             const newMod = await server.moduleGraph.ensureEntryFromUrl(file, false);
             if (newMod) {
-              server.moduleGraph.invalidateModule(newMod, void 0, void 0, true);
+              server.moduleGraph.invalidateModule(newMod, void 0, timestamp, true);
             }
           }
         }
@@ -146,7 +143,7 @@ function reactServerPlugin(options) {
       }
     }
   };
-}
+};
 
 export { reactServerPlugin };
-//# sourceMappingURL=plugin.js.map
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"plugin.js","sources":["../../../plugin/react-server/plugin.ts"],"sourcesContent":["import { performance } from \"node:perf_hooks\";\nimport {\n  type ResolvedConfig,\n  type UserConfig,\n  type ViteDevServer,\n  type Manifest,\n} from \"vite\";\nimport { resolveOptions } from \"../config/resolveOptions.js\";\nimport { resolveUserConfig } from \"../config/resolveUserConfig.js\";\nimport type {\n  AutoDiscoveredFiles,\n  BuildTiming,\n  ReactStreamPluginFn,\n  ReactStreamPluginMeta,\n} from \"../types.js\";\nimport {\n  resolveAutoDiscover\n} from \"../config/autoDiscover/resolveAutoDiscover.js\";\nimport { configureReactServer } from \"./configureReactServer.js\";\nimport { configurePreviewServer } from \"../react-static/configurePreviewServer.js\";\nimport { getBundleManifest } from \"../helpers/getBundleManifest.js\";\nimport { createDefaultModuleID } from \"../config/createModuleID.js\";\n\nlet resolvedConfig: ResolvedConfig | null = null;\n\nexport type ReactServerPluginFn = ReactStreamPluginFn<{\n  meta: ReactStreamPluginMeta;\n}>\n\nexport const reactServerPlugin:ReactServerPluginFn = function _reactServerPlugin(options) {\n  const timing: BuildTiming = {\n    start: performance.now(),\n  };\n\n  let autoDiscoveredFiles: AutoDiscoveredFiles;\n  let serverManifest: Manifest = {};\n\n  const resolvedOptions = resolveOptions(options);\n  if (resolvedOptions.type === \"error\") {\n    throw resolvedOptions.error;\n  }\n  const userOptions = resolvedOptions.userOptions;\n  \n\n  return {\n    name: \"vite:react-stream-server\",\n    enforce: \"post\",\n    api: {\n      meta: { timing },\n    },  \n    configResolved(_resolvedConfig) {\n      resolvedConfig = _resolvedConfig;\n      if (\n        userOptions.projectRoot != resolvedConfig.root &&\n        typeof userOptions.projectRoot === \"string\" &&\n        userOptions.projectRoot !== \"\"\n      ) {\n        throw new Error(\n          \"[RSC] Project root is not the current working directory, please set projectRoot in your config.\\n\" +\n            \" projectRoot: \" + userOptions.projectRoot + \"\\n\" +\n            \" resolvedConfig.root: \" + resolvedConfig.root\n        );\n      }\n      timing.configResolved = performance.now();\n\n      // Verify transformer runs first, preserver runs last\n      const plugins = resolvedConfig.plugins;\n      const transformerIndex = plugins.findIndex(\n        (p) => p.name.includes(\"vite-plugin-react-server:transform\")\n      );\n      const preserverIndex = plugins.findIndex(\n        (p) => p.name.includes(\"vite-plugin-react-server:preserve-directives\")\n      );\n\n      if (transformerIndex === -1) {\n        throw new Error(\"Transformer plugin not installed\");\n      }\n      if (preserverIndex < transformerIndex) {\n        console.warn(\n          \"Transformer plugin isn't installed or isn't running before preserver\"\n        );\n      }\n    },\n\n    async configurePreviewServer(server) {\n      await configurePreviewServer({\n        server,\n        userOptions,\n      });\n    },\n    async configureServer(server: ViteDevServer) {\n      configureReactServer({\n        server,\n        autoDiscoveredFiles,\n        userOptions,\n        serverManifest,\n      });\n    },\n    async config(config, configEnv): Promise<UserConfig> {\n      // Create the proper moduleID function now that we have ConfigEnv\n      if (typeof userOptions.moduleID !== \"function\") {\n        userOptions.moduleID = createDefaultModuleID(userOptions, configEnv, userOptions.loader.mode);\n      }\n\n      const autoDiscoverResult = await resolveAutoDiscover({\n        config,\n        configEnv,\n        userOptions,\n        condition: \"react-server\",\n      });\n      if (autoDiscoverResult.type === \"error\") {\n        throw autoDiscoverResult.error;\n      }\n      autoDiscoveredFiles = autoDiscoverResult.autoDiscoveredFiles;\n\n      const resolvedConfig = resolveUserConfig({\n        condition: \"react-server\",\n        config,\n        configEnv,\n        userOptions,\n        autoDiscoveredFiles,\n      });\n\n      if (resolvedConfig.type === \"error\") {\n        console.error(\n          \"[react-server-plugin] Failed to resolve config:\",\n          resolvedConfig.error\n        );\n        throw resolvedConfig.error;\n      }\n\n      return resolvedConfig.userConfig;\n    },\n    async writeBundle(options, bundle) {\n      if (userOptions.onEvent) {\n        userOptions.onEvent({\n          type: \"build.writeBundle.server\",\n          data: {\n            pages: Array.from(autoDiscoveredFiles?.urlMap.keys() ?? []),\n            options,\n            bundle,\n          },\n        });\n      }\n    },\n    async buildStart() {\n      if (!timing.buildStart) {\n        timing.buildStart = performance.now();\n      } else {\n        console.log(\"Build already started\");\n      }\n    },\n    async generateBundle(_options, bundle) {\n      // Create manifest entries for each chunk\n      serverManifest = getBundleManifest<false>({\n        bundle,\n        normalizer: userOptions.normalizer,\n      });\n    },\n    async handleHotUpdate({ file, server, timestamp, ...ctx }) {\n      try {\n        // Invalidate the module in Vite's cache for both client and SSR\n        if (server.moduleGraph) {\n          const mod = server.moduleGraph.getModuleById(file);\n          if (mod) {\n            // Invalidate the parent module which will handle both client and SSR\n            server.moduleGraph.invalidateModule(mod, undefined, timestamp, true);\n            \n            // Force a reload of the module\n            const newMod = await server.moduleGraph.ensureEntryFromUrl(file, false);\n            if (newMod) {\n              server.moduleGraph.invalidateModule(newMod, undefined, timestamp, true);\n            }\n          }\n        }\n        \n        // Let Vite handle the HMR update\n        return ctx.modules;\n      } catch (error) {\n        console.error(\"[react-server] HMR Error:\", error);\n        return ctx.modules;\n      }\n    },\n  };\n}\n"],"names":["resolvedConfig","options"],"mappings":";;;;;;;;;;;;;;;AAuBA,IAAI,cAAwC,GAAA,IAAA;AAM/B,MAAA,iBAAA,GAAwC,SAAS,kBAAA,CAAmB,OAAS,EAAA;AACxF,EAAA,MAAM,MAAsB,GAAA;AAAA,IAC1B,KAAA,EAAO,YAAY,GAAI;AAAA,GACzB;AAEA,EAAI,IAAA,mBAAA;AACJ,EAAA,IAAI,iBAA2B,EAAC;AAEhC,EAAM,MAAA,eAAA,GAAkB,eAAe,OAAO,CAAA;AAC9C,EAAI,IAAA,eAAA,CAAgB,SAAS,OAAS,EAAA;AACpC,IAAA,MAAM,eAAgB,CAAA,KAAA;AAAA;AAExB,EAAA,MAAM,cAAc,eAAgB,CAAA,WAAA;AAGpC,EAAO,OAAA;AAAA,IACL,IAAM,EAAA,0BAAA;AAAA,IACN,OAAS,EAAA,MAAA;AAAA,IACT,GAAK,EAAA;AAAA,MACH,IAAA,EAAM,EAAE,MAAO;AAAA,KACjB;AAAA,IACA,eAAe,eAAiB,EAAA;AAC9B,MAAiB,cAAA,GAAA,eAAA;AACjB,MACE,IAAA,WAAA,CAAY,WAAe,IAAA,cAAA,CAAe,IAC1C,IAAA,OAAO,YAAY,WAAgB,KAAA,QAAA,IACnC,WAAY,CAAA,WAAA,KAAgB,EAC5B,EAAA;AACA,QAAA,MAAM,IAAI,KAAA;AAAA,UACR,iHACqB,GAAA,WAAA,CAAY,WAAc,GAAA,0BAAA,GAClB,cAAe,CAAA;AAAA,SAC9C;AAAA;AAEF,MAAO,MAAA,CAAA,cAAA,GAAiB,YAAY,GAAI,EAAA;AAGxC,MAAA,MAAM,UAAU,cAAe,CAAA,OAAA;AAC/B,MAAA,MAAM,mBAAmB,OAAQ,CAAA,SAAA;AAAA,QAC/B,CAAC,CAAA,KAAM,CAAE,CAAA,IAAA,CAAK,SAAS,oCAAoC;AAAA,OAC7D;AACA,MAAA,MAAM,iBAAiB,OAAQ,CAAA,SAAA;AAAA,QAC7B,CAAC,CAAA,KAAM,CAAE,CAAA,IAAA,CAAK,SAAS,8CAA8C;AAAA,OACvE;AAEA,MAAA,IAAI,qBAAqB,EAAI,EAAA;AAC3B,QAAM,MAAA,IAAI,MAAM,kCAAkC,CAAA;AAAA;AAEpD,MAAA,IAAI,iBAAiB,gBAAkB,EAAA;AACrC,QAAQ,OAAA,CAAA,IAAA;AAAA,UACN;AAAA,SACF;AAAA;AACF,KACF;AAAA,IAEA,MAAM,uBAAuB,MAAQ,EAAA;AACnC,MAAA,MAAM,sBAAuB,CAAA;AAAA,QAC3B,MAAA;AAAA,QACA;AAAA,OACD,CAAA;AAAA,KACH;AAAA,IACA,MAAM,gBAAgB,MAAuB,EAAA;AAC3C,MAAqB,oBAAA,CAAA;AAAA,QACnB,MAAA;AAAA,QACA,mBAAA;AAAA,QACA,WAAA;AAAA,QACA;AAAA,OACD,CAAA;AAAA,KACH;AAAA,IACA,MAAM,MAAO,CAAA,MAAA,EAAQ,SAAgC,EAAA;AAEnD,MAAI,IAAA,OAAO,WAAY,CAAA,QAAA,KAAa,UAAY,EAAA;AAC9C,QAAA,WAAA,CAAY,WAAW,qBAAsB,CAAA,WAAA,EAAa,SAAW,EAAA,WAAA,CAAY,OAAO,IAAI,CAAA;AAAA;AAG9F,MAAM,MAAA,kBAAA,GAAqB,MAAM,mBAAoB,CAAA;AAAA,QACnD,MAAA;AAAA,QACA,SAAA;AAAA,QACA,WAAA;AAAA,QACA,SAAW,EAAA;AAAA,OACZ,CAAA;AACD,MAAI,IAAA,kBAAA,CAAmB,SAAS,OAAS,EAAA;AACvC,QAAA,MAAM,kBAAmB,CAAA,KAAA;AAAA;AAE3B,MAAA,mBAAA,GAAsB,kBAAmB,CAAA,mBAAA;AAEzC,MAAA,MAAMA,kBAAiB,iBAAkB,CAAA;AAAA,QACvC,SAAW,EAAA,cAAA;AAAA,QACX,MAAA;AAAA,QACA,SAAA;AAAA,QACA,WAAA;AAAA,QACA;AAAA,OACD,CAAA;AAED,MAAIA,IAAAA,eAAAA,CAAe,SAAS,OAAS,EAAA;AACnC,QAAQ,OAAA,CAAA,KAAA;AAAA,UACN,iDAAA;AAAA,UACAA,eAAe,CAAA;AAAA,SACjB;AACA,QAAA,MAAMA,eAAe,CAAA,KAAA;AAAA;AAGvB,MAAA,OAAOA,eAAe,CAAA,UAAA;AAAA,KACxB;AAAA,IACA,MAAM,WAAYC,CAAAA,QAAAA,EAAS,MAAQ,EAAA;AACjC,MAAA,IAAI,YAAY,OAAS,EAAA;AACvB,QAAA,WAAA,CAAY,OAAQ,CAAA;AAAA,UAClB,IAAM,EAAA,0BAAA;AAAA,UACN,IAAM,EAAA;AAAA,YACJ,KAAA,EAAO,MAAM,IAAK,CAAA,mBAAA,EAAqB,OAAO,IAAK,EAAA,IAAK,EAAE,CAAA;AAAA,YAC1D,OAAAA,EAAAA,QAAAA;AAAA,YACA;AAAA;AACF,SACD,CAAA;AAAA;AACH,KACF;AAAA,IACA,MAAM,UAAa,GAAA;AACjB,MAAI,IAAA,CAAC,OAAO,UAAY,EAAA;AACtB,QAAO,MAAA,CAAA,UAAA,GAAa,YAAY,GAAI,EAAA;AAAA,OAC/B,MAAA;AACL,QAAA,OAAA,CAAQ,IAAI,uBAAuB,CAAA;AAAA;AACrC,KACF;AAAA,IACA,MAAM,cAAe,CAAA,QAAA,EAAU,MAAQ,EAAA;AAErC,MAAA,cAAA,GAAiB,iBAAyB,CAAA;AAAA,QACxC,MAAA;AAAA,QACA,YAAY,WAAY,CAAA;AAAA,OACzB,CAAA;AAAA,KACH;AAAA,IACA,MAAM,gBAAgB,EAAE,IAAA,EAAM,QAAQ,SAAW,EAAA,GAAG,KAAO,EAAA;AACzD,MAAI,IAAA;AAEF,QAAA,IAAI,OAAO,WAAa,EAAA;AACtB,UAAA,MAAM,GAAM,GAAA,MAAA,CAAO,WAAY,CAAA,aAAA,CAAc,IAAI,CAAA;AACjD,UAAA,IAAI,GAAK,EAAA;AAEP,YAAA,MAAA,CAAO,WAAY,CAAA,gBAAA,CAAiB,GAAK,EAAA,KAAA,CAAA,EAAW,WAAW,IAAI,CAAA;AAGnE,YAAA,MAAM,SAAS,MAAM,MAAA,CAAO,WAAY,CAAA,kBAAA,CAAmB,MAAM,KAAK,CAAA;AACtE,YAAA,IAAI,MAAQ,EAAA;AACV,cAAA,MAAA,CAAO,WAAY,CAAA,gBAAA,CAAiB,MAAQ,EAAA,KAAA,CAAA,EAAW,WAAW,IAAI,CAAA;AAAA;AACxE;AACF;AAIF,QAAA,OAAO,GAAI,CAAA,OAAA;AAAA,eACJ,KAAO,EAAA;AACd,QAAQ,OAAA,CAAA,KAAA,CAAM,6BAA6B,KAAK,CAAA;AAChD,QAAA,OAAO,GAAI,CAAA,OAAA;AAAA;AACb;AACF,GACF;AACF;;;;"}