@cenk1cenk2/oclif-common 3.9.5 → 3.9.7

package/dist/index.js

@@ -1,14 +1,7 @@
-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 __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-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))
@@ -17,1338 +10,13 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
 var src_exports = {};
-__export(src_exports, {
-  CLI_FLAGS: () => CLI_FLAGS,
-  CliUx: () => import_core2.CliUx,
-  Command: () => Command,
-  ConfigCommand: () => ConfigCommand,
-  ConfigService: () => ConfigService,
-  EnvironmentVariableParser: () => EnvironmentVariableParser,
-  FileConstants: () => FileConstants,
-  FileSystemService: () => FileSystemService,
-  Flags: () => import_core.Flags,
-  HelpGroups: () => HelpGroups,
-  JsonParser: () => JsonParser,
-  ListrLogger: () => ListrLogger,
-  LockerService: () => LockerService,
-  LogFieldStatus: () => LogFieldStatus,
-  LogLevels: () => LogLevels,
-  Logger: () => Logger,
-  MergeStrategy: () => MergeStrategy,
-  ParserService: () => ParserService,
-  StoreService: () => StoreService,
-  ValidatorService: () => ValidatorService,
-  YamlParser: () => YamlParser,
-  color: () => color,
-  fs: () => import_fs_extra.default,
-  isDebug: () => isDebug,
-  isSilent: () => isSilent,
-  isVerbose: () => isVerbose,
-  merge: () => merge,
-  notFoundHook: () => notFoundHook,
-  pipeProcessThroughListr: () => pipeProcessThroughListr,
-  pipeProcessToLogger: () => pipeProcessToLogger,
-  setCtxAssign: () => setCtxAssign,
-  setCtxDefaults: () => setCtxDefaults,
-  setup: () => setup,
-  storeHook: () => storeHook,
-  uniqueFilter: () => uniqueFilter,
-  updateNotifierHook: () => updateNotifierHook
-});
 module.exports = __toCommonJS(src_exports);
