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

package/dist/plugin/config/resolveUserConfig.js

@@ -5,9 +5,10 @@
  */
 import { join } from 'node:path';
 import { DEFAULT_CONFIG } from './defaults.js';
+import { getNodeEnv } from '../getNodeEnv.js';
 
-let stashedUserConfig = {};
-function resolveUserConfig({
+const stashedUserConfig = {};
+const resolveUserConfig = function _resolveUserConfig({
   condition,
   config,
   configEnv,
@@ -24,29 +25,55 @@ function resolveUserConfig({
     };
   }
   const root = config.root ?? userOptions.projectRoot ?? process.cwd();
-  const handleSsrName = (info, input, fallback, ssr2) => {
-    if ("source" in info && info.source === "") {
+  const handleSsrEntryName = (info, input, fallback, ssr2) => {
+    if (!ssr2 || !input) {
+      if (typeof fallback === "function") {
+        return fallback(info, false);
+      }
+      return userOptions.normalizer(info.name)[0];
+    }
+    const normalized = userOptions.normalizer(input);
+    let value = normalized[1];
+    if (value.startsWith(userOptions.moduleBasePath)) {
+      value = value.slice(userOptions.moduleBasePath.length);
+    }
+    const entry = autoDiscoveredFiles.staticManifest[value];
+    if (entry) {
+      return entry.file;
+    }
+    return fallback(info, true);
+  };
+  const handleSsrAssetName = (info, input, fallback, ssr2) => {
+    if (info.source === "") {
       return "";
     }
-    if (!ssr2 || !input) {
-      return fallback(info, false);
+    const isCssFile = input?.endsWith(".css") || info.names?.some((name) => name.endsWith(".css"));
+    if (!ssr2 || !input || isCssFile) {
+      if (typeof fallback === "function") {
+        return fallback(info, ssr2);
+      }
+      return userOptions.normalizer(info.names[0])[0];
     }
-    let [id, value] = userOptions.normalizer(input);
+    const normalized = userOptions.normalizer(input);
+    const id = normalized[0];
+    let value = normalized[1];
     if (value.startsWith(userOptions.moduleBasePath)) {
       value = value.slice(userOptions.moduleBasePath.length);
     }
     const entry = autoDiscoveredFiles.staticManifest[value];
-    if (entry?.name && info.type === "asset" && userOptions.autoDiscover.cssPattern(value)) {
-      const found = entry.css?.find((css) => css.startsWith(id));
-      if (found) {
-        return found;
+    if (entry) {
+      if (entry?.name && userOptions.autoDiscover.cssPattern.test(value)) {
+        const found = entry.css?.find((css) => css.startsWith(id));
+        if (found) {
+          return join(userOptions.build.assetsDir, found);
+        } else {
+          return join(userOptions.build.assetsDir, entry.file);
+        }
       } else {
         return entry.file;
       }
-    } else if (entry) {
-      return entry.file;
     }
-    return fallback(info, true);
+    return fallback(info, ssr2);
   };
   const userDefinedOutput = config.build?.rollupOptions?.output;
   const hasOtherOutput = Array.isArray(userDefinedOutput) && userDefinedOutput.length > 1;
@@ -58,14 +85,14 @@ function resolveUserConfig({
   );
   const userDefinedChunkFileNames = hasValidOutput ? "chunkFileNames" in userDefinedOutput ? userDefinedOutput.chunkFileNames : void 0 : void 0;
   const userDefinedEntryFileNames = hasValidOutput ? "entryFileNames" in userDefinedOutput ? userDefinedOutput.entryFileNames : void 0 : void 0;
-  let stashedReturns = {};
+  const stashedReturns = {};
   const pluginOutput = {
     preserveModulesRoot: userOptions.build.preserveModulesRoot ? userOptions.moduleBase : void 0,
     entryFileNames: userDefinedEntryFileNames ?? ((info) => {
-      const input = info.facadeModuleId ?? info.name + userOptions.autoDiscover.moduleExtension;
+      const input = info.facadeModuleId ?? info.name + userOptions.build.moduleExtension;
       const inputId = input + (ssr ? "-ssr" : "");
       if (!stashedReturns[inputId]) {
-        const r = handleSsrName(
+        const r = handleSsrEntryName(
           info,
           input,
           userOptions.build.entryFile,
@@ -74,45 +101,63 @@ function resolveUserConfig({
         if (userOptions.verbose) {
           console.log("entryFileNames", input, r);
         }
-        stashedReturns[inputId] = r;
+        stashedReturns[inputId] = r ?? info.name;
       }
-      return stashedReturns[inputId].slice(Number(stashedReturns[inputId].startsWith("/")));
+      return stashedReturns[inputId].slice(
+        Number(stashedReturns[inputId].startsWith("/"))
+      );
     }),
-    assetFileNames: process.env["VITEST"] ? void 0 : userDefinedAssetFileNames ?? ((i) => {
-      const input = i.originalFileNames[0];
+    assetFileNames: process.env["VITEST"] ? void 0 : userDefinedAssetFileNames ?? ((info) => {
+      const input = info.originalFileNames[0];
       const inputId = input + (ssr ? "-ssr" : "");
       if (!stashedReturns[inputId]) {
-        const r = handleSsrName(i, input, userOptions.build.assetFile, ssr);
+        const r = handleSsrAssetName(
+          info,
+          input,
+          userOptions.build.assetFile,
+          ssr
+        );
         if (userOptions.verbose) {
-          console.log("assetFileNames", input, stashedReturns[input]);
+          console.log("assetFileNames", input, r);
         }
-        stashedReturns[inputId] = r;
+        stashedReturns[inputId] = r ?? join(userOptions.build.assetsDir, userOptions.normalizer(input)[0]);
       }
-      return stashedReturns[inputId].slice(Number(stashedReturns[inputId].startsWith("/")));
+      return stashedReturns[inputId].slice(
+        Number(stashedReturns[inputId].startsWith("/"))
+      );
     }),
     chunkFileNames: userDefinedChunkFileNames ?? ((info) => {
-      const input = info.facadeModuleId ?? info.name + userOptions.autoDiscover.moduleExtension;
+      const input = info.facadeModuleId ?? info.name + userOptions.autoDiscover.modulePattern.source;
       const inputId = input + (ssr ? "-ssr" : "");
       if (!stashedReturns[inputId]) {
-        const r = handleSsrName(
+        const r = handleSsrEntryName(
           info,
           input,
           userOptions.build.chunkFile,
           ssr
         );
         if (userOptions.verbose) {
-          console.log("chunkFileNames", input, stashedReturns[input]);
+          console.log("chunkFileNames", input, stashedReturns[inputId]);
         }
-        stashedReturns[inputId] = r;
+        stashedReturns[inputId] = r ?? info.name;
       }
-      return stashedReturns[inputId].slice(Number(stashedReturns[inputId].startsWith("/")));
+      return stashedReturns[inputId].slice(
+        Number(stashedReturns[inputId].startsWith("/"))
+      );
     }),
     format: "esm",
     exports: "named"
   };
-  let newOutput = Array.isArray(config.build?.rollupOptions?.output) ? [...config.build?.rollupOptions?.output, pluginOutput] : typeof config.build?.rollupOptions?.output === "object" && config.build?.rollupOptions?.output !== null ? [config.build?.rollupOptions?.output, pluginOutput] : pluginOutput;
+  const newOutput = Array.isArray(config.build?.rollupOptions?.output) ? [...config.build?.rollupOptions?.output || null, pluginOutput] : typeof config.build?.rollupOptions?.output === "object" && config.build?.rollupOptions?.output !== null ? [config.build?.rollupOptions?.output, pluginOutput] : pluginOutput;
   const vitePrefix = config.envPrefix ?? DEFAULT_CONFIG.ENV_PREFIX;
-  const mode = config.mode ?? process.env[`${vitePrefix}MODE`] ?? process.env["NODE_ENV"] ?? "production";
+  const nodeEnv = getNodeEnv();
+  let mode = config.mode ?? process.env[`${vitePrefix}MODE`] ?? process.env["NODE_ENV"] ?? nodeEnv;
+  if (mode !== nodeEnv) {
+    if (typeof config.mode === "string" && nodeEnv !== "production") {
+      throw new Error(`Mode ${mode} must be equal to NODE_ENV ${nodeEnv}.`);
+    }
+    mode = nodeEnv;
+  }
   const minify = config.build?.minify;
   const srrConfig = {
     ...config.ssr,
@@ -133,11 +178,11 @@ function resolveUserConfig({
     }
   };
   let publicOrigin = userOptions.publicOrigin ?? process.env[`${vitePrefix}PUBLIC_ORIGIN`] ?? "";
-  let PROD = mode === "production";
-  let DEV = mode === "development";
-  let port = typeof config.server?.port === "number" ? config.server?.port : 5173;
-  let strictPort = config.server?.strictPort ?? true;
-  let host = typeof config.server?.host === "string" ? config.server?.host : "localhost";
+  const PROD = mode === "production";
+  const DEV = mode === "development";
+  const port = typeof config.server?.port === "number" ? config.server?.port : 5173;
+  const strictPort = config.server?.strictPort ?? true;
+  const host = typeof config.server?.host === "string" ? config.server?.host : "localhost";
   if (configEnv.command === "serve" && !configEnv.isPreview) {
     if (strictPort) {
       publicOrigin = `http${config.server?.https ? "s" : ""}://${host}:${port}`;
@@ -155,6 +200,7 @@ function resolveUserConfig({
   } : {};
   const define = {
     ...config.define,
+    [`import.meta.env.BASE_URL`]: `"${userOptions.moduleBaseURL}"`,
     [`import.meta.env.PUBLIC_ORIGIN`]: `"${publicOrigin}"`,
     ...ssrDefine
   };
@@ -169,7 +215,7 @@ function resolveUserConfig({
       ...config,
       root,
       mode,
-      base: userOptions.moduleBaseURL,
+      base: config.base ?? userOptions.moduleBaseURL,
       envPrefix: vitePrefix,
       resolve: {
         ...config.resolve,
@@ -269,7 +315,7 @@ function resolveUserConfig({
       userConfig: serverConfig
     };
   }
-}
+};
 
 export { resolveUserConfig };
-//# sourceMappingURL=resolveUserConfig.js.map
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"resolveUserConfig.js","sources":["../../../plugin/config/resolveUserConfig.ts"],"sourcesContent":["import type { ConfigEnv, UserConfig } from \"vite\";\nimport type {\n  ResolvedUserConfig,\n  ResolvedUserOptions,\n  AutoDiscoveredFiles,\n} from \"../types.js\";\nimport { join } from \"node:path\";\nimport type { OutputOptions, PreRenderedAsset, PreRenderedChunk } from \"rollup\";\nimport { DEFAULT_CONFIG } from \"./defaults.js\";\nimport { getNodeEnv } from \"../getNodeEnv.js\";\n\nconst stashedUserConfig: Record<string, ResolvedUserConfig | null> = {};\n\nexport type ResolveUserConfigProps = {\n  condition: \"react-client\" | \"react-server\";\n  config: UserConfig;\n  configEnv: ConfigEnv;\n  userOptions: ResolvedUserOptions;\n  autoDiscoveredFiles: Pick<AutoDiscoveredFiles, \"inputs\" | \"staticManifest\">;\n};\n\nexport type ResolveUserConfigReturn =\n  | { type: \"success\"; userConfig: ResolvedUserConfig }\n  | { type: \"error\"; error: Error };\n\nexport type ResolveUserConfigFn = (\n  props: ResolveUserConfigProps\n) => ResolveUserConfigReturn;\n\nexport const resolveUserConfig: ResolveUserConfigFn =\n  function _resolveUserConfig({\n    condition,\n    config,\n    configEnv,\n    userOptions,\n    autoDiscoveredFiles,\n  }) {\n    const ssr =\n      typeof config.build?.ssr === \"boolean\"\n        ? config.build?.ssr\n        : Boolean(configEnv.isSsrBuild) ||\n          condition === \"react-server\" ||\n          (typeof process.env[\"VITE_SSR\"] === \"string\"\n            ? process.env[\"VITE_SSR\"] === \"true\" ||\n              process.env[\"VITE_SSR\"] === \"1\"\n            : Boolean(process.env[\"VITE_SSR\"]));\n    const envDir =\n      condition === \"react-client\" && ssr\n        ? userOptions.build.client\n        : condition === \"react-client\"\n        ? userOptions.build.static\n        : userOptions.build.server;\n    const envId = `${envDir}${ssr ? \"-ssr\" : \"\"}`;\n\n    if (stashedUserConfig[envId]) {\n      return {\n        type: \"success\",\n        userConfig: stashedUserConfig[envId],\n      };\n    }\n\n    // Get existing inputs\n    const root = config.root ?? userOptions.projectRoot ?? process.cwd();\n\n    const handleSsrEntryName = (\n      info: PreRenderedChunk,\n      input: string | null,\n      fallback: (info: PreRenderedChunk, ssr: boolean) => string,\n      ssr: boolean\n    ) => {\n      if (!ssr || !input) {\n        if (typeof fallback === \"function\") {\n          return fallback(info, false);\n        }\n        return userOptions.normalizer(info.name)[0];\n      }\n      const normalized = userOptions.normalizer(input);\n      let value = normalized[1];\n      if (value.startsWith(userOptions.moduleBasePath)) {\n        value = value.slice(userOptions.moduleBasePath.length);\n      }\n      const entry = autoDiscoveredFiles.staticManifest[value];\n      if (entry) {\n        return entry.file;\n      }\n      return fallback(info, true);\n    };\n\n    const handleSsrAssetName = (\n      info: PreRenderedAsset,\n      input: string | null,\n      fallback: (info: PreRenderedAsset, ssr: boolean) => string,\n      ssr: boolean\n    ) => {\n      if (info.source === \"\") {\n        return \"\";\n      }\n      \n      // Check if this is a CSS file\n      const isCssFile = input?.endsWith('.css') || \n        info.names?.some(name => name.endsWith('.css'));\n      \n      if (!ssr || !input || isCssFile) {\n        if (typeof fallback === \"function\") {\n          return fallback(info, ssr);\n        }\n        return userOptions.normalizer(info.names[0])[0];\n      }\n      \n      \n      // First check if we have a static manifest entry for consistent module ID resolution\n      const normalized = userOptions.normalizer(input);\n      const id = normalized[0];\n      let value = normalized[1];\n      if (value.startsWith(userOptions.moduleBasePath)) {\n        value = value.slice(userOptions.moduleBasePath.length);\n      }\n      \n      const entry = autoDiscoveredFiles.staticManifest[value];\n      if (entry) {\n        // For CSS files, look for a specific CSS file that matches our normalized ID\n        if (entry?.name && userOptions.autoDiscover.cssPattern.test(value)) {\n          const found = entry.css?.find((css) => css.startsWith(id as string));\n          if (found) {\n            return join(userOptions.build.assetsDir, found);\n          } else {\n            return join(userOptions.build.assetsDir, entry.file);\n          }\n        } else {\n          // For other assets, use the entry file\n          return entry.file;\n        }\n      }\n      \n      // Fall back to the user's assetFile function for consistent behavior\n      return fallback(info, ssr);\n    };\n    const userDefinedOutput = config.build?.rollupOptions?.output;\n    const hasOtherOutput =\n      Array.isArray(userDefinedOutput) && userDefinedOutput.length > 1;\n    const hasValidOutput = userDefinedOutput && !hasOtherOutput;\n    const hasObjectOutput =\n      userDefinedOutput &&\n      !hasOtherOutput &&\n      typeof userDefinedOutput === \"object\" &&\n      userDefinedOutput !== null;\n\n    const userDefinedAssetFileNames = hasObjectOutput\n      ? \"assetFileNames\" in userDefinedOutput\n        ? userDefinedOutput.assetFileNames\n        : undefined\n      : // find the other asset file names\n      hasOtherOutput\n      ? (userDefinedOutput.find((o) => o.assetFileNames) as OutputOptions)\n          .assetFileNames\n      : undefined;\n\n    const userDefinedChunkFileNames = hasValidOutput\n      ? \"chunkFileNames\" in userDefinedOutput\n        ? userDefinedOutput.chunkFileNames\n        : undefined\n      : undefined;\n    const userDefinedEntryFileNames = hasValidOutput\n      ? \"entryFileNames\" in userDefinedOutput\n        ? userDefinedOutput.entryFileNames\n        : undefined\n      : undefined;\n\n    const stashedReturns: Record<string, string> = {};\n    const pluginOutput = {\n      preserveModulesRoot: userOptions.build.preserveModulesRoot\n        ? userOptions.moduleBase\n        : undefined,\n      entryFileNames:\n        userDefinedEntryFileNames ??\n        ((info) => {\n          const input =\n            info.facadeModuleId ??\n            info.name + userOptions.build.moduleExtension;\n          const inputId = input + (ssr ? \"-ssr\" : \"\");\n          if (!stashedReturns[inputId]) {\n            const r = handleSsrEntryName(\n              info,\n              input,\n              userOptions.build.entryFile,\n              ssr\n            );\n            if (userOptions.verbose) {\n              console.log(\"entryFileNames\", input, r);\n            }\n            stashedReturns[inputId] = r ?? info.name;\n          }\n          // in the case of empty basePath, it will not be sliced from the path, so, we need to slice it here\n          // at the last possible moment as to not confuse the rest of the logic around the basePath\n          return stashedReturns[inputId].slice(\n            Number(stashedReturns[inputId].startsWith(\"/\"))\n          );\n        }),\n      assetFileNames: process.env[\"VITEST\"]\n        ? undefined\n        : userDefinedAssetFileNames ??\n          ((info) => {\n            const input = info.originalFileNames[0];\n            const inputId = input + (ssr ? \"-ssr\" : \"\");\n\n            if (!stashedReturns[inputId]) {\n              const r = handleSsrAssetName(\n                info,\n                input,\n                userOptions.build.assetFile,\n                ssr\n              );\n              \n              if (userOptions.verbose) {\n                console.log(\"assetFileNames\", input, r);\n              }\n              stashedReturns[inputId] = r ?? join(userOptions.build.assetsDir, userOptions.normalizer(input)[0]);\n            }\n            // in the case of empty basePath, it will not be sliced from the path, so, we need to slice it here\n            // at the last possible moment as to not confuse the rest of the logic around the basePath\n            return stashedReturns[inputId].slice(\n              Number(stashedReturns[inputId].startsWith(\"/\"))\n            );\n          }),\n      chunkFileNames:\n        userDefinedChunkFileNames ??\n        ((info) => {\n          const input =\n            info.facadeModuleId ??\n            info.name + userOptions.autoDiscover.modulePattern.source;\n          const inputId = input + (ssr ? \"-ssr\" : \"\");\n\n          if (!stashedReturns[inputId]) {\n            const r = handleSsrEntryName(\n              info,\n              input,\n              userOptions.build.chunkFile,\n              ssr\n            );\n\n            if (userOptions.verbose) {\n              console.log(\"chunkFileNames\", input, stashedReturns[inputId]);\n            }\n            stashedReturns[inputId] = r ?? info.name;\n          }\n          // in the case of empty basePath, it will not be sliced from the path, so, we need to slice it here\n          // at the last possible moment as to not confuse the rest of the logic around the basePath\n          return stashedReturns[inputId].slice(\n            Number(stashedReturns[inputId].startsWith(\"/\"))\n          );\n        }),\n      format: \"esm\",\n      exports: \"named\",\n    } satisfies OutputOptions;\n\n    const newOutput = Array.isArray(config.build?.rollupOptions?.output)\n      ? [...(config.build?.rollupOptions?.output || null), pluginOutput]\n      : typeof config.build?.rollupOptions?.output === \"object\" &&\n        config.build?.rollupOptions?.output !== null\n      ? [config.build?.rollupOptions?.output, pluginOutput]\n      : pluginOutput;\n    const vitePrefix = config.envPrefix ?? DEFAULT_CONFIG.ENV_PREFIX;\n    const nodeEnv = getNodeEnv();\n    let mode =\n      config.mode ??\n      process.env[`${vitePrefix}MODE`] ??\n      process.env[\"NODE_ENV\"] ??\n      nodeEnv;\n\n    if (mode !== nodeEnv) {\n      if (typeof config.mode === \"string\" && nodeEnv !== \"production\") {\n        throw new Error(`Mode ${mode} must be equal to NODE_ENV ${nodeEnv}.`);\n      }\n      mode = nodeEnv;\n    }\n    const minify = config.build?.minify;\n\n    const srrConfig = {\n      ...config.ssr,\n      target: config.ssr?.target ?? \"node\",\n      optimizeDeps: {\n        ...config.ssr?.optimizeDeps,\n        include: config.ssr?.optimizeDeps?.include ?? [\n          \"react\",\n          \"react-dom\",\n          \"react-server-dom-esm/client\",\n        ],\n      },\n      resolve: {\n        ...config.ssr?.resolve,\n        externalConditions: config.ssr?.resolve?.externalConditions ?? [\n          \"react-server\",\n        ],\n      },\n    };\n    let publicOrigin =\n      userOptions.publicOrigin ??\n      process.env[`${vitePrefix}PUBLIC_ORIGIN`] ??\n      \"\";\n    const PROD = mode === \"production\";\n    const DEV = mode === \"development\";\n    const port =\n      typeof config.server?.port === \"number\" ? config.server?.port : 5173;\n    const strictPort = config.server?.strictPort ?? true;\n    const host =\n      typeof config.server?.host === \"string\"\n        ? config.server?.host\n        : \"localhost\";\n    if (configEnv.command === \"serve\" && !configEnv.isPreview) {\n      if (strictPort) {\n        publicOrigin = `http${\n          config.server?.https ? \"s\" : \"\"\n        }://${host}:${port}`;\n      } else {\n        publicOrigin = \"\";\n      }\n    }\n    const ssrDefine = ssr\n      ? {\n          [`process.env.${vitePrefix}SSR`]: `${ssr}`,\n          [`process.env.${vitePrefix}DEV`]: `${DEV}`,\n          [`process.env.${vitePrefix}PROD`]: `${PROD}`,\n          [`process.env.${vitePrefix}MODE`]: `\"${mode}\"`,\n          [`process.env.${vitePrefix}BASE_URL`]: `\"${userOptions.moduleBaseURL}\"`,\n          [`process.env.${vitePrefix}PUBLIC_ORIGIN`]: `\"${publicOrigin}\"`,\n        }\n      : {};\n    const define = {\n      ...config.define,\n      [`import.meta.env.BASE_URL`]: `\"${userOptions.moduleBaseURL}\"`,\n      [`import.meta.env.PUBLIC_ORIGIN`]: `\"${publicOrigin}\"`,\n      ...ssrDefine,\n    };\n    // these will never be cleaned up, because, we are resolving the user config\n    // and it's assumed the thread closes after this and we don't want\n    // it to change after the config has been resolved\n    if (process.env[`${vitePrefix}BASE_URL`] !== userOptions.moduleBaseURL) {\n      process.env[`${vitePrefix}BASE_URL`] = userOptions.moduleBaseURL;\n    }\n    if (process.env[`${vitePrefix}PUBLIC_ORIGIN`] !== publicOrigin) {\n      process.env[`${vitePrefix}PUBLIC_ORIGIN`] = publicOrigin;\n    }\n\n    if (condition === \"react-client\") {\n      // client plugin build options (client plugin still outputs server files)\n      const clientConfig = {\n        ...config,\n        root: root,\n        mode: mode,\n        base: config.base ?? userOptions.moduleBaseURL,\n        envPrefix: vitePrefix,\n        resolve: {\n          ...config.resolve,\n          external: config.resolve?.external ?? [\n            \"react\",\n            \"react-dom\",\n            \"react-server-dom-esm/client\",\n          ],\n        },\n        define: define,\n        ssr: srrConfig,\n        server: {\n          ...config.server,\n          // common default for stricter server operations\n          // and ensures tests that use a server will fail early\n          // also, we can't set the public origin without a port\n          port: port,\n          strictPort: strictPort,\n          host: host,\n        },\n        // client build options\n        build: {\n          ...config.build,\n          modulePreload: config.build?.modulePreload ?? false,\n          emptyOutDir: config.build?.emptyOutDir ?? true,\n          outDir:\n            config.build?.outDir ?? join(userOptions.build.outDir, envDir),\n          assetsDir: config.build?.assetsDir ?? userOptions.build.assetsDir,\n          copyPublicDir:\n            typeof config.build?.copyPublicDir === \"boolean\"\n              ? config.build?.copyPublicDir\n              : !ssr,\n          // modern browsers\n          target: config.build?.target ?? [\"esnext\"],\n          minify: minify,\n          rollupOptions: {\n            ...config.build?.rollupOptions,\n            input: Object.fromEntries(\n              Object.entries(autoDiscoveredFiles.inputs).map(([key, value]) => [\n                key,\n                value.slice(Number(value.startsWith(\"/\"))),\n              ])\n            ),\n            output: newOutput,\n            preserveEntrySignatures:\n              config.build?.rollupOptions?.preserveEntrySignatures ??\n              \"exports-only\",\n          },\n          ssr: ssr,\n          manifest: config.build?.manifest ?? `.vite/manifest.json`,\n          ssrManifest: config.build?.ssrManifest ?? `.vite/ssr-manifest.json`,\n          ssrEmitAssets: config.build?.ssrEmitAssets ?? true,\n          cssCodeSplit:\n            typeof config.build?.cssCodeSplit === \"boolean\"\n              ? config.build?.cssCodeSplit\n              : true,\n        },\n      } satisfies ResolvedUserConfig;\n      stashedUserConfig[envId] = clientConfig;\n      return {\n        type: \"success\",\n        userConfig: clientConfig,\n      };\n    } else {\n      const serverConfig = {\n        ...config,\n        root: root,\n        mode: mode,\n        base: userOptions.moduleBaseURL,\n        envPrefix: vitePrefix,\n        resolve: {\n          ...config.resolve,\n          externalConditions: config.resolve?.externalConditions ?? [\n            \"react-server\",\n          ],\n        },\n        define: define,\n        ssr: srrConfig,\n        // server build options\n        build: {\n          ...config.build,\n          modulePreload: config.build?.modulePreload ?? false,\n          emptyOutDir: config.build?.emptyOutDir ?? true,\n          outDir:\n            config.build?.outDir ?? join(userOptions.build.outDir, envDir),\n          target: config.build?.target ?? \"node18\",\n          minify: minify,\n          ssr: ssr,\n          manifest: config.build?.manifest ?? `.vite/manifest.json`,\n          ssrManifest: config.build?.ssrManifest ?? `.vite/ssr-manifest.json`,\n          ssrEmitAssets:\n            typeof config.build?.ssrEmitAssets === \"boolean\"\n              ? config.build?.ssrEmitAssets\n              : true,\n          copyPublicDir:\n            typeof config.build?.copyPublicDir === \"boolean\"\n              ? config.build?.copyPublicDir\n              : !ssr,\n          assetsDir: config.build?.assetsDir ?? userOptions.build.assetsDir,\n          // Ensure CSS files are output to static directory\n          cssCodeSplit:\n            typeof config.build?.cssCodeSplit === \"boolean\"\n              ? config.build?.cssCodeSplit\n              : true,\n          rollupOptions: {\n            ...config.build?.rollupOptions,\n            input: autoDiscoveredFiles.inputs,\n            preserveEntrySignatures:\n              config.build?.rollupOptions?.preserveEntrySignatures ?? \"strict\",\n            output: newOutput,\n          },\n        },\n      } satisfies ResolvedUserConfig;\n      stashedUserConfig[envId] = serverConfig;\n      return {\n        type: \"success\",\n        userConfig: serverConfig,\n      };\n    }\n  };\n"],"names":["ssr"],"mappings":"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"}

package/dist/plugin/env/plugin.d.ts

@@ -1,4 +1,10 @@
 import type { Plugin } from "vite";
+import type { ConfigEnv } from "vite";
+/**
+ * Reconstruct ConfigEnv from process.argv and environment variables
+ * This allows us to determine the config environment before the config hook runs
+ */
+export declare const createConfigEnv: () => ConfigEnv;
 /**
  * This plugin can be used to set up the environment defined in the env file
  * and the `define` clause in the vite config to be directly assigned to the process.env,

package/dist/plugin/env/plugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../../../plugin/env/plugin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAiBnC;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,SAAS,IAAI,MAAM,CAqElC"}
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../../../plugin/env/plugin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAKnC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,MAAM,CAAC;AAEtC;;;GAGG;AACH,eAAO,MAAM,eAAe,QAAO,SA0BlC,CAAC;AA4CF;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,SAAS,IAAI,MAAM,CAqElC"}

package/dist/plugin/env/plugin.js

@@ -1,97 +1,115 @@
-import { resolveConfigDefine, resolveEnv } from "../config/resolveEnv.js";
-import { DEFAULT_CONFIG } from "../config/defaults.js";
-import { userProjectRoot } from "../root.js";
-const isBuild = process.argv[process.argv.length - 1] === "build";
-const isPreview = process.argv.findIndex((arg) => arg === "preview") !== -1;
-// Set up environment variables from .env files as early as possible
-// This is to ensure that the env variables are available even in the config file,
-// and you can use process.env to configure the plugin.
-const cleanupInitialUserConfigEnv = resolveEnv(process.env["NODE_ENV"] || (isBuild || isPreview ? "production" : "development"), userProjectRoot, DEFAULT_CONFIG.ENV_PREFIX);
 /**
- * This plugin can be used to set up the environment defined in the env file
- * and the `define` clause in the vite config to be directly assigned to the process.env,
- * making it available in workers, server components and plugin hooks like config, configureServer, etc.
- *
- * You can also set these variable in the package.json script like `VITE_PUBLIC_ORIGIN=https://example.com npm run build`
- * The default ones like `VITE_DEV` etc, are set to the default values if not defined in the env file or the `define` clause.
- *
- * If they do end up in the build, the define clause replaces process.env.VITE_BASE_URL etc, same like it
- * replaces `import.meta.env.BASE_URL`.
- *
- * While using node.process.env is dangerous as it may expose valuable information to the client, the define clause
- * replaces them in the build so it's safe as long as you stick to simple stuff like const baseUrl = process.env.VITE_BASE_URL
- * would be the same as writing const baseUrl = import.meta.env.BASE_URL. But this plugin doesn't enable that feature nor does
- * it return any config, it just sets the process.env variables at a early momemt and deletes them after the build unless they were
- * already set in the environment.
- *
- * This plugin will not override process.env variable that were previously set, and will remove any values that it did set after the bundle closes.
- * ```example
- * const config = {
- *    moduleBase: 'src',
- *    // loaded from either .env file or existing process.env, based on the NODE_ENV
- *    publicOrigin: process.env.VITE_PUBLIC_ORIGIN,
- * }
- * ```
- * @returns
+ * vite-plugin-react-server
+ * Copyright (c) Nico Brinkkemper
+ * MIT License
  */
-export function envPlugin() {
-    let cleanupEnv;
-    let vitePrefix = DEFAULT_CONFIG.ENV_PREFIX;
-    return {
-        name: "vite-plugin-react-server:env",
-        enforce: "pre",
-        config(config, { mode }) {
-            if (config.envPrefix) {
-                if (typeof config.envPrefix === "string") {
-                    vitePrefix = config.envPrefix;
-                }
-                else if (Array.isArray(config.envPrefix)) {
-                    vitePrefix = config.envPrefix[0];
-                }
-            }
-            const invalidEnv = (mode !== undefined && mode !== process.env[`${vitePrefix}MODE`]) ||
-                (config.root !== undefined && config.root !== userProjectRoot);
-            if (invalidEnv) {
-                cleanupInitialUserConfigEnv();
-            }
-            // Clean up any previous env setup
-            const cleanupUserConfigEnv = invalidEnv
-                ? resolveEnv(mode || process.env[`${vitePrefix}MODE`] || "production", config.root ?? userProjectRoot, vitePrefix)
-                : cleanupInitialUserConfigEnv;
-            const cleanupUserConfig = resolveConfigDefine(config);
-            // Combine cleanup functions
-            cleanupEnv = () => {
-                cleanupUserConfig();
-                cleanupUserConfigEnv();
-            };
-        },
-        closeBundle() {
-            // Clean up environment variables when the bundle is closed
-            cleanupEnv?.();
-        },
-        configureServer(server) {
-            let envPrefix = Array.isArray(server.config.envPrefix) ? server.config.envPrefix[0] : server.config.envPrefix ?? DEFAULT_CONFIG.ENV_PREFIX;
-            let publicOrigin = process.env[`${envPrefix}PUBLIC_ORIGIN`] ?? "";
-            let desiredPort = server.config.server.port;
-            let shouldUpdatePublicOrigin = false;
-            if (publicOrigin && publicOrigin.includes(`:${desiredPort}`)) {
-                shouldUpdatePublicOrigin = true;
-            }
-            // Listen for when the server actually starts
-            if (shouldUpdatePublicOrigin) {
-                server.httpServer?.once("listening", () => {
-                    const address = server.httpServer?.address();
-                    if (address && typeof address !== "string") {
-                        const port = address.port;
-                        if (port !== desiredPort) {
-                            let envPrefix = Array.isArray(server.config.envPrefix) ? server.config.envPrefix[0] : server.config.envPrefix ?? DEFAULT_CONFIG.ENV_PREFIX;
-                            const newOrigin = publicOrigin.replace(`:${desiredPort}`, `:${port}`);
-                            process.env[`${envPrefix}PUBLIC_ORIGIN`] = newOrigin;
-                            console.warn("PUBLIC_ORIGIN did not match the port: " + port);
-                        }
-                    }
-                });
-            }
+import { resolveEnv, resolveConfigDefine } from '../config/resolveEnv.js';
+import { DEFAULT_CONFIG } from '../config/defaults.js';
+import { userProjectRoot } from '../root.js';
+import { getNodeEnv } from '../getNodeEnv.js';
+
+const createConfigEnv = () => {
+  const argv = process.argv;
+  let command = "serve";
+  if (argv.includes("build")) {
+    command = "build";
+  } else if (argv.includes("dev") || argv.includes("serve") || argv.includes("preview")) {
+    command = "serve";
+  }
+  let mode = getNodeEnv();
+  const modeIndex = argv.findIndex((arg) => arg === "--mode" || arg === "-m");
+  if (modeIndex !== -1 && argv[modeIndex + 1]) {
+    mode = argv[modeIndex + 1];
+  }
+  const isSsrBuild = argv.includes("--ssr");
+  return {
+    command,
+    mode,
+    isSsrBuild
+  };
+};
+function getArgValue(argName) {
+  const equalsArg = process.argv.find((arg) => arg.startsWith(`--${argName}=`));
+  if (equalsArg) {
+    return equalsArg.substring(`--${argName}=`.length);
+  }
+  const argIndex = process.argv.findIndex((arg) => arg === `--${argName}`);
+  if (argIndex !== -1 && argIndex + 1 < process.argv.length) {
+    const value = process.argv[argIndex + 1];
+    if (value && !value.startsWith("--")) {
+      return value;
+    }
+  }
+  return void 0;
+}
+const isBuild = process.argv.includes("build");
+const isPreview = process.argv.includes("preview");
+const detectedMode = getArgValue("mode");
+const cleanupInitialUserConfigEnv = resolveEnv(
+  detectedMode || process.env["NODE_ENV"] || (isBuild || isPreview ? "production" : "development"),
+  userProjectRoot,
+  DEFAULT_CONFIG.ENV_PREFIX
+);
+function envPlugin() {
+  let cleanupEnv;
+  let vitePrefix = DEFAULT_CONFIG.ENV_PREFIX;
+  return {
+    name: "vite-plugin-react-server:env",
+    enforce: "pre",
+    config(config, { mode }) {
+      if (config.envPrefix) {
+        if (typeof config.envPrefix === "string") {
+          vitePrefix = config.envPrefix;
+        } else if (Array.isArray(config.envPrefix)) {
+          vitePrefix = config.envPrefix[0];
         }
-    };
+      }
+      const invalidEnv = mode !== void 0 && mode !== process.env[`${vitePrefix}MODE`] || config.root !== void 0 && config.root !== userProjectRoot;
+      if (invalidEnv) {
+        cleanupInitialUserConfigEnv();
+      }
+      const cleanupUserConfigEnv = invalidEnv ? resolveEnv(
+        mode || process.env[`${vitePrefix}MODE`] || "production",
+        config.root ?? userProjectRoot,
+        vitePrefix
+      ) : cleanupInitialUserConfigEnv;
+      const cleanupUserConfig = resolveConfigDefine(config);
+      cleanupEnv = () => {
+        cleanupUserConfig();
+        cleanupUserConfigEnv();
+      };
+    },
+    closeBundle() {
+      cleanupEnv?.();
+    },
+    configureServer(server) {
+      const envPrefix = Array.isArray(server.config.envPrefix) ? server.config.envPrefix[0] : server.config.envPrefix ?? DEFAULT_CONFIG.ENV_PREFIX;
+      const publicOrigin = process.env[`${envPrefix}PUBLIC_ORIGIN`] ?? "";
+      const desiredPort = server.config.server.port;
+      let shouldUpdatePublicOrigin = false;
+      if (publicOrigin && publicOrigin.includes(`:${desiredPort}`)) {
+        shouldUpdatePublicOrigin = true;
+      }
+      if (shouldUpdatePublicOrigin) {
+        server.httpServer?.once("listening", () => {
+          const address = server.httpServer?.address();
+          if (address && typeof address !== "string") {
+            const port = address.port;
+            if (port !== desiredPort) {
+              const envPrefix2 = Array.isArray(server.config.envPrefix) ? server.config.envPrefix[0] : server.config.envPrefix ?? DEFAULT_CONFIG.ENV_PREFIX;
+              const newOrigin = publicOrigin.replace(
+                `:${desiredPort}`,
+                `:${port}`
+              );
+              process.env[`${envPrefix2}PUBLIC_ORIGIN`] = newOrigin;
+              console.warn("PUBLIC_ORIGIN did not match the port: " + port);
+            }
+          }
+        });
+      }
+    }
+  };
 }
+
+export { createConfigEnv, envPlugin };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"plugin.js","sources":["../../../plugin/env/plugin.ts"],"sourcesContent":["import type { Plugin } from \"vite\";\nimport { resolveConfigDefine, resolveEnv } from \"../config/resolveEnv.js\";\nimport { DEFAULT_CONFIG } from \"../config/defaults.js\";\nimport { userProjectRoot } from \"../root.js\";\nimport { getNodeEnv } from \"../getNodeEnv.js\";\nimport type { ConfigEnv } from \"vite\";\n\n/**\n * Reconstruct ConfigEnv from process.argv and environment variables\n * This allows us to determine the config environment before the config hook runs\n */\nexport const createConfigEnv = (): ConfigEnv => {\n  const argv = process.argv;\n  \n  // Detect command from argv\n  let command: 'build' | 'serve' = 'serve';\n  if (argv.includes('build')) {\n    command = 'build';\n  } else if (argv.includes('dev') || argv.includes('serve') || argv.includes('preview')) {\n    command = 'serve';\n  }\n  \n  // Detect mode from argv or environment\n  let mode: string = getNodeEnv();\n  const modeIndex = argv.findIndex(arg => arg === '--mode' || arg === '-m');\n  if (modeIndex !== -1 && argv[modeIndex + 1]) {\n    mode = argv[modeIndex + 1];\n  }\n  \n  // Detect SSR build\n  const isSsrBuild = argv.includes('--ssr');\n  \n  return {\n    command,\n    mode,\n    isSsrBuild\n  };\n};\n\n/**\n * Helper function to parse command-line arguments in both formats:\n * --arg value (space-separated) and --arg=value (equals-separated)\n * Handles any IFS characters and edge cases\n */\nfunction getArgValue(argName: string): string | undefined {\n  // Check for --arg=value format first (handles any character after =)\n  const equalsArg = process.argv.find((arg) => arg.startsWith(`--${argName}=`));\n  if (equalsArg) {\n    return equalsArg.substring(`--${argName}=`.length);\n  }\n  \n  // Check for --arg value format (handles any IFS characters)\n  const argIndex = process.argv.findIndex((arg) => arg === `--${argName}`);\n  if (argIndex !== -1 && argIndex + 1 < process.argv.length) {\n    const value = process.argv[argIndex + 1];\n    // Only return if the next argument doesn't start with -- (isn't another flag)\n    if (value && !value.startsWith(\"--\")) {\n      return value;\n    }\n  }\n  \n  return undefined;\n}\n\nconst isBuild = process.argv.includes(\"build\");\nconst isPreview = process.argv.includes(\"preview\");\n\n\n// Set up environment variables from .env files as early as possible\n// This is to ensure that the env variables are available even in the config file,\n// and you can use process.env to configure the plugin.\n\n// Detect mode from command line arguments\nconst detectedMode = getArgValue(\"mode\");\n\nconst cleanupInitialUserConfigEnv = resolveEnv(\n  detectedMode || process.env[\"NODE_ENV\"] || (isBuild || isPreview ? \"production\" : \"development\"),\n  userProjectRoot,\n  DEFAULT_CONFIG.ENV_PREFIX\n);\n\n/**\n * This plugin can be used to set up the environment defined in the env file\n * and the `define` clause in the vite config to be directly assigned to the process.env,\n * making it available in workers, server components and plugin hooks like config, configureServer, etc.\n *\n * You can also set these variable in the package.json script like `VITE_PUBLIC_ORIGIN=https://example.com npm run build`\n * The default ones like `VITE_DEV` etc, are set to the default values if not defined in the env file or the `define` clause.\n *\n * If they do end up in the build, the define clause replaces process.env.VITE_BASE_URL etc, same like it\n * replaces `import.meta.env.BASE_URL`.\n *\n * While using node.process.env is dangerous as it may expose valuable information to the client, the define clause\n * replaces them in the build so it's safe as long as you stick to simple stuff like const baseUrl = process.env.VITE_BASE_URL\n * would be the same as writing const baseUrl = import.meta.env.BASE_URL. But this plugin doesn't enable that feature nor does\n * it return any config, it just sets the process.env variables at a early momemt and deletes them after the build unless they were\n * already set in the environment.\n * \n * This plugin will not override process.env variable that were previously set, and will remove any values that it did set after the bundle closes.\n * ```example\n * const config = {\n *    moduleBase: 'src',\n *    // loaded from either .env file or existing process.env, based on the NODE_ENV\n *    publicOrigin: process.env.VITE_PUBLIC_ORIGIN,\n * }\n * ```\n * @returns\n */\nexport function envPlugin(): Plugin {\n  let cleanupEnv: (() => void) | undefined;\n  let vitePrefix = DEFAULT_CONFIG.ENV_PREFIX as string;\n  return {\n    name: \"vite-plugin-react-server:env\",\n    enforce: \"pre\",\n    config(config, { mode }) {\n      if(config.envPrefix) {\n        if(typeof config.envPrefix === \"string\") {\n          vitePrefix = config.envPrefix;\n        } else if(Array.isArray(config.envPrefix)) {\n          vitePrefix = config.envPrefix[0];\n        }\n      }\n      const invalidEnv =\n        (mode !== undefined && mode !== process.env[`${vitePrefix}MODE`]) ||\n        (config.root !== undefined && config.root !== userProjectRoot);\n      if (invalidEnv) {\n        cleanupInitialUserConfigEnv();\n      }\n      // Clean up any previous env setup\n      const cleanupUserConfigEnv = invalidEnv\n        ? resolveEnv(\n            mode || process.env[`${vitePrefix}MODE`] || \"production\",\n            config.root ?? userProjectRoot,\n            vitePrefix\n          )\n        : cleanupInitialUserConfigEnv;\n      const cleanupUserConfig = resolveConfigDefine(config);\n\n      // Combine cleanup functions\n      cleanupEnv = () => {\n        cleanupUserConfig();\n        cleanupUserConfigEnv();\n      };\n    },\n    closeBundle() {\n      // Clean up environment variables when the bundle is closed\n      cleanupEnv?.();\n    },\n    configureServer(server) {\n      const envPrefix = Array.isArray(server.config.envPrefix) ? server.config.envPrefix[0] : server.config.envPrefix ?? DEFAULT_CONFIG.ENV_PREFIX;\n      const publicOrigin = process.env[`${envPrefix}PUBLIC_ORIGIN`] ?? \"\"\n\n      const desiredPort = server.config.server.port;\n      let shouldUpdatePublicOrigin = false;\n      if (publicOrigin && publicOrigin.includes(`:${desiredPort}`)) {\n        shouldUpdatePublicOrigin = true;\n      }\n      // Listen for when the server actually starts\n      if (shouldUpdatePublicOrigin) {\n        server.httpServer?.once(\"listening\", () => {\n          const address = server.httpServer?.address();\n          if (address && typeof address !== \"string\") {\n            const port = address.port;\n            if (port !== desiredPort) {\n              const envPrefix = Array.isArray(server.config.envPrefix) ? server.config.envPrefix[0] : server.config.envPrefix ?? DEFAULT_CONFIG.ENV_PREFIX;\n              const newOrigin = publicOrigin.replace(\n                `:${desiredPort}`,\n                `:${port}`\n              );\n              process.env[`${envPrefix}PUBLIC_ORIGIN`] = newOrigin\n              console.warn(\"PUBLIC_ORIGIN did not match the port: \" + port);\n            }\n          }\n        });\n      }\n    }\n  };\n}\n"],"names":["envPrefix"],"mappings":";;;;;;;;;;AAWO,MAAM,kBAAkB,MAAiB;AAC9C,EAAA,MAAM,OAAO,OAAQ,CAAA,IAAA;AAGrB,EAAA,IAAI,OAA6B,GAAA,OAAA;AACjC,EAAI,IAAA,IAAA,CAAK,QAAS,CAAA,OAAO,CAAG,EAAA;AAC1B,IAAU,OAAA,GAAA,OAAA;AAAA,GACD,MAAA,IAAA,IAAA,CAAK,QAAS,CAAA,KAAK,CAAK,IAAA,IAAA,CAAK,QAAS,CAAA,OAAO,CAAK,IAAA,IAAA,CAAK,QAAS,CAAA,SAAS,CAAG,EAAA;AACrF,IAAU,OAAA,GAAA,OAAA;AAAA;AAIZ,EAAA,IAAI,OAAe,UAAW,EAAA;AAC9B,EAAA,MAAM,YAAY,IAAK,CAAA,SAAA,CAAU,SAAO,GAAQ,KAAA,QAAA,IAAY,QAAQ,IAAI,CAAA;AACxE,EAAA,IAAI,SAAc,KAAA,EAAA,IAAM,IAAK,CAAA,SAAA,GAAY,CAAC,CAAG,EAAA;AAC3C,IAAO,IAAA,GAAA,IAAA,CAAK,YAAY,CAAC,CAAA;AAAA;AAI3B,EAAM,MAAA,UAAA,GAAa,IAAK,CAAA,QAAA,CAAS,OAAO,CAAA;AAExC,EAAO,OAAA;AAAA,IACL,OAAA;AAAA,IACA,IAAA;AAAA,IACA;AAAA,GACF;AACF;AAOA,SAAS,YAAY,OAAqC,EAAA;AAExD,EAAM,MAAA,SAAA,GAAY,OAAQ,CAAA,IAAA,CAAK,IAAK,CAAA,CAAC,GAAQ,KAAA,GAAA,CAAI,UAAW,CAAA,CAAA,EAAA,EAAK,OAAO,CAAA,CAAA,CAAG,CAAC,CAAA;AAC5E,EAAA,IAAI,SAAW,EAAA;AACb,IAAA,OAAO,SAAU,CAAA,SAAA,CAAU,CAAK,EAAA,EAAA,OAAO,IAAI,MAAM,CAAA;AAAA;AAInD,EAAM,MAAA,QAAA,GAAW,QAAQ,IAAK,CAAA,SAAA,CAAU,CAAC,GAAQ,KAAA,GAAA,KAAQ,CAAK,EAAA,EAAA,OAAO,CAAE,CAAA,CAAA;AACvE,EAAA,IAAI,aAAa,EAAM,IAAA,QAAA,GAAW,CAAI,GAAA,OAAA,CAAQ,KAAK,MAAQ,EAAA;AACzD,IAAA,MAAM,KAAQ,GAAA,OAAA,CAAQ,IAAK,CAAA,QAAA,GAAW,CAAC,CAAA;AAEvC,IAAA,IAAI,KAAS,IAAA,CAAC,KAAM,CAAA,UAAA,CAAW,IAAI,CAAG,EAAA;AACpC,MAAO,OAAA,KAAA;AAAA;AACT;AAGF,EAAO,OAAA,MAAA;AACT;AAEA,MAAM,OAAU,GAAA,OAAA,CAAQ,IAAK,CAAA,QAAA,CAAS,OAAO,CAAA;AAC7C,MAAM,SAAY,GAAA,OAAA,CAAQ,IAAK,CAAA,QAAA,CAAS,SAAS,CAAA;AAQjD,MAAM,YAAA,GAAe,YAAY,MAAM,CAAA;AAEvC,MAAM,2BAA8B,GAAA,UAAA;AAAA,EAClC,gBAAgB,OAAQ,CAAA,GAAA,CAAI,UAAU,CAAM,KAAA,OAAA,IAAW,YAAY,YAAe,GAAA,aAAA,CAAA;AAAA,EAClF,eAAA;AAAA,EACA,cAAe,CAAA;AACjB,CAAA;AA6BO,SAAS,SAAoB,GAAA;AAClC,EAAI,IAAA,UAAA;AACJ,EAAA,IAAI,aAAa,cAAe,CAAA,UAAA;AAChC,EAAO,OAAA;AAAA,IACL,IAAM,EAAA,8BAAA;AAAA,IACN,OAAS,EAAA,KAAA;AAAA,IACT,MAAO,CAAA,MAAA,EAAQ,EAAE,IAAA,EAAQ,EAAA;AACvB,MAAA,IAAG,OAAO,SAAW,EAAA;AACnB,QAAG,IAAA,OAAO,MAAO,CAAA,SAAA,KAAc,QAAU,EAAA;AACvC,UAAA,UAAA,GAAa,MAAO,CAAA,SAAA;AAAA,SACZ,MAAA,IAAA,KAAA,CAAM,OAAQ,CAAA,MAAA,CAAO,SAAS,CAAG,EAAA;AACzC,UAAa,UAAA,GAAA,MAAA,CAAO,UAAU,CAAC,CAAA;AAAA;AACjC;AAEF,MAAA,MAAM,UACH,GAAA,IAAA,KAAS,MAAa,IAAA,IAAA,KAAS,QAAQ,GAAI,CAAA,CAAA,EAAG,UAAU,CAAA,IAAA,CAAM,CAC9D,IAAA,MAAA,CAAO,IAAS,KAAA,MAAA,IAAa,OAAO,IAAS,KAAA,eAAA;AAChD,MAAA,IAAI,UAAY,EAAA;AACd,QAA4B,2BAAA,EAAA;AAAA;AAG9B,MAAA,MAAM,uBAAuB,UACzB,GAAA,UAAA;AAAA,QACE,QAAQ,OAAQ,CAAA,GAAA,CAAI,CAAG,EAAA,UAAU,MAAM,CAAK,IAAA,YAAA;AAAA,QAC5C,OAAO,IAAQ,IAAA,eAAA;AAAA,QACf;AAAA,OAEF,GAAA,2BAAA;AACJ,MAAM,MAAA,iBAAA,GAAoB,oBAAoB,MAAM,CAAA;AAGpD,MAAA,UAAA,GAAa,MAAM;AACjB,QAAkB,iBAAA,EAAA;AAClB,QAAqB,oBAAA,EAAA;AAAA,OACvB;AAAA,KACF;AAAA,IACA,WAAc,GAAA;AAEZ,MAAa,UAAA,IAAA;AAAA,KACf;AAAA,IACA,gBAAgB,MAAQ,EAAA;AACtB,MAAA,MAAM,SAAY,GAAA,KAAA,CAAM,OAAQ,CAAA,MAAA,CAAO,OAAO,SAAS,CAAA,GAAI,MAAO,CAAA,MAAA,CAAO,UAAU,CAAC,CAAA,GAAI,MAAO,CAAA,MAAA,CAAO,aAAa,cAAe,CAAA,UAAA;AAClI,MAAA,MAAM,eAAe,OAAQ,CAAA,GAAA,CAAI,CAAG,EAAA,SAAS,eAAe,CAAK,IAAA,EAAA;AAEjE,MAAM,MAAA,WAAA,GAAc,MAAO,CAAA,MAAA,CAAO,MAAO,CAAA,IAAA;AACzC,MAAA,IAAI,wBAA2B,GAAA,KAAA;AAC/B,MAAA,IAAI,gBAAgB,YAAa,CAAA,QAAA,CAAS,CAAI,CAAA,EAAA,WAAW,EAAE,CAAG,EAAA;AAC5D,QAA2B,wBAAA,GAAA,IAAA;AAAA;AAG7B,MAAA,IAAI,wBAA0B,EAAA;AAC5B,QAAO,MAAA,CAAA,UAAA,EAAY,IAAK,CAAA,WAAA,EAAa,MAAM;AACzC,UAAM,MAAA,OAAA,GAAU,MAAO,CAAA,UAAA,EAAY,OAAQ,EAAA;AAC3C,UAAI,IAAA,OAAA,IAAW,OAAO,OAAA,KAAY,QAAU,EAAA;AAC1C,YAAA,MAAM,OAAO,OAAQ,CAAA,IAAA;AACrB,YAAA,IAAI,SAAS,WAAa,EAAA;AACxB,cAAA,MAAMA,UAAY,GAAA,KAAA,CAAM,OAAQ,CAAA,MAAA,CAAO,OAAO,SAAS,CAAA,GAAI,MAAO,CAAA,MAAA,CAAO,UAAU,CAAC,CAAA,GAAI,MAAO,CAAA,MAAA,CAAO,aAAa,cAAe,CAAA,UAAA;AAClI,cAAA,MAAM,YAAY,YAAa,CAAA,OAAA;AAAA,gBAC7B,IAAI,WAAW,CAAA,CAAA;AAAA,gBACf,IAAI,IAAI,CAAA;AAAA,eACV;AACA,cAAA,OAAA,CAAQ,GAAI,CAAA,CAAA,EAAGA,UAAS,CAAA,aAAA,CAAe,CAAI,GAAA,SAAA;AAC3C,cAAQ,OAAA,CAAA,IAAA,CAAK,2CAA2C,IAAI,CAAA;AAAA;AAC9D;AACF,SACD,CAAA;AAAA;AACH;AACF,GACF;AACF;;;;"}

package/dist/plugin/error/directiveError.d.ts

@@ -0,0 +1,13 @@
+import type { DirectiveMatch } from "../loader/directives/types.js";
+export declare const DIRECTIVE_ERRORS: {
+    readonly FILE_LEVEL: {
+        readonly NOT_AT_TOP: "'use {directive}' directive must be at the top of the file, before any other statements.";
+        readonly MIXED_DIRECTIVES: "Cannot use both 'use client' and 'use server' directives in the same file";
+    };
+    readonly FUNCTION_LEVEL: {
+        readonly CLIENT_NOT_ALLOWED: "Directive 'use client' is not allowed at function level. Only 'use server' is allowed at the start of async functions.";
+        readonly SERVER_NOT_ASYNC: "'use server' directive is only allowed at the start of async functions";
+    };
+};
+export declare function isFileLevelWarning(warning: DirectiveMatch): boolean;
+//# sourceMappingURL=directiveError.d.ts.map

package/dist/plugin/error/directiveError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"directiveError.d.ts","sourceRoot":"","sources":["../../../plugin/error/directiveError.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAGpE,eAAO,MAAM,gBAAgB;;;;;;;;;CAanB,CAAC;AAGX,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CASnE"}

package/dist/plugin/error/directiveError.js

@@ -0,0 +1,21 @@
+// Error types for better maintainability
+export const DIRECTIVE_ERRORS = {
+    FILE_LEVEL: {
+        NOT_AT_TOP: "'use {directive}' directive must be at the top of the file, before any other statements.",
+        MIXED_DIRECTIVES: "Cannot use both 'use client' and 'use server' directives in the same file",
+    },
+    FUNCTION_LEVEL: {
+        CLIENT_NOT_ALLOWED: "Directive 'use client' is not allowed at function level. Only 'use server' is allowed at the start of async functions.",
+        SERVER_NOT_ASYNC: "'use server' directive is only allowed at the start of async functions",
+    },
+};
+// Helper to check if a warning is about file-level issues
+export function isFileLevelWarning(warning) {
+    if (!warning.message)
+        return false;
+    return (warning.message ===
+        DIRECTIVE_ERRORS.FILE_LEVEL.NOT_AT_TOP.replace("{directive}", "client") ||
+        warning.message ===
+            DIRECTIVE_ERRORS.FILE_LEVEL.NOT_AT_TOP.replace("{directive}", "server") ||
+        warning.message === DIRECTIVE_ERRORS.FILE_LEVEL.MIXED_DIRECTIVES);
+}

package/dist/plugin/error/enhanceError.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Creates a new error with context from any input.
+ * Always creates a fresh stack trace and sets the original as the cause.
+ * This is the preferred way to wrap errors with context.
+ */
+export declare function enhanceError(originalError: Error | string | {
+    message: string;
+}, captureStackTraceFunction: Function, context?: string): Error;
+/**
+ * Creates a new error with context and captured stack trace
+ * Useful for creating contextual errors at specific points in the code
+ */
+export declare function createContextualError(message: string, context?: string, captureStackTraceFunction?: Function): Error;
+//# sourceMappingURL=enhanceError.d.ts.map

package/dist/plugin/error/enhanceError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enhanceError.d.ts","sourceRoot":"","sources":["../../../plugin/error/enhanceError.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,wBAAgB,YAAY,CAC1B,aAAa,EAAE,KAAK,GAAG,MAAM,GAAG;IAAC,OAAO,EAAE,MAAM,CAAA;CAAC,EACjD,yBAAyB,EAAE,QAAQ,EACnC,OAAO,GAAE,MAAuC,GAC/C,KAAK,CASP;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,MAAW,EACpB,yBAAyB,CAAC,EAAE,QAAQ,GACnC,KAAK,CAYP"}