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

package/dist/plugin/config/getCondition.d.ts

@@ -1,4 +1,55 @@
-export declare const getCondition: <Prefix extends string = "react-">(prefix?: Prefix) => `${Prefix}client` | `${Prefix}server`;
-export declare const isReactServerCondition: (condition?: string) => condition is "react-server";
-export declare const isReactClientCondition: (condition?: string) => condition is "react-client";
+/**
+ * Gets all conditions from both NODE_OPTIONS and command-line arguments
+ */
+export declare const getAllConditions: () => string[];
+export declare const detectReactConditionAmbiguity: () => string[];
+export declare const warnIfAmbiguousReactConditions: () => void;
+/**
+ * Gets the current condition, defaulting to "react-client" if no conditions are set
+ */
+export declare const getCurrentCondition: () => "react-server" | "react-client" | undefined;
+/**
+ * Gets the condition with a custom prefix
+ */
+export declare const getCondition: <Prefix extends string = "react-", DefaultCondition extends `${Prefix}${string}` = `${Prefix}client`>(prefix?: Prefix, defaultReturn?: `${Prefix}server` | `${Prefix}client`) => `${Prefix}client` | `${Prefix}server` | DefaultCondition;
+/**
+ * Asserts that the current condition is react-server
+ * Throws an error with a descriptive message if not
+ */
+export declare function assertReactServer(): asserts this is {
+    condition: "react-server";
+};
+export declare function assertNonReactServer(): asserts this is {
+    condition: "react-client";
+};
+/**
+ * Checks if the current condition is react-server (strict - requires both NODE_OPTIONS and execArgv)
+ * Use this for React Server DOM compatibility checks
+ */
+export declare const isReactServerCondition: () => boolean;
+/**
+ * Checks if the current condition is react-client (strict - requires both NODE_OPTIONS and execArgv)
+ * Use this for React Server DOM compatibility checks
+ */
+export declare const isReactClientCondition: () => boolean;
+/**
+ * Checks if react-server condition is present in either NODE_OPTIONS OR execArgv (lenient)
+ * Use this for plugin internal environment gating
+ */
+export declare const hasReactServerCondition: () => boolean;
+/**
+ * Checks if react-client condition is present in either NODE_OPTIONS OR execArgv (lenient)
+ * Use this for plugin internal environment gating
+ */
+export declare const hasReactClientCondition: () => boolean;
+/**
+ * Legacy function for backward compatibility
+ * @deprecated Use getAllConditions() instead
+ */
+export declare const getNodeOptionsConditions: () => string[];
+/**
+ * Legacy export for backward compatibility
+ * @deprecated Use getCurrentCondition() instead
+ */
+export declare const condition: "react-server" | "react-client" | undefined;
 //# sourceMappingURL=getCondition.d.ts.map

package/dist/plugin/config/getCondition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getCondition.d.ts","sourceRoot":"","sources":["../../../plugin/config/getCondition.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,YAAY,GAAI,MAAM,SAAS,MAAM,GAAG,QAAQ,EAC3D,SAAQ,MAA2B,KAClC,GAAG,MAAM,QAAQ,GAAG,GAAG,MAAM,QAI/B,CAAC;AAEF,eAAO,MAAM,sBAAsB,GAAI,YAAW,MAAuB,gCAC3C,CAAC;AAE/B,eAAO,MAAM,sBAAsB,GAAI,YAAW,MAAuB,gCAC3C,CAAC"}
+{"version":3,"file":"getCondition.d.ts","sourceRoot":"","sources":["../../../plugin/config/getCondition.ts"],"names":[],"mappings":"AAsGA;;GAEG;AACH,eAAO,MAAM,gBAAgB,QAAO,MAAM,EAUzC,CAAC;AASF,eAAO,MAAM,6BAA6B,QAAO,MAAM,EAKtD,CAAC;AAEF,eAAO,MAAM,8BAA8B,QAAO,IAwBjD,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,mBAAmB,QAC5B,cAAc,GACd,cAAc,GACd,SAWH,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,YAAY,GAAI,MAAM,SAAS,MAAM,GAAG,QAAQ,EAAE,gBAAgB,SAAS,GAAG,MAAM,GAAG,MAAM,EAAE,GAAG,GAAG,MAAM,QAAQ,EAC9H,SAAQ,MAA2B,EACnC,gBACI,GAAG,MAAM,QAAQ,GACjB,GAAG,MAAM,QAAiD,KAC7D,GAAG,MAAM,QAAQ,GAAG,GAAG,MAAM,QAAQ,GAAG,gBAS1C,CAAC;AAEF;;;GAGG;AACH,wBAAgB,iBAAiB,IAAI,OAAO,CAAC,IAAI,IAAI;IACnD,SAAS,EAAE,cAAc,CAAC;CAC3B,CAQA;AAED,wBAAgB,oBAAoB,IAAI,OAAO,CAAC,IAAI,IAAI;IACtD,SAAS,EAAE,cAAc,CAAC;CAC3B,CAQA;AAED;;;GAGG;AACH,eAAO,MAAM,sBAAsB,QAAO,OACA,CAAC;AAE3C;;;GAGG;AACH,eAAO,MAAM,sBAAsB,QAAO,OACA,CAAC;AAE3C;;;GAGG;AACH,eAAO,MAAM,uBAAuB,QAAO,OAG1C,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,uBAAuB,QAAO,OAG1C,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,wBAAwB,QAAO,MAAM,EAIjD,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,SAAS,6CAAwB,CAAC"}

package/dist/plugin/config/getCondition.js

@@ -3,11 +3,163 @@
  * Copyright (c) Nico Brinkkemper
  * MIT License
  */
