@storm-software/config-tools 1.5.5 → 1.5.6

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+## [1.5.5](https://github.com/storm-software/storm-ops/compare/config-tools-v1.5.4...config-tools-v1.5.5) (2023-12-20)
+
+
+### Bug Fixes
+
+* **config-tools:** Update project config to no longer bundle ([06b72cd](https://github.com/storm-software/storm-ops/commit/06b72cdea2b85826571d177dad1cb352769c0f76))
+
 ## [1.5.4](https://github.com/storm-software/storm-ops/compare/config-tools-v1.5.3...config-tools-v1.5.4) (2023-12-20)
 
 

package/index.cjs

@@ -1,42 +1,465 @@
-const Module = require("module");
-const path = require("path");
-const fs = require("fs");
-const originalResolveFilename = Module._resolveFilename;
-const distPath = __dirname;
-const manifest = [{ "module": "@storm-software/linting-tools/*", "pattern": "packages/linting-tools/*" }, { "module": "@storm-software/testing-tools/*", "pattern": "packages/testing-tools/src/*" }, { "module": "@storm-software/config-tools/*", "pattern": "packages/config-tools/src/*" }, { "module": "@storm-software/design-tools/*", "pattern": "packages/design-tools/src/*" }, { "module": "@storm-software/git-tools/*", "pattern": "packages/git-tools/*" }, { "module": "@storm-software/config-tools", "exactMatch": "packages/config-tools/src/index.cjs", "pattern": "packages/config-tools/src/index.ts" }, { "module": "@storm-software/design-tools", "exactMatch": "packages/design-tools/src/index.cjs", "pattern": "packages/design-tools/src/index.ts" }, { "module": "@storm-software/git-tools", "exactMatch": "packages/git-tools/src/index.cjs", "pattern": "packages/git-tools/src/index.ts" }, { "module": "@storm-software/linting-tools", "exactMatch": "packages/linting-tools/src/index.cjs", "pattern": "packages/linting-tools/src/index.ts" }, { "module": "@storm-software/testing-tools", "exactMatch": "packages/testing-tools/src/index.cjs", "pattern": "packages/testing-tools/src/index.ts" }, { "module": "@storm-software/workspace-tools", "exactMatch": "packages/workspace-tools/index.cjs", "pattern": "packages/workspace-tools/index.ts" }, { "module": "create-storm-workspace", "exactMatch": "packages/create-storm-workspace/bin/index.cjs", "pattern": "packages/create-storm-workspace/bin/index.ts" }];
-Module._resolveFilename = function(request, parent) {
-  let found;
-  for (const entry of manifest) {
-    if (request === entry.module && entry.exactMatch) {
-      const entry2 = manifest.find((x) => request === x.module || request.startsWith(x.module + "/"));
-      const candidate = path.join(distPath, entry2.exactMatch);
-      if (isFile(candidate)) {
-        found = candidate;
-        break;
-      }
-    } else {
-      const re = new RegExp(entry.module.replace(/\*$/, "(?<rest>.*)"));
-      const match = request.match(re);
-      if (match?.groups) {
-        const candidate = path.join(distPath, entry.pattern.replace("*", ""), match.groups.rest + ".js");
-        if (isFile(candidate)) {
-          found = candidate;
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// packages/config-tools/src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  ColorConfigSchema: () => ColorConfigSchema,
+  DefaultColorConfig: () => DefaultColorConfig,
+  DefaultStormConfig: () => DefaultStormConfig,
+  LogLevel: () => LogLevel,
+  LogLevelLabel: () => LogLevelLabel,
+  StormConfigSchema: () => StormConfigSchema,
+  createConfigExtension: () => createConfigExtension,
+  createStormConfig: () => createStormConfig,
+  getConfigEnv: () => getConfigEnv,
+  getConfigFile: () => getConfigFile,
+  getDefaultConfig: () => getDefaultConfig,
+  getExtensionEnv: () => getExtensionEnv,
+  getLogLevel: () => getLogLevel,
+  getLogLevelLabel: () => getLogLevelLabel,
+  setConfigEnv: () => setConfigEnv,
+  setExtensionEnv: () => setExtensionEnv
+});
+module.exports = __toCommonJS(src_exports);
+
+// packages/config-tools/src/config-file/get-config-file.ts
+var import_cosmiconfig = require("cosmiconfig");
+var _static_cache = void 0;
+var getConfigFileName = (fileName) => (0, import_cosmiconfig.cosmiconfig)(fileName, { cache: true }).search();
+var getConfigFile = async () => {
+  if (_static_cache) {
+    return _static_cache;
+  }
+  let cosmiconfigResult = await getConfigFileName("storm");
+  if (!cosmiconfigResult || cosmiconfigResult.isEmpty) {
+    cosmiconfigResult = await getConfigFileName("storm-software");
+    if (!cosmiconfigResult || cosmiconfigResult.isEmpty) {
+      cosmiconfigResult = await getConfigFileName("storm-stack");
+      if (!cosmiconfigResult || cosmiconfigResult.isEmpty) {
+        cosmiconfigResult = await getConfigFileName("storm-cloud");
+        if (!cosmiconfigResult || cosmiconfigResult.isEmpty) {
+          cosmiconfigResult = await getConfigFileName("acidic");
+          if (!cosmiconfigResult || cosmiconfigResult.isEmpty) {
+            cosmiconfigResult = await getConfigFileName("acid");
+          }
         }
       }
     }
   }
-  if (found) {
-    const modifiedArguments = [found, ...[].slice.call(arguments, 1)];
-    return originalResolveFilename.apply(this, modifiedArguments);
+  if (!cosmiconfigResult || Object.keys(cosmiconfigResult).length === 0 || cosmiconfigResult.isEmpty || !cosmiconfigResult.filepath) {
+    console.warn(
+      "No Storm config file found in the current workspace. Please ensure this is the expected behavior - you can add a `storm.config.js` file to the root of your workspace if it is not."
+    );
+    return void 0;
+  }
+  const config = cosmiconfigResult.config ?? {};
+  cosmiconfigResult.filepath && (config.configFile = cosmiconfigResult.filepath);
+  config.runtimeVersion = "0.0.1";
+  _static_cache = config;
+  return config;
+};
+
+// packages/config-tools/src/types.ts
+var LogLevel = {
+  SILENT: 0,
+  FATAL: 10,
+  ERROR: 20,
+  WARN: 30,
+  INFO: 40,
+  DEBUG: 60,
+  TRACE: 70
+};
+var LogLevelLabel = {
+  SILENT: "silent",
+  FATAL: "fatal",
+  ERROR: "error",
+  WARN: "warn",
+  INFO: "info",
+  DEBUG: "debug",
+  TRACE: "trace"
+};
+
+// packages/config-tools/src/utilities/get-default-config.ts
+var import_fs = require("fs");
+var import_find_workspace_root = require("nx/src/utils/find-workspace-root.js");
+var import_path = require("path");
+
+// packages/config-tools/src/schema.ts
+var z = __toESM(require("zod"));
+var ColorConfigSchema = z.object({
+  primary: z.string().trim().toLowerCase().regex(/^#([0-9a-f]{3}){1,2}$/i).length(7).default("#0ea5e9").describe("The primary color of the workspace"),
+  background: z.string().trim().toLowerCase().regex(/^#([0-9a-f]{3}){1,2}$/i).length(7).default("#1d232a").describe("The background color of the workspace"),
+  success: z.string().trim().toLowerCase().regex(/^#([0-9a-f]{3}){1,2}$/i).length(7).default("#087f5b").describe("The success color of the workspace"),
+  info: z.string().trim().toLowerCase().regex(/^#([0-9a-f]{3}){1,2}$/i).length(7).default("#0ea5e9").describe("The informational color of the workspace"),
+  warning: z.string().trim().toLowerCase().regex(/^#([0-9a-f]{3}){1,2}$/i).length(7).default("#fcc419").describe("The warning color of the workspace"),
+  error: z.string().trim().toLowerCase().regex(/^#([0-9a-f]{3}){1,2}$/i).length(7).default("#990000").describe("The error color of the workspace"),
+  fatal: z.string().trim().toLowerCase().regex(/^#([0-9a-f]{3}){1,2}$/i).length(7).default("#7d1a1a").describe("The fatal color of the workspace")
+}).describe("Colors used for various workspace elements");
+var StormConfigSchema = z.object({
+  name: z.string().trim().toLowerCase().describe("The name of the package"),
+  namespace: z.string().trim().toLowerCase().default("storm-software").describe("The namespace of the package"),
+  organization: z.string().trim().default("storm-software").describe("The organization of the workspace"),
+  repository: z.string().trim().url().optional().describe("The repo URL of the workspace (i.e. GitHub)"),
+  license: z.string().trim().default("Apache License 2.0").describe("The root directory of the package"),
+  homepage: z.string().trim().url().default("https://stormsoftware.org").describe("The homepage of the workspace"),
+  branch: z.string().trim().default("main").describe("The branch of the workspace"),
+  preMajor: z.boolean().default(false).describe(
+    "An indicator specifying if the package is still in it's pre-major version"
+  ),
+  owner: z.string().trim().default("@storm-software/development").describe("The owner of the package"),
+  worker: z.string().trim().default("stormie-bot").describe(
+    "The worker of the package (this is the bot that will be used to perform various tasks)"
+  ),
+  env: z.enum(["development", "staging", "production"]).default("production").describe("The current runtime environment of the package"),
+  ci: z.boolean().default(true).describe(
+    "An indicator specifying if the current environment is a CI environment"
+  ),
+  workspaceRoot: z.string().trim().describe("The root directory of the workspace"),
+  packageDirectory: z.string().trim().optional().describe("The root directory of the package"),
+  buildDirectory: z.string().trim().default("dist").describe("The build directory for the workspace"),
+  runtimeDirectory: z.string().trim().default("node_modules/.storm").describe("The runtime directory of Storm"),
+  runtimeVersion: z.string().trim().regex(
+    /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/
+  ).default("1.0.0").describe("The global version of the Storm runtime"),
+  timezone: z.string().trim().default("America/New_York").describe("The default timezone of the workspace"),
+  locale: z.string().trim().default("en-US").describe("The default locale of the workspace"),
+  logLevel: z.enum(["silent", "fatal", "error", "warn", "info", "debug", "trace"]).optional().describe(
+    "The log level used to filter out lower priority log messages. If not provided, this is defaulted using the `environment` config value (if `environment` is set to `production` then `level` is `error`, else `level` is `debug`)."
+  ),
+  configFile: z.string().trim().nullable().default(null).describe(
+    "The filepath of the Storm config. When this field is null, no config file was found in the current workspace."
+  ),
+  colors: ColorConfigSchema.describe(
+    "Storm theme config values used for styling various package elements"
+  ),
+  extensions: z.record(z.any()).default({}).describe("Configuration of each used extension")
+}).describe(
+  "Storm Workspace config values used during various dev-ops processes. This type is a combination of the StormPackageConfig and StormProject types. It represents the config of the entire monorepo."
+);
+
+// packages/config-tools/src/utilities/get-default-config.ts
+var DefaultColorConfig = {
+  primary: "#1fb2a6",
+  background: "#1d232a",
+  success: "#087f5b",
+  info: "#0ea5e9",
+  warning: "#fcc419",
+  error: "#990000",
+  fatal: "#7d1a1a"
+};
+var DefaultStormConfig = {
+  namespace: "storm-software",
+  license: "Apache License 2.0",
+  homepage: "https://stormsoftware.org",
+  preMajor: false,
+  owner: "@storm-software/development",
+  worker: "stormie-bot",
+  runtimeDirectory: "node_modules/.storm",
+  timezone: "America/New_York",
+  locale: "en-US",
+  env: "production",
+  branch: "main",
+  organization: "storm-software",
+  ci: true,
+  configFile: null,
+  runtimeVersion: "1.0.0",
+  colors: { ...DefaultColorConfig },
+  extensions: {}
+};
+var getDefaultConfig = (config = {}) => {
+  let name = "storm-workspace";
+  let namespace = "storm-software";
+  let repository = "https://github.com/storm-software/storm-stack";
+  let license = DefaultStormConfig.license;
+  let homepage = DefaultStormConfig.homepage;
+  const workspaceRoot = getWorkspaceRoot() ?? process.cwd();
+  if ((0, import_fs.existsSync)((0, import_path.join)(workspaceRoot, "package.json"))) {
+    const file = (0, import_fs.readFileSync)((0, import_path.join)(workspaceRoot, "package.json"), {
+      encoding: "utf-8"
+    });
+    if (file) {
+      const packageJson = JSON.parse(file);
+      packageJson.name && (name = packageJson.name);
+      packageJson.namespace && (namespace = packageJson.namespace);
+      packageJson.repository?.url && (repository = packageJson.repository?.url);
+      packageJson.license && (license = packageJson.license);
+      packageJson.homepage && (homepage = packageJson.homepage);
+    }
+  }
+  return StormConfigSchema.parse(
+    Object.assign(config, {
+      ...DefaultStormConfig,
+      colors: { ...DefaultColorConfig },
+      workspaceRoot,
+      name,
+      namespace,
+      repository,
+      license: license ?? DefaultStormConfig.license,
+      homepage: homepage ?? DefaultStormConfig.homepage,
+      extensions: {}
+    })
+  );
+};
+var getWorkspaceRoot = () => {
+  const root = (0, import_find_workspace_root.findWorkspaceRoot)(process.cwd());
+  process.env.STORM_WORKSPACE_ROOT ??= root?.dir;
+  process.env.NX_WORKSPACE_ROOT_PATH ??= root?.dir;
+  return root?.dir;
+};
+
+// packages/config-tools/src/utilities/get-log-level.ts
+var getLogLevel = (label) => {
+  switch (label) {
+    case "trace":
+      return LogLevel.TRACE;
+    case "debug":
+      return LogLevel.DEBUG;
+    case "info":
+      return LogLevel.INFO;
+    case "warn":
+      return LogLevel.WARN;
+    case "error":
+      return LogLevel.ERROR;
+    case "fatal":
+      return LogLevel.FATAL;
+    case "silent":
+      return LogLevel.SILENT;
+    default:
+      return LogLevel.INFO;
+  }
+};
+var getLogLevelLabel = (logLevel) => {
+  if (logLevel >= LogLevel.TRACE) {
+    return LogLevelLabel.TRACE;
+  } else if (logLevel >= LogLevel.DEBUG) {
+    return LogLevelLabel.DEBUG;
+  } else if (logLevel >= LogLevel.INFO) {
+    return LogLevelLabel.INFO;
+  } else if (logLevel >= LogLevel.WARN) {
+    return LogLevelLabel.WARN;
+  } else if (logLevel >= LogLevel.ERROR) {
+    return LogLevelLabel.ERROR;
+  } else if (logLevel >= LogLevel.FATAL) {
+    return LogLevelLabel.FATAL;
+  } else if (logLevel <= LogLevel.SILENT) {
+    return LogLevelLabel.SILENT;
   } else {
-    return originalResolveFilename.apply(this, arguments);
+    return LogLevelLabel.INFO;
+  }
+};
+
+// packages/config-tools/src/env/get-env.ts
+var getExtensionEnv = (extensionName) => {
+  const prefix = `STORM_EXTENSION_${extensionName.toUpperCase()}_`;
+  return Object.keys(process.env).filter((key) => key.startsWith(prefix)).reduce((ret, key) => {
+    const name = key.replace(prefix, "").split("_").map(
+      (i) => i.length > 0 ? i.trim().charAt(0).toUpperCase() + i.trim().slice(1) : ""
+    ).join("");
+    name && (ret[name] = process.env[key]);
+    return ret;
+  }, {});
+};
+var getConfigEnv = () => {
+  const prefix = `STORM_`;
+  let config = {
+    name: process.env[`${prefix}NAME`],
+    namespace: process.env[`${prefix}NAMESPACE`],
+    owner: process.env[`${prefix}OWNER`],
+    worker: process.env[`${prefix}WORKER`],
+    organization: process.env[`${prefix}ORGANIZATION`],
+    license: process.env[`${prefix}LICENSE`],
+    homepage: process.env[`${prefix}HOMEPAGE`],
+    timezone: process.env[`${prefix}TIMEZONE`] ?? process.env.TZ,
+    locale: process.env[`${prefix}LOCALE`] ?? process.env.LOCALE,
+    configFile: process.env[`${prefix}CONFIG_FILE`],
+    workspaceRoot: process.env[`${prefix}WORKSPACE_ROOT`],
+    packageDirectory: process.env[`${prefix}PACKAGE_DIRECTORY`],
+    buildDirectory: process.env[`${prefix}BUILD_DIRECTORY`],
+    runtimeVersion: process.env[`${prefix}RUNTIME_VERSION`],
+    runtimeDirectory: process.env[`${prefix}RUNTIME_DIRECTORY`],
+    env: process.env[`${prefix}ENV`] ?? process.env.NODE_ENV ?? process.env.ENVIRONMENT,
+    ci: Boolean(
+      process.env[`${prefix}CI`] ?? process.env.CI ?? process.env.CONTINUOUS_INTEGRATION
+    ),
+    colors: {
+      primary: process.env[`${prefix}COLOR_PRIMARY`],
+      background: process.env[`${prefix}COLOR_BACKGROUND`],
+      success: process.env[`${prefix}COLOR_SUCCESS`],
+      info: process.env[`${prefix}COLOR_INFO`],
+      warning: process.env[`${prefix}COLOR_WARNING`],
+      error: process.env[`${prefix}COLOR_ERROR`],
+      fatal: process.env[`${prefix}COLOR_FATAL`]
+    },
+    repository: process.env[`${prefix}REPOSITORY`],
+    branch: process.env[`${prefix}BRANCH`],
+    preMajor: Boolean(process.env[`${prefix}PRE_MAJOR`]),
+    logLevel: process.env[`${prefix}LOG_LEVEL`] !== null && process.env[`${prefix}LOG_LEVEL`] !== void 0 ? Number.isSafeInteger(
+      Number.parseInt(process.env[`${prefix}LOG_LEVEL`])
+    ) ? getLogLevelLabel(Number.parseInt(process.env[`${prefix}LOG_LEVEL`])) : process.env[`${prefix}LOG_LEVEL`] : LogLevelLabel.INFO,
+    extensions: {}
+  };
+  const serializedConfig = process.env[`${prefix}CONFIG`];
+  if (serializedConfig) {
+    config = Object.assign(config, JSON.parse(serializedConfig));
   }
+  const extensionPrefix = `${prefix}EXTENSION_`;
+  return Object.keys(process.env).filter((key) => key.startsWith(extensionPrefix)).reduce((ret, key) => {
+    const extensionName = key.substring(prefix.length, key.indexOf("_", prefix.length)).split("_").map(
+      (i) => i.length > 0 ? i.trim().charAt(0).toUpperCase() + i.trim().slice(1) : ""
+    ).join("");
+    extensionName && (ret.extensions[extensionName] = getExtensionEnv(extensionName));
+    return ret;
+  }, config);
 };
-function isFile(s) {
-  try {
-    return fs.statSync(s).isFile();
-  } catch (_e) {
-    return false;
+
+// packages/config-tools/src/create-storm-config.ts
+var _extension_cache = /* @__PURE__ */ new WeakMap();
+var _static_cache2 = void 0;
+var createStormConfig = (extensionName, schema) => {
+  let result;
+  if (!_static_cache2) {
+    let config = getConfigEnv();
+    result = StormConfigSchema.parse(config);
+  } else {
+    result = _static_cache2;
   }
-}
-require("./packages/config-tools/src/index.cjs");
+  if (schema && extensionName) {
+    result.extensions = {
+      ...result.extensions,
+      [extensionName]: createConfigExtension(extensionName, schema)
+    };
+  }
+  _static_cache2 = result;
+  return result;
+};
+var createConfigExtension = (extensionName, schema) => {
+  const extension_cache_key = { extensionName };
+  if (_extension_cache.has(extension_cache_key)) {
+    return _extension_cache.get(extension_cache_key);
+  }
+  let extension = getExtensionEnv(extensionName);
+  if (schema) {
+    extension = schema.parse(extension);
+  }
+  _extension_cache.set(extension_cache_key, extension);
+  return extension;
+};
+
+// packages/config-tools/src/env/set-env.ts
+var setExtensionEnv = (extensionName, extension) => {
+  Object.keys(extension ?? {}).forEach((key) => {
+    if (extension[key]) {
+      let 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;
+      } else 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];
+    }
+  });
+};
+var setConfigEnv = (config) => {
+  const prefix = `STORM_`;
+  process.env[`${prefix}NAME`] = config.name;
+  process.env[`${prefix}NAMESPACE`] = config.namespace;
+  process.env[`${prefix}OWNER`] = config.owner;
+  process.env[`${prefix}WORKER`] = config.worker;
+  process.env[`${prefix}ORGANIZATION`] = config.organization;
+  process.env[`${prefix}LICENSE`] = config.license;
+  process.env[`${prefix}HOMEPAGE`] = config.homepage;
+  process.env[`${prefix}TIMEZONE`] = config.timezone;
+  process.env.TZ = config.timezone;
+  process.env.DEFAULT_TIMEZONE = config.timezone;
+  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";
+  process.env[`${prefix}CONFIG_FILE`] = config.configFile;
+  process.env[`${prefix}WORKSPACE_ROOT`] = config.workspaceRoot;
+  process.env.NX_WORKSPACE_ROOT = config.workspaceRoot;
+  process.env.NX_WORKSPACE_ROOT_PATH = config.workspaceRoot;
+  process.env[`${prefix}PACKAGE_DIRECTORY`] = config.packageDirectory;
+  process.env[`${prefix}BUILD_DIRECTORY`] = config.buildDirectory;
+  process.env[`${prefix}RUNTIME_VERSION`] = config.runtimeVersion;
+  process.env[`${prefix}RUNTIME_DIRECTORY`] = config.runtimeDirectory;
+  process.env[`${prefix}ENV`] = config.env;
+  process.env.NODE_ENV = config.env;
+  process.env.ENVIRONMENT = config.env;
+  process.env[`${prefix}CI`] = String(config.ci);
+  process.env.CI = String(config.ci);
+  process.env.CONTINUOUS_INTEGRATION = String(config.ci);
+  process.env[`${prefix}COLOR_PRIMARY`] = config.colors.primary;
+  process.env[`${prefix}COLOR_BACKGROUND`] = config.colors.background;
+  process.env[`${prefix}COLOR_SUCCESS`] = config.colors.success;
+  process.env[`${prefix}COLOR_INFO`] = config.colors.info;
+  process.env[`${prefix}COLOR_WARNING`] = config.colors.warning;
+  process.env[`${prefix}COLOR_ERROR`] = config.colors.error;
+  process.env[`${prefix}COLOR_FATAL`] = config.colors.fatal;
+  process.env[`${prefix}REPOSITORY`] = config.repository;
+  process.env[`${prefix}BRANCH`] = config.branch;
+  process.env[`${prefix}PRE_MAJOR`] = String(config.preMajor);
+  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);
+  Object.keys(config.extensions ?? {}).forEach((key) => {
+    config.extensions[key] && Object.keys(config.extensions[key]) && setExtensionEnv(key, config.extensions[key]);
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ColorConfigSchema,
+  DefaultColorConfig,
+  DefaultStormConfig,
+  LogLevel,
+  LogLevelLabel,
+  StormConfigSchema,
+  createConfigExtension,
+  createStormConfig,
+  getConfigEnv,
+  getConfigFile,
+  getDefaultConfig,
+  getExtensionEnv,
+  getLogLevel,
+  getLogLevelLabel,
+  setConfigEnv,
+  setExtensionEnv
+});