@storm-software/config-tools 1.142.1 → 1.142.2

package/dist/chunk-3ER2D3OU.js

@@ -0,0 +1,67 @@
+import {
+  findWorkspaceRoot
+} from "./chunk-7A74BDUJ.js";
+import {
+  __name,
+  init_esm_shims
+} from "./chunk-BFNZYC5O.js";
+
+// src/utilities/apply-workspace-tokens.ts
+init_esm_shims();
+var applyWorkspaceBaseTokens = /* @__PURE__ */ __name(async (option, tokenParams) => {
+  let result = option;
+  if (!result) {
+    return result;
+  }
+  if (tokenParams) {
+    const optionKeys = Object.keys(tokenParams);
+    if (optionKeys.some((optionKey) => result.includes(`{${optionKey}}`))) {
+      for (const optionKey of optionKeys) {
+        if (result.includes(`{${optionKey}}`)) {
+          result = result.replaceAll(`{${optionKey}}`, tokenParams?.[optionKey] || "");
+        }
+      }
+    }
+  }
+  if (tokenParams.config) {
+    const configKeys = Object.keys(tokenParams.config);
+    if (configKeys.some((configKey) => result.includes(`{${configKey}}`))) {
+      for (const configKey of configKeys) {
+        if (result.includes(`{${configKey}}`)) {
+          result = result.replaceAll(`{${configKey}}`, tokenParams.config[configKey] || "");
+        }
+      }
+    }
+  }
+  if (result.includes("{workspaceRoot}")) {
+    result = result.replaceAll("{workspaceRoot}", tokenParams.workspaceRoot ?? tokenParams.config?.workspaceRoot ?? findWorkspaceRoot());
+  }
+  return result;
+}, "applyWorkspaceBaseTokens");
+var applyWorkspaceProjectTokens = /* @__PURE__ */ __name((option, tokenParams) => {
+  return applyWorkspaceBaseTokens(option, tokenParams);
+}, "applyWorkspaceProjectTokens");
+var applyWorkspaceTokens = /* @__PURE__ */ __name(async (options, tokenParams, tokenizerFn) => {
+  if (!options) {
+    return {};
+  }
+  const result = {};
+  for (const option of Object.keys(options)) {
+    if (typeof options[option] === "string") {
+      result[option] = await Promise.resolve(tokenizerFn(options[option], tokenParams));
+    } else if (Array.isArray(options[option])) {
+      result[option] = await Promise.all(options[option].map(async (item) => typeof item === "string" ? await Promise.resolve(tokenizerFn(item, tokenParams)) : item));
+    } else if (typeof options[option] === "object") {
+      result[option] = await applyWorkspaceTokens(options[option], tokenParams, tokenizerFn);
+    } else {
+      result[option] = options[option];
+    }
+  }
+  return result;
+}, "applyWorkspaceTokens");
+
+export {
+  applyWorkspaceBaseTokens,
+  applyWorkspaceProjectTokens,
+  applyWorkspaceTokens
+};

package/dist/chunk-3W5JECK3.cjs

@@ -0,0 +1,6 @@
+"use strict";
+
+var _chunkDFJNOFN2cjs = require('./chunk-DFJNOFN2.cjs');
+
+// src/logger/index.ts
+_chunkDFJNOFN2cjs.init_cjs_shims.call(void 0, );

package/dist/chunk-46O7IOH6.js

@@ -0,0 +1,24 @@
+import {
+  __name,
+  init_esm_shims
+} from "./chunk-BFNZYC5O.js";
+
+// src/logger/is-unicode-supported.ts
+init_esm_shims();
+import process from "node:process";
+function isUnicodeSupported() {
+  const { env } = process;
+  const { TERM, TERM_PROGRAM } = env;
+  if (process.platform !== "win32") {
+    return TERM !== "linux";
+  }
+  return Boolean(env.WT_SESSION) || // Windows Terminal
+  Boolean(env.TERMINUS_SUBLIME) || // Terminus (<0.2.27)
+  env.ConEmuTask === "{cmd::Cmder}" || // ConEmu and cmder
+  TERM_PROGRAM === "Terminus-Sublime" || TERM_PROGRAM === "vscode" || TERM === "xterm-256color" || TERM === "alacritty" || TERM === "rxvt-unicode" || TERM === "rxvt-unicode-256color" || env.TERMINAL_EMULATOR === "JetBrains-JediTerm";
+}
+__name(isUnicodeSupported, "isUnicodeSupported");
+
+export {
+  isUnicodeSupported
+};