-const getCondition = (prefix = "react-") => {
-  return process.env["NODE_OPTIONS"]?.match(/--conditions[= ]react-server/) ? `${prefix}server` : `${prefix}client`;
+const tokenizeNodeOptions = () => {
+  const nodeOptions = process.env["NODE_OPTIONS"] || "";
+  if (!nodeOptions.trim()) {
+    return [];
+  }
+  const tokens = [];
+  let current = "";
+  let inQuotes = false;
+  let quoteChar = "";
+  let i = 0;
+  while (i < nodeOptions.length) {
+    const char = nodeOptions[i];
+    if (inQuotes) {
+      if (char === quoteChar) {
+        inQuotes = false;
+        quoteChar = "";
+        if (current.trim()) {
+          tokens.push(current.trim());
+          current = "";
+        }
+      } else {
+        current += char;
+      }
+    } else {
+      if (char === '"' || char === "'") {
+        if (current.trim()) {
+          tokens.push(current.trim());
+          current = "";
+        }
+        inQuotes = true;
+        quoteChar = char;
+      } else if (char === " " || char === "	" || char === "\n") {
+        if (current.trim()) {
+          tokens.push(current.trim());
+          current = "";
+        }
+      } else {
+        current += char;
+      }
+    }
+    i++;
+  }
+  if (current.trim()) {
+    tokens.push(current.trim());
+  }
+  return tokens.filter(Boolean);
 };
-const isReactServerCondition = (condition = getCondition()) => condition === "react-server";
-const isReactClientCondition = (condition = getCondition()) => condition === "react-client";
+const parseNodeArgs = (args) => {
+  const conditions = [];
+  const flags = /* @__PURE__ */ new Set();
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--conditions" || arg === "-C") {
+      if (i + 1 < args.length) {
+        const conditionValue = args[i + 1];
+        conditions.push(
+          ...conditionValue.split(",").map((c) => c.trim()).filter(Boolean)
+        );
+        i++;
+      }
+    } else if (arg.startsWith("--conditions=")) {
+      const conditionValue = arg.substring("--conditions=".length);
+      conditions.push(
+        ...conditionValue.split(",").map((c) => c.trim()).filter(Boolean)
+      );
+    } else if (arg === "--no-addons") {
+      flags.add("no-addons");
+    } else if (arg.startsWith("--")) {
+      flags.add(arg);
+    }
+  }
+  return { conditions, flags };
+};
+const getAllConditions = () => {
+  const nodeOptionsTokens = tokenizeNodeOptions();
+  const { conditions: envConditions } = parseNodeArgs(nodeOptionsTokens);
+  const { conditions: cliConditions } = parseNodeArgs(process.execArgv);
+  return [...envConditions, ...cliConditions];
+};
+let didWarnAmbiguousConditions = false;
+const reactConditionSet = /* @__PURE__ */ new Set(["react-server", "react-client"]);
+const detectReactConditionAmbiguity = () => {
+  const conditions = getAllConditions();
+  const found = conditions.filter((c) => reactConditionSet.has(c));
+  const unique = Array.from(new Set(found));
+  return unique;
+};
+const warnIfAmbiguousReactConditions = () => {
+  if (didWarnAmbiguousConditions) return;
+  const unique = detectReactConditionAmbiguity();
+  if (unique.includes("react-server") && unique.includes("react-client")) {
+    didWarnAmbiguousConditions = true;
+    const nodeOptions = process.env["NODE_OPTIONS"] || "";
+    const argv = process.execArgv.join(" ");
+    const msg = `Both react-server and react-client conditions detected in NODE_OPTIONS/execArgv. This can lead to ambiguous resolution. Found: [${unique.join(", ")}]
+NODE_OPTIONS="${nodeOptions}"
+execArgv="${argv}"
+Tip: set exactly one condition or let the plugin manage worker conditions.`;
+    try {
+      process.emitWarning(msg, {
+        code: "VPRS_CONDITION_AMBIGUITY",
+        detail: "vite-plugin-react-server detected conflicting conditions"
+      });
+    } catch {
+      console.warn(`[vite-plugin-react-server] ${msg}`);
+    }
+  }
+};
+const getCurrentCondition = () => {
+  warnIfAmbiguousReactConditions();
+  const conditions = getAllConditions();
+  if (conditions.includes("react-server")) return "react-server";
+  if (conditions.includes("react-client")) return "react-client";
+  return void 0;
+};
+const getCondition = (prefix = "react-", defaultReturn = `${prefix}client`) => {
+  const condition2 = getCurrentCondition();
+  if (condition2 === "react-server") {
+    return `${prefix}server`;
+  }
+  if (condition2 === "react-client") {
+    return `${prefix}client`;
+  }
+  return defaultReturn;
+};
+function assertReactServer() {
+  const currentCondition = getCurrentCondition();
+  if (currentCondition !== "react-server") {
+    throw new Error(
+      `Condition mismatch, should be react-server. Set NODE_OPTIONS="--conditions=react-server" or --conditions=react-server`
+    );
+  }
+}
+function assertNonReactServer() {
+  const currentCondition = getCurrentCondition();
+  if (currentCondition === "react-server") {
+    throw new Error(
+      `Condition mismatch, should not be react-server. Remove NODE_OPTIONS="--conditions=react-server" or --conditions=react-server`
+    );
+  }
+}
+const isReactServerCondition = () => getCurrentCondition() === "react-server";
+const isReactClientCondition = () => getCurrentCondition() === "react-client";
+const hasReactServerCondition = () => {
+  const allConditions = getAllConditions();
+  return allConditions.includes("react-server");
+};
+const hasReactClientCondition = () => {
+  const allConditions = getAllConditions();
+  return allConditions.includes("react-client");
+};
+const getNodeOptionsConditions = () => {
+  const nodeOptionsTokens = tokenizeNodeOptions();
+  const { conditions } = parseNodeArgs(nodeOptionsTokens);
+  return conditions;
+};
+const condition = getCurrentCondition();
 
