@cloudflare/workers-utils 0.35.0 → 0.37.0

package/dist/local-env.d.mts

@@ -0,0 +1,54 @@
+type LocalEnvValueSource = {
+    type: "file";
+    path: string;
+} | {
+    type: "process";
+};
+interface LoadedEnv {
+    values: Record<string, string>;
+    sources: Record<string, LocalEnvValueSource>;
+}
+/**
+ * Returns the local `.env` candidates in increasing precedence order.
+ *
+ * @param envDir The resolved environment directory. `false` disables file
+ * loading, matching Vite's `envDir` convention.
+ * @param mode The optional mode used for mode-specific files.
+ * @returns Absolute candidate paths in load order.
+ */
+declare function getEnvPaths(envDir: string | false, mode?: string): string[];
+/**
+ * Returns the `.dev.vars` candidates in decreasing selection priority.
+ *
+ * @param envDir The resolved environment directory. `false` disables file
+ * loading, matching Vite's `envDir` convention.
+ * @param mode The optional mode used to select `.dev.vars.<mode>`.
+ * @returns Absolute candidate paths in selection order.
+ */
+declare function getDevVarsCandidatePaths(envDir: string | false, mode?: string): string[];
+/**
+ * Loads local `.env` files using Vite-compatible file precedence and
+ * Wrangler-compatible parsing and expansion.
+ *
+ * Expansion is progressive: references can use process values and values
+ * declared earlier in the merged environment, but not values declared later.
+ * Loading has no process-global side effects.
+ *
+ * @param envDir The resolved environment directory. `false` disables file
+ * loading, matching Vite's `envDir` convention.
+ * @param mode The optional mode used for mode-specific files.
+ * @returns Resolved values and metadata describing their sources.
+ */
+declare function loadEnv(envDir: string | false, mode?: string): Promise<LoadedEnv>;
+/**
+ * Loads the first existing `.dev.vars` candidate without merging it with other
+ * files or process-environment values.
+ *
+ * @param envDir The resolved environment directory. `false` disables file
+ * loading, matching Vite's `envDir` convention.
+ * @param mode The optional mode used to select `.dev.vars.<mode>`.
+ * @returns The selected `.dev.vars` values, or `undefined` when no candidate exists.
+ */
+declare function loadDevVars(envDir: string | false, mode?: string): Promise<Record<string, string> | undefined>;
+
+export { type LoadedEnv, type LocalEnvValueSource, getDevVarsCandidatePaths, getEnvPaths, loadDevVars, loadEnv };

package/dist/local-env.mjs