package/dist/chunk-4AYNBMPP.cjs

@@ -0,0 +1,27 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+
+var _chunkDFJNOFN2cjs = require('./chunk-DFJNOFN2.cjs');
+
+// src/utilities/find-up.ts
+_chunkDFJNOFN2cjs.init_cjs_shims.call(void 0, );
+var _fs = require('fs');
+var _path = require('path');
+var MAX_PATH_SEARCH_DEPTH = 30;
+var depth = 0;
+function findFolderUp(startPath, endFileNames) {
+  const _startPath = _nullishCoalesce(startPath, () => ( process.cwd()));
+  if (endFileNames.some((endFileName) => _fs.existsSync.call(void 0, _path.join.call(void 0, _startPath, endFileName)))) {
+    return _startPath;
+  }
+  if (_startPath !== "/" && depth++ < MAX_PATH_SEARCH_DEPTH) {
+    const parent = _path.join.call(void 0, _startPath, "..");
+    return findFolderUp(parent, endFileNames);
+  }
+  return void 0;
+}
+_chunkDFJNOFN2cjs.__name.call(void 0, findFolderUp, "findFolderUp");
+
+
+
+exports.findFolderUp = findFolderUp;

package/dist/chunk-4OKHW64R.js

@@ -0,0 +1,271 @@
+import {
+  correctPaths
+} from "./chunk-S3QN6LZI.js";
+import {
+  getLogLevel
+} from "./chunk-LQFUWYSF.js";
+import {
+  LogLevel
+} from "./chunk-PEPDFP2O.js";
+import {
+  __name,
+  init_esm_shims
+} from "./chunk-BFNZYC5O.js";
+
+// src/env/set-env.ts
+init_esm_shims();
+var setExtensionEnv = /* @__PURE__ */ __name((extensionName, extension) => {
+  for (const key of Object.keys(extension ?? {})) {
+    if (extension[key]) {
+      const result = key?.replace(/([A-Z])+/g, (input) => input ? input[0]?.toUpperCase() + input.slice(1) : "").split(/(?=[A-Z])|[.\-\s_]/).map((x) => x.toLowerCase()) ?? [];
+      let extensionKey;
+      if (result.length === 0) {
+        return;
+      }
+      if (result.length === 1) {
+        extensionKey = result[0]?.toUpperCase() ?? "";
+      } else {
+        extensionKey = result.reduce((ret, part) => {
+          return `${ret}_${part.toLowerCase()}`;
+        });
+      }
+      process.env[`STORM_EXTENSION_${extensionName.toUpperCase()}_${extensionKey.toUpperCase()}`] = extension[key];
+    }
+  }
+}, "setExtensionEnv");
+var setConfigEnv = /* @__PURE__ */ __name((config) => {
+  const prefix = "STORM_";
+  if (config.extends) {
+    process.env[`${prefix}EXTENDS`] = Array.isArray(config.extends) ? JSON.stringify(config.extends) : config.extends;
+  }
+  if (config.name) {
+    process.env[`${prefix}NAME`] = config.name;
+  }
+  if (config.namespace) {
+    process.env[`${prefix}NAMESPACE`] = config.namespace;
+  }
+  if (config.owner) {
+    process.env[`${prefix}OWNER`] = config.owner;
+  }
+  if (config.bot) {
+    process.env[`${prefix}BOT_NAME`] = config.bot.name;
+    process.env[`${prefix}BOT_EMAIL`] = config.bot.email;
+  }
+  if (config.organization) {
+    process.env[`${prefix}ORGANIZATION`] = config.organization;
+  }
+  if (config.packageManager) {
+    process.env[`${prefix}PACKAGE_MANAGER`] = config.packageManager;
+  }
+  if (config.license) {
+    process.env[`${prefix}LICENSE`] = config.license;
+  }
+  if (config.homepage) {
+    process.env[`${prefix}HOMEPAGE`] = config.homepage;
+  }
+  if (config.docs) {
+    process.env[`${prefix}DOCS`] = config.docs;
+  }
+  if (config.licensing) {
+    process.env[`${prefix}LICENSING`] = config.licensing;
+  }
+  if (config.timezone) {
+    process.env[`${prefix}TIMEZONE`] = config.timezone;
+    process.env.TZ = config.timezone;
+    process.env.DEFAULT_TIMEZONE = config.timezone;
+  }
+  if (config.locale) {
+    process.env[`${prefix}LOCALE`] = config.locale;
+    process.env.LOCALE = config.locale;
+    process.env.DEFAULT_LOCALE = config.locale;
+    process.env.LANG = config.locale ? `${config.locale.replaceAll("-", "_")}.UTF-8` : "en_US.UTF-8";
+  }
+  if (config.configFile) {
+    process.env[`${prefix}CONFIG_FILE`] = correctPaths(config.configFile);
+  }
+  if (config.workspaceRoot) {
+    process.env[`${prefix}WORKSPACE_ROOT`] = correctPaths(config.workspaceRoot);
+    process.env.NX_WORKSPACE_ROOT = correctPaths(config.workspaceRoot);
+    process.env.NX_WORKSPACE_ROOT_PATH = correctPaths(config.workspaceRoot);
+  }
+  if (config.directories) {
+    if (!config.skipCache && config.directories.cache) {
+      process.env[`${prefix}CACHE_DIR`] = correctPaths(config.directories.cache);
+    }
+    if (config.directories.data) {
+      process.env[`${prefix}DATA_DIR`] = correctPaths(config.directories.data);
+    }
+    if (config.directories.config) {
+      process.env[`${prefix}CONFIG_DIR`] = correctPaths(config.directories.config);
+    }
+    if (config.directories.temp) {
+      process.env[`${prefix}TEMP_DIR`] = correctPaths(config.directories.temp);
+    }
+    if (config.directories.log) {
+      process.env[`${prefix}LOG_DIR`] = correctPaths(config.directories.log);
+    }
+    if (config.directories.build) {
+      process.env[`${prefix}BUILD_DIR`] = correctPaths(config.directories.build);
+    }
+  }
+  if (config.skipCache !== void 0) {
+    process.env[`${prefix}SKIP_CACHE`] = String(config.skipCache);
+    if (config.skipCache) {
+      process.env.NX_SKIP_NX_CACHE ??= String(config.skipCache);
+      process.env.NX_CACHE_PROJECT_GRAPH ??= String(config.skipCache);
+    }
+  }
+  if (config.env) {
+    process.env[`${prefix}ENV`] = config.env;
+    process.env.NODE_ENV = config.env;
+    process.env.ENVIRONMENT = config.env;
+  }
+  if (config.colors?.base?.light || config.colors?.base?.dark) {
+    for (const key of Object.keys(config.colors)) {
+      setThemeColorConfigEnv(`${prefix}COLOR_${key}_`, config.colors[key]);
+    }
+  } else {
+    setThemeColorConfigEnv(`${prefix}COLOR_`, config.colors);
+  }
+  if (config.repository) {
+    process.env[`${prefix}REPOSITORY`] = config.repository;
+  }
+  if (config.branch) {
+    process.env[`${prefix}BRANCH`] = config.branch;
+  }
+  if (config.preid) {
+    process.env[`${prefix}PRE_ID`] = String(config.preid);
+  }
+  if (config.externalPackagePatterns) {
+    process.env[`${prefix}EXTERNAL_PACKAGE_PATTERNS`] = JSON.stringify(config.externalPackagePatterns);
+  }
+  if (config.registry) {
+    if (config.registry.github) {
+      process.env[`${prefix}REGISTRY_GITHUB`] = String(config.registry.github);
+    }
+    if (config.registry.npm) {
+      process.env[`${prefix}REGISTRY_NPM`] = String(config.registry.npm);
+    }
+    if (config.registry.cargo) {
+      process.env[`${prefix}REGISTRY_CARGO`] = String(config.registry.cargo);
+    }
+    if (config.registry.cyclone) {
+      process.env[`${prefix}REGISTRY_CYCLONE`] = String(config.registry.cyclone);
+    }
+    if (config.registry.container) {
+      process.env[`${prefix}REGISTRY_CONTAINER`] = String(config.registry.cyclone);
+    }
+  }
+  if (config.logLevel) {
+    process.env[`${prefix}LOG_LEVEL`] = String(config.logLevel);
+    process.env.LOG_LEVEL = String(config.logLevel);
+    process.env.NX_VERBOSE_LOGGING = String(getLogLevel(config.logLevel) >= LogLevel.DEBUG ? true : false);
+    process.env.RUST_BACKTRACE = getLogLevel(config.logLevel) >= LogLevel.DEBUG ? "full" : "none";
+  }
+  process.env[`${prefix}CONFIG`] = JSON.stringify(config);
+  for (const key of Object.keys(config.extensions ?? {})) {
+    config.extensions[key] && Object.keys(config.extensions[key]) && setExtensionEnv(key, config.extensions[key]);
+  }
+}, "setConfigEnv");
+var setThemeColorConfigEnv = /* @__PURE__ */ __name((prefix, config) => {
+  return config?.light?.brand || config?.dark?.brand ? setMultiThemeColorConfigEnv(prefix, config) : setSingleThemeColorConfigEnv(prefix, config);
+}, "setThemeColorConfigEnv");
+var setSingleThemeColorConfigEnv = /* @__PURE__ */ __name((prefix, config) => {
+  if (config.dark) {
+    process.env[`${prefix}DARK`] = config.dark;
+  }
+  if (config.light) {
+    process.env[`${prefix}LIGHT`] = config.light;
+  }
+  if (config.brand) {
+    process.env[`${prefix}BRAND`] = config.brand;
+  }
+  if (config.alternate) {
+    process.env[`${prefix}ALTERNATE`] = config.alternate;
+  }
+  if (config.accent) {
+    process.env[`${prefix}ACCENT`] = config.accent;
+  }
+  if (config.link) {
+    process.env[`${prefix}LINK`] = config.link;
+  }
+  if (config.help) {
+    process.env[`${prefix}HELP`] = config.help;
+  }
+  if (config.success) {
+    process.env[`${prefix}SUCCESS`] = config.success;
+  }
+  if (config.info) {
+    process.env[`${prefix}INFO`] = config.info;
+  }
+  if (config.warning) {
+    process.env[`${prefix}WARNING`] = config.warning;
+  }
+  if (config.danger) {
+    process.env[`${prefix}DANGER`] = config.danger;
+  }
+  if (config.fatal) {
+    process.env[`${prefix}FATAL`] = config.fatal;
+  }
+  if (config.positive) {
+    process.env[`${prefix}POSITIVE`] = config.positive;
+  }
+  if (config.negative) {
+    process.env[`${prefix}NEGATIVE`] = config.negative;
+  }
+}, "setSingleThemeColorConfigEnv");
+var setMultiThemeColorConfigEnv = /* @__PURE__ */ __name((prefix, config) => {
+  return {
+    light: setBaseThemeColorConfigEnv(`${prefix}LIGHT_`, config.light),
+    dark: setBaseThemeColorConfigEnv(`${prefix}DARK_`, config.dark)
+  };
+}, "setMultiThemeColorConfigEnv");
+var setBaseThemeColorConfigEnv = /* @__PURE__ */ __name((prefix, config) => {
+  if (config.foreground) {
+    process.env[`${prefix}FOREGROUND`] = config.foreground;
+  }
+  if (config.background) {
+    process.env[`${prefix}BACKGROUND`] = config.background;
+  }
+  if (config.brand) {
+    process.env[`${prefix}BRAND`] = config.brand;
+  }
+  if (config.alternate) {
+    process.env[`${prefix}ALTERNATE`] = config.alternate;
+  }
+  if (config.accent) {
+    process.env[`${prefix}ACCENT`] = config.accent;
+  }
+  if (config.link) {
+    process.env[`${prefix}LINK`] = config.link;
+  }
+  if (config.help) {
+    process.env[`${prefix}HELP`] = config.help;
+  }
+  if (config.success) {
+    process.env[`${prefix}SUCCESS`] = config.success;
+  }
+  if (config.info) {
+    process.env[`${prefix}INFO`] = config.info;
+  }
+  if (config.warning) {
+    process.env[`${prefix}WARNING`] = config.warning;
+  }
+  if (config.danger) {
+    process.env[`${prefix}DANGER`] = config.danger;
+  }
+  if (config.fatal) {
+    process.env[`${prefix}FATAL`] = config.fatal;
+  }
+  if (config.positive) {
+    process.env[`${prefix}POSITIVE`] = config.positive;
+  }
+  if (config.negative) {
+    process.env[`${prefix}NEGATIVE`] = config.negative;
+  }
+}, "setBaseThemeColorConfigEnv");
+
+export {
+  setExtensionEnv,
+  setConfigEnv
+};