-export { getCondition, isReactClientCondition, isReactServerCondition };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0Q29uZGl0aW9uLmpzIiwic291cmNlcyI6WyIuLi8uLi8uLi9wbHVnaW4vY29uZmlnL2dldENvbmRpdGlvbi50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgY29uc3QgZ2V0Q29uZGl0aW9uID0gPFByZWZpeCBleHRlbmRzIHN0cmluZyA9IFwicmVhY3QtXCI+KFxuICBwcmVmaXg6IFByZWZpeCA9IFwicmVhY3QtXCIgYXMgUHJlZml4XG4pOiBgJHtQcmVmaXh9Y2xpZW50YCB8IGAke1ByZWZpeH1zZXJ2ZXJgID0+IHtcbiAgcmV0dXJuIHByb2Nlc3MuZW52W1wiTk9ERV9PUFRJT05TXCJdPy5tYXRjaCgvLS1jb25kaXRpb25zWz0gXXJlYWN0LXNlcnZlci8pXG4gICAgPyAoYCR7cHJlZml4fXNlcnZlcmAgYXMgYCR7UHJlZml4fXNlcnZlcmApXG4gICAgOiAoYCR7cHJlZml4fWNsaWVudGAgYXMgYCR7UHJlZml4fWNsaWVudGApO1xufTtcblxuZXhwb3J0IGNvbnN0IGlzUmVhY3RTZXJ2ZXJDb25kaXRpb24gPSAoY29uZGl0aW9uOiBzdHJpbmcgPSBnZXRDb25kaXRpb24oKSkgPT5cbiAgY29uZGl0aW9uID09PSBcInJlYWN0LXNlcnZlclwiO1xuXG5leHBvcnQgY29uc3QgaXNSZWFjdENsaWVudENvbmRpdGlvbiA9IChjb25kaXRpb246IHN0cmluZyA9IGdldENvbmRpdGlvbigpKSA9PlxuICBjb25kaXRpb24gPT09IFwicmVhY3QtY2xpZW50XCI7XG4iXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7QUFBYSxNQUFBLFlBQUEsR0FBZSxDQUMxQixNQUFBLEdBQWlCLFFBQ3lCLEtBQUE7QUFDMUMsRUFBTyxPQUFBLE9BQUEsQ0FBUSxHQUFJLENBQUEsY0FBYyxDQUFHLEVBQUEsS0FBQSxDQUFNLDhCQUE4QixDQUFBLEdBQ25FLENBQUcsRUFBQSxNQUFNLENBQ1QsTUFBQSxDQUFBLEdBQUEsQ0FBQSxFQUFHLE1BQU0sQ0FBQSxNQUFBLENBQUE7QUFDaEI7QUFFTyxNQUFNLHNCQUF5QixHQUFBLENBQUMsU0FBb0IsR0FBQSxZQUFBLE9BQ3pELFNBQWMsS0FBQTtBQUVULE1BQU0sc0JBQXlCLEdBQUEsQ0FBQyxTQUFvQixHQUFBLFlBQUEsT0FDekQsU0FBYyxLQUFBOzs7OyJ9
+export { assertNonReactServer, assertReactServer, condition, detectReactConditionAmbiguity, getAllConditions, getCondition, getCurrentCondition, getNodeOptionsConditions, hasReactClientCondition, hasReactServerCondition, isReactClientCondition, isReactServerCondition, warnIfAmbiguousReactConditions };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"getCondition.js","sources":["../../../plugin/config/getCondition.ts"],"sourcesContent":["// Note: do not import Node-only modules here (e.g., 'node:worker_threads').\n// This file is consumed in both server and client plugin contexts.\n\n/**\n * Tokenizes NODE_OPTIONS string into individual arguments\n * Handles quoted strings, spaces, and special characters\n */\nconst tokenizeNodeOptions = (): string[] => {\n  const nodeOptions = process.env[\"NODE_OPTIONS\"] || \"\";\n  if (!nodeOptions.trim()) {\n    return [];\n  }\n\n  const tokens: string[] = [];\n  let current = \"\";\n  let inQuotes = false;\n  let quoteChar = \"\";\n  let i = 0;\n\n  while (i < nodeOptions.length) {\n    const char = nodeOptions[i];\n\n    if (inQuotes) {\n      if (char === quoteChar) {\n        inQuotes = false;\n        quoteChar = \"\";\n        if (current.trim()) {\n          tokens.push(current.trim());\n          current = \"\";\n        }\n      } else {\n        current += char;\n      }\n    } else {\n      if (char === '\"' || char === \"'\") {\n        if (current.trim()) {\n          tokens.push(current.trim());\n          current = \"\";\n        }\n        inQuotes = true;\n        quoteChar = char;\n      } else if (char === \" \" || char === \"\\t\" || char === \"\\n\") {\n        if (current.trim()) {\n          tokens.push(current.trim());\n          current = \"\";\n        }\n      } else {\n        current += char;\n      }\n    }\n    i++;\n  }\n\n  if (current.trim()) {\n    tokens.push(current.trim());\n  }\n\n  return tokens.filter(Boolean);\n};\n\n/**\n * Parses command-line arguments for conditions and other flags\n */\nconst parseNodeArgs = (args: string[]) => {\n  const conditions: string[] = [];\n  const flags = new Set<string>();\n\n  for (let i = 0; i < args.length; i++) {\n    const arg = args[i];\n\n    if (arg === \"--conditions\" || arg === \"-C\") {\n      // Next argument is the condition value\n      if (i + 1 < args.length) {\n        const conditionValue = args[i + 1];\n        conditions.push(\n          ...conditionValue\n            .split(\",\")\n            .map((c) => c.trim())\n            .filter(Boolean)\n        );\n        i++; // Skip the next argument since we consumed it\n      }\n    } else if (arg.startsWith(\"--conditions=\")) {\n      // Condition value is part of the same argument\n      const conditionValue = arg.substring(\"--conditions=\".length);\n      conditions.push(\n        ...conditionValue\n          .split(\",\")\n          .map((c) => c.trim())\n          .filter(Boolean)\n      );\n    } else if (arg === \"--no-addons\") {\n      flags.add(\"no-addons\");\n    } else if (arg.startsWith(\"--\")) {\n      // Other flags\n      flags.add(arg);\n    }\n  }\n\n  return { conditions, flags };\n};\n\n/**\n * Gets all conditions from both NODE_OPTIONS and command-line arguments\n */\nexport const getAllConditions = (): string[] => {\n  // Parse NODE_OPTIONS\n  const nodeOptionsTokens = tokenizeNodeOptions();\n  const { conditions: envConditions } = parseNodeArgs(nodeOptionsTokens);\n\n  // Parse command-line arguments\n  const { conditions: cliConditions } = parseNodeArgs(process.execArgv);\n\n  // Combine all conditions\n  return [...envConditions, ...cliConditions];\n};\n\n// ----------------------------------------------------------------------------\n// Ambiguity detection and warning\n// ----------------------------------------------------------------------------\nlet didWarnAmbiguousConditions = false;\n// react-static does not exists, because you still need condition react-server for the .static imports to work.\nconst reactConditionSet = new Set([\"react-server\", \"react-client\"]);\n\nexport const detectReactConditionAmbiguity = (): string[] => {\n  const conditions = getAllConditions();\n  const found = conditions.filter((c) => reactConditionSet.has(c));\n  const unique = Array.from(new Set(found));\n  return unique;\n};\n\nexport const warnIfAmbiguousReactConditions = (): void => {\n  if (didWarnAmbiguousConditions) return;\n  const unique = detectReactConditionAmbiguity();\n  if (unique.includes(\"react-server\") && unique.includes(\"react-client\")) {\n    didWarnAmbiguousConditions = true;\n    const nodeOptions = process.env[\"NODE_OPTIONS\"] || \"\";\n    const argv = process.execArgv.join(\" \");\n    const msg =\n      `Both react-server and react-client conditions detected in NODE_OPTIONS/execArgv. ` +\n      `This can lead to ambiguous resolution. Found: [${unique.join(\", \")}]\\n` +\n      `NODE_OPTIONS=\"${nodeOptions}\"\\nexecArgv=\"${argv}\"\\n` +\n      `Tip: set exactly one condition or let the plugin manage worker conditions.`;\n    // Use process.emitWarning to avoid throwing\n    try {\n      process.emitWarning(msg, {\n        code: \"VPRS_CONDITION_AMBIGUITY\",\n        detail: \"vite-plugin-react-server detected conflicting conditions\",\n      } as any);\n    } catch {\n      // Fallback\n\n      console.warn(`[vite-plugin-react-server] ${msg}`);\n    }\n  }\n};\n\n/**\n * Gets the current condition, defaulting to \"react-client\" if no conditions are set\n */\nexport const getCurrentCondition = ():\n  | \"react-server\"\n  | \"react-client\"\n  | undefined => {\n  // Warn if we detect both conditions present\n  warnIfAmbiguousReactConditions();\n\n  // Check both NODE_OPTIONS and execArgv for conditions\n  const conditions = getAllConditions();\n  if (conditions.includes(\"react-server\")) return \"react-server\";\n  if (conditions.includes(\"react-client\")) return \"react-client\";\n\n  // Default to react-client when nothing is set\n  return undefined;\n};\n\n/**\n * Gets the condition with a custom prefix\n */\nexport const getCondition = <Prefix extends string = \"react-\", DefaultCondition extends `${Prefix}${string}` = `${Prefix}client`>(\n  prefix: Prefix = \"react-\" as Prefix,\n  defaultReturn:\n    | `${Prefix}server`\n    | `${Prefix}client` = `${prefix}client` as `${Prefix}client`\n): `${Prefix}client` | `${Prefix}server` | DefaultCondition => {\n  const condition = getCurrentCondition();\n  if (condition === \"react-server\") {\n    return `${prefix}server` as `${Prefix}server`;\n  }\n  if (condition === \"react-client\") {\n    return `${prefix}client` as `${Prefix}client`;\n  }\n  return defaultReturn;\n};\n\n/**\n * Asserts that the current condition is react-server\n * Throws an error with a descriptive message if not\n */\nexport function assertReactServer(): asserts this is {\n  condition: \"react-server\";\n} {\n  const currentCondition = getCurrentCondition();\n  if (currentCondition !== \"react-server\") {\n    // Debug-only: avoid Node-only APIs to keep this file browser-safe\n    throw new Error(\n      `Condition mismatch, should be react-server. Set NODE_OPTIONS=\"--conditions=react-server\" or --conditions=react-server`\n    );\n  }\n}\n\nexport function assertNonReactServer(): asserts this is {\n  condition: \"react-client\";\n} {\n  const currentCondition = getCurrentCondition();\n  if (currentCondition === \"react-server\") {\n    // Debug-only: avoid Node-only APIs to keep this file browser-safe\n    throw new Error(\n      `Condition mismatch, should not be react-server. Remove NODE_OPTIONS=\"--conditions=react-server\" or --conditions=react-server`\n    );\n  }\n}\n\n/**\n * Checks if the current condition is react-server (strict - requires both NODE_OPTIONS and execArgv)\n * Use this for React Server DOM compatibility checks\n */\nexport const isReactServerCondition = (): boolean =>\n  getCurrentCondition() === \"react-server\";\n\n/**\n * Checks if the current condition is react-client (strict - requires both NODE_OPTIONS and execArgv)\n * Use this for React Server DOM compatibility checks\n */\nexport const isReactClientCondition = (): boolean =>\n  getCurrentCondition() === \"react-client\";\n\n/**\n * Checks if react-server condition is present in either NODE_OPTIONS OR execArgv (lenient)\n * Use this for plugin internal environment gating\n */\nexport const hasReactServerCondition = (): boolean => {\n  const allConditions = getAllConditions();\n  return allConditions.includes(\"react-server\");\n};\n\n/**\n * Checks if react-client condition is present in either NODE_OPTIONS OR execArgv (lenient)\n * Use this for plugin internal environment gating  \n */\nexport const hasReactClientCondition = (): boolean => {\n  const allConditions = getAllConditions();\n  return allConditions.includes(\"react-client\");\n};\n\n/**\n * Legacy function for backward compatibility\n * @deprecated Use getAllConditions() instead\n */\nexport const getNodeOptionsConditions = (): string[] => {\n  const nodeOptionsTokens = tokenizeNodeOptions();\n  const { conditions } = parseNodeArgs(nodeOptionsTokens);\n  return conditions;\n};\n\n/**\n * Legacy export for backward compatibility\n * @deprecated Use getCurrentCondition() instead\n */\nexport const condition = getCurrentCondition();\n"],"names":["condition"],"mappings":"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"}