@@ -0,0 +1,176 @@
+import { __commonJS, __name, __toESM } from './chunk-Q72B4Q5Z.mjs';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { parse } from 'dotenv';
+
+// ../../node_modules/.pnpm/dotenv-expand@13.0.0/node_modules/dotenv-expand/lib/main.js
+var require_main = __commonJS({
+  "../../node_modules/.pnpm/dotenv-expand@13.0.0/node_modules/dotenv-expand/lib/main.js"(exports$1, module) {
+    function _resolveEscapeSequences(value) {
+      return value.replace(/\\\$/g, "$");
+    }
+    __name(_resolveEscapeSequences, "_resolveEscapeSequences");
+    function expandValue(value, processEnv, runningParsed) {
+      const env = { ...runningParsed, ...processEnv };
+      const regex = /(?<!\\)\${([^{}]+)}|(?<!\\)\$([A-Za-z_][A-Za-z0-9_]*)/g;
+      let result = value;
+      let match;
+      const seen = /* @__PURE__ */ new Set();
+      while ((match = regex.exec(result)) !== null) {
+        seen.add(result);
+        const [template, bracedExpression, unbracedExpression] = match;
+        const expression = bracedExpression || unbracedExpression;
+        const opRegex = /(:\+|\+|:-|-)/;
+        const opMatch = expression.match(opRegex);
+        const splitter = opMatch ? opMatch[0] : null;
+        const r = expression.split(splitter);
+        let defaultValue;
+        let value2;
+        const key = r.shift();
+        if ([":+", "+"].includes(splitter)) {
+          defaultValue = env[key] ? r.join(splitter) : "";
+          value2 = null;
+        } else {
+          defaultValue = r.join(splitter);
+          value2 = env[key];
+        }
+        if (value2) {
+          if (seen.has(value2)) {
+            result = result.replace(template, defaultValue);
+          } else {
+            result = result.replace(template, value2);
+          }
+        } else {
+          result = result.replace(template, defaultValue);
+        }
+        if (result === runningParsed[key]) {
+          break;
+        }
+        regex.lastIndex = 0;
+      }
+      return result;
+    }
+    __name(expandValue, "expandValue");
+    function expand2(options) {
+      const runningParsed = {};
+      let processEnv = process.env;
+      if (options && options.processEnv != null) {
+        processEnv = options.processEnv;
+      }
+      for (const key in options.parsed) {
+        let value = options.parsed[key];
+        if (processEnv[key] && processEnv[key] !== value) {
+          value = processEnv[key];
+        } else {
+          value = expandValue(value, processEnv, runningParsed);
+        }
+        options.parsed[key] = _resolveEscapeSequences(value);
+        runningParsed[key] = _resolveEscapeSequences(value);
+      }
+      for (const processKey in options.parsed) {
+        processEnv[processKey] = options.parsed[processKey];
+      }
+      return options;
+    }
+    __name(expand2, "expand");
+    module.exports.expand = expand2;
+  }
+});
+
+// src/local-env.ts
+var import_dotenv_expand = __toESM(require_main());
+function getEnvPaths(envDir, mode) {
+  if (envDir === false) {
+    return [];
+  }
+  const filenames = [
+    ".env",
+    ".env.local",
+    ...mode === void 0 ? [] : [`.env.${mode}`, `.env.${mode}.local`]
+  ];
+  return filenames.map((filename) => path.resolve(envDir, filename));
+}
+__name(getEnvPaths, "getEnvPaths");
+function getDevVarsCandidatePaths(envDir, mode) {
+  if (envDir === false) {
+    return [];
+  }
+  return [
+    ...mode === void 0 ? [] : [`.dev.vars.${mode}`],
+    ".dev.vars"
+  ].map((filename) => path.resolve(envDir, filename));
+}
+__name(getDevVarsCandidatePaths, "getDevVarsCandidatePaths");
+async function loadEnv(envDir, mode) {
+  if (mode === "local") {
+    throw new Error(
+      '"local" cannot be used as a mode name because it conflicts with the .local postfix for .env files.'
+    );
+  }
+  const candidateFiles = getEnvPaths(envDir, mode);
+  const parsed = {};
+  const parsedSources = {};
+  for (const candidate of candidateFiles) {
+    const loaded = await tryParseFile(candidate, parse);
+    if (loaded === void 0) {
+      continue;
+    }
+    for (const [key, value] of Object.entries(loaded.values)) {
+      parsed[key] = value;
+      parsedSources[key] = { type: "file", path: loaded.path };
+    }
+  }
+  const processEnv = copyProcessEnv();
+  (0, import_dotenv_expand.expand)({ parsed, processEnv: { ...processEnv } });
+  const values = { ...parsed };
+  const sources = { ...parsedSources };
+  for (const [key, value] of Object.entries(processEnv)) {
+    values[key] = value;
+    sources[key] = { type: "process" };
+  }
+  return { values, sources };
+}
+__name(loadEnv, "loadEnv");
+async function loadDevVars(envDir, mode) {
+  const candidateFiles = getDevVarsCandidatePaths(envDir, mode);
+  for (const candidate of candidateFiles) {
+    const loaded = await tryParseFile(candidate, parse);
+    if (loaded === void 0) {
+      continue;
+    }
+    return loaded.values;
+  }
+}
+__name(loadDevVars, "loadDevVars");
+async function tryParseFile(filePath, parse) {
+  try {
+    const stat2 = await fs.stat(filePath);
+    if (!stat2.isFile() && !stat2.isFIFO()) {
+      return;
+    }
+    return {
+      path: filePath,
+      values: parse(await fs.readFile(filePath, "utf8"))
+    };
+  } catch (error) {
+    if (isMissingFileError(error)) {
+      return;
+    }
+    throw error;
+  }
+}
+__name(tryParseFile, "tryParseFile");
+function isMissingFileError(error) {
+  return error instanceof Error && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR");
+}
+__name(isMissingFileError, "isMissingFileError");
+function copyProcessEnv() {
+  return Object.fromEntries(
+    Object.entries(process.env).filter(
+      (entry) => entry[1] !== void 0
+    )
+  );
+}
+__name(copyProcessEnv, "copyProcessEnv");
+
+export { getDevVarsCandidatePaths, getEnvPaths, loadDevVars, loadEnv };