@storm-software/config-tools 1.119.0 → 1.130.2

package/dist/chunk-JDK3PXQR.js

@@ -0,0 +1,545 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkOXK45X3Ljs = require('./chunk-OXK45X3L.js');
+
+
+var _chunk6SJLAEJ3js = require('./chunk-6SJLAEJ3.js');
+
+
+var _chunkH6XXDZ7Ajs = require('./chunk-H6XXDZ7A.js');
+
+
+
+var _chunkXJEQHMOEjs = require('./chunk-XJEQHMOE.js');
+
+// src/config-file/get-config-file.ts
+_chunkXJEQHMOEjs.init_cjs_shims.call(void 0, );
+
+// ../../node_modules/.pnpm/c12@2.0.1/node_modules/c12/dist/index.mjs
+_chunkXJEQHMOEjs.init_cjs_shims.call(void 0, );
+
+// ../../node_modules/.pnpm/c12@2.0.1/node_modules/c12/dist/shared/c12.B4fc1S0C.mjs
+_chunkXJEQHMOEjs.init_cjs_shims.call(void 0, );
+var _fs = require('fs');
+var _promises = require('fs/promises');
+var _os = require('os');
+var _pathe = require('pathe');
+var _jiti = require('jiti');
+var _mlly = require('mlly');
+var _rc9 = require('rc9'); var rc9 = _interopRequireWildcard(_rc9);
+
+// ../../node_modules/.pnpm/defu@6.1.4/node_modules/defu/dist/defu.mjs
+_chunkXJEQHMOEjs.init_cjs_shims.call(void 0, );
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object") {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== null && prototype !== Object.prototype && Object.getPrototypeOf(prototype) !== null) {
+    return false;
+  }
+  if (Symbol.iterator in value) {
+    return false;
+  }
+  if (Symbol.toStringTag in value) {
+    return Object.prototype.toString.call(value) === "[object Module]";
+  }
+  return true;
+}
+_chunkXJEQHMOEjs.__name.call(void 0, isPlainObject, "isPlainObject");
+function _defu(baseObject, defaults, namespace = ".", merger) {
+  if (!isPlainObject(defaults)) {
+    return _defu(baseObject, {}, namespace, merger);
+  }
+  const object = Object.assign({}, defaults);
+  for (const key in baseObject) {
+    if (key === "__proto__" || key === "constructor") {
+      continue;
+    }
+    const value = baseObject[key];
+    if (value === null || value === void 0) {
+      continue;
+    }
+    if (merger && merger(object, key, value, namespace)) {
+      continue;
+    }
+    if (Array.isArray(value) && Array.isArray(object[key])) {
+      object[key] = [...value, ...object[key]];
+    } else if (isPlainObject(value) && isPlainObject(object[key])) {
+      object[key] = _defu(
+        value,
+        object[key],
+        (namespace ? `${namespace}.` : "") + key.toString(),
+        merger
+      );
+    } else {
+      object[key] = value;
+    }
+  }
+  return object;
+}
+_chunkXJEQHMOEjs.__name.call(void 0, _defu, "_defu");
+function createDefu(merger) {
+  return (...arguments_) => (
+    // eslint-disable-next-line unicorn/no-array-reduce
+    arguments_.reduce((p, c) => _defu(p, c, "", merger), {})
+  );
+}
+_chunkXJEQHMOEjs.__name.call(void 0, createDefu, "createDefu");
+var defu = createDefu();
+var defuFn = createDefu((object, key, currentValue) => {
+  if (object[key] !== void 0 && typeof currentValue === "function") {
+    object[key] = currentValue(object[key]);
+    return true;
+  }
+});
+var defuArrayFn = createDefu((object, key, currentValue) => {
+  if (Array.isArray(object[key]) && typeof currentValue === "function") {
+    object[key] = currentValue(object[key]);
+    return true;
+  }
+});
+
+// ../../node_modules/.pnpm/c12@2.0.1/node_modules/c12/dist/shared/c12.B4fc1S0C.mjs
+var _ohash = require('ohash');
+var _pkgtypes = require('pkg-types');
+var _dotenv = require('dotenv'); var dotenv = _interopRequireWildcard(_dotenv);
+async function setupDotenv(options) {
+  const targetEnvironment = _nullishCoalesce(options.env, () => ( process.env));
+  const environment = await loadDotenv({
+    cwd: options.cwd,
+    fileName: _nullishCoalesce(options.fileName, () => ( ".env")),
+    env: targetEnvironment,
+    interpolate: _nullishCoalesce(options.interpolate, () => ( true))
+  });
+  for (const key in environment) {
+    if (!key.startsWith("_") && targetEnvironment[key] === void 0) {
+      targetEnvironment[key] = environment[key];
+    }
+  }
+  return environment;
+}
+_chunkXJEQHMOEjs.__name.call(void 0, setupDotenv, "setupDotenv");
+async function loadDotenv(options) {
+  const environment = /* @__PURE__ */ Object.create(null);
+  const dotenvFile = _pathe.resolve.call(void 0, options.cwd, options.fileName);
+  if (_fs.existsSync.call(void 0, dotenvFile)) {
+    const parsed = dotenv.parse(await _fs.promises.readFile(dotenvFile, "utf8"));
+    Object.assign(environment, parsed);
+  }
+  if (!_optionalChain([options, 'access', _ => _.env, 'optionalAccess', _2 => _2._applied])) {
+    Object.assign(environment, options.env);
+    environment._applied = true;
+  }
+  if (options.interpolate) {
+    interpolate(environment);
+  }
+  return environment;
+}
+_chunkXJEQHMOEjs.__name.call(void 0, loadDotenv, "loadDotenv");
+function interpolate(target, source = {}, parse2 = (v) => v) {
+  function getValue(key) {
+    return source[key] === void 0 ? target[key] : source[key];
+  }
+  _chunkXJEQHMOEjs.__name.call(void 0, getValue, "getValue");
+  function interpolate2(value, parents = []) {
+    if (typeof value !== "string") {
+      return value;
+    }
+    const matches = value.match(/(.?\${?(?:[\w:]+)?}?)/g) || [];
+    return parse2(
+      // eslint-disable-next-line unicorn/no-array-reduce
+      matches.reduce((newValue, match) => {
+        const parts = /(.?)\${?([\w:]+)?}?/g.exec(match) || [];
+        const prefix = parts[1];
+        let value2, replacePart;
+        if (prefix === "\\") {
+          replacePart = parts[0] || "";
+          value2 = replacePart.replace(String.raw`\$`, "$");
+        } else {
+          const key = parts[2];
+          replacePart = (parts[0] || "").slice(prefix.length);
+          if (parents.includes(key)) {
+            console.warn(
+              `Please avoid recursive environment variables ( loop: ${parents.join(
+                " > "
+              )} > ${key} )`
+            );
+            return "";
+          }
+          value2 = getValue(key);
+          value2 = interpolate2(value2, [...parents, key]);
+        }
+        return value2 === void 0 ? newValue : newValue.replace(replacePart, value2);
+      }, value)
+    );
+  }
+  _chunkXJEQHMOEjs.__name.call(void 0, interpolate2, "interpolate2");
+  for (const key in target) {
+    target[key] = interpolate2(getValue(key));
+  }
+}
+_chunkXJEQHMOEjs.__name.call(void 0, interpolate, "interpolate");
+var _normalize = /* @__PURE__ */ _chunkXJEQHMOEjs.__name.call(void 0, (p) => _optionalChain([p, 'optionalAccess', _3 => _3.replace, 'call', _4 => _4(/\\/g, "/")]), "_normalize");
+var ASYNC_LOADERS = {
+  ".yaml": /* @__PURE__ */ _chunkXJEQHMOEjs.__name.call(void 0, () => Promise.resolve().then(() => _interopRequireWildcard(require("confbox/yaml"))).then((r) => r.parseYAML), ".yaml"),
+  ".yml": /* @__PURE__ */ _chunkXJEQHMOEjs.__name.call(void 0, () => Promise.resolve().then(() => _interopRequireWildcard(require("confbox/yaml"))).then((r) => r.parseYAML), ".yml"),
+  ".jsonc": /* @__PURE__ */ _chunkXJEQHMOEjs.__name.call(void 0, () => Promise.resolve().then(() => _interopRequireWildcard(require("confbox/jsonc"))).then((r) => r.parseJSONC), ".jsonc"),
+  ".json5": /* @__PURE__ */ _chunkXJEQHMOEjs.__name.call(void 0, () => Promise.resolve().then(() => _interopRequireWildcard(require("confbox/json5"))).then((r) => r.parseJSON5), ".json5"),
+  ".toml": /* @__PURE__ */ _chunkXJEQHMOEjs.__name.call(void 0, () => Promise.resolve().then(() => _interopRequireWildcard(require("confbox/toml"))).then((r) => r.parseTOML), ".toml")
+};
+var SUPPORTED_EXTENSIONS = [
+  // with jiti
+  ".js",
+  ".ts",
+  ".mjs",
+  ".cjs",
+  ".mts",
+  ".cts",
+  ".json",
+  // with confbox
+  ".jsonc",
+  ".json5",
+  ".yaml",
+  ".yml",
+  ".toml"
+];
+async function loadConfig(options) {
+  options.cwd = _pathe.resolve.call(void 0, process.cwd(), options.cwd || ".");
+  options.name = options.name || "config";
+  options.envName = _nullishCoalesce(options.envName, () => ( process.env.NODE_ENV));
+  options.configFile = _nullishCoalesce(options.configFile, () => ( (options.name === "config" ? "config" : `${options.name}.config`)));
+  options.rcFile = _nullishCoalesce(options.rcFile, () => ( `.${options.name}rc`));
+  if (options.extend !== false) {
+    options.extend = {
+      extendKey: "extends",
+      ...options.extend
+    };
+  }
+  const _merger = options.merger || defu;
+  options.jiti = options.jiti || _jiti.createJiti.call(void 0, _pathe.join.call(void 0, options.cwd, options.configFile), {
+    interopDefault: true,
+    moduleCache: false,
+    extensions: [...SUPPORTED_EXTENSIONS],
+    ...options.jitiOptions
+  });
+  const r = {
+    config: {},
+    cwd: options.cwd,
+    configFile: _pathe.resolve.call(void 0, options.cwd, options.configFile),
+    layers: []
+  };
+  const _configs = {
+    overrides: options.overrides,
+    main: void 0,
+    rc: void 0,
+    packageJson: void 0,
+    defaultConfig: options.defaultConfig
+  };
+  if (options.dotenv) {
+    await setupDotenv({
+      cwd: options.cwd,
+      ...options.dotenv === true ? {} : options.dotenv
+    });
+  }
+  const _mainConfig = await resolveConfig(".", options);
+  if (_mainConfig.configFile) {
+    _configs.main = _mainConfig.config;
+    r.configFile = _mainConfig.configFile;
+  }
+  if (options.rcFile) {
+    const rcSources = [];
+    rcSources.push(rc9.read({ name: options.rcFile, dir: options.cwd }));
+    if (options.globalRc) {
+      const workspaceDir = await _pkgtypes.findWorkspaceDir.call(void 0, options.cwd).catch(() => {
+      });
+      if (workspaceDir) {
+        rcSources.push(rc9.read({ name: options.rcFile, dir: workspaceDir }));
+      }
+      rcSources.push(rc9.readUser({ name: options.rcFile, dir: options.cwd }));
+    }
+    _configs.rc = _merger({}, ...rcSources);
+  }
+  if (options.packageJson) {
+    const keys = (Array.isArray(options.packageJson) ? options.packageJson : [
+      typeof options.packageJson === "string" ? options.packageJson : options.name
+    ]).filter((t) => t && typeof t === "string");
+    const pkgJsonFile = await _pkgtypes.readPackageJSON.call(void 0, options.cwd).catch(() => {
+    });
+    const values = keys.map((key) => _optionalChain([pkgJsonFile, 'optionalAccess', _5 => _5[key]]));
+    _configs.packageJson = _merger({}, ...values);
+  }
+  const configs = {};
+  for (const key in _configs) {
+    const value = _configs[key];
+    configs[key] = await (typeof value === "function" ? value({ configs }) : value);
+  }
+  r.config = _merger(
+    configs.overrides,
+    configs.main,
+    configs.rc,
+    configs.packageJson,
+    configs.defaultConfig
+  );
+  if (options.extend) {
+    await extendConfig(r.config, options);
+    r.layers = r.config._layers;
+    delete r.config._layers;
+    r.config = _merger(r.config, ...r.layers.map((e) => e.config));
+  }
+  const baseLayers = [
+    configs.overrides && {
+      config: configs.overrides,
+      configFile: void 0,
+      cwd: void 0
+    },
+    { config: configs.main, configFile: options.configFile, cwd: options.cwd },
+    configs.rc && { config: configs.rc, configFile: options.rcFile },
+    configs.packageJson && {
+      config: configs.packageJson,
+      configFile: "package.json"
+    }
+  ].filter((l) => l && l.config);
+  r.layers = [...baseLayers, ...r.layers];
+  if (options.defaults) {
+    r.config = _merger(r.config, options.defaults);
+  }
+  if (options.omit$Keys) {
+    for (const key in r.config) {
+      if (key.startsWith("$")) {
+        delete r.config[key];
+      }
+    }
+  }
+  return r;
+}
+_chunkXJEQHMOEjs.__name.call(void 0, loadConfig, "loadConfig");
+async function extendConfig(config, options) {
+  config._layers = config._layers || [];
+  if (!options.extend) {
+    return;
+  }
+  let keys = options.extend.extendKey;
+  if (typeof keys === "string") {
+    keys = [keys];
+  }
+  const extendSources = [];
+  for (const key of keys) {
+    extendSources.push(
+      ...(Array.isArray(config[key]) ? config[key] : [config[key]]).filter(
+        Boolean
+      )
+    );
+    delete config[key];
+  }
+  for (let extendSource of extendSources) {
+    const originalExtendSource = extendSource;
+    let sourceOptions = {};
+    if (extendSource.source) {
+      sourceOptions = extendSource.options || {};
+      extendSource = extendSource.source;
+    }
+    if (Array.isArray(extendSource)) {
+      sourceOptions = extendSource[1] || {};
+      extendSource = extendSource[0];
+    }
+    if (typeof extendSource !== "string") {
+      console.warn(
+        `Cannot extend config from \`${JSON.stringify(
+          originalExtendSource
+        )}\` in ${options.cwd}`
+      );
+      continue;
+    }
+    const _config = await resolveConfig(extendSource, options, sourceOptions);
+    if (!_config.config) {
+      console.warn(
+        `Cannot extend config from \`${extendSource}\` in ${options.cwd}`
+      );
+      continue;
+    }
+    await extendConfig(_config.config, { ...options, cwd: _config.cwd });
+    config._layers.push(_config);
+    if (_config.config._layers) {
+      config._layers.push(..._config.config._layers);
+      delete _config.config._layers;
+    }
+  }
+}
+_chunkXJEQHMOEjs.__name.call(void 0, extendConfig, "extendConfig");
+var GIGET_PREFIXES = [
+  "gh:",
+  "github:",
+  "gitlab:",
+  "bitbucket:",
+  "https://",
+  "http://"
+];
+var NPM_PACKAGE_RE = /^(@[\da-z~-][\d._a-z~-]*\/)?[\da-z~-][\d._a-z~-]*($|\/.*)/;
+async function resolveConfig(source, options, sourceOptions = {}) {
+  if (options.resolve) {
+    const res2 = await options.resolve(source, options);
+    if (res2) {
+      return res2;
+    }
+  }
+  const _merger = options.merger || defu;
+  if (options.giget !== false && GIGET_PREFIXES.some((prefix) => source.startsWith(prefix))) {
+    const { downloadTemplate } = await Promise.resolve().then(() => _interopRequireWildcard(require("giget")));
+    const cloneName = source.replace(/\W+/g, "_").split("_").splice(0, 3).join("_") + "_" + _ohash.hash.call(void 0, source);
+    let cloneDir;
+    const localNodeModules = _pathe.resolve.call(void 0, options.cwd, "node_modules");
+    const parentDir = _pathe.dirname.call(void 0, options.cwd);
+    if (_pathe.basename.call(void 0, parentDir) === ".c12") {
+      cloneDir = _pathe.join.call(void 0, parentDir, cloneName);
+    } else if (_fs.existsSync.call(void 0, localNodeModules)) {
+      cloneDir = _pathe.join.call(void 0, localNodeModules, ".c12", cloneName);
+    } else {
+      cloneDir = process.env.XDG_CACHE_HOME ? _pathe.resolve.call(void 0, process.env.XDG_CACHE_HOME, "c12", cloneName) : _pathe.resolve.call(void 0, _os.homedir.call(void 0, ), ".cache/c12", cloneName);
+    }
+    if (_fs.existsSync.call(void 0, cloneDir) && !sourceOptions.install) {
+      await _promises.rm.call(void 0, cloneDir, { recursive: true });
+    }
+    const cloned = await downloadTemplate(source, {
+      dir: cloneDir,
+      install: sourceOptions.install,
+      force: sourceOptions.install,
+      auth: sourceOptions.auth,
+      ...options.giget,
+      ...sourceOptions.giget
+    });
+    source = cloned.dir;
+  }
+  const tryResolve = /* @__PURE__ */ _chunkXJEQHMOEjs.__name.call(void 0, (id) => {
+    const resolved = options.jiti.esmResolve(id, { try: true });
+    return resolved ? _mlly.fileURLToPath.call(void 0, resolved) : void 0;
+  }, "tryResolve");
+  if (NPM_PACKAGE_RE.test(source)) {
+    source = tryResolve(source) || source;
+  }
+  const ext = _pathe.extname.call(void 0, source);
+  const isDir = !ext || ext === _pathe.basename.call(void 0, source);
+  const cwd = _pathe.resolve.call(void 0, options.cwd, isDir ? source : _pathe.dirname.call(void 0, source));
+  if (isDir) {
+    source = options.configFile;
+  }
+  const res = {
+    config: void 0,
+    configFile: void 0,
+    cwd,
+    source,
+    sourceOptions
+  };
+  res.configFile = tryResolve(_pathe.resolve.call(void 0, cwd, source)) || tryResolve(_pathe.resolve.call(void 0, cwd, ".config", source.replace(/\.config$/, ""))) || tryResolve(_pathe.resolve.call(void 0, cwd, ".config", source)) || source;
+  if (!_fs.existsSync.call(void 0, res.configFile)) {
+    return res;
+  }
+  const configFileExt = _pathe.extname.call(void 0, res.configFile) || "";
+  if (configFileExt in ASYNC_LOADERS) {
+    const asyncLoader = await ASYNC_LOADERS[configFileExt]();
+    const contents = await _promises.readFile.call(void 0, res.configFile, "utf8");
+    res.config = asyncLoader(contents);
+  } else {
+    res.config = await options.jiti.import(res.configFile, {
+      default: true
+    });
+  }
+  if (res.config instanceof Function) {
+    res.config = await res.config();
+  }
+  if (options.envName) {
+    const envConfig = {
+      ...res.config["$" + options.envName],
+      ..._optionalChain([res, 'access', _6 => _6.config, 'access', _7 => _7.$env, 'optionalAccess', _8 => _8[options.envName]])
+    };
+    if (Object.keys(envConfig).length > 0) {
+      res.config = _merger(envConfig, res.config);
+    }
+  }
+  res.meta = defu(res.sourceOptions.meta, res.config.$meta);
+  delete res.config.$meta;
+  if (res.sourceOptions.overrides) {
+    res.config = _merger(res.sourceOptions.overrides, res.config);
+  }
+  res.configFile = _normalize(res.configFile);
+  res.source = _normalize(res.source);
+  return res;
+}
+_chunkXJEQHMOEjs.__name.call(void 0, resolveConfig, "resolveConfig");
+
+// ../../node_modules/.pnpm/c12@2.0.1/node_modules/c12/dist/index.mjs
+var _perfectdebounce = require('perfect-debounce');
+
+
+
+
+
+
+
+
+
+
+
+// src/config-file/get-config-file.ts
+var getConfigFileByName = /* @__PURE__ */ _chunkXJEQHMOEjs.__name.call(void 0, async (fileName, filePath, options = {}) => {
+  const workspacePath = filePath || _chunk6SJLAEJ3js.findWorkspaceRoot.call(void 0, filePath);
+  let config = loadConfig({
+    cwd: workspacePath,
+    packageJson: true,
+    name: fileName,
+    envName: _optionalChain([fileName, 'optionalAccess', _9 => _9.toUpperCase, 'call', _10 => _10()]),
+    jitiOptions: {
+      debug: false,
+      cache: process.env.STORM_SKIP_CACHE === "true" ? false : _chunkH6XXDZ7Ajs.joinPaths.call(void 0, process.env.STORM_CACHE_DIR || "node_modules/.cache", "storm")
+    },
+    ...options
+  });
+  if (!config || Object.keys(config).length === 0) {
+    config = loadConfig({
+      cwd: workspacePath,
+      packageJson: true,
+      name: fileName,
+      envName: _optionalChain([fileName, 'optionalAccess', _11 => _11.toUpperCase, 'call', _12 => _12()]),
+      jitiOptions: {
+        debug: false,
+        cache: process.env.STORM_SKIP_CACHE === "true" ? false : _chunkH6XXDZ7Ajs.joinPaths.call(void 0, process.env.STORM_CACHE_DIR || "node_modules/.cache", "storm")
+      },
+      configFile: fileName,
+      ...options
+    });
+  }
+  return config;
+}, "getConfigFileByName");
+var getConfigFile = /* @__PURE__ */ _chunkXJEQHMOEjs.__name.call(void 0, async (filePath, additionalFileNames = []) => {
+  const workspacePath = filePath ? filePath : _chunk6SJLAEJ3js.findWorkspaceRoot.call(void 0, filePath);
+  const result = await getConfigFileByName("storm", workspacePath);
+  let config = result.config;
+  const configFile = result.configFile;
+  if (config && configFile && Object.keys(config).length > 0) {
+    _chunkOXK45X3Ljs.writeSystem.call(void 0, `Found Storm configuration file "${configFile.includes(`${workspacePath}/`) ? configFile.replace(`${workspacePath}/`, "") : configFile}" at "${workspacePath}"`, {
+      logLevel: "all"
+    });
+  }
+  if (additionalFileNames && additionalFileNames.length > 0) {
+    const results = await Promise.all(additionalFileNames.map((fileName) => getConfigFileByName(fileName, workspacePath)));
+    for (const result2 of results) {
+      if (_optionalChain([result2, 'optionalAccess', _13 => _13.config]) && _optionalChain([result2, 'optionalAccess', _14 => _14.configFile]) && Object.keys(result2.config).length > 0) {
+        _chunkOXK45X3Ljs.writeSystem.call(void 0, `Found alternative configuration file "${result2.configFile.includes(`${workspacePath}/`) ? result2.configFile.replace(`${workspacePath}/`, "") : result2.configFile}" at "${workspacePath}"`, {
+          logLevel: "all"
+        });
+        config = defu(_nullishCoalesce(result2.config, () => ( {})), _nullishCoalesce(config, () => ( {})));
+      }
+    }
+  }
+  if (!config) {
+    return void 0;
+  }
+  config.configFile = configFile;
+  return config;
+}, "getConfigFile");
+
+
+
+
+
+exports.defu = defu; exports.getConfigFileByName = getConfigFileByName; exports.getConfigFile = getConfigFile;

package/dist/chunk-K6TQN2LZ.js

@@ -0,0 +1,6 @@
+"use strict";
+
+var _chunkXJEQHMOEjs = require('./chunk-XJEQHMOE.js');
+
+// src/utilities/index.ts
+_chunkXJEQHMOEjs.init_cjs_shims.call(void 0, );