@cenk1cenk2/oclif-common 4.0.2 → 5.0.0

package/dist/index.js

@@ -1,4 +1,5 @@
 "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 _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await 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 __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
@@ -7,6 +8,10 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
     return require.apply(this, arguments);
   throw new Error('Dynamic require of "' + x + '" is not supported');
 });
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
 
 // src/commands/base.command.ts
 var _core = require('@oclif/core');
@@ -15,30 +20,34 @@ var _readline = require('readline');
 require('reflect-metadata');
 
 // src/constants/file.constants.ts
-var FileConstants = /* @__PURE__ */ ((FileConstants2) => {
+var FileConstants;
+(function(FileConstants2) {
   FileConstants2["CONFIG_SERVICE_DEFAULTS_DIR"] = "config";
-  return FileConstants2;
-})(FileConstants || {});
+})(FileConstants || (FileConstants = exports.FileConstants = {}));
 
 // src/constants/help-groups.constants.ts
-var HelpGroups = /* @__PURE__ */ ((HelpGroups2) => {
+var HelpGroups;
+(function(HelpGroups2) {
   HelpGroups2["CLI"] = "CLI";
-  return HelpGroups2;
-})(HelpGroups || {});
+})(HelpGroups || (HelpGroups = exports.HelpGroups = {}));
 
 // src/interfaces/oclif.interface.ts
 
 
-// src/utils/logger/listr-logger.ts
-
-
-// src/utils/logger/logger.ts
+// src/utils/logger/pipe/pipe-process-to-listr.ts
+function pipeProcessThroughListr(task, instance) {
+  instance.stdout.pipe(task.stdout());
+  instance.stderr.pipe(task.stdout());
+  return instance;
+}
+__name(pipeProcessThroughListr, "pipeProcessThroughListr");
 
-var _os = require('os');
-var _winston = require('winston'); var _winston2 = _interopRequireDefault(_winston);
+// src/utils/logger/pipe/pipe-process-to-logger.ts
+var _stream = require('stream');
 
 // src/utils/logger/logger.constants.ts