-
-// src/commands/base.command.ts
-var import_core3 = require("@oclif/core");
-var import_listr23 = require("listr2");
-var import_readline = require("readline");
-var import_reflect_metadata = require("reflect-metadata");
-
-// src/constants/file.constants.ts
-var FileConstants = /* @__PURE__ */ ((FileConstants2) => {
-  FileConstants2["CONFIG_SERVICE_DEFAULTS_DIR"] = "config";
-  return FileConstants2;
-})(FileConstants || {});
-
-// src/constants/help-groups.constants.ts
-var HelpGroups = /* @__PURE__ */ ((HelpGroups2) => {
-  HelpGroups2["CLI"] = "CLI";
-  return HelpGroups2;
-})(HelpGroups || {});
-
-// src/interfaces/oclif.interface.ts
-var import_core = require("@oclif/core");
-
-// src/utils/logger/listr-logger.ts
-var import_listr22 = require("listr2");
-
-// src/utils/logger/logger.ts
-var import_listr2 = require("listr2");
-var import_os2 = require("os");
-var import_winston = __toESM(require("winston"));
-
-// src/utils/logger/logger.constants.ts
-var LogLevels = /* @__PURE__ */ ((LogLevels2) => {
-  LogLevels2["SILENT"] = "SILENT";
-  LogLevels2["DIRECT"] = "DIRECT";
-  LogLevels2["FATAL"] = "FATAL";
-  LogLevels2["ERROR"] = "ERROR";
-  LogLevels2["WARN"] = "WARN";
-  LogLevels2["INFO"] = "INFO";
-  LogLevels2["VERBOSE"] = "VERBOSE";
-  LogLevels2["DEBUG"] = "DEBUG";
-  LogLevels2["TRACE"] = "TRACE";
-  return LogLevels2;
-})(LogLevels || {});
-var LogFieldStatus = /* @__PURE__ */ ((LogFieldStatus2) => {
-  LogFieldStatus2["RUN"] = "run";
-  LogFieldStatus2["END"] = "end";
-  LogFieldStatus2["STAGE"] = "stage";
-  LogFieldStatus2["EXIT"] = "exit";
-  LogFieldStatus2["TERMINATE"] = "terminate";
-  return LogFieldStatus2;
-})(LogFieldStatus || {});
-
-// src/lib/config/config.service.ts
-var import_object_path_immutable = __toESM(require("object-path-immutable"));
-var import_path2 = require("path");
-
-// src/lib/parser/env-parser.service.ts
-var import_os = require("os");
-var _EnvironmentVariableParser = class {
-  constructor() {
-    this.LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/gm;
-    if (_EnvironmentVariableParser.instance) {
-      return _EnvironmentVariableParser.instance;
-    }
-    _EnvironmentVariableParser.instance = this;
-    this.logger = new Logger(this.constructor.name);
-    this.logger.trace("Created a new instance.");
-  }
-  parse(data) {
-    try {
-      return data.toString().split(import_os.EOL).reduce((o, line) => {
-        const match = this.LINE.exec(line);
-        const key = match[1];
-        const value = match[2] ?? "";
-        return {
-          ...o,
-          [key]: value
-        };
-      }, {});
-    } catch (e) {
-      this.logger.trace("Error during parsing environment file: %s", e.message);
-      throw e;
-    }
-  }
-  stringify(data) {
-    return Object.entries(data).map(([k, v]) => `${k}=${v}`).join(import_os.EOL) + import_os.EOL;
-  }
-};
-var EnvironmentVariableParser = _EnvironmentVariableParser;
-__name(EnvironmentVariableParser, "EnvironmentVariableParser");
-EnvironmentVariableParser.extensions = ["env"];
-
-// src/lib/parser/json-parser.service.ts
-var _JsonParser = class {
-  constructor() {
-    if (_JsonParser.instance) {
-      return _JsonParser.instance;
-    }
-    _JsonParser.instance = this;
-    this.logger = new Logger(this.constructor.name);
-    this.logger.trace("Created a new instance.");
-  }
-  parse(data) {
-    try {
-      return JSON.parse(data.toString());
-    } catch (e) {
-      this.logger.trace("Error during parsing JSON file: %s", e.message);
-      throw e;
-    }
-  }
-  stringify(data) {
-    return JSON.stringify(data, null, 2);
-  }
-};
-var JsonParser = _JsonParser;
-__name(JsonParser, "JsonParser");
-JsonParser.extensions = ["json"];
-
-// src/lib/parser/yaml-parser.service.ts
-var import_yaml = require("yaml");
-var _YamlParser = class {
-  constructor() {
-    if (_YamlParser.instance) {
-      return _YamlParser.instance;
-    }
-    _YamlParser.instance = this;
-    this.logger = new Logger(this.constructor.name);
-    this.logger.trace("Created a new instance.");
-  }
-  parse(data) {
-    try {
-      return (0, import_yaml.parse)(data.toString());
-    } catch (e) {
-      this.logger.trace("Error during parsing YAML file: %s", e.message);
-      throw e;
-    }
-  }
-  stringify(data) {
-    return (0, import_yaml.stringify)(data, { prettyErrors: true });
-  }
-};
-var YamlParser = _YamlParser;
-__name(YamlParser, "YamlParser");
-YamlParser.extensions = ["yaml", "yml"];
-
-// src/lib/fs/filesystem.service.ts
-var import_fs_extra = __toESM(require("fs-extra"));
-var import_path = require("path");
-var FileSystemService = class {
-  constructor() {
-    if (FileSystemService.instance) {
-      return FileSystemService.instance;
-    } else {
-      FileSystemService.instance = this;
-      this.logger = new Logger(this.constructor.name);
-      this.logger.trace("Created a new instance.");
-    }
-  }
-  exists(path) {
-    return import_fs_extra.default.existsSync(path);
-  }
-  stats(path) {
-    return import_fs_extra.default.statSync(path, { throwIfNoEntry: true });
-  }
-  dirname(path) {
-    return (0, import_path.dirname)(path);
-  }
-  extname(path) {
-    return (0, import_path.extname)(path);
-  }
-  async read(file) {
-    try {
-      const raw = await import_fs_extra.default.readFile(file, "utf-8");
-      return raw;
-    } catch (e) {
-      throw new Error(`Error while reading file from "${file}": ${e.message}`);
-    }
-  }
-  readSync(file) {
-    try {
-      const raw = import_fs_extra.default.readFileSync(file, "utf-8");
-      return raw;
-    } catch (e) {
-      throw new Error(`Error while reading file from "${file}": ${e.message}`);
-    }
-  }
-  async write(file, data, options = {}) {
-    try {
-      await import_fs_extra.default.writeFile(file, data, { encoding: "utf-8", ...options });
-    } catch (e) {
-      throw new Error(`Error while writing file to "${file}": ${e.message}`);
-    }
-  }
-  writeSync(file, data, options = {}) {
-    try {
-      import_fs_extra.default.writeFileSync(file, data, { encoding: "utf-8", ...options });
-    } catch (e) {
-      throw new Error(`Error while writing file to "${file}": ${e.message}`);
-    }
-  }
-  async append(file, data, options) {
-    try {
-      await import_fs_extra.default.appendFile(file, data, options);
-    } catch (e) {
-      throw new Error(`Error while appending to file  "${file}": ${e.message}`);
-    }
-  }
-  appendSync(file, data) {
-    try {
-      import_fs_extra.default.appendFileSync(file, data);
-    } catch (e) {
-      throw new Error(`Error while appending to file  "${file}": ${e.message}`);
-    }
-  }
-  async remove(file, options) {
-    try {
-      await import_fs_extra.default.rm(file, options);
-    } catch (e) {
-      throw new Error(`Error while deleting the file "${file}": ${e.message}`);
-    }
-  }
-  removeSync(file, options) {
-    try {
-      import_fs_extra.default.rmSync(file, options);
-    } catch (e) {
-      throw new Error(`Error while deleting the file "${file}": ${e.message}`);
-    }
-  }
-  async emptyDir(directory) {
-    try {
-      await import_fs_extra.default.emptyDir(directory);
-    } catch (e) {
-      throw new Error(`Error while emptying the directory "${directory}": ${e.message}`);
-    }
-  }
-  emptyDirSync(directory) {
-    try {
-      import_fs_extra.default.emptyDirSync(directory);
-    } catch (e) {
-      throw new Error(`Error while emptying the directory "${directory}": ${e.message}`);
-    }
-  }
-  async removeDir(directory) {
-    try {
-      await import_fs_extra.default.rmdir(directory);
-    } catch (e) {
-      throw new Error(`Error while removing the directory "${directory}": ${e.message}`);
-    }
-  }
-  removeDirSync(directory) {
-    try {
-      import_fs_extra.default.rmdirSync(directory);
-    } catch (e) {
-      throw new Error(`Error while removing the directory "${directory}": ${e.message}`);
-    }
-  }
-  async mkdir(directory) {
-    try {
-      await import_fs_extra.default.mkdirp(directory);
-    } catch (e) {
-      throw new Error(`Error while creating the directory "${directory}": ${e.message}`);
-    }
-  }
-  mkdirSync(directory) {
-    try {
-      import_fs_extra.default.mkdirSync(directory);
-    } catch (e) {
-      throw new Error(`Error while creating the directory "${directory}": ${e.message}`);
-    }
-  }
-};
-__name(FileSystemService, "FileSystemService");
-
-// src/lib/parser/parser.service.ts
-var ParserService = class {
-  constructor(parsers) {
-    this.parsers = [YamlParser, JsonParser, EnvironmentVariableParser];
-    if (ParserService.instance) {
-      return ParserService.instance;
-    } else {
-      if (parsers) {
-        this.parsers = parsers;
-      }
-      this.logger = new Logger(this.constructor.name);
-      this.fs = new FileSystemService();
-      ParserService.instance = this;
-      this.logger.trace("Created a new instance.");
-    }
-  }
-  getParser(file) {
-    const ext = (file.includes(".") ? this.fs.extname(file) : file).replace(/^\./, "");
-    const Parser = this.parsers.find((parser) => parser.extensions.includes(ext));
-    if (!Parser) {
-      throw new Error(`Parser for the extension is not configured: ${ext}`);
-    }
-    return new Parser();
-  }
-  setParsers(...parsers) {
-    this.parsers = parsers;
-    this.logger.trace(
-      "Set parsers: %s",
-      this.parsers.map((p) => p.name)
-    );
-  }
-  addParsers(...parsers) {
-    this.parsers.push(...parsers);
-    this.logger.trace(
-      "Added parser, current parsers: %s",
-      this.parsers.map((p) => p.name)
-    );
-  }
-  async read(file) {
-    return this.parse(file, await this.fs.read(file));
-  }
-  async write(file, data) {
-    return this.fs.write(file, await this.stringify(file, data));
-  }
-  parse(file, data) {
-    const parser = this.getParser(file);
-    this.logger.trace("Parsing file: %s -> %s", file, parser.constructor.name);
-    return parser.parse(data);
-  }
-  stringify(file, data) {
-    const parser = this.getParser(file);
-    this.logger.trace("Stringifying file: %s -> %s", file, parser.constructor.name);
-    return parser.stringify(data);
-  }
-};
-__name(ParserService, "ParserService");
-
-// src/utils/color.ts
-var colorette = __toESM(require("colorette"));
-var color = colorette.createColors({ useColor: true });
-
-// src/utils/environment.ts
-function isVerbose(logLevel) {
-  return logLevel === "VERBOSE" /* VERBOSE */;
-}
-__name(isVerbose, "isVerbose");
-function isDebug(logLevel) {
-  return ["DEBUG" /* DEBUG */, "TRACE" /* TRACE */].includes(logLevel);
-}
-__name(isDebug, "isDebug");
-function isSilent(logLevel) {
-  return logLevel === "SILENT" /* SILENT */;
-}
-__name(isSilent, "isSilent");
-
-// src/utils/merge.constants.ts
-var MergeStrategy = /* @__PURE__ */ ((MergeStrategy2) => {
-  MergeStrategy2["OVERWRITE"] = "OVERWRITE";
-  MergeStrategy2["EXTEND"] = "EXTEND";
-  return MergeStrategy2;
-})(MergeStrategy || {});
-
-// src/utils/merge.ts
-var import_deepmerge = __toESM(require("deepmerge"));
-function merge(strategy, ...source) {
-  return import_deepmerge.default.all(source, {
-    arrayMerge: strategy === "EXTEND" /* EXTEND */ ? (dest, src) => [...dest, ...src].filter(uniqueFilter) : (_, src) => src
-  });
-}
-__name(merge, "merge");
-function uniqueFilter(value, index, self) {
-  return self.indexOf(value) === index;
-}
-__name(uniqueFilter, "uniqueFilter");
-
-// src/utils/defaults.ts
-function setCtxDefaults(ctx, ...defaults) {
-  defaults?.forEach((i) => {
-    if (typeof i === "object" && !Array.isArray(i)) {
-      Object.assign(ctx, i);
-    }
-  });
-}
-__name(setCtxDefaults, "setCtxDefaults");
-function setCtxAssign(ctx, ...assigns) {
-  assigns.forEach((assign) => {
-    assign?.keys.forEach((i) => {
-      if (assign.from[i]) {
-        ctx[i] = assign.from[i];
-      }
-    });
-  });
-}
-__name(setCtxAssign, "setCtxAssign");
-
-// src/utils/index.ts
-var import_core2 = require("@oclif/core");
-
-// src/lib/config/config.service.ts
-var ConfigService = class {
-  constructor(oclif, command, config) {
-    this.oclif = oclif;
-    this.command = command;
-    if (ConfigService.instance) {
-      if (Object.entries(config).some(([key, value]) => value !== ConfigService.instance[key])) {
-        ConfigService.instance.recalculate(config);
-      }
-      return ConfigService.instance;
-    }
-    this.root = this.oclif.root;
-    this.defaults = (0, import_path2.join)(this.oclif.root, "config" /* CONFIG_SERVICE_DEFAULTS_DIR */);
-    this.logger = new Logger(this.constructor.name, { level: config.logLevel });
-    this.parser = new ParserService();
-    this.recalculate(config);
-    ConfigService.instance = this;
-    this.logger.trace("Created a new instance.");
-  }
-  async read(path) {
-    const config = await this.parser.read(path);
-    this.logger.trace("Read config from: %s", path);
-    return config;
-  }
-  async extend(paths, strategy = "OVERWRITE" /* OVERWRITE */) {
-    this.logger.trace("Will generate config from: %o with %s", paths, strategy);
-    const configs = (await Promise.all(
-      paths.map(async (path) => {
-        try {
-          const config = typeof path === "string" ? await this.parser.read(path) : path;
-          this.logger.trace("Extending config from: %s", path);
-          return config;
-        } catch (e) {
-          this.logger.trace("Failed to extend config from: %s", e.message);
-        }
-      })
-    )).filter(Boolean);
-    return this.merge(configs, strategy);
-  }
-  merge(configs, strategy = "OVERWRITE" /* OVERWRITE */) {
-    if (configs.length === 0) {
-      throw new Error("Nothing to merge, configuration files are empty.");
-    }
-    return merge(strategy, ...configs);
-  }
-  async env(definition, config) {
-    const env = typeof definition === "string" ? await this.parser.read(definition) : definition;
-    this.logger.trace("Environment variable extensions read: %o", definition);
-    const iter = /* @__PURE__ */ __name(async (obj, parent) => {
-      const data = await Promise.all(
-        Object.entries(obj).map(async ([key, value]) => {
-          const location = [...parent ?? [], key];
-          if (typeof value === "string") {
-            return [{ key: location, env: value }];
-          } else if (typeof value === "object") {
-            let extensions;
-            if ("__element" /* ELEMENT */ in value) {
-              extensions = await iter(value["__element" /* ELEMENT */], [...location, "__element" /* ELEMENT */]);
-              this.logger.trace("Expanding location to elements: %s -> %s", location, extensions.map((extension) => extension.key.join(".")).join(", "));
-            }
-            if ("__name" /* NAME */ in value && "__format" /* PARSER */ in value) {
-              const variable = [
-                {
-                  key: location,
-                  env: value["__name" /* NAME */],
-                  parser: value["__format" /* PARSER */],
-                  extensions
-                }
-              ];
-              return variable;
-            } else {
-              return iter(value, location);
-            }
-          }
-        })
-      );
-      return data.flatMap((d) => d).filter(Boolean);
-    }, "iter");
-    const parsed = await iter(env);
-    const cb = /* @__PURE__ */ __name((config2, variable, data) => {
-      if (variable.parser) {
-        try {
-          data = this.parser.parse(variable.parser, data);
-        } catch (e) {
-          this.logger.trace("Can not parse environment environment variable for config: %s -> %s with %s", variable.key.join("."), variable.env, variable.parser);
-          throw e;
-        }
-      }
-      this.logger.trace("Overwriting config with environment variable: %s -> %s", variable.key.join("."), variable.env);
-      return import_object_path_immutable.default.set(config2, variable.key, data);
-    }, "cb");
-    parsed.forEach((variable) => {
-      let data;
-      data = process.env[variable.env];
-      if (data) {
-        config = cb(config, variable, data);
-      }
-      if (variable.extensions && variable.extensions.length > 0) {
-        const timeout = 6e4;
-        const startedAt = Date.now();
-        for (let i = 0; i < Infinity; i++) {
-          if (Date.now() - startedAt > timeout) {
-            throw new Error(`Timed-out in ${timeout}ms while looking for element environment variables.`);
-          }
-          const extensions = variable.extensions.map((extension) => {
-            const clone = JSON.parse(JSON.stringify(extension));
-            clone.env = clone.env.replace("${i}" /* ELEMENT_REPLACER */, i.toString());
-            clone.key[clone.key.findIndex((value) => value === "__element" /* ELEMENT */)] = i.toString();
-            data = process.env[clone.env];
-            if (!data) {
-              this.logger.trace("No extension for environment variable: %s -> %s", clone.key.join("."), clone.env);
-              return;
-            }
-            config = cb(config, clone, data);
-            return true;
-          }).filter(Boolean);
-          if (extensions.length === 0) {
-            this.logger.trace("No more extensions for environment variables: %s -> %d", variable.key.join("."), i);
-            break;
-          }
-        }
-      }
-    });
-    return config;
-  }
-  async write(path, data) {
-    return this.parser.write(path, data);
-  }
-  recalculate(config) {
-    this.ci = config.ci;
-    this.json = config.json;
-    this.logLevel = config.logLevel;
-    this.isVerbose = isVerbose(config.logLevel);
-    this.isDebug = isDebug(config.logLevel);
-    this.isSilent = isSilent(config.logLevel);
-  }
-};
-__name(ConfigService, "ConfigService");
-
-// src/lib/locker/locker.service.ts
-var import_object_path_immutable2 = __toESM(require("object-path-immutable"));
-var LockerService = class {
-  constructor(file, parser, root, context) {
-    this.file = file;
-    this.parser = parser;
-    this.root = root;
-    this.toLock = [];
-    this.toUnlock = [];
-    this.fs = new FileSystemService();
-    this.logger = new Logger(context ?? this.constructor.name);
-    if (!this.parser) {
-      const parser2 = new ParserService();
-      this.parser = parser2.getParser(file);
-    }
-  }
-  hasLock() {
-    return this.toLock.length > 0;
-  }
-  hasUnlock() {
-    return this.toUnlock.length > 0;
-  }
-  addLock(...data) {
-    this.toLock = [...this.toLock, ...data];
-  }
-  addUnlock(...data) {
-    this.toUnlock = [...this.toUnlock, ...data];
-  }
-  async lockAll() {
-    if (this.hasLock()) {
-      await this.lock(...this.toLock);
-      this.toLock = [];
-    }
-  }
-  async unlockAll() {
-    if (this.toUnlock.length > 0) {
-      await this.unlock(...this.toUnlock);
-      this.toUnlock = [];
-    }
-  }
-  async all() {
-    await this.unlockAll();
-    await this.lockAll();
-  }
-  async lock(...data) {
-    let lock = await this.tryRead() ?? {};
-    data.forEach((d) => {
-      if (d?.enabled === false) {
-        return;
-      } else if (!d?.data || Array.isArray(d?.data) && d.data.length === 0 || typeof d?.data === "object" && Object.keys(d.data).length === 0) {
-        return;
-      }
-      const path = this.buildPath(d);
-      if (d?.merge) {
-        let parsed;
-        if (typeof d.data === "object") {
-          parsed = merge(d.merge, import_object_path_immutable2.default.get(lock, path, Array.isArray(d.data) ? [] : {}), d.data);
-        } else {
-          this.logger.warn('"%s" path with type "%s" is not mergeable.', path, typeof d.data);
-          parsed = d.data;
-        }
-        lock = import_object_path_immutable2.default.set(lock, path, parsed);
-        this.logger.verbose("Merge lock: %s -> %o", path, d.data);
-      } else {
-        lock = import_object_path_immutable2.default.set(lock, path, d.data);
-        this.logger.verbose("Override lock: %s -> %o", path, d.data);
-      }
-    });
-    await this.write(lock);
-  }
-  async unlock(...data) {
-    let lock = await this.tryRead();
-    if (!lock) {
-      this.logger.verbose("Lock file not found. Nothing to unlock.");
-      return;
-    }
-    if (data.length > 0) {
-      data.forEach((d) => {
-        if (d?.enabled === false) {
-          return;
-        }
-        const path = this.buildPath(d);
-        lock = import_object_path_immutable2.default.del(lock, path);
-        this.logger.verbose("Unlocked: %s", path);
-        for (let i = path.length - 1; i >= 0; i--) {
-          const parentPath = path.slice(0, i);
-          const parent = import_object_path_immutable2.default.get(lock, parentPath);
-          if (!parent || Array.isArray(parent) && parent.length === 0 || typeof parent === "object" && Object.keys(parent).length === 0) {
-            this.logger.verbose("Unlocked parent: %s -> %s", path, parentPath);
-            lock = import_object_path_immutable2.default.del(lock, parentPath);
-          } else {
-            break;
-          }
-        }
-      });
-    } else {
-      lock = import_object_path_immutable2.default.del(lock, this.root);
-      this.logger.verbose("Unlocked module: %s", this.root);
-    }
-    await this.write(lock ?? {});
-  }
-  async read() {
-    return this.parser.parse(await this.fs.read(this.file));
-  }
-  async tryRead() {
-    try {
-      return this.parser.parse(await this.fs.read(this.file));
-    } catch {
-      this.logger.trace("Can not read lockfile: %s", this.file);
-    }
-  }
-  async write(data) {
-    if (!data || Array.isArray(data) && data.length === 0 || typeof data === "object" && Object.keys(data).length === 0) {
-      this.logger.trace("Trying to write empty lock file, deleting it instead: %s", this.file);
-      return this.fs.remove(this.file);
-    }
-    return this.fs.write(this.file, this.parser.stringify(data));
-  }
-  buildPath(d) {
-    if (d?.root !== true && this.root?.length) {
-      return [...this.root, ...this.normalizePath(d.path)];
-    }
-    return this.normalizePath(d.path);
-  }
-  normalizePath(path) {
-    if (Array.isArray(path)) {
-      return path.map((p) => p.toString());
-    } else if (typeof path === "string") {
-      return path.split(".");
-    }
-    return [];
-  }
-};
-__name(LockerService, "LockerService");
-
-// src/lib/store/store.service.ts
-var StoreService = class {
-  constructor() {
-    this.store = {};
-    if (StoreService.instance) {
-      return StoreService.instance;
-    } else {
-      StoreService.instance = this;
-    }
-  }
-  has(key) {
-    return !!this.store[key];
-  }
-  get(key) {
-    return this.store[key];
-  }
-  set(key, data) {
-    this.store[key] = data;
-    return data;
-  }
-};
-__name(StoreService, "StoreService");
-
-// src/lib/validator/validator.service.ts
-var import_class_transformer = require("class-transformer");
-var import_class_validator = require("class-validator");
-var ValidatorService = class {
-  constructor(options) {
-    this.options = options;
-    if (ValidatorService.instance) {
-      return ValidatorService.instance;
-    }
-    this.options = {
-      validator: {
-        skipMissingProperties: true,
-        whitelist: false,
-        always: true,
-        enableDebugMessages: true
-      },
-      transformer: { enableImplicitConversion: true },
-      ...options ?? {}
-    };
-    this.logger = new Logger(this.constructor.name);
-    ValidatorService.instance = this;
-    this.logger.trace("Created a new instance.");
-  }
-  async validate(classType, object, options) {
-    const classObject = (0, import_class_transformer.plainToClass)(classType, object, { ...this.options.transformer, ...options?.transformer ?? {} });
-    const errors = await (0, import_class_validator.validate)(classObject, { ...this.options.validator, ...options?.validator ?? {} });
-    if (errors.length) {
-      errors.forEach((error) => {
-        this.logValidationError(error);
-      });
-      throw new Error("Validation failed.");
-    }
-    return classObject;
-  }
-  validateSync(classType, object, options) {
-    const classObject = (0, import_class_transformer.plainToClass)(classType, object, { ...this.options.transformer, ...options?.transformer ?? {} });
-    const errors = (0, import_class_validator.validateSync)(classObject, { ...this.options.validator, ...options?.validator ?? {} });
-    if (errors.length) {
-      errors.forEach((error) => {
-        this.logValidationError(error);
-      });
-      throw new Error("Validation failed.");
-    }
-    return classObject;
-  }
-  logValidationError(err) {
-    this.logger.error('Field "%s" failed validation with value "%s": %s', err.property, err.value, Object.values(err.constraints).join(", "));
-  }
-};
-__name(ValidatorService, "ValidatorService");
-
-// src/lib/setup.ts
-function setup() {
-  const inspect = process.argv.indexOf("--inspect");
-  if (inspect !== -1) {
-    require("inspector").open();
-    process.argv.splice(inspect, 1);
-  }
-  const verbose = process.argv.indexOf("--verbose");
-  if (verbose !== -1) {
-    process.env.LOG_LEVEL = "verbose";
-    process.argv.splice(verbose, 1);
-  }
-  const debug = process.argv.indexOf("--debug");
-  if (debug !== -1) {
-    process.env.LOG_LEVEL = "debug";
-    process.argv.splice(debug, 1);
-  }
-  const trace = process.argv.indexOf("--trace");
-  if (trace !== -1) {
-    process.env.LOG_LEVEL = "trace";
-    process.argv.splice(trace, 1);
-  }
-  const silent = process.argv.indexOf("--silent");
-  if (silent !== -1) {
-    process.env.LOG_LEVEL = "silent";
-    process.argv.splice(silent, 1);
-  }
-  const sourceMaps = process.argv.indexOf("--source-map");
-  if (sourceMaps !== -1) {
-    require("source-map-support").install();
-    process.argv.splice(sourceMaps, 1);
-  }
-}
-__name(setup, "setup");
-
-// src/utils/logger/logger.ts
-var Logger = class {
-  constructor(context, options) {
-    this.context = context;
-    this.options = options;
-    const parsed = (process.env.LOG_LEVEL ?? options?.level ?? "INFO" /* INFO */).toUpperCase();
-    const level = Object.values(LogLevels).includes(parsed) ? parsed : "INFO" /* INFO */;
-    this.options = {
-      useIcons: true,
-      ...options,
-      level
-    };
-    if (Logger.instance) {
-      this.logger = Logger.instance;
-    } else if (context === ConfigService.name) {
-      this.logger = this.initiateLogger();
-      this.trace("Logger singleton initiated from context: %s", context);
-      Logger.instance = this.logger;
-    }
-  }
-  log(level, data, ...args) {
-    return this.parseMessage(level, data, args);
-  }
-  direct(data, ...args) {
-    return this.parseMessage("DIRECT" /* DIRECT */, data, args);
-  }
-  fatal(data, ...args) {
-    return this.parseMessage("FATAL" /* FATAL */, data, args);
-  }
-  error(data, ...args) {
-    return this.parseMessage("ERROR" /* ERROR */, data, args);
-  }
-  warn(data, ...args) {
-    return this.parseMessage("WARN" /* WARN */, data, args);
-  }
-  info(data, ...args) {
-    return this.parseMessage("INFO" /* INFO */, data, args);
-  }
-  debug(data, ...args) {
-    return this.parseMessage("DEBUG" /* DEBUG */, data, args);
-  }
-  verbose(data, ...args) {
-    return this.parseMessage("VERBOSE" /* VERBOSE */, data, args);
-  }
-  trace(data, ...args) {
-    return this.parseMessage("TRACE" /* TRACE */, data, args);
-  }
-  run(data, ...args) {
-    return this.parseMessage("INFO" /* INFO */, data, args, { status: "run" /* RUN */ });
-  }
-  end(data, ...args) {
-    return this.parseMessage("INFO" /* INFO */, data, args, { status: "end" /* END */ });
-  }
-  stage(data, ...args) {
-    return this.parseMessage("TRACE" /* TRACE */, data, args, { status: "stage" /* STAGE */ });
-  }
-  initiateLogger() {
-    const logFormat = import_winston.format.printf(({ level, message, context, status }) => {
-      let multiLineMessage;
-      multiLineMessage = message.split(import_os2.EOL);
-      multiLineMessage = multiLineMessage.filter((msg) => msg.trim() !== "").filter(Boolean);
-      multiLineMessage = multiLineMessage.map((msg) => {
-        return this.logColoring({
-          level,
-          message: msg,
-          context,
-          status
-        });
-      });
-      return multiLineMessage.join(import_os2.EOL);
-    });
-    const logger = import_winston.default.createLogger({
-      level: this.options.level,
-      format: import_winston.format.combine(import_winston.format.splat(), import_winston.format.json({ space: 2 }), import_winston.format.prettyPrint(), logFormat),
-      levels: Object.values(LogLevels).reduce((o, level, i) => {
-        return {
-          ...o,
-          [level]: i
-        };
-      }, {}),
-      silent: this.options.level === "SILENT" /* SILENT */,
-      transports: [
-        new import_winston.transports.Console({
-          stderrLevels: ["FATAL" /* FATAL */, "ERROR" /* ERROR */]
-        })
-      ]
-    });
-    logger.log("TRACE" /* TRACE */, "Initiated new logger with level: %s", this.options.level, { context: this.constructor.name });
-    return logger;
-  }
-  parseMessage(level, data, args, format2) {
-    if (!this.logger && !Logger.instance) {
-      return;
-    } else if (Logger.instance) {
-      this.logger = Logger.instance;
-    }
-    this.logger.log(level, data.toString(), ...args ?? [], { context: this.context, ...format2 ?? {} });
-  }
-  logColoring({ level, message, context, status }) {
-    let icon;
-    let coloring = /* @__PURE__ */ __name((input) => {
-      return input;
-    }, "coloring");
-    let msgColoring = /* @__PURE__ */ __name((input) => {
-      return input;
-    }, "msgColoring");
-    switch (level) {
-      case "DIRECT" /* DIRECT */:
-        return message;
-      case "FATAL" /* FATAL */:
-        coloring = /* @__PURE__ */ __name((input) => color.red(input), "coloring");
-        if (this.options?.useIcons) {
-          icon = import_listr2.figures.checkboxOn;
-        }
-        break;
-      case "ERROR" /* ERROR */:
-        coloring = color.red;
-        if (this.options?.useIcons) {
-          icon = import_listr2.figures.cross;
-        }
-        break;
-      case "WARN" /* WARN */:
-        coloring = color.yellow;
-        if (this.options?.useIcons) {
-          icon = import_listr2.figures.warning;
-        }
-        break;
-      case "INFO" /* INFO */:
-        coloring = color.green;
-        if (this.options?.useIcons) {
-          icon = import_listr2.figures.pointerSmall;
-        }
-        break;
-      case "VERBOSE" /* VERBOSE */:
-        coloring = color.dim;
-        if (this.options?.useIcons) {
-          icon = "\u2607";
-        }
-        break;
-      case "DEBUG" /* DEBUG */:
-        coloring = color.cyan;
-        msgColoring = color.dim;
-        if (this.options?.useIcons) {
-          icon = "\uF188";
-        }
-        break;
-      case "TRACE" /* TRACE */:
-        coloring = color.magenta;
-        msgColoring = color.dim;
-        if (this.options?.useIcons) {
-          icon = "\u26B1";
-        }
-        break;
-    }
-    if (!icon) {
-      icon = `[${level.at(0).toUpperCase()}]`;
-    }
-    return `${coloring(icon)}${context ? " " + coloring(`[${context}]`) : ""}${status ? " " + coloring(`[${status}]`) : ""} ${msgColoring(message)}`;
-  }
-};
-__name(Logger, "Logger");
-
-// src/utils/logger/listr-logger.ts
-var ListrLogger = class extends import_listr22.Logger {
-  constructor(context) {
-    super();
-    this.logger = new Logger(context);
-  }
-  fail(message) {
-    this.logger.error(message);
-  }
-  skip(message) {
-    this.logger.warn(message, { status: "skip" });
-  }
-  success(message) {
-    this.logger.info(message, { status: "end" });
-  }
-  data(message) {
-    this.logger.info(message);
-  }
-  start(message) {
-    this.logger.info(message, { status: "run" });
-  }
-  title(message) {
-    this.logger.info(message);
-  }
-  retry(message) {
-    this.logger.warn(message, { status: "retry" });
-  }
-  rollback(message) {
-    this.logger.error(message, { status: "rollback" });
-  }
-};
-__name(ListrLogger, "ListrLogger");
-
-// src/utils/logger/pipe/pipe-process-to-listr.ts
-var import_through = __toESM(require("through"));
-function pipeProcessThroughListr(task, instance) {
-  const logOut = (0, import_through.default)((chunk) => {
-    task.output = chunk?.toString("utf-8").trim();
-  });
-  instance.stdout.pipe(logOut);
-  instance.stderr.pipe(logOut);
-  return instance;
-}
-__name(pipeProcessThroughListr, "pipeProcessThroughListr");
-
-// src/utils/logger/pipe/pipe-process-to-logger.ts
-var import_through2 = __toESM(require("through"));
-function pipeProcessToLogger(logger, instance, options) {
-  options = {
-    start: "INFO" /* INFO */,
-    end: "INFO" /* INFO */,
-    stdout: "INFO" /* INFO */,
-    stderr: "WARN" /* WARN */,
-    ...options
-  };
-  if (options.start) {
-    logger.run(instance.spawnargs.join(" "), { level: options.start });
-  }
-  if (instance.stdout) {
-    instance.stdout.pipe(
-      (0, import_through2.default)((chunk) => {
-        logger.log(options.stdout, chunk);
-      })
-    );
-  }
-  if (instance.stderr) {
-    instance.stderr.pipe(
-      (0, import_through2.default)((chunk) => {
-        logger.log(options.stderr, chunk);
-      })
-    );
-  }
-  void instance.on("exit", (code, signal) => {
-    const message = `Process ended with code ${code}${signal ? ` and signal ${signal}` : ""}.`;
-    logger.debug(message);
-    if (options.end) {
-      logger.end(instance.spawnargs.join(" "), { level: options.end });
-    }
-    if (options?.callback) {
-      options.callback();
-    }
-  });
-  void instance.on("error", (error) => {
-    logger.fatal(error.message);
-    logger.debug(error.stack);
-    if (options?.callback) {
-      options.callback(error);
-    }
-  });
-  return instance;
-}
-__name(pipeProcessToLogger, "pipeProcessToLogger");
-
-// src/constants/global-flags.constants.ts
-var CLI_FLAGS = {
-  ["log-level"]: import_core.Flags.enum({
-    default: "INFO" /* INFO */,
-    env: "LOG_LEVEL",
-    description: "Set the log level of the application.",
-    options: [...Object.values(LogLevels), ...Object.values(LogLevels).map((level) => level.toLowerCase())],
-    helpGroup: "CLI" /* CLI */,
-    parse: async (input) => input?.toUpperCase()
-  }),
-  ci: import_core.Flags.boolean({
-    default: false,
-    env: "CI",
-    description: "Instruct whether this is running the CI/CD configuration.",
-    helpGroup: "CLI" /* CLI */
-  }),
-  json: import_core.Flags.boolean({
-    default: false,
-    env: "JSON",
-    description: "Put the CLI to respond in JSON.",
-    helpGroup: "CLI" /* CLI */
-  })
-};
-
-// src/commands/base.command.ts
-var Command = class extends import_core3.Command {
-  constructor() {
-    super(...arguments);
-    this.flags = {};
-    this.args = {};
-  }
-  static get globalFlags() {
-    return { ...CLI_FLAGS, ...this._globalFlags };
-  }
-  static set globalFlags(flags) {
-    this._globalFlags = Object.assign({}, this.globalFlags, flags);
-    this.flags = {};
-  }
-  shouldRunBefore() {
-  }
-  shouldRunAfter(_ctx) {
-  }
-  run() {
-    throw new Error("The command should have a run function to do something!");
-  }
-  async _run() {
-    let result;
-    try {
-      delete process.env[this.config.scopedEnvVarKey("REDIRECTED")];
-      await this.init();
-      result = await this.run();
-      await this.finally();
-    } catch (error) {
-      await this.catch(error, 127);
-    }
-    if (result && this.jsonEnabled()) {
-      import_core2.CliUx.ux.styledJSON(this.toSuccessJson(result));
-    }
-    return result;
-  }
-  exit(code) {
-    this.logger.trace("Code -> %d", code, { status: "exit" /* EXIT */ });
-    process.exit(code ?? 0);
-  }
-  runTasks() {
-    return this.tasks.runAll();
-  }
-  prompt(options) {
-    return (0, import_listr23.createPrompt)(options, {
-      error: true,
-      stdout: process.stdout
-    });
-  }
-  setCtxDefaults(...defaults) {
-    setCtxDefaults(this.tasks.options.ctx, ...defaults);
-    this.logger.trace("Updated context with defaults: %o", this.tasks.options.ctx, { status: "ctx" });
-  }
-  setCtxAssign(...assigns) {
-    setCtxAssign(this.tasks.options.ctx, ...assigns);
-    this.logger.trace("Updated context with assign: %o", this.tasks.options.ctx, { status: "ctx" });
-  }
-  async init() {
-    await super.init();
-    let err;
-    try {
-      const { flags, args } = await this.parse();
-      this.flags = flags;
-      this.args = args;
-    } catch (e) {
-      err = e;
-    }
-    this.cs = new ConfigService(this.config, this.ctor, {
-      logLevel: this.flags["log-level"],
-      ci: this.flags.ci,
-      json: this.flags.json
-    });
-    const context = this.cs.command.id ? this.cs.command.id : this.cs.command.name;
-    this.logger = new Logger(null, { level: this.cs.logLevel });
-    this.store = new StoreService();
-    this.greet();
-    if (err) {
-      throw err;
-    }
-    this.logger.stage("Initiating services.");
-    this.parser = new ParserService();
-    this.fs = new FileSystemService();
-    this.validator = new ValidatorService();
-    this.tasks = new import_listr23.Manager({
-      rendererFallback: this.cs.isDebug,
-      rendererSilent: this.cs.isSilent,
-      nonTTYRendererOptions: {
-        logEmptyTitle: false,
-        logTitleChange: false,
-        logger: ListrLogger,
-        options: [context]
-      },
-      ctx: {}
-    });
-    if (this.cs.oclif.windows) {
-      (0, import_readline.createInterface)({
-        input: process.stdin,
-        output: process.stdout
-      }).on("SIGINT", () => {
-        process.kill(process.pid, "SIGINT");
-      });
-    }
-    const terminate = /* @__PURE__ */ __name(() => {
-      this.logger.fatal("Caught terminate signal.", { status: "terminate" /* TERMINATE */ });
-      process.exit(1);
-    }, "terminate");
-    process.on("SIGINT", terminate);
-    process.on("SIGTERM", terminate);
-    this.logger.stage("Running shouldRunBefore.");
-    await this.shouldRunBefore();
-    this.logger.stage("Finished shouldRunBefore.");
-  }
-  async finally() {
-    this.logger.stage("Running tasks.");
-    const ctx = await this.runTasks();
-    this.logger.stage("Finished tasks.");
-    this.logger.stage("Running shouldRunAfter.");
-    await this.shouldRunAfter(ctx);
-    this.logger.stage("Finished shouldRunAfter.");
-    return { ctx };
-  }
-  catch(e, exit) {
-    this.logger.fatal(e.message);
-    this.logger.debug(e.stack, { context: "crash" });
-    if (exit > 0) {
-      this.exit(exit);
-    }
-    return;
-  }
-  greet() {
-    if (this.cs.isSilent || this.cs.json) {
-      return;
-    }
-    const logo = this.store.get("logo") ?? `${this.cs.oclif.name} v${this.cs.oclif.version}`;
-    this.logger.direct(logo);
-    if (!this.store.has("logo")) {
-      this.logger.direct("-".repeat(logo.length));
-    }
-  }
-};
-__name(Command, "Command");
-
-// src/commands/config.command.ts
-var ConfigCommand = class extends Command {
-  constructor() {
-    super(...arguments);
-    this.ux = import_core2.CliUx.ux;
-  }
-  async run() {
-    this.logger.stage("Setting up config command.");
-    const setup2 = await this.setup();
-    this.choices = setup2.choices;
-    this.locker = setup2.locker;
-    this.logger.stage("User selection for configuration.");
-    const response = await this.select();
-    this.logger.stage("Will run selection: %s", response);
-    return this.choices[response].bind(this)();
-  }
-  setup() {
-    throw new Error("The command should be setup first!");
-  }
-  table(...options) {
-    this.ux.table(...options);
-  }
-  async select() {
-    const response = await this.prompt({
-      type: "Select",
-      message: "Please select what to do with the configuration.",
-      choices: Object.keys(this.choices)
-    });
-    return response;
-  }
-};
-__name(ConfigCommand, "ConfigCommand");
-
-// src/hooks/not-found.hook.ts
-var import_core4 = require("@oclif/core");
-var notFoundHook = /* @__PURE__ */ __name(async (opts) => {
-  const logger = new Logger(opts.config.name);
-  logger.fatal("Command not found. Take a look at help. You can also use --[h]elp flag for subcommands.", { custom: opts.config.name });
-  logger.direct("");
-  const help = new import_core4.Help(opts.config);
-  await help.showHelp(["--all"]);
-  process.exit(127);
-}, "notFoundHook");
-
-// src/hooks/update-notifier.hook.ts
-var import_update_notifier = __toESM(require("update-notifier"));
-var updateNotifierHook = /* @__PURE__ */ __name(async (opts) => {
-  (0, import_update_notifier.default)({ pkg: { name: opts.config.name, version: opts.config.version } }).notify({ isGlobal: true });
-}, "updateNotifierHook");
-
-// src/hooks/store.hook.ts
-var storeHook = /* @__PURE__ */ __name((cb) => async (opts) => {
-  cb(opts, new StoreService());
-}, "storeHook");
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  CLI_FLAGS,
-  CliUx,
-  Command,
-  ConfigCommand,
-  ConfigService,
-  EnvironmentVariableParser,
-  FileConstants,
-  FileSystemService,
-  Flags,
-  HelpGroups,
-  JsonParser,
-  ListrLogger,
-  LockerService,
-  LogFieldStatus,
-  LogLevels,
-  Logger,
-  MergeStrategy,
-  ParserService,
-  StoreService,
-  ValidatorService,
-  YamlParser,
-  color,
-  fs,
-  isDebug,
-  isSilent,
-  isVerbose,
-  merge,
-  notFoundHook,
-  pipeProcessThroughListr,
-  pipeProcessToLogger,
-  setCtxAssign,
-  setCtxDefaults,
-  setup,
-  storeHook,
-  uniqueFilter,
-  updateNotifierHook
-});
+__reExport(src_exports, require("./commands"), module.exports);
+__reExport(src_exports, require("./constants"), module.exports);
+__reExport(src_exports, require("./hooks"), module.exports);
+__reExport(src_exports, require("./interfaces"), module.exports);
+__reExport(src_exports, require("./lib"), module.exports);
+__reExport(src_exports, require("./utils"), module.exports);