ultraenv 1.0.0

package/dist/chunk-3VYXPTYV.js

@@ -0,0 +1,179 @@
+import {
+  FileSystemError
+} from "./chunk-5G2DU52U.js";
+
+// src/utils/fs.ts
+import { promises as fsp, existsSync, readFileSync as fsReadFileSync } from "fs";
+import { join, dirname, resolve, relative } from "path";
+async function readFile(filePath, encoding = "utf-8") {
+  try {
+    return await fsp.readFile(filePath, { encoding });
+  } catch (error) {
+    throw new FileSystemError(`Failed to read file "${filePath}"`, {
+      path: filePath,
+      operation: "read",
+      cause: error instanceof Error ? error : void 0
+    });
+  }
+}
+function readFileSync(filePath, encoding = "utf-8") {
+  try {
+    return fsReadFileSync(filePath, { encoding });
+  } catch (error) {
+    throw new FileSystemError(`Failed to read file "${filePath}"`, {
+      path: filePath,
+      operation: "read",
+      cause: error instanceof Error ? error : void 0
+    });
+  }
+}
+async function writeFile(filePath, content, encoding = "utf-8") {
+  try {
+    await ensureDir(dirname(filePath));
+    await fsp.writeFile(filePath, content, { encoding });
+  } catch (error) {
+    throw new FileSystemError(`Failed to write file "${filePath}"`, {
+      path: filePath,
+      operation: "write",
+      cause: error instanceof Error ? error : void 0
+    });
+  }
+}
+async function exists(filePath) {
+  try {
+    await fsp.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function existsSyncCheck(filePath) {
+  return existsSync(filePath);
+}
+async function isFile(filePath) {
+  try {
+    const stat = await fsp.stat(filePath);
+    return stat.isFile();
+  } catch {
+    return false;
+  }
+}
+async function isDirectory(dirPath) {
+  try {
+    const stat = await fsp.stat(dirPath);
+    return stat.isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function ensureDir(dirPath) {
+  try {
+    await fsp.mkdir(dirPath, { recursive: true });
+  } catch (error) {
+    if (error.code !== "EEXIST") {
+      throw new FileSystemError(`Failed to create directory "${dirPath}"`, {
+        path: dirPath,
+        operation: "mkdir",
+        cause: error instanceof Error ? error : void 0
+      });
+    }
+  }
+}
+async function removeFile(filePath) {
+  try {
+    await fsp.unlink(filePath);
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      throw new FileSystemError(`Failed to remove file "${filePath}"`, {
+        path: filePath,
+        operation: "unlink",
+        cause: error instanceof Error ? error : void 0
+      });
+    }
+  }
+}
+async function copyFile(src, dest) {
+  try {
+    await ensureDir(dirname(dest));
+    await fsp.copyFile(src, dest);
+  } catch (error) {
+    throw new FileSystemError(`Failed to copy "${src}" to "${dest}"`, {
+      path: src,
+      operation: "copy",
+      cause: error instanceof Error ? error : void 0
+    });
+  }
+}
+async function listFiles(dirPath, recursive = false) {
+  const results = [];
+  async function walk(currentDir) {
+    let entries;
+    try {
+      entries = await fsp.readdir(currentDir, { withFileTypes: true });
+    } catch (error) {
+      throw new FileSystemError(`Failed to list directory "${currentDir}"`, {
+        path: currentDir,
+        operation: "readdir",
+        cause: error instanceof Error ? error : void 0
+      });
+    }
+    for (const entry of entries) {
+      const fullPath = join(currentDir, entry.name);
+      if (entry.isFile()) {
+        results.push(relative(dirPath, fullPath));
+      } else if (entry.isDirectory() && recursive && !entry.name.startsWith(".") && entry.name !== "node_modules") {
+        await walk(fullPath);
+      }
+    }
+  }
+  await walk(dirPath);
+  return results;
+}
+async function findUp(name, cwd) {
+  let current = resolve(cwd ?? process.cwd());
+  const root = resolve("/");
+  while (current !== root && current !== dirname(current)) {
+    const candidate = join(current, name);
+    if (await exists(candidate)) {
+      return candidate;
+    }
+    current = dirname(current);
+  }
+  const rootCandidate = join(root, name);
+  if (await exists(rootCandidate)) {
+    return rootCandidate;
+  }
+  return null;
+}
+function findUpSync(name, cwd) {
+  let current = resolve(cwd ?? process.cwd());
+  const root = resolve("/");
+  while (current !== root && current !== dirname(current)) {
+    const candidate = join(current, name);
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+    current = dirname(current);
+  }
+  const rootCandidate = join(root, name);
+  if (existsSync(rootCandidate)) {
+    return rootCandidate;
+  }
+  return null;
+}
+
+export {
+  readFile,
+  readFileSync,
+  writeFile,
+  exists,
+  existsSyncCheck,
+  isFile,
+  isDirectory,
+  ensureDir,
+  removeFile,
+  copyFile,
+  listFiles,
+  findUp,
+  findUpSync
+};

package/dist/chunk-4XUYMRK5.js

@@ -0,0 +1,366 @@
+import {
+  findUpSync
+} from "./chunk-3VYXPTYV.js";
+import {
+  DEFAULT_ENV_DIR,
+  ENCODING,
+  MAX_INTERPOLATION_DEPTH,
+  MAX_VALUE_LENGTH
+} from "./chunk-XC65ORJ5.js";
+import {
+  ConfigError
+} from "./chunk-5G2DU52U.js";
+
+// src/core/config.ts
+import { existsSync, readFileSync } from "fs";
+import { resolve } from "path";
+var CONFIG_FILE_NAMES = [
+  ".ultraenvrc.json",
+  ".ultraenvrc.yaml",
+  ".ultraenvrc.yml",
+  "ultraenv.config.js",
+  "ultraenv.config.cjs"
+];
+var DEFAULT_CONFIG = {
+  envDir: DEFAULT_ENV_DIR,
+  files: [],
+  encoding: ENCODING,
+  expandVariables: true,
+  overrideProcessEnv: false,
+  mergeStrategy: "last-wins",
+  prefixErrors: true,
+  silent: false,
+  outputFormat: "terminal",
+  debug: false,
+  maxValueLength: MAX_VALUE_LENGTH,
+  maxInterpolationDepth: MAX_INTERPOLATION_DEPTH
+};
+function findConfig(cwd) {
+  const startDir = resolve(cwd ?? process.cwd());
+  for (const fileName of CONFIG_FILE_NAMES) {
+    const found = findUpSync(fileName, startDir);
+    if (found !== null) {
+      return found;
+    }
+  }
+  const pkgJson = findUpSync("package.json", startDir);
+  if (pkgJson !== null) {
+    try {
+      const content = readFileSync(pkgJson, "utf-8");
+      const pkg = JSON.parse(content);
+      if (pkg.ultraenv !== void 0 && pkg.ultraenv !== null && typeof pkg.ultraenv === "object") {
+        return pkgJson;
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+function loadConfig(configPath) {
+  const resolvedPath = configPath ?? findConfig();
+  if (resolvedPath === null) {
+    return { ...DEFAULT_CONFIG };
+  }
+  const baseName = resolvedPath.split("/").pop() ?? resolvedPath;
+  const ext = getExtension(baseName);
+  let rawConfig;
+  if (baseName === "package.json") {
+    rawConfig = loadFromPackageJson(resolvedPath);
+  } else if (ext === ".json") {
+    rawConfig = loadFromJson(resolvedPath);
+  } else if (ext === ".yaml" || ext === ".yml") {
+    rawConfig = loadFromYaml(resolvedPath);
+  } else if (ext === ".js" || ext === ".cjs") {
+    rawConfig = loadFromJs(resolvedPath);
+  } else {
+    return { ...DEFAULT_CONFIG };
+  }
+  return normalizeConfig(rawConfig, resolvedPath);
+}
+function loadFromJson(filePath) {
+  try {
+    const content = readFileSync(filePath, "utf-8");
+    return JSON.parse(content);
+  } catch (error) {
+    throw new ConfigError(`Failed to parse JSON config file "${filePath}"`, {
+      field: "config",
+      cause: error instanceof Error ? error : void 0,
+      hint: "Ensure the JSON file is valid. Check for trailing commas or missing quotes."
+    });
+  }
+}
+function loadFromYaml(filePath) {
+  try {
+    const content = readFileSync(filePath, "utf-8");
+    return parseSimpleYaml(content);
+  } catch (error) {
+    if (error instanceof ConfigError) throw error;
+    throw new ConfigError(`Failed to parse YAML config file "${filePath}"`, {
+      field: "config",
+      cause: error instanceof Error ? error : void 0,
+      hint: "Ensure the YAML file is valid. For advanced YAML features, consider using JSON format instead."
+    });
+  }
+}
+function loadFromJs(filePath) {
+  try {
+    const content = readFileSync(filePath, "utf-8");
+    if (filePath.endsWith(".cjs")) {
+      const moduleExports2 = {};
+      const factory2 = new Function("module", "exports", content);
+      factory2(moduleExports2, moduleExports2);
+      return moduleExports2.exports ?? moduleExports2;
+    }
+    const moduleExports = {};
+    const factory = new Function("module", "exports", content);
+    factory(moduleExports, moduleExports);
+    return moduleExports.exports ?? moduleExports;
+  } catch (error) {
+    throw new ConfigError(`Failed to load JS config file "${filePath}"`, {
+      field: "config",
+      cause: error instanceof Error ? error : void 0,
+      hint: "Ensure the JS file exports a configuration object. Use module.exports = { ... } for CommonJS."
+    });
+  }
+}
+function loadFromPackageJson(filePath) {
+  try {
+    const content = readFileSync(filePath, "utf-8");
+    const pkg = JSON.parse(content);
+    const ultraenv = pkg.ultraenv;
+    if (ultraenv === void 0 || ultraenv === null || typeof ultraenv !== "object") {
+      throw new ConfigError(`"ultraenv" key in package.json is not an object`, {
+        field: "ultraenv",
+        hint: 'Add an "ultraenv" key with your configuration to package.json.'
+      });
+    }
+    return ultraenv;
+  } catch (error) {
+    if (error instanceof ConfigError) throw error;
+    throw new ConfigError(`Failed to parse package.json "${filePath}"`, {
+      field: "config",
+      cause: error instanceof Error ? error : void 0
+    });
+  }
+}
+function normalizeConfig(raw, filePath) {
+  const config = { ...DEFAULT_CONFIG };
+  if (raw.envDir !== void 0 && typeof raw.envDir === "string") {
+    config.envDir = raw.envDir;
+    if (!isValidDirectory(config.envDir)) {
+      throw new ConfigError(`Invalid envDir: "${config.envDir}"`, {
+        field: "envDir",
+        hint: "envDir must be a valid directory path."
+      });
+    }
+  }
+  if (raw.files !== void 0 && Array.isArray(raw.files)) {
+    const validFiles = [];
+    for (const f of raw.files) {
+      if (typeof f === "string" && isValidEnvFile(f)) {
+        validFiles.push(f);
+      } else {
+        throw new ConfigError(`Invalid file type "${String(f)}" in files array`, {
+          field: "files",
+          hint: 'Each entry must be a valid .env file variant (e.g., ".env", ".env.local", ".env.production").'
+        });
+      }
+    }
+    config.files = validFiles;
+  }
+  if (raw.encoding !== void 0 && typeof raw.encoding === "string") {
+    config.encoding = raw.encoding;
+    if (!isValidEncoding(config.encoding)) {
+      throw new ConfigError(`Invalid encoding: "${config.encoding}"`, {
+        field: "encoding",
+        hint: "Supported encodings: utf-8, utf-16le, utf-16be, ascii, latin1, binary."
+      });
+    }
+  }
+  if (raw.expandVariables !== void 0) {
+    config.expandVariables = Boolean(raw.expandVariables);
+  }
+  if (raw.overrideProcessEnv !== void 0) {
+    config.overrideProcessEnv = Boolean(raw.overrideProcessEnv);
+  }
+  if (raw.mergeStrategy !== void 0 && typeof raw.mergeStrategy === "string") {
+    const validStrategies = ["first-wins", "last-wins", "error-on-conflict"];
+    if (validStrategies.includes(raw.mergeStrategy)) {
+      config.mergeStrategy = raw.mergeStrategy;
+    } else {
+      throw new ConfigError(`Invalid mergeStrategy: "${raw.mergeStrategy}"`, {
+        field: "mergeStrategy",
+        hint: 'Must be one of: "first-wins", "last-wins", "error-on-conflict".'
+      });
+    }
+  }
+  if (raw.prefixErrors !== void 0) {
+    config.prefixErrors = Boolean(raw.prefixErrors);
+  }
+  if (raw.silent !== void 0) {
+    config.silent = Boolean(raw.silent);
+  }
+  if (raw.outputFormat !== void 0 && typeof raw.outputFormat === "string") {
+    const validFormats = ["terminal", "json", "silent"];
+    if (validFormats.includes(raw.outputFormat)) {
+      config.outputFormat = raw.outputFormat;
+    } else {
+      throw new ConfigError(`Invalid outputFormat: "${raw.outputFormat}"`, {
+        field: "outputFormat",
+        hint: 'Must be one of: "terminal", "json", "silent".'
+      });
+    }
+  }
+  if (raw.debug !== void 0) {
+    config.debug = Boolean(raw.debug);
+  }
+  if (raw.maxValueLength !== void 0 && typeof raw.maxValueLength === "number") {
+    if (raw.maxValueLength > 0 && Number.isFinite(raw.maxValueLength)) {
+      config.maxValueLength = raw.maxValueLength;
+    } else {
+      throw new ConfigError(`Invalid maxValueLength: ${raw.maxValueLength}`, {
+        field: "maxValueLength",
+        hint: "maxValueLength must be a positive finite number."
+      });
+    }
+  }
+  if (raw.maxInterpolationDepth !== void 0 && typeof raw.maxInterpolationDepth === "number") {
+    if (raw.maxInterpolationDepth > 0 && Number.isInteger(raw.maxInterpolationDepth)) {
+      config.maxInterpolationDepth = raw.maxInterpolationDepth;
+    } else {
+      throw new ConfigError(`Invalid maxInterpolationDepth: ${raw.maxInterpolationDepth}`, {
+        field: "maxInterpolationDepth",
+        hint: "maxInterpolationDepth must be a positive integer."
+      });
+    }
+  }
+  if (raw.schema !== void 0) {
+    config.schema = raw.schema;
+  }
+  if (raw.vault !== void 0) {
+    config.vault = raw.vault;
+  }
+  if (raw.watch !== void 0) {
+    config.watch = raw.watch;
+  }
+  if (raw.scan !== void 0) {
+    config.scan = raw.scan;
+  }
+  if (filePath && config.envDir) {
+    const configDir = resolve(filePath, "..");
+    const resolvedDir = resolve(configDir, config.envDir);
+    if (existsSync(resolvedDir)) {
+      config.envDir = resolvedDir;
+    }
+  }
+  return config;
+}
+function parseSimpleYaml(content) {
+  const result = {};
+  const lines = content.split("\n");
+  const stack = [{ obj: result, indent: -1 }];
+  for (const rawLine of lines) {
+    const trimmed = rawLine.trimStart();
+    const indent = rawLine.length - trimmed.length;
+    if (trimmed === "" || trimmed.startsWith("#")) continue;
+    while (stack.length > 1 && stack[stack.length - 1].indent >= indent) {
+      stack.pop();
+    }
+    const parent = stack[stack.length - 1];
+    const colonIdx = trimmed.indexOf(":");
+    if (colonIdx === -1) continue;
+    const key = trimmed.slice(0, colonIdx).trim();
+    const afterColon = trimmed.slice(colonIdx + 1).trim();
+    if (afterColon === "" || afterColon.startsWith("#")) {
+      const newObj = {};
+      parent.obj[key] = newObj;
+      stack.push({ obj: newObj, indent });
+    } else if (afterColon.startsWith("[")) {
+      const arrayMatch = afterColon.match(/^\[(.*)\]$/s);
+      if (arrayMatch !== null) {
+        parent.obj[key] = parseYamlInlineArray(arrayMatch[1]);
+      } else {
+        parent.obj[key] = afterColon;
+      }
+    } else if (afterColon.startsWith("{")) {
+      parent.obj[key] = parseYamlInlineObject(afterColon);
+    } else if (afterColon.startsWith("|") || afterColon.startsWith(">")) {
+      parent.obj[key] = "";
+    } else {
+      parent.obj[key] = parseYamlScalar(afterColon);
+    }
+  }
+  return result;
+}
+function parseYamlScalar(value) {
+  const commentIdx = value.indexOf(" #");
+  const cleanValue = commentIdx >= 0 ? value.slice(0, commentIdx).trim() : value.trim();
+  if (cleanValue === "") return "";
+  if (cleanValue === "true" || cleanValue === "True" || cleanValue === "TRUE") return true;
+  if (cleanValue === "false" || cleanValue === "False" || cleanValue === "FALSE") return false;
+  if (cleanValue === "null" || cleanValue === "Null" || cleanValue === "NULL" || cleanValue === "~") return null;
+  if (/^-?\d+$/.test(cleanValue)) return parseInt(cleanValue, 10);
+  if (/^-?\d+\.\d+$/.test(cleanValue)) return parseFloat(cleanValue);
+  if (cleanValue.startsWith('"') && cleanValue.endsWith('"') || cleanValue.startsWith("'") && cleanValue.endsWith("'")) {
+    return cleanValue.slice(1, -1);
+  }
+  return cleanValue;
+}
+function parseYamlInlineArray(content) {
+  const trimmed = content.trim();
+  if (trimmed === "") return [];
+  return trimmed.split(",").map((s) => s.trim().replace(/^['"]|['"]$/g, ""));
+}
+function parseYamlInlineObject(content) {
+  const obj = {};
+  const trimmed = content.trim().replace(/^\{|\}$/g, "");
+  if (trimmed === "") return obj;
+  const pairs = splitYamlObjectPairs(trimmed);
+  for (const pair of pairs) {
+    const colonIdx = pair.indexOf(":");
+    if (colonIdx === -1) continue;
+    const key = pair.slice(0, colonIdx).trim();
+    const value = pair.slice(colonIdx + 1).trim();
+    obj[key] = parseYamlScalar(value);
+  }
+  return obj;
+}
+function splitYamlObjectPairs(content) {
+  const pairs = [];
+  let depth = 0;
+  let current = "";
+  for (let i = 0; i < content.length; i++) {
+    const ch = content[i];
+    if (ch === "{" || ch === "[") depth++;
+    else if (ch === "}" || ch === "]") depth--;
+    if (ch === "," && depth === 0) {
+      pairs.push(current.trim());
+      current = "";
+    } else {
+      current += ch;
+    }
+  }
+  if (current.trim()) pairs.push(current.trim());
+  return pairs;
+}
+function getExtension(fileName) {
+  const dotIdx = fileName.lastIndexOf(".");
+  if (dotIdx === -1) return "";
+  return fileName.slice(dotIdx).toLowerCase();
+}
+function isValidDirectory(dir) {
+  return typeof dir === "string" && dir.length > 0;
+}
+function isValidEnvFile(file) {
+  return typeof file === "string" && file.startsWith(".env");
+}
+function isValidEncoding(encoding) {
+  const supported = ["utf-8", "utf-16le", "utf-16be", "ascii", "latin1", "binary", "ucs2", "utf8"];
+  return supported.includes(encoding.toLowerCase());
+}
+
+export {
+  DEFAULT_CONFIG,
+  findConfig,
+  loadConfig
+};