-var LogLevels = /* @__PURE__ */ ((LogLevels2) => {
+var LogLevels;
+(function(LogLevels2) {
   LogLevels2["SILENT"] = "SILENT";
   LogLevels2["DIRECT"] = "DIRECT";
   LogLevels2["FATAL"] = "FATAL";
@@ -48,26 +57,105 @@ var LogLevels = /* @__PURE__ */ ((LogLevels2) => {
   LogLevels2["VERBOSE"] = "VERBOSE";
   LogLevels2["DEBUG"] = "DEBUG";
   LogLevels2["TRACE"] = "TRACE";
-  return LogLevels2;
-})(LogLevels || {});
-var LogFieldStatus = /* @__PURE__ */ ((LogFieldStatus2) => {
+})(LogLevels || (LogLevels = exports.LogLevels = {}));
+var LogFieldStatus;
+(function(LogFieldStatus2) {
   LogFieldStatus2["RUN"] = "run";
   LogFieldStatus2["END"] = "end";
   LogFieldStatus2["STAGE"] = "stage";
   LogFieldStatus2["EXIT"] = "exit";
   LogFieldStatus2["TERMINATE"] = "terminate";
-  return LogFieldStatus2;
-})(LogFieldStatus || {});
+})(LogFieldStatus || (LogFieldStatus = exports.LogFieldStatus = {}));
+
+// src/utils/logger/pipe/pipe-process-to-logger.ts
+function pipeProcessToLogger(logger, instance, options) {
+  options = {
+    start: LogLevels.INFO,
+    end: LogLevels.INFO,
+    stdout: LogLevels.INFO,
+    stderr: LogLevels.WARN,
+    ...options
+  };
+  if (options.start) {
+    logger.run(instance.spawnargs.join(" "), {
+      level: options.start,
+      context: options.context
+    });
+  }
+  if (instance.stdout) {
+    const writable = new (0, _stream.Writable)();
+    writable.write = (chunk) => {
+      logger.log(options.stdout, chunk, {
+        context: options.context
+      });
+      return true;
+    };
+    instance.stdout.pipe(writable);
+  }
+  if (instance.stderr) {
+    const writable = new (0, _stream.Writable)();
+    writable.write = (chunk) => {
+      logger.log(options.stderr, chunk, {
+        context: options.context
+      });
+      return true;
+    };
+    instance.stderr.pipe(writable);
+  }
+  void instance.on("exit", (code, signal) => {
+    const message = `Process ended with code ${code}${signal ? ` and signal ${signal}` : ""}.`;
+    logger.debug(message, {
+      context: options.context
+    });
+    if (options.end) {
+      logger.end(instance.spawnargs.join(" "), {
+        level: options.end,
+        context: options.context
+      });
+    }
+    if (_optionalChain([options, 'optionalAccess', _2 => _2.callback])) {
+      options.callback();
+    }
+  });
+  void instance.on("error", (error) => {
+    logger.fatal(error.message, {
+      context: options.context
+    });
+    logger.debug(error.stack, {
+      context: options.context
+    });
+    if (_optionalChain([options, 'optionalAccess', _3 => _3.callback])) {
+      options.callback(error);
+    }
+  });
+  return instance;
+}
+__name(pipeProcessToLogger, "pipeProcessToLogger");
+
+// src/utils/logger/logger.ts
+
+var _os = require('os');
+var _winston = require('winston'); var _winston2 = _interopRequireDefault(_winston);
 
 // src/lib/config/config.service.ts
 var _objectpathimmutable = require('object-path-immutable'); var _objectpathimmutable2 = _interopRequireDefault(_objectpathimmutable);
 var _path = require('path');
 
+// src/lib/config/config.constants.ts
+var ConfigEnvKeys;
+(function(ConfigEnvKeys2) {
+  ConfigEnvKeys2["NAME"] = "__name";
+  ConfigEnvKeys2["PARSER"] = "__format";
+  ConfigEnvKeys2["ELEMENT"] = "__element";
+  ConfigEnvKeys2["ELEMENT_REPLACER"] = "${i}";
+})(ConfigEnvKeys || (ConfigEnvKeys = {}));
+
 // src/lib/parser/env-parser.service.ts
 
 var _EnvironmentVariableParser = class {
   constructor() {
-    this.LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/gm;
+    __publicField(this, "logger");
+    __publicField(this, "LINE", /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/gm);
     if (_EnvironmentVariableParser.instance) {
       return _EnvironmentVariableParser.instance;
     }
@@ -97,11 +185,15 @@ var _EnvironmentVariableParser = class {
 };
 var EnvironmentVariableParser = _EnvironmentVariableParser;
 __name(EnvironmentVariableParser, "EnvironmentVariableParser");
-EnvironmentVariableParser.extensions = ["env"];
+__publicField(EnvironmentVariableParser, "extensions", [
+  "env"
+]);
+__publicField(EnvironmentVariableParser, "instance");
 
 // src/lib/parser/json-parser.service.ts
 var _JsonParser = class {
   constructor() {
+    __publicField(this, "logger");
     if (_JsonParser.instance) {
       return _JsonParser.instance;
     }
@@ -123,12 +215,16 @@ var _JsonParser = class {
 };
 var JsonParser = _JsonParser;
 __name(JsonParser, "JsonParser");
-JsonParser.extensions = ["json"];
+__publicField(JsonParser, "extensions", [
+  "json"
+]);
+__publicField(JsonParser, "instance");
 
 // src/lib/parser/yaml-parser.service.ts
 var _yaml = require('yaml');
 var _YamlParser = class {
   constructor() {
+    __publicField(this, "logger");
     if (_YamlParser.instance) {
       return _YamlParser.instance;
     }
@@ -145,22 +241,29 @@ var _YamlParser = class {
     }
   }
   stringify(data) {
-    return _yaml.stringify.call(void 0, data, { prettyErrors: true });
+    return _yaml.stringify.call(void 0, data, {
+      prettyErrors: true
+    });
   }
 };
 var YamlParser = _YamlParser;
 __name(YamlParser, "YamlParser");
-YamlParser.extensions = ["yaml", "yml"];
+__publicField(YamlParser, "extensions", [
+  "yaml",
+  "yml"
+]);
+__publicField(YamlParser, "instance");
 
 // src/lib/fs/filesystem.service.ts
 var _fsextra = require('fs-extra'); var _fsextra2 = _interopRequireDefault(_fsextra);
 
-var FileSystemService = class {
+var _FileSystemService = class {
   constructor() {
-    if (FileSystemService.instance) {
-      return FileSystemService.instance;
+    __publicField(this, "logger");
+    if (_FileSystemService.instance) {
+      return _FileSystemService.instance;
     } else {
-      FileSystemService.instance = this;
+      _FileSystemService.instance = this;
       this.logger = new Logger(this.constructor.name);
       this.logger.trace("Created a new instance.");
     }
@@ -169,7 +272,9 @@ var FileSystemService = class {
     return _fsextra2.default.existsSync(path);
   }
   stats(path) {
-    return _fsextra2.default.statSync(path, { throwIfNoEntry: true });
+    return _fsextra2.default.statSync(path, {
+      throwIfNoEntry: true
+    });
   }
   dirname(path) {
     return _path.dirname.call(void 0, path);
@@ -195,14 +300,20 @@ var FileSystemService = class {
   }
   async write(file, data, options = {}) {
     try {
-      await _fsextra2.default.writeFile(file, data, typeof options === "object" ? { encoding: "utf-8", ...options } : options);
+      await _fsextra2.default.writeFile(file, data, typeof options === "object" ? {
+        encoding: "utf-8",
+        ...options
+      } : options);
     } catch (e) {
       throw new Error(`Error while writing file to "${file}": ${e.message}`);
     }
   }
   writeSync(file, data, options = {}) {
     try {
-      _fsextra2.default.writeFileSync(file, data, typeof options === "object" ? { encoding: "utf-8", ...options } : options);
+      _fsextra2.default.writeFileSync(file, data, typeof options === "object" ? {
+        encoding: "utf-8",
+        ...options
+      } : options);
     } catch (e) {
       throw new Error(`Error while writing file to "${file}": ${e.message}`);
     }
@@ -278,21 +389,29 @@ var FileSystemService = class {
     }
   }
 };
+var FileSystemService = _FileSystemService;
 __name(FileSystemService, "FileSystemService");
+__publicField(FileSystemService, "instance");
 
 // src/lib/parser/parser.service.ts
-var ParserService = class {
+var _ParserService = class {
   constructor(parsers) {
-    this.parsers = [YamlParser, JsonParser, EnvironmentVariableParser];
-    if (ParserService.instance) {
-      return ParserService.instance;
+    __publicField(this, "parsers", [
+      YamlParser,
+      JsonParser,
+      EnvironmentVariableParser
+    ]);
+    __publicField(this, "logger");
+    __publicField(this, "fs");
+    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;
+      _ParserService.instance = this;
       this.logger.trace("Created a new instance.");
     }
   }
@@ -306,17 +425,11 @@ var ParserService = class {
   }
   setParsers(...parsers) {
     this.parsers = parsers;
-    this.logger.trace(
-      "Set parsers: %s",
-      this.parsers.map((p) => p.name)
-    );
+    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)
-    );
+    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));
@@ -335,38 +448,48 @@ var ParserService = class {
     return parser.stringify(data);
   }
 };
+var ParserService = _ParserService;
 __name(ParserService, "ParserService");
+__publicField(ParserService, "instance");
 
 // src/utils/color.ts
 var _colorette = require('colorette'); var colorette = _interopRequireWildcard(_colorette);
-var color = colorette.createColors({ useColor: true });
+var color = colorette.createColors({
+  useColor: true
+});
 
 // src/utils/environment.ts
 function isVerbose(logLevel) {
-  return logLevel === "VERBOSE" /* VERBOSE */;
+  return logLevel === LogLevels.VERBOSE;
 }
 __name(isVerbose, "isVerbose");
 function isDebug(logLevel) {
-  return ["DEBUG" /* DEBUG */, "TRACE" /* TRACE */].includes(logLevel);
+  return [
+    LogLevels.DEBUG,
+    LogLevels.TRACE
+  ].includes(logLevel);
 }
 __name(isDebug, "isDebug");
 function isSilent(logLevel) {
-  return logLevel === "SILENT" /* SILENT */;
+  return logLevel === LogLevels.SILENT;
 }
 __name(isSilent, "isSilent");
 
 // src/utils/merge.constants.ts
-var MergeStrategy = /* @__PURE__ */ ((MergeStrategy2) => {
+var MergeStrategy;
+(function(MergeStrategy2) {
   MergeStrategy2["OVERWRITE"] = "OVERWRITE";
   MergeStrategy2["EXTEND"] = "EXTEND";
-  return MergeStrategy2;
-})(MergeStrategy || {});
+})(MergeStrategy || (MergeStrategy = exports.MergeStrategy = {}));
 
 // src/utils/merge.ts
 var _deepmerge = require('deepmerge'); var _deepmerge2 = _interopRequireDefault(_deepmerge);
 function merge(strategy, ...source) {
   return _deepmerge2.default.all(source, {
-    arrayMerge: strategy === "EXTEND" /* EXTEND */ ? (dest, src) => [...dest, ...src].filter(uniqueFilter) : (_, src) => src
+    arrayMerge: strategy === MergeStrategy.EXTEND ? (dest, src) => [
+      ...dest,
+      ...src
+    ].filter(uniqueFilter) : (_, src) => src
   });
 }
 __name(merge, "merge");
@@ -377,7 +500,7 @@ __name(uniqueFilter, "uniqueFilter");
 
 // src/utils/defaults.ts
 function setCtxDefaults(ctx, ...defaults) {
-  _optionalChain([defaults, 'optionalAccess', _2 => _2.forEach, 'call', _3 => _3((i) => {
+  _optionalChain([defaults, 'optionalAccess', _4 => _4.forEach, 'call', _5 => _5((i) => {
     if (typeof i === "object" && !Array.isArray(i)) {
       Object.assign(ctx, i);
     }
@@ -386,7 +509,7 @@ function setCtxDefaults(ctx, ...defaults) {
 __name(setCtxDefaults, "setCtxDefaults");
 function setCtxAssign(ctx, ...assigns) {
   assigns.forEach((assign) => {
-    _optionalChain([assign, 'optionalAccess', _4 => _4.keys, 'access', _5 => _5.forEach, 'call', _6 => _6((i) => {
+    _optionalChain([assign, 'optionalAccess', _6 => _6.keys, 'access', _7 => _7.forEach, 'call', _8 => _8((i) => {
       if (assign.from[i]) {
         ctx[i] = assign.from[i];
       }
@@ -399,20 +522,34 @@ __name(setCtxAssign, "setCtxAssign");
 
 
 // src/lib/config/config.service.ts
-var ConfigService = class {
+var _ConfigService = class {
   constructor(oclif, command, config) {
+    __publicField(this, "oclif");
+    __publicField(this, "command");
+    __publicField(this, "defaults");
+    __publicField(this, "root");
+    __publicField(this, "parser");
+    __publicField(this, "logLevel");
+    __publicField(this, "isVerbose");
+    __publicField(this, "isDebug");
+    __publicField(this, "isSilent");
+    __publicField(this, "ci");
+    __publicField(this, "json");
+    __publicField(this, "logger");
     this.oclif = oclif;
     this.command = command;
-    if (ConfigService.instance) {
-      return ConfigService.instance;
+    if (_ConfigService.instance) {
+      return _ConfigService.instance;
     }
     this.root = this.oclif.root;
-    this.defaults = _path.join.call(void 0, this.oclif.root, "config" /* CONFIG_SERVICE_DEFAULTS_DIR */);
-    this.logger = new Logger(this.constructor.name, { level: config.logLevel });
+    this.defaults = _path.join.call(void 0, this.oclif.root, FileConstants.CONFIG_SERVICE_DEFAULTS_DIR);
+    this.logger = new Logger(this.constructor.name, {
+      level: config.logLevel
+    });
     Object.assign(this, config);
     this.recalculate();
     this.parser = new ParserService();
-    ConfigService.instance = this;
+    _ConfigService.instance = this;
     this.logger.trace("Created a new instance.");
   }
   async read(path) {
@@ -420,22 +557,20 @@ var ConfigService = class {
     this.logger.trace("Read config from: %s", path);
     return config;
   }
-  async extend(paths, strategy = "OVERWRITE" /* OVERWRITE */) {
+  async extend(paths, strategy = MergeStrategy.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);
+    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 */) {
+  merge(configs, strategy = MergeStrategy.OVERWRITE) {
     if (configs.length === 0) {
       throw new Error("Nothing to merge, configuration files are empty.");
     }
@@ -445,35 +580,44 @@ var ConfigService = class {
     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 = [..._nullishCoalesce(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,
-                  // eslint-disable-next-line no-underscore-dangle
-                  env: value["__name" /* NAME */],
-                  // eslint-disable-next-line no-underscore-dangle
-                  parser: value["__format" /* PARSER */],
-                  extensions
-                }
-              ];
-              return variable;
-            } else {
-              return iter(value, location);
+      const data = await Promise.all(Object.entries(obj).map(async ([key, value]) => {
+        const location = [
+          ..._nullishCoalesce(parent, () => ( [])),
+          key
+        ];
+        if (typeof value === "string") {
+          return [
+            {
+              key: location,
+              env: value
             }
+          ];
+        } else if (typeof value === "object") {
+          let extensions;
+          if (ConfigEnvKeys.ELEMENT in value) {
+            extensions = await iter(value[ConfigEnvKeys.ELEMENT], [
+              ...location,
+              ConfigEnvKeys.ELEMENT
+            ]);
+            this.logger.trace("Expanding location to elements: %s -> %s", location, extensions.map((extension) => extension.key.join(".")).join(", "));
           }
-        })
-      );
+          if (ConfigEnvKeys.NAME in value && ConfigEnvKeys.PARSER in value) {
+            const variable = [
+              {
+                key: location,
+                // eslint-disable-next-line no-underscore-dangle
+                env: value[ConfigEnvKeys.NAME],
+                // eslint-disable-next-line no-underscore-dangle
+                parser: value[ConfigEnvKeys.PARSER],
+                extensions
+              }
+            ];
+            return variable;
+          } else {
+            return iter(value, location);
+          }
+        }
+      }));
       return data.flatMap((d) => d).filter(Boolean);
     }, "iter");
     const parsed = await iter(env);
@@ -504,8 +648,8 @@ var ConfigService = class {
           }
           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();
+            clone.env = clone.env.replace(ConfigEnvKeys.ELEMENT_REPLACER, i.toString());
+            clone.key[clone.key.findIndex((value) => value === ConfigEnvKeys.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);
@@ -532,12 +676,21 @@ var ConfigService = class {
     this.isSilent = isSilent(this.logLevel);
   }
 };
+var ConfigService = _ConfigService;
 __name(ConfigService, "ConfigService");
+__publicField(ConfigService, "instance");
 
 // src/lib/locker/locker.service.ts
 
 var LockerService = class {
   constructor(file, parser, root, context) {
+    __publicField(this, "file");
+    __publicField(this, "parser");
+    __publicField(this, "root");
+    __publicField(this, "toLock");
+    __publicField(this, "toUnlock");
+    __publicField(this, "logger");
+    __publicField(this, "fs");
     this.file = file;
     this.parser = parser;
     this.root = root;
@@ -557,10 +710,16 @@ var LockerService = class {
     return this.toUnlock.length > 0;
   }
   addLock(...data) {
-    this.toLock = [...this.toLock, ...data];
+    this.toLock = [
+      ...this.toLock,
+      ...data
+    ];
   }
   addUnlock(...data) {
-    this.toUnlock = [...this.toUnlock, ...data];
+    this.toUnlock = [
+      ...this.toUnlock,
+      ...data
+    ];
   }
   async lockAll() {
     if (this.hasLock()) {
@@ -581,13 +740,13 @@ var LockerService = class {
   async lock(...data) {
     let lock = await _asyncNullishCoalesce(await this.tryRead(), async () => ( {}));
     data.forEach((d) => {
-      if (_optionalChain([d, 'optionalAccess', _7 => _7.enabled]) === false) {
+      if (_optionalChain([d, 'optionalAccess', _9 => _9.enabled]) === false) {
         return;
-      } else if (!_optionalChain([d, 'optionalAccess', _8 => _8.data]) || Array.isArray(_optionalChain([d, 'optionalAccess', _9 => _9.data])) && d.data.length === 0 || typeof _optionalChain([d, 'optionalAccess', _10 => _10.data]) === "object" && Object.keys(d.data).length === 0) {
+      } else if (!_optionalChain([d, 'optionalAccess', _10 => _10.data]) || Array.isArray(_optionalChain([d, 'optionalAccess', _11 => _11.data])) && d.data.length === 0 || typeof _optionalChain([d, 'optionalAccess', _12 => _12.data]) === "object" && Object.keys(d.data).length === 0) {
         return;
       }
       const path = this.buildPath(d);
-      if (_optionalChain([d, 'optionalAccess', _11 => _11.merge])) {
+      if (_optionalChain([d, 'optionalAccess', _13 => _13.merge])) {
         let parsed;
         if (typeof d.data === "object") {
           parsed = merge(d.merge, _objectpathimmutable2.default.get(lock, path, Array.isArray(d.data) ? [] : {}), d.data);
@@ -612,7 +771,7 @@ var LockerService = class {
     }
     if (data.length > 0) {
       data.forEach((d) => {
-        if (_optionalChain([d, 'optionalAccess', _12 => _12.enabled]) === false) {
+        if (_optionalChain([d, 'optionalAccess', _14 => _14.enabled]) === false) {
           return;
         }
         const path = this.buildPath(d);
@@ -653,8 +812,11 @@ var LockerService = class {
     return this.fs.write(this.file, this.parser.stringify(data));
   }
   buildPath(d) {
-    if (_optionalChain([d, 'optionalAccess', _13 => _13.root]) !== true && _optionalChain([this, 'access', _14 => _14.root, 'optionalAccess', _15 => _15.length])) {
-      return [...this.root, ...this.normalizePath(d.path)];
+    if (_optionalChain([d, 'optionalAccess', _15 => _15.root]) !== true && _optionalChain([this, 'access', _16 => _16.root, 'optionalAccess', _17 => _17.length])) {
+      return [
+        ...this.root,
+        ...this.normalizePath(d.path)
+      ];
     }
     return this.normalizePath(d.path);
   }
@@ -670,13 +832,13 @@ var LockerService = class {
 __name(LockerService, "LockerService");
 
 // src/lib/store/store.service.ts
-var StoreService = class {
+var _StoreService = class {
   constructor() {
-    this.store = {};
-    if (StoreService.instance) {
-      return StoreService.instance;
+    __publicField(this, "store", {});
+    if (_StoreService.instance) {
+      return _StoreService.instance;
     } else {
-      StoreService.instance = this;
+      _StoreService.instance = this;
     }
   }
   has(key) {
@@ -690,16 +852,20 @@ var StoreService = class {
     return data;
   }
 };
+var StoreService = _StoreService;
 __name(StoreService, "StoreService");
+__publicField(StoreService, "instance");
 
 // src/lib/validator/validator.service.ts
 var _classtransformer = require('class-transformer');
 var _classvalidator = require('class-validator');
-var ValidatorService = class {
+var _ValidatorService = class {
   constructor(options) {
+    __publicField(this, "options");
+    __publicField(this, "logger");
     this.options = options;
-    if (ValidatorService.instance) {
-      return ValidatorService.instance;
+    if (_ValidatorService.instance) {
+      return _ValidatorService.instance;
     }
     this.options = {
       validator: {
@@ -708,16 +874,24 @@ var ValidatorService = class {
         always: true,
         enableDebugMessages: true
       },
-      transformer: { enableImplicitConversion: true },
+      transformer: {
+        enableImplicitConversion: true
+      },
       ..._nullishCoalesce(options, () => ( {}))
     };
     this.logger = new Logger(this.constructor.name);
-    ValidatorService.instance = this;
+    _ValidatorService.instance = this;
     this.logger.trace("Created a new instance.");
   }
   async validate(classType, object, options) {
-    const classObject = _classtransformer.plainToClass.call(void 0, classType, object, { ...this.options.transformer, ..._nullishCoalesce(_optionalChain([options, 'optionalAccess', _16 => _16.transformer]), () => ( {})) });
-    const errors = await _classvalidator.validate.call(void 0, classObject, { ...this.options.validator, ..._nullishCoalesce(_optionalChain([options, 'optionalAccess', _17 => _17.validator]), () => ( {})) });
+    const classObject = _classtransformer.plainToClass.call(void 0, classType, object, {
+      ...this.options.transformer,
+      ..._nullishCoalesce(_optionalChain([options, 'optionalAccess', _18 => _18.transformer]), () => ( {}))
+    });
+    const errors = await _classvalidator.validate.call(void 0, classObject, {
+      ...this.options.validator,
+      ..._nullishCoalesce(_optionalChain([options, 'optionalAccess', _19 => _19.validator]), () => ( {}))
+    });
     if (errors.length) {
       errors.forEach((error) => {
         this.logValidationError(error);
@@ -727,8 +901,14 @@ var ValidatorService = class {
     return classObject;
   }
   validateSync(classType, object, options) {
-    const classObject = _classtransformer.plainToClass.call(void 0, classType, object, { ...this.options.transformer, ..._nullishCoalesce(_optionalChain([options, 'optionalAccess', _18 => _18.transformer]), () => ( {})) });
-    const errors = _classvalidator.validateSync.call(void 0, classObject, { ...this.options.validator, ..._nullishCoalesce(_optionalChain([options, 'optionalAccess', _19 => _19.validator]), () => ( {})) });
+    const classObject = _classtransformer.plainToClass.call(void 0, classType, object, {
+      ...this.options.transformer,
+      ..._nullishCoalesce(_optionalChain([options, 'optionalAccess', _20 => _20.transformer]), () => ( {}))
+    });
+    const errors = _classvalidator.validateSync.call(void 0, classObject, {
+      ...this.options.validator,
+      ..._nullishCoalesce(_optionalChain([options, 'optionalAccess', _21 => _21.validator]), () => ( {}))
+    });
     if (errors.length) {
       errors.forEach((error) => {
         this.logValidationError(error);
@@ -741,7 +921,9 @@ var ValidatorService = class {
     this.logger.error('Field "%s" failed validation with value "%s": %o', err.property, err.value, err.constraints);
   }
 };
+var ValidatorService = _ValidatorService;
 __name(ValidatorService, "ValidatorService");
+__publicField(ValidatorService, "instance");
 
 // src/lib/setup.ts
 function setup() {
@@ -779,14 +961,17 @@ function setup() {
 __name(setup, "setup");
 
 // src/utils/logger/logger.ts
-var Logger = class {
+var _Logger = class {
   constructor(context, options) {
+    __publicField(this, "context");
+    __publicField(this, "options");
+    __publicField(this, "logger");
     this.context = context;
     this.options = options;
-    if (Logger.instance) {
-      this.logger = Logger.instance;
+    if (_Logger.instance) {
+      this.logger = _Logger.instance;
     } else if (context === ConfigService.name) {
-      const level = Object.values(LogLevels).includes(_optionalChain([options, 'optionalAccess', _20 => _20.level])) ? options.level : "INFO" /* INFO */;
+      const level = Object.values(LogLevels).includes(_optionalChain([options, 'optionalAccess', _22 => _22.level])) ? options.level : LogLevels.INFO;
       this.options = {
         useIcons: true,
         ...options,
@@ -794,7 +979,7 @@ var Logger = class {
       };
       this.logger = this.initiateLogger();
       this.trace("Logger singleton initiated from context: %s", context);
-      Logger.instance = this.logger;
+      _Logger.instance = this.logger;
     } else {
       throw new Error("Logger can only be initiated inside the config service context!");
     }
@@ -803,38 +988,44 @@ var Logger = class {
     return this.parseMessage(level, data, args);
   }
   direct(data, ...args) {
-    return this.parseMessage("DIRECT" /* DIRECT */, data, args);
+    return this.parseMessage(LogLevels.DIRECT, data, args);
   }
   fatal(data, ...args) {
-    return this.parseMessage("FATAL" /* FATAL */, data, args);
+    return this.parseMessage(LogLevels.FATAL, data, args);
   }
   error(data, ...args) {
-    return this.parseMessage("ERROR" /* ERROR */, data, args);
+    return this.parseMessage(LogLevels.ERROR, data, args);
   }
   warn(data, ...args) {
-    return this.parseMessage("WARN" /* WARN */, data, args);
+    return this.parseMessage(LogLevels.WARN, data, args);
   }
   info(data, ...args) {
-    return this.parseMessage("INFO" /* INFO */, data, args);
+    return this.parseMessage(LogLevels.INFO, data, args);
   }
   debug(data, ...args) {
-    return this.parseMessage("DEBUG" /* DEBUG */, data, args);
+    return this.parseMessage(LogLevels.DEBUG, data, args);
   }
   verbose(data, ...args) {
-    return this.parseMessage("VERBOSE" /* VERBOSE */, data, args);
+    return this.parseMessage(LogLevels.VERBOSE, data, args);
   }
   trace(data, ...args) {
-    return this.parseMessage("TRACE" /* TRACE */, data, args);
+    return this.parseMessage(LogLevels.TRACE, data, args);
   }
   // status levels
   run(data, ...args) {
-    return this.parseMessage("INFO" /* INFO */, data, args, { status: "run" /* RUN */ });
+    return this.parseMessage(LogLevels.INFO, data, args, {
+      status: LogFieldStatus.RUN
+    });
   }
   end(data, ...args) {
-    return this.parseMessage("INFO" /* INFO */, data, args, { status: "end" /* END */ });
+    return this.parseMessage(LogLevels.INFO, data, args, {
+      status: LogFieldStatus.END
+    });
   }
   stage(data, ...args) {
-    return this.parseMessage("TRACE" /* TRACE */, data, args, { status: "stage" /* STAGE */ });
+    return this.parseMessage(LogLevels.TRACE, data, args, {
+      status: LogFieldStatus.STAGE
+    });
   }
   initiateLogger() {
     const logFormat = _winston.format.printf(({ level, message, context, status }) => {
@@ -853,30 +1044,40 @@ var Logger = class {
     });
     const logger = _winston2.default.createLogger({
       level: this.options.level,
-      format: _winston.format.combine(_winston.format.splat(), _winston.format.json({ space: 2 }), _winston.format.prettyPrint(), logFormat),
+      format: _winston.format.combine(_winston.format.splat(), _winston.format.json({
+        space: 2
+      }), _winston.format.prettyPrint(), logFormat),
       levels: Object.values(LogLevels).reduce((o, level, i) => {
         return {
           ...o,
           [level]: i
         };
       }, {}),
-      silent: this.options.level === "SILENT" /* SILENT */,
+      silent: this.options.level === LogLevels.SILENT,
       transports: [
         new _winston.transports.Console({
-          stderrLevels: ["FATAL" /* FATAL */, "ERROR" /* ERROR */]
+          stderrLevels: [
+            LogLevels.FATAL,
+            LogLevels.ERROR
+          ]
         })
       ]
     });
-    logger.log("TRACE" /* TRACE */, "Initiated new logger with level: %s", this.options.level, { context: this.constructor.name });
+    logger.log(LogLevels.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) {
+    if (!this.logger && !_Logger.instance) {
       return;
-    } else if (Logger.instance) {
-      this.logger = Logger.instance;
+    } else if (_Logger.instance) {
+      this.logger = _Logger.instance;
     }
-    this.logger.log(level, data.toString(), ..._nullishCoalesce(args, () => ( [])), { context: this.context, ..._nullishCoalesce(format2, () => ( {})) });
+    this.logger.log(level, data.toString(), ..._nullishCoalesce(args, () => ( [])), {
+      context: this.context,
+      ..._nullishCoalesce(format2, () => ( {}))
+    });
   }
   logColoring({ level, message, context, status }) {
     let icon;
@@ -887,49 +1088,49 @@ var Logger = class {
       return input;
     }, "msgColoring");
     switch (level) {
-      case "DIRECT" /* DIRECT */:
+      case LogLevels.DIRECT:
         return message;
-      case "FATAL" /* FATAL */:
+      case LogLevels.FATAL:
         coloring = /* @__PURE__ */ __name((input) => color.red(input), "coloring");
-        if (_optionalChain([this, 'access', _21 => _21.options, 'optionalAccess', _22 => _22.useIcons])) {
+        if (_optionalChain([this, 'access', _23 => _23.options, 'optionalAccess', _24 => _24.useIcons])) {
           icon = _listr2.figures.checkboxOn;
         }
         break;
-      case "ERROR" /* ERROR */:
+      case LogLevels.ERROR:
         coloring = color.red;
-        if (_optionalChain([this, 'access', _23 => _23.options, 'optionalAccess', _24 => _24.useIcons])) {
+        if (_optionalChain([this, 'access', _25 => _25.options, 'optionalAccess', _26 => _26.useIcons])) {
           icon = _listr2.figures.cross;
         }
         break;
-      case "WARN" /* WARN */:
+      case LogLevels.WARN:
         coloring = color.yellow;
-        if (_optionalChain([this, 'access', _25 => _25.options, 'optionalAccess', _26 => _26.useIcons])) {
+        if (_optionalChain([this, 'access', _27 => _27.options, 'optionalAccess', _28 => _28.useIcons])) {
           icon = _listr2.figures.warning;
         }
         break;
-      case "INFO" /* INFO */:
+      case LogLevels.INFO:
         coloring = color.green;
-        if (_optionalChain([this, 'access', _27 => _27.options, 'optionalAccess', _28 => _28.useIcons])) {
+        if (_optionalChain([this, 'access', _29 => _29.options, 'optionalAccess', _30 => _30.useIcons])) {
           icon = _listr2.figures.pointerSmall;
         }
         break;
-      case "VERBOSE" /* VERBOSE */:
+      case LogLevels.VERBOSE:
         coloring = color.dim;
-        if (_optionalChain([this, 'access', _29 => _29.options, 'optionalAccess', _30 => _30.useIcons])) {
+        if (_optionalChain([this, 'access', _31 => _31.options, 'optionalAccess', _32 => _32.useIcons])) {
           icon = "\u2607";
         }
         break;
-      case "DEBUG" /* DEBUG */:
+      case LogLevels.DEBUG:
         coloring = color.cyan;
         msgColoring = color.dim;
-        if (_optionalChain([this, 'access', _31 => _31.options, 'optionalAccess', _32 => _32.useIcons])) {
+        if (_optionalChain([this, 'access', _33 => _33.options, 'optionalAccess', _34 => _34.useIcons])) {
           icon = "\uF188";
         }
         break;
-      case "TRACE" /* TRACE */:
+      case LogLevels.TRACE:
         coloring = color.magenta;
         msgColoring = color.dim;
-        if (_optionalChain([this, 'access', _33 => _33.options, 'optionalAccess', _34 => _34.useIcons])) {
+        if (_optionalChain([this, 'access', _35 => _35.options, 'optionalAccess', _36 => _36.useIcons])) {
           icon = "\u26B1";
         }
         break;
@@ -940,124 +1141,33 @@ var Logger = class {
     return `${coloring(icon)}${context ? " " + coloring(`[${context}]`) : ""}${status ? " " + coloring(`[${status}]`) : ""} ${msgColoring(message)}`;
   }
 };
+var Logger = _Logger;
 __name(Logger, "Logger");
-
-// src/utils/logger/listr-logger.ts
-var ListrLogger = class extends _listr2.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 _through = require('through'); var _through2 = _interopRequireDefault(_through);
-function pipeProcessThroughListr(task, instance) {
-  const logOut = _through2.default.call(void 0, (chunk) => {
-    task.output = _optionalChain([chunk, 'optionalAccess', _35 => _35.toString, 'call', _36 => _36("utf-8"), 'access', _37 => _37.trim, 'call', _38 => _38()]);
-  });
-  instance.stdout.pipe(logOut);
-  instance.stderr.pipe(logOut);
-  return instance;
-}
-__name(pipeProcessThroughListr, "pipeProcessThroughListr");
-
-// src/utils/logger/pipe/pipe-process-to-logger.ts
-
-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, context: options.context });
-  }
-  if (instance.stdout) {
-    instance.stdout.pipe(
-      _through2.default.call(void 0, (chunk) => {
-        logger.log(options.stdout, chunk, { context: options.context });
-      })
-    );
-  }
-  if (instance.stderr) {
-    instance.stderr.pipe(
-      _through2.default.call(void 0, (chunk) => {
-        logger.log(options.stderr, chunk, { context: options.context });
-      })
-    );
-  }
-  void instance.on("exit", (code, signal) => {
-    const message = `Process ended with code ${code}${signal ? ` and signal ${signal}` : ""}.`;
-    logger.debug(message, { context: options.context });
-    if (options.end) {
-      logger.end(instance.spawnargs.join(" "), { level: options.end, context: options.context });
-    }
-    if (_optionalChain([options, 'optionalAccess', _39 => _39.callback])) {
-      options.callback();
-    }
-  });
-  void instance.on("error", (error) => {
-    logger.fatal(error.message, { context: options.context });
-    logger.debug(error.stack, { context: options.context });
-    if (_optionalChain([options, 'optionalAccess', _40 => _40.callback])) {
-      options.callback(error);
-    }
-  });
-  return instance;
-}
-__name(pipeProcessToLogger, "pipeProcessToLogger");
+__publicField(Logger, "instance");
 
 // src/constants/global-flags.constants.ts
 var CLI_FLAGS = {
   ["log-level"]: _core.Flags.string({
-    default: "INFO" /* INFO */,
+    default: LogLevels.INFO,
     env: "LOG_LEVEL",
     description: "Set the log level of the application.",
     options: Object.values(LogLevels).map((level) => level.toLowerCase()),
-    helpGroup: "CLI" /* CLI */,
-    parse: async (input) => _optionalChain([input, 'optionalAccess', _41 => _41.toUpperCase, 'call', _42 => _42()])
+    helpGroup: HelpGroups.CLI,
+    parse: async (input) => _optionalChain([input, 'optionalAccess', _37 => _37.toUpperCase, 'call', _38 => _38()])
   }),
   ci: _core.Flags.boolean({
     default: false,
     hidden: true,
     env: "CI",
     description: "Instruct whether this is running the CI/CD configuration.",
-    helpGroup: "CLI" /* CLI */
+    helpGroup: HelpGroups.CLI
   }),
   json: _core.Flags.boolean({
     default: false,
     hidden: true,
     env: "JSON",
     description: "Put the CLI to respond in JSON.",
-    helpGroup: "CLI" /* CLI */
+    helpGroup: HelpGroups.CLI
   })
 };
 
@@ -1065,8 +1175,16 @@ var CLI_FLAGS = {
 var Command = class extends _core.Command {
   constructor() {
     super(...arguments);
-    this.flags = {};
-    this.args = {};
+    __publicField(this, "context");
+    __publicField(this, "logger");
+    __publicField(this, "tasks");
+    __publicField(this, "validator");
+    __publicField(this, "cs");
+    __publicField(this, "parser");
+    __publicField(this, "fs");
+    __publicField(this, "store");
+    __publicField(this, "flags", {});
+    __publicField(this, "args", {});
   }
   static get baseFlags() {
     return this._baseFlags;
@@ -1076,14 +1194,14 @@ var Command = class extends _core.Command {
     this.flags = {};
   }
   /**
-   * Construct the class if you dont want to extend init or constructor.
-   */
+  * Construct the class if you dont want to extend init or constructor.
+  */
   // eslint-disable-next-line @typescript-eslint/no-empty-function
   shouldRunBefore() {
   }
   /**
-   * Deconstruct the class if you dont want to extend finally or catch.
-   */
+  * Deconstruct the class if you dont want to extend finally or catch.
+  */
   // eslint-disable-next-line @typescript-eslint/no-empty-function, @typescript-eslint/no-unused-vars
   shouldRunAfter(_ctx) {
   }
@@ -1108,7 +1226,9 @@ var Command = class extends _core.Command {
     return result;
   }
   exit(code) {
-    this.logger.trace("Code -> %d", code, { status: "exit" /* EXIT */ });
+    this.logger.trace("Code -> %d", code, {
+      status: LogFieldStatus.EXIT
+    });
     process.exit(_nullishCoalesce(code, () => ( 0)));
   }
   /** Run all tasks from task manager. */
@@ -1124,11 +1244,15 @@ var Command = class extends _core.Command {
   }
   setCtxDefaults(...defaults) {
     setCtxDefaults(this.tasks.options.ctx, ...defaults);
-    this.logger.trace("Updated context with defaults: %o", this.tasks.options.ctx, { status: "ctx" });
+    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" });
+    this.logger.trace("Updated context with assign: %o", this.tasks.options.ctx, {
+      status: "ctx"
+    });
   }
   pipeProcessToLogger(instance, options) {
     return pipeProcessToLogger(this.logger, instance, options);
@@ -1155,7 +1279,9 @@ var Command = class extends _core.Command {
       json: this.flags.json
     });
     this.context = this.cs.command.id ? this.cs.command.id : this.cs.command.name;
-    this.logger = new Logger(null, { level: this.cs.logLevel });
+    this.logger = new Logger(null, {
+      level: this.cs.logLevel
+    });
     this.store = new StoreService();
     this.greet();
     if (err) {
@@ -1166,13 +1292,8 @@ var Command = class extends _core.Command {
     this.fs = new FileSystemService();
     this.validator = new ValidatorService();
     this.tasks = new (0, _listr2.Manager)({
-      rendererFallback: this.cs.isDebug,
-      rendererSilent: this.cs.isSilent,
-      nonTTYRendererOptions: {
-        logEmptyTitle: false,
-        logTitleChange: false,
-        logger: ListrLogger
-      },
+      fallbackRendererCondition: this.cs.isDebug,
+      silentRendererCondition: this.cs.isSilent,
       ctx: {}
     });
     if (this.cs.oclif.windows) {
@@ -1184,7 +1305,9 @@ var Command = class extends _core.Command {
       });
     }
     const terminate = /* @__PURE__ */ __name(() => {
-      this.logger.fatal("Caught terminate signal.", { status: "terminate" /* TERMINATE */ });
+      this.logger.fatal("Caught terminate signal.", {
+        status: LogFieldStatus.TERMINATE
+      });
       process.exit(1);
     }, "terminate");
     process.on("SIGINT", terminate);
@@ -1201,7 +1324,9 @@ var Command = class extends _core.Command {
     this.logger.stage("Running shouldRunAfter.");
     await this.shouldRunAfter(ctx);
     this.logger.stage("Finished shouldRunAfter.");
-    return { ctx };
+    return {
+      ctx
+    };
   }
   /** Catch any error occurred during command. */
   // catch all those errors, not verbose
@@ -1212,7 +1337,9 @@ var Command = class extends _core.Command {
       console.debug(e.stack);
     }
     this.logger.fatal(e.message);
-    this.logger.debug(e.stack, { context: "crash" });
+    this.logger.debug(e.stack, {
+      context: "crash"
+    });
     if (exit > 0) {
       this.exit(exit);
     }
@@ -1233,6 +1360,11 @@ __name(Command, "Command");
 
 // src/commands/config.command.ts
 var ConfigCommand = class extends Command {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "choices");
+    __publicField(this, "locker");
+  }
   async run() {
     this.logger.stage("Setting up config command.");
     const setup2 = await this.setup();
@@ -1264,17 +1396,28 @@ __name(ConfigCommand, "ConfigCommand");
 
 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.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 (0, _core.Help)(opts.config);
-  await help.showHelp(["--all"]);
+  await help.showHelp([
+    "--all"
+  ]);
   process.exit(127);
 }, "notFoundHook");
 
 // src/hooks/update-notifier.hook.ts
-var _updatenotifier = require('update-notifier'); var _updatenotifier2 = _interopRequireDefault(_updatenotifier);
 var updateNotifierHook = /* @__PURE__ */ __name(async (opts) => {
-  _updatenotifier2.default.call(void 0, { pkg: { name: opts.config.name, version: opts.config.version } }).notify({ isGlobal: true });
+  const { default: notifier } = await Promise.resolve().then(() => _interopRequireWildcard(require("update-notifier")));
+  notifier({
+    pkg: {
+      name: opts.config.name,
+      version: opts.config.version
+    }
+  }).notify({
+    isGlobal: true
+  });
 }, "updateNotifierHook");
 
 // src/hooks/store.hook.ts
@@ -1317,5 +1460,4 @@ var storeHook = /* @__PURE__ */ __name((cb) => async (opts) => {
 
 
 
-
-exports.CLI_FLAGS = CLI_FLAGS; exports.Command = Command; exports.ConfigCommand = ConfigCommand; exports.ConfigService = ConfigService; exports.EnvironmentVariableParser = EnvironmentVariableParser; exports.FileConstants = FileConstants; exports.FileSystemService = FileSystemService; exports.Flags = _core.Flags; exports.HelpGroups = HelpGroups; exports.JsonParser = JsonParser; exports.ListrLogger = ListrLogger; exports.LockerService = LockerService; exports.LogFieldStatus = LogFieldStatus; exports.LogLevels = LogLevels; exports.Logger = Logger; exports.MergeStrategy = MergeStrategy; exports.ParserService = ParserService; exports.StoreService = StoreService; exports.ValidatorService = ValidatorService; exports.YamlParser = YamlParser; exports.color = color; exports.fs = _fsextra2.default; exports.isDebug = isDebug; exports.isSilent = isSilent; exports.isVerbose = isVerbose; exports.merge = merge; exports.notFoundHook = notFoundHook; exports.pipeProcessThroughListr = pipeProcessThroughListr; exports.pipeProcessToLogger = pipeProcessToLogger; exports.setCtxAssign = setCtxAssign; exports.setCtxDefaults = setCtxDefaults; exports.setup = setup; exports.storeHook = storeHook; exports.uniqueFilter = uniqueFilter; exports.updateNotifierHook = updateNotifierHook; exports.ux = _core.ux;
+exports.CLI_FLAGS = CLI_FLAGS; exports.Command = Command; exports.ConfigCommand = ConfigCommand; exports.ConfigService = ConfigService; exports.EnvironmentVariableParser = EnvironmentVariableParser; exports.FileConstants = FileConstants; exports.FileSystemService = FileSystemService; exports.Flags = _core.Flags; exports.HelpGroups = HelpGroups; exports.JsonParser = JsonParser; exports.LockerService = LockerService; exports.LogFieldStatus = LogFieldStatus; exports.LogLevels = LogLevels; exports.Logger = Logger; exports.MergeStrategy = MergeStrategy; exports.ParserService = ParserService; exports.StoreService = StoreService; exports.ValidatorService = ValidatorService; exports.YamlParser = YamlParser; exports.color = color; exports.fs = _fsextra2.default; exports.isDebug = isDebug; exports.isSilent = isSilent; exports.isVerbose = isVerbose; exports.merge = merge; exports.notFoundHook = notFoundHook; exports.pipeProcessThroughListr = pipeProcessThroughListr; exports.pipeProcessToLogger = pipeProcessToLogger; exports.setCtxAssign = setCtxAssign; exports.setCtxDefaults = setCtxDefaults; exports.setup = setup; exports.storeHook = storeHook; exports.uniqueFilter = uniqueFilter; exports.updateNotifierHook = updateNotifierHook; exports.ux = _core.ux;