package/dist/plugin/{getNodeEnv.d.ts → config/getNodeEnv.d.ts}

@@ -7,5 +7,5 @@ declare global {
 }
 export declare const validEnvs: ["development", "test", "production"];
 export declare const isValidEnv: (env: string) => env is (typeof validEnvs)[number];
-export declare function getNodeEnv(): "development" | "test" | "production";
+export declare function getNodeEnv<E extends string = typeof process.env.NODE_ENV>(currentEnv?: E): "production" | (E & "development") | (E & "test");
 //# sourceMappingURL=getNodeEnv.d.ts.map

package/dist/plugin/config/getNodeEnv.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getNodeEnv.d.ts","sourceRoot":"","sources":["../../../plugin/config/getNodeEnv.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM,CAAC;QACf,UAAU,UAAU;YAClB,QAAQ,EAAE,aAAa,GAAG,MAAM,GAAG,YAAY,CAAC;SACjD;KACF;CACF;AAED,eAAO,MAAM,SAAS,EAA4C,CAChE,aAAa,EACb,MAAM,EACN,YAAY,CACb,CAAC;AAEF,eAAO,MAAM,UAAU,GAAI,KAAK,MAAM,KAAG,GAAG,IAAI,CAAC,OAAO,SAAS,EAAE,MAAM,CACvC,CAAC;AAEnC,wBAAgB,UAAU,CAAC,CAAC,SAAS,MAAM,GAAG,OAAO,OAAO,CAAC,GAAG,CAAC,QAAQ,EACvE,UAAU,GAAE,CAA6B,qDAO1C"}

package/dist/plugin/config/getNodeEnv.js

@@ -0,0 +1,17 @@
+/**
+ * vite-plugin-react-server
+ * Copyright (c) Nico Brinkkemper
+ * MIT License
+ */
+const validEnvs = ["development", "test", "production"];
+const isValidEnv = (env) => validEnvs.includes(env);
+function getNodeEnv(currentEnv = process.env.NODE_ENV) {
+  const env = currentEnv;
+  if (!isValidEnv(env)) {
+    return "production";
+  }
+  return env;
+}
+
+export { getNodeEnv, isValidEnv, validEnvs };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0Tm9kZUVudi5qcyIsInNvdXJjZXMiOlsiLi4vLi4vLi4vcGx1Z2luL2NvbmZpZy9nZXROb2RlRW52LnRzIl0sInNvdXJjZXNDb250ZW50IjpbImRlY2xhcmUgZ2xvYmFsIHtcbiAgbmFtZXNwYWNlIE5vZGVKUyB7XG4gICAgaW50ZXJmYWNlIFByb2Nlc3NFbnYge1xuICAgICAgTk9ERV9FTlY6IFwiZGV2ZWxvcG1lbnRcIiB8IFwidGVzdFwiIHwgXCJwcm9kdWN0aW9uXCI7XG4gICAgfVxuICB9XG59XG5cbmV4cG9ydCBjb25zdCB2YWxpZEVudnMgPSBbXCJkZXZlbG9wbWVudFwiLCBcInRlc3RcIiwgXCJwcm9kdWN0aW9uXCJdIGFzIFtcbiAgXCJkZXZlbG9wbWVudFwiLFxuICBcInRlc3RcIixcbiAgXCJwcm9kdWN0aW9uXCJcbl07XG5cbmV4cG9ydCBjb25zdCBpc1ZhbGlkRW52ID0gKGVudjogc3RyaW5nKTogZW52IGlzICh0eXBlb2YgdmFsaWRFbnZzKVtudW1iZXJdID0+XG4gIHZhbGlkRW52cy5pbmNsdWRlcyhlbnYgYXMgbmV2ZXIpO1xuXG5leHBvcnQgZnVuY3Rpb24gZ2V0Tm9kZUVudjxFIGV4dGVuZHMgc3RyaW5nID0gdHlwZW9mIHByb2Nlc3MuZW52Lk5PREVfRU5WPihcbiAgY3VycmVudEVudjogRSA9IHByb2Nlc3MuZW52Lk5PREVfRU5WIGFzIEVcbikge1xuICBjb25zdCBlbnYgPSBjdXJyZW50RW52O1xuICBpZiAoIWlzVmFsaWRFbnYoZW52KSkge1xuICAgIHJldHVybiBcInByb2R1Y3Rpb25cIjtcbiAgfVxuICByZXR1cm4gZW52O1xufVxuIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7O0FBUU8sTUFBTSxTQUFZLEdBQUEsQ0FBQyxhQUFlLEVBQUEsTUFBQSxFQUFRLFlBQVk7QUFNdEQsTUFBTSxVQUFhLEdBQUEsQ0FBQyxHQUN6QixLQUFBLFNBQUEsQ0FBVSxTQUFTLEdBQVk7QUFFMUIsU0FBUyxVQUNkLENBQUEsVUFBQSxHQUFnQixPQUFRLENBQUEsR0FBQSxDQUFJLFFBQzVCLEVBQUE7QUFDQSxFQUFBLE1BQU0sR0FBTSxHQUFBLFVBQUE7QUFDWixFQUFJLElBQUEsQ0FBQyxVQUFXLENBQUEsR0FBRyxDQUFHLEVBQUE7QUFDcEIsSUFBTyxPQUFBLFlBQUE7QUFBQTtBQUVULEVBQU8sT0FBQSxHQUFBO0FBQ1Q7Ozs7In0=

package/dist/plugin/config/index.d.ts

@@ -1,7 +1,6 @@
 export * from './autoDiscover/index.js';
 export * from './flightBindings.js';
 export * from './interpolatePattern.js';
-export * from './resolveDevServerConfig.js';
 export * from './resolvePages.js';
 export * from './resolveUserConfig.js';
 export * from './createModuleID.js';
@@ -18,4 +17,47 @@ export * from './extMap.js';
 export * from './resolveAllowedDirectives.js';
 export * from './resolveOptions.js';
 export * from './resolveUrlOption.js';