package/dist/chunk-4OURELB7.js

@@ -0,0 +1,6 @@
+import {
+  init_esm_shims
+} from "./chunk-BFNZYC5O.js";
+
+// src/logger/index.ts
+init_esm_shims();

package/dist/chunk-5EL2OHUB.js

@@ -0,0 +1,84 @@
+import {
+  __name,
+  init_esm_shims
+} from "./chunk-BFNZYC5O.js";
+
+// ../../node_modules/.pnpm/confbox@0.1.8/node_modules/confbox/dist/shared/confbox.9388d834.mjs
+init_esm_shims();
+var b = /^(?:( )+|\t+)/;
+var d = "space";
+var h = "tab";
+function g(e, t) {
+  const n = /* @__PURE__ */ new Map();
+  let i = 0, s, o;
+  for (const c of e.split(/\n/g)) {
+    if (!c) continue;
+    let f, a, l, p, r;
+    const y = c.match(b);
+    if (y === null) i = 0, s = "";
+    else {
+      if (f = y[0].length, a = y[1] ? d : h, t && a === d && f === 1) continue;
+      a !== s && (i = 0), s = a, l = 1, p = 0;
+      const u = f - i;
+      if (i = f, u === 0) l = 0, p = 1;
+      else {
+        const I = u > 0 ? u : -u;
+        o = T(a, I);
+      }
+      r = n.get(o), r = r === void 0 ? [1, 0] : [r[0] + l, r[1] + p], n.set(o, r);
+    }
+  }
+  return n;
+}
+__name(g, "g");
+function T(e, t) {
+  return (e === d ? "s" : "t") + String(t);
+}
+__name(T, "T");
+function w(e) {
+  const n = e[0] === "s" ? d : h, i = Number(e.slice(1));
+  return { type: n, amount: i };
+}
+__name(w, "w");
+function E(e) {
+  let t, n = 0, i = 0;
+  for (const [s, [o, c]] of e) (o > n || o === n && c > i) && (n = o, i = c, t = s);
+  return t;
+}
+__name(E, "E");
+function S(e, t) {
+  return (e === d ? " " : "	").repeat(t);
+}
+__name(S, "S");
+function _(e) {
+  if (typeof e != "string") throw new TypeError("Expected a string");
+  let t = g(e, true);
+  t.size === 0 && (t = g(e, false));
+  const n = E(t);
+  let i, s = 0, o = "";
+  return n !== void 0 && ({ type: i, amount: s } = w(n), o = S(i, s)), { amount: s, type: i, indent: o };
+}
+__name(_, "_");
+var m = Symbol.for("__confbox_fmt__");
+var k = /^(\s+)/;
+var v = /(\s+)$/;
+function x(e, t = {}) {
+  const n = t.indent === void 0 && t.preserveIndentation !== false && e.slice(0, t?.sampleSize || 1024), i = t.preserveWhitespace === false ? void 0 : { start: k.exec(e)?.[0] || "", end: v.exec(e)?.[0] || "" };
+  return { sample: n, whiteSpace: i };
+}
+__name(x, "x");
+function N(e, t, n) {
+  !t || typeof t != "object" || Object.defineProperty(t, m, { enumerable: false, configurable: true, writable: true, value: x(e, n) });
+}
+__name(N, "N");
+function C(e, t) {
+  if (!e || typeof e != "object" || !(m in e)) return { indent: t?.indent, whitespace: { start: "", end: "" } };
+  const n = e[m];
+  return { indent: t?.indent || _(n.sample || "").indent, whitespace: n.whiteSpace || { start: "", end: "" } };
+}
+__name(C, "C");
+
+export {
+  N,
+  C
+};