+export * from './getNodeEnv.js';
+export { resolveOptions } from "./resolveOptions.js";
+export { resolveBuildPages } from "./autoDiscover/resolveBuildPages.js";
+export { resolveAutoDiscover } from "./autoDiscover/resolveAutoDiscover.js";
+/**
+ * Main handler options creation (auto-selects environment)
+ *
+ * RECOMMENDED: Use this for most cases - it automatically chooses the right implementation
+ * based on your current environment (react-server vs react-client).
+ *
+ * Example:
+ * ```typescript
+ * import { createHandlerOptions } from "../config/index.js";
+ * const handlerOptions = await createHandlerOptions("/about", options);
+ * ```
+ */
+export { createHandlerOptions } from "./createHandlerOptions.js";
+/**
+ * Handler options creation (environment-specific, when you need explicit control)
+ *
+ * Use these when you need to explicitly control which implementation to use,
+ * regardless of the current environment.
+ *
+ * Examples:
+ * ```typescript
+ * // Force server implementation (for RSC streams)
+ * import { createHandlerOptionsServer } from "../config/index.js";
+ * const rscOptions = await createHandlerOptionsServer("/about", options);
+ *
+ * // Force client implementation (for HTML streams)
+ * import { createHandlerOptionsClient } from "../config/index.js";
+ * const htmlOptions = await createHandlerOptionsClient("/about", options);
+ * ```
+ */
+export { createHandlerOptions as createHandlerOptionsServer } from "./createHandlerOptions.server.js";
+export { createHandlerOptions as createHandlerOptionsClient } from "./createHandlerOptions.client.js";
+export type { CreateHandlerOptionsParams, CreateHandlerOptionsServerFn, CreateHandlerOptionsClientFn, ResolvedDefaults, } from "./createHandlerOptions.types.js";
+export type { CreateHandlerOptions } from "../types.js";
+export { getStashedUserOptions, getStashedHandlerOptions, stashHandlerOptions } from "./stashedOptionsState.js";
+export { getEnvironmentId } from "./stashedOptionsState.js";
+export { getNodeEnv } from "./getNodeEnv.js";
+export { getCondition } from "./getCondition.js";
+export { DEFAULT_CONFIG } from "./defaults.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/plugin/config/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../plugin/config/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,qBAAqB,CAAC;AACpC,cAAc,yBAAyB,CAAC;AACxC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,mBAAmB,CAAC;AAClC,cAAc,wBAAwB,CAAC;AACvC,cAAc,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,CAAC;AAClC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,8BAA8B,CAAC;AAC7C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,oBAAoB,CAAC;AACnC,cAAc,aAAa,CAAC;AAC5B,cAAc,+BAA+B,CAAC;AAC9C,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../plugin/config/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,qBAAqB,CAAC;AACpC,cAAc,yBAAyB,CAAC;AACxC,cAAc,mBAAmB,CAAC;AAClC,cAAc,wBAAwB,CAAC;AACvC,cAAc,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,CAAC;AAClC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,8BAA8B,CAAC;AAC7C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,oBAAoB,CAAC;AACnC,cAAc,aAAa,CAAC;AAC5B,cAAc,+BAA+B,CAAC;AAC9C,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC;AACtC,cAAc,iBAAiB,CAAC;AAChC,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,EAAE,iBAAiB,EAAE,MAAM,qCAAqC,CAAC;AACxE,OAAO,EAAE,mBAAmB,EAAE,MAAM,uCAAuC,CAAC;AAE5E;;;;;;;;;;;GAWG;AACH,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AAEjE;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,EAAE,oBAAoB,IAAI,0BAA0B,EAAE,MAAM,kCAAkC,CAAC;AACtG,OAAO,EAAE,oBAAoB,IAAI,0BAA0B,EAAE,MAAM,kCAAkC,CAAC;AAGtG,YAAY,EACV,0BAA0B,EAC1B,4BAA4B,EAC5B,4BAA4B,EAC5B,gBAAgB,GACjB,MAAM,iCAAiC,CAAC;AAGzC,YAAY,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAGxD,OAAO,EAAE,qBAAqB,EAAE,wBAAwB,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAChH,OAAO,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAG5D,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC"}

package/dist/plugin/config/index.js

@@ -8,11 +8,11 @@ export { interpolatePattern } from './interpolatePattern.js';
 export { resolvePages } from './resolvePages.js';
 export { resolveUserConfig } from './resolveUserConfig.js';
 export { createDefaultModuleID } from './createModuleID.js';
-export { getCondition, isReactClientCondition, isReactServerCondition } from './getCondition.js';
+export { assertNonReactServer, assertReactServer, condition, detectReactConditionAmbiguity, getAllConditions, getCondition, getCurrentCondition, getNodeOptionsConditions, hasReactClientCondition, hasReactServerCondition, isReactClientCondition, isReactServerCondition, warnIfAmbiguousReactConditions } from './getCondition.js';
 export { MIME_TYPES } from './mimeTypes.js';
 export { resolveDirectiveMatcher } from './resolveDirectiveMatcher.js';
 export { resolvePatternWithValues } from './resolvePatternWithValues.js';
-export { BASE_PATTERNS, DEFAULT_CONFIG, DEFAULT_LOADER_CONFIG, DIRECTIVE_CONFIGS, getDirectiveType } from './defaults.js';
+export { BASE_PATTERNS, CONDITION, DEFAULT_CONFIG, DEFAULT_LOADER_CONFIG, DIRECTIVE_CONFIGS, IS_BUILD, IS_CLIENT, IS_SERVE, IS_SERVER, MODE, getDirectiveType } from './defaults.js';
 export { getMode, getNodePath } from './getPaths.js';
 export { parsePattern } from './parsePattern.js';
 export { createCleanupEnv, getMetaEnv, resolveConfigDefine, resolveEnv } from './resolveEnv.js';
@@ -21,9 +21,14 @@ export { jsExtension, replaceExtension } from './extMap.js';
 export { resolveAllowedDirectives } from './resolveAllowedDirectives.js';
 export { resolveOptions } from './resolveOptions.js';
 export { resolveUrlOption } from './resolveUrlOption.js';
-export { resolveAutoDiscover } from './autoDiscover/resolveAutoDiscover.js';
+export { getNodeEnv, isValidEnv, validEnvs } from './getNodeEnv.js';
 export { resolveBuildPages } from './autoDiscover/resolveBuildPages.js';
+export { resolveAutoDiscover } from './autoDiscover/resolveAutoDiscover.js';
+export { createHandlerOptions } from './createHandlerOptions.js';
+export { createHandlerOptions as createHandlerOptionsServer } from './createHandlerOptions.server.js';
+export { createHandlerOptions as createHandlerOptionsClient } from './createHandlerOptions.client.js';
+export { getEnvironmentId, getStashedHandlerOptions, getStashedUserOptions, stashHandlerOptions } from './stashedOptionsState.js';
 export { customWorkerFiles } from './autoDiscover/customWorkerFiles.js';
 export { pageAndPropFiles } from './autoDiscover/pageAndPropFiles.js';
 export { createGlobAutoDiscover } from './autoDiscover/createGlobAutoDiscover.js';
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==

package/dist/plugin/config/resolveDirectiveMatcher.d.ts

@@ -9,16 +9,16 @@ import type { RegExpOpt } from "../types.js";
  * @example
  * ```ts
  * // String patterns
- * resolveDirectiveMatcher("*.js").test("file.js")     // true
- * resolveDirectiveMatcher("*.{js,ts}").test("file.ts") // true
+ * resolveDirectiveMatcher("*.js")("file.js")     // true
+ * resolveDirectiveMatcher("*.{js,ts}")("file.ts") // true
  *
  * // RegExp patterns
- * resolveDirectiveMatcher(/\.js$/).test("file.js")    // true
- * resolveDirectiveMatcher(/\.js$/i).test("file.JS")   // true
+ * resolveDirectiveMatcher(/\.js$/)("file.js")    // true
+ * resolveDirectiveMatcher(/\.js$/i)("file.JS")   // true
  *
  * // Default patterns
- * resolveDirectiveMatcher(undefined, "*.js").test("file.js")     // true
- * resolveDirectiveMatcher(undefined, /\.js$/).test("file.js")    // true
+ * resolveDirectiveMatcher(undefined, "*.js")("file.js")     // true
+ * resolveDirectiveMatcher(undefined, /\.js$/)("file.js")    // true
  * ```
  */
 export declare function resolveDirectiveMatcher(pattern?: RegExpOpt, defaultPattern?: RegExpOpt | ((source: string, moduleId?: string) => boolean)): (source: string, moduleId?: string) => boolean;

package/dist/plugin/config/resolveDirectiveMatcher.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resolveDirectiveMatcher.d.ts","sourceRoot":"","sources":["../../../plugin/config/resolveDirectiveMatcher.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAsB,MAAM,aAAa,CAAC;AAIjE;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,CAAC,EAAE,SAAS,EACnB,cAAc,GAAE,SAAS,GAAG,CAAC,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,KAAK,OAAO,CAAe,GACzF,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,KAAK,OAAO,CA0BhD"}
+{"version":3,"file":"resolveDirectiveMatcher.d.ts","sourceRoot":"","sources":["../../../plugin/config/resolveDirectiveMatcher.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAG7C;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,CAAC,EAAE,SAAS,EACnB,cAAc,GAAE,SAAS,GAAG,CAAC,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,KAAK,OAAO,CAAe,GACzF,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,KAAK,OAAO,CAMhD"}

package/dist/plugin/config/resolveDirectiveMatcher.js

@@ -3,31 +3,15 @@
  * Copyright (c) Nico Brinkkemper
  * MIT License
  */
-import { parsePattern } from './parsePattern.js';
+import { createPatternMatcher } from '../helpers/createPatternMatcher.js';
 
 function resolveDirectiveMatcher(pattern, defaultPattern = () => false) {
-  if (typeof pattern === "function") {
-    return pattern;
-  } else if (pattern instanceof RegExp) {
-    return (source, _moduleId) => pattern.test(source);
-  } else if (typeof pattern === "string") {
-    const regex = parsePattern(pattern);
-    return (source, _moduleId) => regex.test(source);
-  } else if (typeof pattern === "object" && pattern != null && "__isRegExp" in pattern) {
-    const deserialized = pattern;
-    const regex = new RegExp(deserialized.source, deserialized.flags);
-    return (source, _moduleId) => regex.test(source);
-  } else if (typeof defaultPattern === "function") {
-    return defaultPattern;
-  } else if (defaultPattern instanceof RegExp) {
-    return (source, _moduleId) => defaultPattern.test(source);
-  } else if (typeof defaultPattern === "string") {
-    const regex = parsePattern(defaultPattern);
-    return (source, _moduleId) => regex.test(source);
-  } else {
-    return () => false;
-  }
+  return createPatternMatcher(pattern, defaultPattern, {
+    handleDeserialized: true,
+    fallback: () => false,
+    throwOnInvalid: false
+  });
 }
 
 export { resolveDirectiveMatcher };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/plugin/config/resolveEnv.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resolveEnv.d.ts","sourceRoot":"","sources":["../../../plugin/config/resolveEnv.ts"],"names":[],"mappings":"AAAA,OAAO,EAAW,KAAK,cAAc,EAAE,MAAM,MAAM,CAAC;AAMpD,KAAK,SAAS,GAAG;IACf,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS,CAAC;CACpC,CAAC;AAkBF;;GAEG;AACH,wBAAgB,UAAU,CACxB,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EACd,QAAQ,GAAE,MAAM,GAAG,MAAM,EAA8B,cA+GxD;AAED,wBAAgB,mBAAmB,CACjC,cAAc,EAAE,IAAI,CAAC,cAAc,EAAE,QAAQ,GAAG,WAAW,CAAC,EAC5D,OAAO,UAAQ,cAuBhB;AAED,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,SAAS,cAM9C;AAED,eAAO,MAAM,UAAU,GACrB,uBAAiB,EACjB,WAAU,MAAM,GAAG,MAAM,EAA8B,QAgBtD,CAAC"}
+{"version":3,"file":"resolveEnv.d.ts","sourceRoot":"","sources":["../../../plugin/config/resolveEnv.ts"],"names":[],"mappings":"AAAA,OAAO,EAAW,KAAK,cAAc,EAAE,MAAM,MAAM,CAAC;AAMpD,KAAK,SAAS,GAAG;IACf,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS,CAAC;CACpC,CAAC;AAgBF;;GAEG;AACH,wBAAgB,UAAU,CACxB,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EACd,QAAQ,GAAE,MAAM,GAAG,MAAM,EAA8B,cA4GxD;AAED,wBAAgB,mBAAmB,CACjC,cAAc,EAAE,IAAI,CAAC,cAAc,EAAE,QAAQ,GAAG,WAAW,CAAC,EAC5D,OAAO,UAAQ,cAuBhB;AAED,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,SAAS,cAM9C;AAED,eAAO,MAAM,UAAU,GACrB,uBAAiB,EACjB,WAAU,MAAM,GAAG,MAAM,EAA8B,QAgBtD,CAAC"}

package/dist/plugin/config/resolveEnv.js

@@ -6,15 +6,12 @@
 import { loadEnv } from 'vite';
 import { DEFAULT_CONFIG } from './defaults.js';
 import { getCondition } from './getCondition.js';
-import { getNodeEnv } from '../getNodeEnv.js';
+import { getNodeEnv } from './getNodeEnv.js';
 import { getEnvKey } from '../env/getEnvKey.js';
 
 function setNestedEnv(obj, path, value, verbose = false) {
   if (!path.length) return;
   const key = path[0];
-  if (verbose) {
-    console.log("setNestedEnv:", { key, path, value, currentObj: obj[key] });
-  }
   if (path.length === 1) {
     obj[key] = value;
     return;
@@ -75,7 +72,7 @@ function resolveEnv(mode, envDir, prefixes = DEFAULT_CONFIG.ENV_PREFIX) {
       if (modeValue && !modeValue.startsWith("--")) {
         mergedEnv[modeKey] = modeValue;
       } else {
-        mergedEnv[modeKey] = process.env["NODE_ENV"] === "production" ? "production" : "development";
+        mergedEnv[modeKey] = getNodeEnv();
       }
     }
   }
@@ -145,4 +142,4 @@ const getMetaEnv = (env = process.env, prefixes = DEFAULT_CONFIG.ENV_PREFIX) =>
 );
 
 export { createCleanupEnv, getMetaEnv, resolveConfigDefine, resolveEnv };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"resolveEnv.js","sources":["../../../plugin/config/resolveEnv.ts"],"sourcesContent":["import { loadEnv, type ResolvedConfig } from \"vite\";\nimport { DEFAULT_CONFIG } from \"./defaults.js\";\nimport { getCondition } from \"./getCondition.js\";\nimport { getNodeEnv } from \"../getNodeEnv.js\";\nimport { getEnvKey } from \"../env/getEnvKey.js\";\n\ntype NestedEnv = {\n  [key: string]: unknown | NestedEnv;\n};\n\nfunction setNestedEnv(obj: NestedEnv, path: string[], value: string, verbose = false) {\n  if (!path.length) return;\n  const key = path[0];\n  if (verbose) {\n    console.log(\"setNestedEnv:\", { key, path, value, currentObj: obj[key] });\n  }\n  if (path.length === 1) {\n    obj[key] = value;\n    return;\n  }\n  if (!obj[key] || typeof obj[key] === \"string\") {\n    obj[key] = {};\n  }\n  setNestedEnv(obj[key] as NestedEnv, path.slice(1), value, verbose);\n}\n\n/**\n * Adds the env to the process.env directly, returns a function to remove previously added env.\n */\nexport function resolveEnv(\n  mode: string,\n  envDir: string,\n  prefixes: string | string[] = DEFAULT_CONFIG.ENV_PREFIX\n) {\n  const isPrefixesArray = Array.isArray(prefixes);\n  if (isPrefixesArray && !prefixes.includes(DEFAULT_CONFIG.ENV_PREFIX)) {\n    prefixes.push(DEFAULT_CONFIG.ENV_PREFIX);\n  }\n  const env: Record<string, string | boolean> = loadEnv(mode, envDir, prefixes);\n\n  // Get the primary prefix for environment variable names\n  const primaryPrefix = isPrefixesArray ? prefixes[0] : prefixes;\n\n  // First, copy any existing environment variables that match our prefixes\n  const existingEnv = Object.entries(process.env).reduce(\n    (acc, [key, value]) => {\n      if (\n        value &&\n        (isPrefixesArray\n          ? prefixes.some((p) => key.startsWith(p))\n          : key.startsWith(prefixes))\n      ) {\n        acc[key] = value;\n      }\n      return acc;\n    },\n    {} as Record<string, string>\n  );\n\n  // Merge existing env with loaded env, preferring existing values\n  const mergedEnv = { ...env, ...existingEnv };\n\n  const modeKey = getEnvKey(\"MODE\", primaryPrefix);\n  if (!mergedEnv[modeKey] && process.env[modeKey] == null) {\n    const modeIndex = process.argv.findIndex((arg) => arg === \"--mode\");\n    const isBuild = process.argv.includes(\"build\");\n    const isPreview = process.argv.includes(\"preview\");\n    if (modeIndex === -1) {\n      const inferredMode = isPreview || isBuild ? \"production\" : \"development\";\n      if (\n        inferredMode === \"production\" &&\n        process.env[\"NODE_ENV\"] !== \"production\"\n      ) {\n        console.warn(\n          `NODE_ENV is not ${inferredMode} (${process.env[\"NODE_ENV\"]}) but ${modeKey} is ${inferredMode}, NODE_ENV takes precedence`\n        );\n        mergedEnv[modeKey] = getNodeEnv();\n      } else if (\n        inferredMode === \"development\" &&\n        process.env[\"NODE_ENV\"] !== \"development\"\n      ) {\n        if (process.env[\"NODE_ENV\"] === \"test\") {\n          if (process.env[\"NODE_ENV\"] !== \"test\") {\n            console.warn(\n              `NODE_ENV is not ${inferredMode} (${process.env[\"NODE_ENV\"]}) but ${modeKey} is ${mode}, NODE_ENV takes precedence`\n            );\n          }\n          mergedEnv[modeKey] = \"development\";\n        } else {\n          console.warn(\n            `NODE_ENV is not ${inferredMode} (${process.env[\"NODE_ENV\"]}) but ${modeKey} is ${mode}, NODE_ENV takes precedence`\n          );\n          mergedEnv[modeKey] = getNodeEnv();\n        }\n      } else {\n        mergedEnv[modeKey] = inferredMode;\n      }\n    } else {\n      // Check if the mode value is in the next argument\n      const modeValue = process.argv[modeIndex + 1];\n      if (modeValue && !modeValue.startsWith(\"--\")) {\n        mergedEnv[modeKey] = modeValue;\n      } else {\n        // Fallback to default mode\n        mergedEnv[modeKey] =\n          process.env[\"NODE_ENV\"] === \"production\"\n            ? \"production\"\n            : \"development\";\n      }\n    }\n  }\n\n    const baseUrlKey = getEnvKey(\"BASE_URL\", primaryPrefix);\n  const ssrKey = getEnvKey(\"SSR\", primaryPrefix);\n  const devKey = getEnvKey(\"DEV\", primaryPrefix);\n  const prodKey = getEnvKey(\"PROD\", primaryPrefix);\n  const publicOriginKey = getEnvKey(\"PUBLIC_ORIGIN\", primaryPrefix);\n\n  if (!mergedEnv[baseUrlKey]) mergedEnv[baseUrlKey] = \"/\";\n  if (!mergedEnv[ssrKey])\n    mergedEnv[ssrKey] = String(\n      process.argv.includes(\"--ssr\") || getCondition(\"\") === \"server\"\n    );\n  if (!mergedEnv[devKey]) mergedEnv[devKey] = mergedEnv[modeKey] === \"development\";\n  if (!mergedEnv[prodKey]) mergedEnv[prodKey] = mergedEnv[modeKey] === \"production\";\n  if (!mergedEnv[publicOriginKey]) mergedEnv[publicOriginKey] = \"\";\n\n  if (!Object.keys(mergedEnv).length) return () => {};\n  const addedEnv: NestedEnv = {};\n  const exclude = isPrefixesArray\n    ? (key: string) => !prefixes.some((prefix) => key.startsWith(prefix))\n    : (key: string) => !key.startsWith(prefixes);\n\n  for (const key in mergedEnv) {\n    if (exclude(key)) continue;\n    if (process.env[key] != null) {\n      // Environment variable was already set - don't override it or include it in cleanup\n      continue;\n    }\n    process.env[key] = mergedEnv[key] as string;\n    addedEnv[key] = mergedEnv[key];\n  }\n  return createCleanupEnv(addedEnv);\n}\n\nexport function resolveConfigDefine(\n  resolvedConfig: Pick<ResolvedConfig, \"define\" | \"envPrefix\">,\n  verbose = false\n) {\n  const { define } = resolvedConfig;\n  const addedEnv: NestedEnv = {};\n  const envPrefix = Array.isArray(resolvedConfig.envPrefix)\n    ? resolvedConfig.envPrefix[0]\n    : resolvedConfig.envPrefix;\n  for (const key in define) {\n    if (!key || !key.startsWith(`process.env.${envPrefix}`)) continue;\n    const withoutPrefix = key.split(\"process.env.\")[1];\n    if (typeof define[key] === \"string\") {\n      const path = withoutPrefix.split(\".\");\n      setNestedEnv(addedEnv, path, define[key] as string, verbose);\n      if (!process.env[path[0]]) process.env[path[0]] = {} as never;\n      setNestedEnv(\n        process.env[path[0]] as never,\n        path.slice(1),\n        define[key] as string,\n        verbose\n      );\n    }\n  }\n  return createCleanupEnv(addedEnv);\n}\n\nexport function createCleanupEnv(env: NestedEnv) {\n  return () => {\n    for (const key in env) {\n      delete process.env[key];\n    }\n  };\n}\n\nexport const getMetaEnv = (\n  env = process.env,\n  prefixes: string | string[] = DEFAULT_CONFIG.ENV_PREFIX\n) =>\n  Object.fromEntries(\n    Object.entries(env)\n      .map(([key, value]) => {\n        const prefix = Array.isArray(prefixes)\n          ? prefixes.find((prefix) => key.startsWith(prefix))\n          : key.startsWith(prefixes)\n          ? prefixes\n          : undefined;\n        if (typeof prefix !== \"string\" || prefix === \"\") {\n          return undefined;\n        }\n        return [key.slice(prefix.length), value];\n      })\n      .filter(Array.isArray)\n  );\n"],"names":["prefix"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"resolveEnv.js","sources":["../../../plugin/config/resolveEnv.ts"],"sourcesContent":["import { loadEnv, type ResolvedConfig } from \"vite\";\nimport { DEFAULT_CONFIG } from \"./defaults.js\";\nimport { getCondition } from \"./getCondition.js\";\nimport { getNodeEnv } from \"./getNodeEnv.js\";\nimport { getEnvKey } from \"../env/getEnvKey.js\";\n\ntype NestedEnv = {\n  [key: string]: unknown | NestedEnv;\n};\n\nfunction setNestedEnv(obj: NestedEnv, path: string[], value: string, verbose = false) {\n  if (!path.length) return;\n  const key = path[0];\n\n  if (path.length === 1) {\n    obj[key] = value;\n    return;\n  }\n  if (!obj[key] || typeof obj[key] === \"string\") {\n    obj[key] = {};\n  }\n  setNestedEnv(obj[key] as NestedEnv, path.slice(1), value, verbose);\n}\n\n/**\n * Adds the env to the process.env directly, returns a function to remove previously added env.\n */\nexport function resolveEnv(\n  mode: string,\n  envDir: string,\n  prefixes: string | string[] = DEFAULT_CONFIG.ENV_PREFIX\n) {\n  const isPrefixesArray = Array.isArray(prefixes);\n  if (isPrefixesArray && !prefixes.includes(DEFAULT_CONFIG.ENV_PREFIX)) {\n    prefixes.push(DEFAULT_CONFIG.ENV_PREFIX);\n  }\n  const env: Record<string, string | boolean> = loadEnv(mode, envDir, prefixes);\n\n  // Get the primary prefix for environment variable names\n  const primaryPrefix = isPrefixesArray ? prefixes[0] : prefixes;\n\n  // First, copy any existing environment variables that match our prefixes\n  const existingEnv = Object.entries(process.env).reduce(\n    (acc, [key, value]) => {\n      if (\n        value &&\n        (isPrefixesArray\n          ? prefixes.some((p) => key.startsWith(p))\n          : key.startsWith(prefixes))\n      ) {\n        acc[key] = value;\n      }\n      return acc;\n    },\n    {} as Record<string, string>\n  );\n\n  // Merge existing env with loaded env, preferring existing values\n  const mergedEnv = { ...env, ...existingEnv };\n\n  const modeKey = getEnvKey(\"MODE\", primaryPrefix);\n  if (!mergedEnv[modeKey] && process.env[modeKey] == null) {\n    const modeIndex = process.argv.findIndex((arg) => arg === \"--mode\");\n    const isBuild = process.argv.includes(\"build\");\n    const isPreview = process.argv.includes(\"preview\");\n    if (modeIndex === -1) {\n      const inferredMode = isPreview || isBuild ? \"production\" : \"development\";\n      if (\n        inferredMode === \"production\" &&\n        process.env[\"NODE_ENV\"] !== \"production\"\n      ) {\n        console.warn(\n          `NODE_ENV is not ${inferredMode} (${process.env[\"NODE_ENV\"]}) but ${modeKey} is ${inferredMode}, NODE_ENV takes precedence`\n        );\n        mergedEnv[modeKey] = getNodeEnv();\n      } else if (\n        inferredMode === \"development\" &&\n        process.env[\"NODE_ENV\"] !== \"development\"\n      ) {\n        if (process.env[\"NODE_ENV\"] === \"test\") {\n          if (process.env[\"NODE_ENV\"] !== \"test\") {\n            console.warn(\n              `NODE_ENV is not ${inferredMode} (${process.env[\"NODE_ENV\"]}) but ${modeKey} is ${mode}, NODE_ENV takes precedence`\n            );\n          }\n          mergedEnv[modeKey] = \"development\";\n        } else {\n          console.warn(\n            `NODE_ENV is not ${inferredMode} (${process.env[\"NODE_ENV\"]}) but ${modeKey} is ${mode}, NODE_ENV takes precedence`\n          );\n          mergedEnv[modeKey] = getNodeEnv();\n        }\n      } else {\n        mergedEnv[modeKey] = inferredMode;\n      }\n    } else {\n      // Check if the mode value is in the next argument\n      const modeValue = process.argv[modeIndex + 1];\n      if (modeValue && !modeValue.startsWith(\"--\")) {\n        mergedEnv[modeKey] = modeValue;\n      } else {\n        // Fallback to default mode\n        mergedEnv[modeKey] = getNodeEnv();\n      }\n    }\n  }\n\n    const baseUrlKey = getEnvKey(\"BASE_URL\", primaryPrefix);\n  const ssrKey = getEnvKey(\"SSR\", primaryPrefix);\n  const devKey = getEnvKey(\"DEV\", primaryPrefix);\n  const prodKey = getEnvKey(\"PROD\", primaryPrefix);\n  const publicOriginKey = getEnvKey(\"PUBLIC_ORIGIN\", primaryPrefix);\n\n  if (!mergedEnv[baseUrlKey]) mergedEnv[baseUrlKey] = \"/\";\n  if (!mergedEnv[ssrKey])\n    mergedEnv[ssrKey] = String(\n      process.argv.includes(\"--ssr\") || getCondition(\"\") === \"server\"\n    );\n  if (!mergedEnv[devKey]) mergedEnv[devKey] = mergedEnv[modeKey] === \"development\";\n  if (!mergedEnv[prodKey]) mergedEnv[prodKey] = mergedEnv[modeKey] === \"production\";\n  if (!mergedEnv[publicOriginKey]) mergedEnv[publicOriginKey] = \"\";\n\n  if (!Object.keys(mergedEnv).length) return () => {};\n  const addedEnv: NestedEnv = {};\n  const exclude = isPrefixesArray\n    ? (key: string) => !prefixes.some((prefix) => key.startsWith(prefix))\n    : (key: string) => !key.startsWith(prefixes);\n\n  for (const key in mergedEnv) {\n    if (exclude(key)) continue;\n    if (process.env[key] != null) {\n      // Environment variable was already set - don't override it or include it in cleanup\n      continue;\n    }\n    process.env[key] = mergedEnv[key] as string;\n    addedEnv[key] = mergedEnv[key];\n  }\n  return createCleanupEnv(addedEnv);\n}\n\nexport function resolveConfigDefine(\n  resolvedConfig: Pick<ResolvedConfig, \"define\" | \"envPrefix\">,\n  verbose = false\n) {\n  const { define } = resolvedConfig;\n  const addedEnv: NestedEnv = {};\n  const envPrefix = Array.isArray(resolvedConfig.envPrefix)\n    ? resolvedConfig.envPrefix[0]\n    : resolvedConfig.envPrefix;\n  for (const key in define) {\n    if (!key || !key.startsWith(`process.env.${envPrefix}`)) continue;\n    const withoutPrefix = key.split(\"process.env.\")[1];\n    if (typeof define[key] === \"string\") {\n      const path = withoutPrefix.split(\".\");\n      setNestedEnv(addedEnv, path, define[key] as string, verbose);\n      if (!process.env[path[0]]) process.env[path[0]] = {} as never;\n      setNestedEnv(\n        process.env[path[0]] as never,\n        path.slice(1),\n        define[key] as string,\n        verbose\n      );\n    }\n  }\n  return createCleanupEnv(addedEnv);\n}\n\nexport function createCleanupEnv(env: NestedEnv) {\n  return () => {\n    for (const key in env) {\n      delete process.env[key];\n    }\n  };\n}\n\nexport const getMetaEnv = (\n  env = process.env,\n  prefixes: string | string[] = DEFAULT_CONFIG.ENV_PREFIX\n) =>\n  Object.fromEntries(\n    Object.entries(env)\n      .map(([key, value]) => {\n        const prefix = Array.isArray(prefixes)\n          ? prefixes.find((prefix) => key.startsWith(prefix))\n          : key.startsWith(prefixes)\n          ? prefixes\n          : undefined;\n        if (typeof prefix !== \"string\" || prefix === \"\") {\n          return undefined;\n        }\n        return [key.slice(prefix.length), value];\n      })\n      .filter(Array.isArray)\n  );\n"],"names":["prefix"],"mappings":"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"}

package/dist/plugin/config/resolveOptions.d.ts

@@ -1,14 +1,15 @@
 import type { StreamPluginOptions, ResolvedUserOptions } from "../types.js";
+import { type Logger } from "vite";
 export type ResolveOptionsReturn = {
     type: "success";
     userOptions: ResolvedUserOptions;
     error?: never;
 } | {
     type: "error";
-    error: Error;
+    error: unknown;
     userOptions?: never;
 };
-export type ResolveOptionsFn = (options: StreamPluginOptions) => ResolveOptionsReturn;
+export type ResolveOptionsFn = (options: StreamPluginOptions, forceResolve?: boolean, logger?: Logger) => ResolveOptionsReturn;
 /**
  * Resolves the user options for the plugin.
  *