@cenk1cenk2/oclif-common 5.0.8 → 6.0.0

package/dist/index.js

@@ -1,4 +1,4 @@
-"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 __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, {
@@ -13,28 +13,42 @@ var __publicField = (obj, key, value) => {
   return value;
 };
 
+// src/index.ts
+import { Inject as Inject3 } from "@nestjs/common";
+
 // src/commands/base.command.ts
-var _core = require('@oclif/core');
-var _listr2 = require('listr2');
-var _readline = require('readline');
-require('reflect-metadata');
+import { Manager } from "@listr2/manager";
+import { Command as BaseCommand, Flags } from "@oclif/core";
+import { createInterface } from "readline";
 
 // src/constants/file.constants.ts
 var FileConstants;
 (function(FileConstants2) {
   FileConstants2["CONFIG_SERVICE_DEFAULTS_DIR"] = "config";
-})(FileConstants || (FileConstants = exports.FileConstants = {}));
+})(FileConstants || (FileConstants = {}));
 
 // src/constants/help-groups.constants.ts
 var HelpGroups;
 (function(HelpGroups2) {
   HelpGroups2["CLI"] = "CLI";
-})(HelpGroups || (HelpGroups = exports.HelpGroups = {}));
+})(HelpGroups || (HelpGroups = {}));
 
-// src/interfaces/oclif.interface.ts
+// src/lib/config/config.service.ts
+import { Inject as Inject2, Injectable as Injectable8 } from "@nestjs/common";
+import op from "object-path-immutable";
+import { join } from "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 = {}));
+var TOKEN_CONFIG_MODULE_OPTIONS = Symbol("TOKEN_CONFIG_MODULE_OPTIONS");
 
-// src/utils/logger/pipe/pipe-process-to-listr.ts
+// src/lib/logger/pipe/pipe-process-to-listr.ts
 function pipeProcessThroughListr(task, instance) {
   instance.stdout.pipe(task.stdout());
   instance.stderr.pipe(task.stdout());
@@ -42,10 +56,10 @@ function pipeProcessThroughListr(task, instance) {
 }
 __name(pipeProcessThroughListr, "pipeProcessThroughListr");
 
-// src/utils/logger/pipe/pipe-process-to-logger.ts
-var _stream = require('stream');
+// src/lib/logger/pipe/pipe-process-to-logger.ts
+import { Writable } from "stream";
 
-// src/utils/logger/logger.constants.ts
+// src/lib/logger/logger.constants.ts
 var LogLevels;
 (function(LogLevels2) {
   LogLevels2["SILENT"] = "SILENT";
@@ -57,7 +71,7 @@ var LogLevels;
   LogLevels2["VERBOSE"] = "VERBOSE";
   LogLevels2["DEBUG"] = "DEBUG";
   LogLevels2["TRACE"] = "TRACE";
-})(LogLevels || (LogLevels = exports.LogLevels = {}));
+})(LogLevels || (LogLevels = {}));
 var LogFieldStatus;
 (function(LogFieldStatus2) {
   LogFieldStatus2["RUN"] = "run";
@@ -65,9 +79,9 @@ var LogFieldStatus;
   LogFieldStatus2["STAGE"] = "stage";
   LogFieldStatus2["EXIT"] = "exit";
   LogFieldStatus2["TERMINATE"] = "terminate";
-})(LogFieldStatus || (LogFieldStatus = exports.LogFieldStatus = {}));
+})(LogFieldStatus || (LogFieldStatus = {}));
 
-// src/utils/logger/pipe/pipe-process-to-logger.ts
+// src/lib/logger/pipe/pipe-process-to-logger.ts
 function pipeProcessToLogger(logger, instance, options) {
   options = {
     start: LogLevels.INFO,
@@ -83,7 +97,7 @@ function pipeProcessToLogger(logger, instance, options) {
     });
   }
   if (instance.stdout) {
-    const writable = new (0, _stream.Writable)();
+    const writable = new Writable();
     writable.write = (chunk) => {
       logger.log(options.stdout, chunk, {
         context: options.context
@@ -93,7 +107,7 @@ function pipeProcessToLogger(logger, instance, options) {
     instance.stdout.pipe(writable);
   }
   if (instance.stderr) {
-    const writable = new (0, _stream.Writable)();
+    const writable = new Writable();
     writable.write = (chunk) => {
       logger.log(options.stderr, chunk, {
         context: options.context
@@ -113,7 +127,7 @@ function pipeProcessToLogger(logger, instance, options) {
         context: options.context
       });
     }
-    if (_optionalChain([options, 'optionalAccess', _2 => _2.callback])) {
+    if (options?.callback) {
       options.callback();
     }
   });
@@ -124,7 +138,7 @@ function pipeProcessToLogger(logger, instance, options) {
     logger.debug(error.stack, {
       context: options.context
     });
-    if (_optionalChain([options, 'optionalAccess', _3 => _3.callback])) {
+    if (options?.callback) {
       options.callback(error);
     }
   });
@@ -132,43 +146,303 @@ function pipeProcessToLogger(logger, instance, options) {
 }
 __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
+// src/lib/logger/logger.module.ts
+import { Global, Module } from "@nestjs/common";
+
+// src/lib/logger/logger.service.ts
+import { Injectable as Injectable2, Scope } from "@nestjs/common";
+import { splat } from "listr2";
+
+// src/lib/logger/winston.service.ts
+import { Inject, Injectable } from "@nestjs/common";
+import { color, figures } from "listr2";
+import { EOL } from "os";
+import winston, { format, transports } from "winston";
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1; i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+function _ts_metadata(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+}
+__name(_ts_metadata, "_ts_metadata");
+function _ts_param(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param, "_ts_param");
+var _a;
+var WinstonService = (_a = class {
+  constructor(options) {
+    __publicField(this, "options");
+    __publicField(this, "instance");
+    this.options = options;
+    this.instance = this.initiateLogger();
+  }
+  initiateLogger() {
+    const logFormat = format.printf(({ level, message, context, status }) => {
+      return message.split(EOL).filter((msg) => !msg || msg.trim() !== "").map((msg) => {
+        return this.logColoring({
+          level,
+          message: msg,
+          context,
+          status
+        });
+      }).join(EOL);
+    });
+    const logger = winston.createLogger({
+      level: this.options.config.logLevel,
+      format: format.combine(format.splat(), format.json({
+        space: 2
+      }), format.prettyPrint(), logFormat),
+      levels: Object.fromEntries(Object.values(LogLevels).map((level, i) => {
+        return [
+          level,
+          i
+        ];
+      })),
+      silent: this.options.config.logLevel === LogLevels.SILENT || this.options.config.isJson,
+      transports: [
+        new transports.Console({
+          stderrLevels: [
+            LogLevels.FATAL,
+            LogLevels.ERROR
+          ]
+        })
+      ]
+    });
+    logger.log(LogLevels.TRACE, "Initiated new winston with level: %s", this.options.config.logLevel, {
+      context: this.constructor.name
+    });
+    return logger;
+  }
+  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 LogLevels.DIRECT:
+        return message;
+      case LogLevels.FATAL:
+        coloring = color.red;
+        msgColoring = color.red;
+        break;
+      case LogLevels.ERROR:
+        coloring = color.red;
+        icon = figures.cross;
+        break;
+      case LogLevels.WARN:
+        coloring = color.yellow;
+        icon = figures.warning;
+        break;
+      case LogLevels.INFO:
+        coloring = color.green;
+        icon = figures.pointerSmall;
+        break;
+      case LogLevels.VERBOSE:
+        coloring = color.dim;
+        break;
+      case LogLevels.DEBUG:
+        coloring = color.cyan;
+        msgColoring = color.dim;
+        break;
+      case LogLevels.TRACE:
+        coloring = color.magenta;
+        msgColoring = color.dim;
+        break;
+    }
+    if (!icon) {
+      icon = `[${level.at(0).toUpperCase()}]`;
+    }
+    return `${coloring(icon)}${context ? " " + coloring(`[${context}]`) : ""}${status ? " " + coloring(`[${status}]`) : ""} ${msgColoring(message)}`;
+  }
+}, __name(_a, "WinstonService"), _a);
+WinstonService = _ts_decorate([
+  Injectable(),
+  _ts_param(0, Inject(TOKEN_CONFIG_MODULE_OPTIONS)),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof ConfigModuleOptions === "undefined" ? Object : ConfigModuleOptions
+  ])
+], WinstonService);
+
+// src/lib/logger/logger.service.ts
+function _ts_decorate2(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1; i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate2, "_ts_decorate");
+function _ts_metadata2(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+}
+__name(_ts_metadata2, "_ts_metadata");
+var _a2;
+var LoggerService = (_a2 = class {
+  constructor(winston2) {
+    __publicField(this, "winston");
+    __publicField(this, "context");
+    this.winston = winston2;
+  }
+  setup(context) {
+    this.context = context;
+    return this;
+  }
+  log(level, data, ...args) {
+    return this.parseMessage(level, data, args);
+  }
+  direct(data, ...args) {
+    return this.parseMessage(LogLevels.DIRECT, data, args);
+  }
+  fatal(data, ...args) {
+    return this.parseMessage(LogLevels.FATAL, data, args);
+  }
+  error(data, ...args) {
+    return this.parseMessage(LogLevels.ERROR, data, args);
+  }
+  warn(data, ...args) {
+    return this.parseMessage(LogLevels.WARN, data, args);
+  }
+  info(data, ...args) {
+    return this.parseMessage(LogLevels.INFO, data, args);
+  }
+  verbose(data, ...args) {
+    return this.parseMessage(LogLevels.VERBOSE, data, args);
+  }
+  debug(data, ...args) {
+    return this.parseMessage(LogLevels.DEBUG, data, args);
+  }
+  trace(data, ...args) {
+    return this.parseMessage(LogLevels.TRACE, data, args);
+  }
+  // status levels
+  run(data, ...args) {
+    return this.parseMessage(LogLevels.INFO, data, args, {
+      status: LogFieldStatus.RUN
+    });
+  }
+  end(data, ...args) {
+    return this.parseMessage(LogLevels.INFO, data, args, {
+      status: LogFieldStatus.END
+    });
+  }
+  stage(data, ...args) {
+    return this.parseMessage(LogLevels.TRACE, data, args, {
+      status: LogFieldStatus.STAGE
+    });
+  }
+  splat(...args) {
+    const message = args.shift();
+    if (typeof message === "undefined") {
+      return "";
+    }
+    if (args.length === 0) {
+      return message;
+    }
+    return splat(message, args);
+  }
+  parseMessage(level, data, args, format2) {
+    this.winston.instance.log(level, data.toString(), ...args ?? [], {
+      context: this.context,
+      ...format2 ?? {}
+    });
+  }
+}, __name(_a2, "LoggerService"), _a2);
+LoggerService = _ts_decorate2([
+  Injectable2({
+    scope: Scope.TRANSIENT
+  }),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    typeof WinstonService === "undefined" ? Object : WinstonService
+  ])
+], LoggerService);
+
+// src/lib/logger/logger.module.ts
+function _ts_decorate3(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1; i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate3, "_ts_decorate");
+var _a3;
+var LoggerModule = (_a3 = class {
+}, __name(_a3, "LoggerModule"), _a3);
+LoggerModule = _ts_decorate3([
+  Global(),
+  Module({
+    providers: [
+      WinstonService,
+      LoggerService
+    ],
+    exports: [
+      LoggerService
+    ]
+  })
+], LoggerModule);
 
-var _EnvironmentVariableParser = class _EnvironmentVariableParser {
-  constructor() {
+// src/lib/parser/parser.service.ts
+import { Injectable as Injectable7 } from "@nestjs/common";
+import { ModuleRef } from "@nestjs/core";
+
+// src/lib/parser/fts/env-parser.service.ts
+import { Injectable as Injectable3 } from "@nestjs/common";
+import { EOL as EOL2 } from "os";
+function _ts_decorate4(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1; i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate4, "_ts_decorate");
+function _ts_metadata3(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+}
+__name(_ts_metadata3, "_ts_metadata");
+var _a4;
+var EnvironmentVariableParser = (_a4 = class {
+  constructor(logger) {
     __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;
-    }
-    _EnvironmentVariableParser.instance = this;
-    this.logger = new Logger(this.constructor.name);
-    this.logger.trace("Created a new instance.");
+    __publicField(this, "LINE");
+    this.logger = logger;
+    this.LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/gm;
+    this.logger.setup(this.constructor.name);
   }
   parse(data) {
     try {
-      return data.toString().split(_os.EOL).reduce((o, line) => {
+      return data.toString().split(EOL2).reduce((o, line) => {
         const match = this.LINE.exec(line);
         const key = match[1];
-        const value = _nullishCoalesce(match[2], () => ( ""));
+        const value = match[2] ?? "";
         return {
           ...o,
           [key]: value
@@ -180,26 +454,43 @@ var _EnvironmentVariableParser = class _EnvironmentVariableParser {
     }
   }
   stringify(data) {
-    return Object.entries(data).map(([k, v]) => `${k}=${v}`).join(_os.EOL) + _os.EOL;
+    return Object.entries(data).map(([k, v]) => `${k}=${v}`).join(EOL2) + EOL2;
   }
-};
-__name(_EnvironmentVariableParser, "EnvironmentVariableParser");
-__publicField(_EnvironmentVariableParser, "extensions", [
+}, __name(_a4, "EnvironmentVariableParser"), __publicField(_a4, "extensions", [
   "env"
-]);
-__publicField(_EnvironmentVariableParser, "instance");
-var EnvironmentVariableParser = _EnvironmentVariableParser;
-
-// src/lib/parser/json-parser.service.ts
-var _JsonParser = class _JsonParser {
-  constructor() {
+]), _a4);
+EnvironmentVariableParser = _ts_decorate4([
+  Injectable3(),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof LoggerService === "undefined" ? Object : LoggerService
+  ])
+], EnvironmentVariableParser);
+
+// src/lib/parser/fts/json-parser.service.ts
+import { Injectable as Injectable4 } from "@nestjs/common";
+function _ts_decorate5(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1; i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate5, "_ts_decorate");
+function _ts_metadata4(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+}
+__name(_ts_metadata4, "_ts_metadata");
+var _a5;
+var JsonParser = (_a5 = class {
+  constructor(logger) {
     __publicField(this, "logger");
-    if (_JsonParser.instance) {
-      return _JsonParser.instance;
-    }
-    _JsonParser.instance = this;
-    this.logger = new Logger(this.constructor.name);
-    this.logger.trace("Created a new instance.");
+    this.logger = logger;
+    this.logger.setup(this.constructor.name);
   }
   parse(data) {
     try {
@@ -212,79 +503,114 @@ var _JsonParser = class _JsonParser {
   stringify(data) {
     return JSON.stringify(data, null, 2);
   }
-};
-__name(_JsonParser, "JsonParser");
-__publicField(_JsonParser, "extensions", [
+}, __name(_a5, "JsonParser"), __publicField(_a5, "extensions", [
   "json"
-]);
-__publicField(_JsonParser, "instance");
-var JsonParser = _JsonParser;
-
-// src/lib/parser/yaml-parser.service.ts
-var _yaml = require('yaml');
-var _YamlParser = class _YamlParser {
-  constructor() {
+]), _a5);
+JsonParser = _ts_decorate5([
+  Injectable4(),
+  _ts_metadata4("design:type", Function),
+  _ts_metadata4("design:paramtypes", [
+    typeof LoggerService === "undefined" ? Object : LoggerService
+  ])
+], JsonParser);
+
+// src/lib/parser/fts/yaml-parser.service.ts
+import { Injectable as Injectable5 } from "@nestjs/common";
+import { parse, stringify } from "yaml";
+function _ts_decorate6(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1; i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate6, "_ts_decorate");
+function _ts_metadata5(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+}
+__name(_ts_metadata5, "_ts_metadata");
+var _a6;
+var YamlParser = (_a6 = class {
+  constructor(logger) {
     __publicField(this, "logger");
-    if (_YamlParser.instance) {
-      return _YamlParser.instance;
-    }
-    _YamlParser.instance = this;
-    this.logger = new Logger(this.constructor.name);
-    this.logger.trace("Created a new instance.");
+    this.logger = logger;
+    this.logger.setup(this.constructor.name);
   }
   parse(data) {
     try {
-      return _yaml.parse.call(void 0, data.toString());
+      return parse(data.toString());
     } catch (e) {
       this.logger.trace("Error during parsing YAML file: %s", e.message);
       throw e;
     }
   }
   stringify(data) {
-    return _yaml.stringify.call(void 0, data, {
+    return stringify(data, {
       prettyErrors: true
     });
   }
-};
-__name(_YamlParser, "YamlParser");
-__publicField(_YamlParser, "extensions", [
+}, __name(_a6, "YamlParser"), __publicField(_a6, "extensions", [
   "yaml",
   "yml"
-]);
-__publicField(_YamlParser, "instance");
-var YamlParser = _YamlParser;
+]), _a6);
+YamlParser = _ts_decorate6([
+  Injectable5(),
+  _ts_metadata5("design:type", Function),
+  _ts_metadata5("design:paramtypes", [
+    typeof LoggerService === "undefined" ? Object : LoggerService
+  ])
+], YamlParser);
 
 // src/lib/fs/filesystem.service.ts
-var _fsextra = require('fs-extra'); var _fsextra2 = _interopRequireDefault(_fsextra);
-
-var _FileSystemService = class _FileSystemService {
-  constructor() {
+import { Injectable as Injectable6 } from "@nestjs/common";
+import fs from "fs-extra";
+import { extname, dirname } from "path";
+function _ts_decorate7(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1; i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate7, "_ts_decorate");
+function _ts_metadata6(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+}
+__name(_ts_metadata6, "_ts_metadata");
+var _a7;
+var FileSystemService = (_a7 = class {
+  constructor(logger) {
     __publicField(this, "logger");
-    if (_FileSystemService.instance) {
-      return _FileSystemService.instance;
-    } else {
-      _FileSystemService.instance = this;
-      this.logger = new Logger(this.constructor.name);
-      this.logger.trace("Created a new instance.");
-    }
+    __publicField(this, "fs");
+    this.logger = logger;
+    this.fs = fs;
+    this.logger.setup(this.constructor.name);
   }
   exists(path) {
-    return _fsextra2.default.existsSync(path);
+    return this.fs.existsSync(path);
   }
   stats(path) {
-    return _fsextra2.default.statSync(path, {
+    return this.fs.statSync(path, {
       throwIfNoEntry: true
     });
   }
   dirname(path) {
-    return _path.dirname.call(void 0, path);
+    return dirname(path);
   }
   extname(path) {
-    return _path.extname.call(void 0, path);
+    return extname(path);
   }
   async read(file) {
     try {
-      const raw = await _fsextra2.default.readFile(file, "utf-8");
+      const raw = await this.fs.readFile(file, "utf-8");
       return raw;
     } catch (e) {
       throw new Error(`Error while reading file from "${file}": ${e.message}`);
@@ -292,7 +618,7 @@ var _FileSystemService = class _FileSystemService {
   }
   readSync(file) {
     try {
-      const raw = _fsextra2.default.readFileSync(file, "utf-8");
+      const raw = this.fs.readFileSync(file, "utf-8");
       return raw;
     } catch (e) {
       throw new Error(`Error while reading file from "${file}": ${e.message}`);
@@ -300,7 +626,7 @@ var _FileSystemService = class _FileSystemService {
   }
   async write(file, data, options = {}) {
     try {
-      await _fsextra2.default.writeFile(file, data, typeof options === "object" ? {
+      await this.fs.writeFile(file, data, typeof options === "object" ? {
         encoding: "utf-8",
         ...options
       } : options);
@@ -310,7 +636,7 @@ var _FileSystemService = class _FileSystemService {
   }
   writeSync(file, data, options = {}) {
     try {
-      _fsextra2.default.writeFileSync(file, data, typeof options === "object" ? {
+      this.fs.writeFileSync(file, data, typeof options === "object" ? {
         encoding: "utf-8",
         ...options
       } : options);
@@ -320,108 +646,153 @@ var _FileSystemService = class _FileSystemService {
   }
   async append(file, data, options) {
     try {
-      await _fsextra2.default.appendFile(file, data, options);
+      await this.fs.appendFile(file, data, options);
     } catch (e) {
       throw new Error(`Error while appending to file  "${file}": ${e.message}`);
     }
   }
   appendSync(file, data) {
     try {
-      _fsextra2.default.appendFileSync(file, data);
+      this.fs.appendFileSync(file, data);
     } catch (e) {
       throw new Error(`Error while appending to file  "${file}": ${e.message}`);
     }
   }
   async remove(file, options) {
     try {
-      await _fsextra2.default.rm(file, options);
+      await this.fs.rm(file, options);
     } catch (e) {
       throw new Error(`Error while deleting the file "${file}": ${e.message}`);
     }
   }
   removeSync(file, options) {
     try {
-      _fsextra2.default.rmSync(file, options);
+      this.fs.rmSync(file, options);
     } catch (e) {
       throw new Error(`Error while deleting the file "${file}": ${e.message}`);
     }
   }
   async emptyDir(directory) {
     try {
-      await _fsextra2.default.emptyDir(directory);
+      await this.fs.emptyDir(directory);
     } catch (e) {
       throw new Error(`Error while emptying the directory "${directory}": ${e.message}`);
     }
   }
   emptyDirSync(directory) {
     try {
-      _fsextra2.default.emptyDirSync(directory);
+      this.fs.emptyDirSync(directory);
     } catch (e) {
       throw new Error(`Error while emptying the directory "${directory}": ${e.message}`);
     }
   }
   async removeDir(directory) {
     try {
-      await _fsextra2.default.rmdir(directory);
+      await this.fs.rmdir(directory);
     } catch (e) {
       throw new Error(`Error while removing the directory "${directory}": ${e.message}`);
     }
   }
   removeDirSync(directory) {
     try {
-      _fsextra2.default.rmdirSync(directory);
+      this.fs.rmdirSync(directory);
     } catch (e) {
       throw new Error(`Error while removing the directory "${directory}": ${e.message}`);
     }
   }
   async mkdir(directory) {
     try {
-      await _fsextra2.default.mkdirp(directory);
+      await this.fs.mkdirp(directory);
     } catch (e) {
       throw new Error(`Error while creating the directory "${directory}": ${e.message}`);
     }
   }
   mkdirSync(directory) {
     try {
-      _fsextra2.default.mkdirSync(directory);
+      this.fs.mkdirpSync(directory);
     } catch (e) {
       throw new Error(`Error while creating the directory "${directory}": ${e.message}`);
     }
   }
-};
-__name(_FileSystemService, "FileSystemService");
-__publicField(_FileSystemService, "instance");
-var FileSystemService = _FileSystemService;
+}, __name(_a7, "FileSystemService"), _a7);
+FileSystemService = _ts_decorate7([
+  Injectable6(),
+  _ts_metadata6("design:type", Function),
+  _ts_metadata6("design:paramtypes", [
+    typeof LoggerService === "undefined" ? Object : LoggerService
+  ])
+], FileSystemService);
+
+// src/lib/fs/filesystem.module.ts
+import { Global as Global2, Module as Module2 } from "@nestjs/common";
+function _ts_decorate8(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1; i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate8, "_ts_decorate");
+var _a8;
+var FilesystemModule = (_a8 = class {
+}, __name(_a8, "FilesystemModule"), _a8);
+FilesystemModule = _ts_decorate8([
+  Global2(),
+  Module2({
+    providers: [
+      FileSystemService
+    ],
+    exports: [
+      FileSystemService
+    ]
+  })
+], FilesystemModule);
 
 // src/lib/parser/parser.service.ts
-var _ParserService = class _ParserService {
-  constructor(parsers) {
-    __publicField(this, "parsers", [
+function _ts_decorate9(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1; i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate9, "_ts_decorate");
+function _ts_metadata7(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+}
+__name(_ts_metadata7, "_ts_metadata");
+var _a9;
+var ParserService = (_a9 = class {
+  constructor(moduleRef, fs2, logger) {
+    __publicField(this, "moduleRef");
+    __publicField(this, "fs");
+    __publicField(this, "logger");
+    __publicField(this, "parsers");
+    this.moduleRef = moduleRef;
+    this.fs = fs2;
+    this.logger = logger;
+    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;
-      this.logger.trace("Created a new instance.");
-    }
+    ];
+    this.logger.setup(this.constructor.name);
   }
-  getParser(file) {
+  async getParser(file) {
     const ext = (file.includes(".") ? this.fs.extname(file) : file).replace(/^\./, "");
-    const Parser = this.parsers.find((parser) => parser.extensions.includes(ext));
+    const Parser = this.parsers.find((parser2) => parser2.extensions.includes(ext));
     if (!Parser) {
       throw new Error(`Parser for the extension is not configured: ${ext}`);
     }
-    return new Parser();
+    const parser = await this.moduleRef.create(Parser);
+    return parser;
   }
   setParsers(...parsers) {
     this.parsers = parsers;
@@ -437,20 +808,46 @@ var _ParserService = class _ParserService {
   async write(file, data) {
     return this.fs.write(file, await this.stringify(file, data));
   }
-  parse(file, data) {
-    const parser = this.getParser(file);
+  async parse(file, data) {
+    const parser = await 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);
+  async stringify(file, data) {
+    const parser = await this.getParser(file);
     this.logger.trace("Stringifying file: %s -> %s", file, parser.constructor.name);
     return parser.stringify(data);
   }
-};
-__name(_ParserService, "ParserService");
-__publicField(_ParserService, "instance");
-var ParserService = _ParserService;
+}, __name(_a9, "ParserService"), _a9);
+ParserService = _ts_decorate9([
+  Injectable7(),
+  _ts_metadata7("design:type", Function),
+  _ts_metadata7("design:paramtypes", [
+    typeof ModuleRef === "undefined" ? Object : ModuleRef,
+    typeof FileSystemService === "undefined" ? Object : FileSystemService,
+    typeof LoggerService === "undefined" ? Object : LoggerService
+  ])
+], ParserService);
+
+// 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/environment.ts
 function isVerbose(logLevel) {
@@ -469,82 +866,99 @@ function isSilent(logLevel) {
 }
 __name(isSilent, "isSilent");
 
+// src/utils/guards.ts
+function isHookedWithShouldRunBefore(command) {
+  return typeof command.shouldRunBefore === "function";
+}
+__name(isHookedWithShouldRunBefore, "isHookedWithShouldRunBefore");
+function isHookedWithShouldRunAfter(command) {
+  return typeof command.shouldRunAfter === "function";
+}
+__name(isHookedWithShouldRunAfter, "isHookedWithShouldRunAfter");
+function isHookedWithRegister(command) {
+  return typeof command.register === "function";
+}
+__name(isHookedWithRegister, "isHookedWithRegister");
+
 // src/utils/merge.constants.ts
 var MergeStrategy;
 (function(MergeStrategy2) {
   MergeStrategy2["OVERWRITE"] = "OVERWRITE";
   MergeStrategy2["EXTEND"] = "EXTEND";
-})(MergeStrategy || (MergeStrategy = exports.MergeStrategy = {}));
+})(MergeStrategy || (MergeStrategy = {}));
 
 // src/utils/merge.ts
-var _deepmerge = require('deepmerge'); var _deepmerge2 = _interopRequireDefault(_deepmerge);
+import deepmerge from "deepmerge";
 function merge(strategy, ...source) {
-  return _deepmerge2.default.all(source, {
+  return deepmerge.all(source, {
     arrayMerge: strategy === MergeStrategy.EXTEND ? (dest, src) => [
       ...dest,
       ...src
-    ].filter(uniqueFilter) : (_, src) => src
+    ].filter(uniqueArrayFilter) : (_, src) => src
   });
 }
 __name(merge, "merge");
-function uniqueFilter(value, index, self) {
+function uniqueArrayFilter(value, index, self) {
   return self.indexOf(value) === index;
 }
-__name(uniqueFilter, "uniqueFilter");
-
-// src/utils/defaults.ts
-function setCtxDefaults(ctx, ...defaults) {
-  _optionalChain([defaults, 'optionalAccess', _4 => _4.forEach, 'call', _5 => _5((i) => {
-    if (typeof i === "object" && !Array.isArray(i)) {
-      Object.assign(ctx, i);
-    }
-  })]);
-}
-__name(setCtxDefaults, "setCtxDefaults");
-function setCtxAssign(ctx, ...assigns) {
-  assigns.forEach((assign) => {
-    _optionalChain([assign, 'optionalAccess', _6 => _6.keys, 'access', _7 => _7.forEach, 'call', _8 => _8((i) => {
-      if (assign.from[i]) {
-        ctx[i] = assign.from[i];
-      }
-    })]);
-  });
-}
-__name(setCtxAssign, "setCtxAssign");
+__name(uniqueArrayFilter, "uniqueArrayFilter");
 
 // src/utils/index.ts
-
+import { ux } from "@oclif/core";
 
 // src/lib/config/config.service.ts
-var _ConfigService = class _ConfigService {
-  constructor(oclif, command, config) {
-    __publicField(this, "oclif");
-    __publicField(this, "command");
-    __publicField(this, "defaults");
-    __publicField(this, "root");
+function _ts_decorate10(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1; i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate10, "_ts_decorate");
+function _ts_metadata8(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+}
+__name(_ts_metadata8, "_ts_metadata");
+function _ts_param2(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param2, "_ts_param");
+var _a10;
+var ConfigService = (_a10 = class {
+  constructor(parser, logger, options) {
     __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;
-    }
-    this.root = this.oclif.root;
-    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;
-    this.logger.trace("Created a new instance.");
+    __publicField(this, "defaults");
+    __publicField(this, "root");
+    __publicField(this, "config");
+    __publicField(this, "oclif");
+    __publicField(this, "command");
+    this.parser = parser;
+    this.logger = logger;
+    this.root = options.oclif.root;
+    this.defaults = join(options.oclif.root, FileConstants.CONFIG_SERVICE_DEFAULTS_DIR);
+    this.oclif = options.oclif;
+    this.config = options.config;
+    this.command = options.command;
+    this.logger.setup(this.constructor.name);
+  }
+  get isVerbose() {
+    return isVerbose(this.config.logLevel);
+  }
+  get isDebug() {
+    return isDebug(this.config.logLevel);
+  }
+  get isSilent() {
+    return isSilent(this.config.logLevel);
+  }
+  get isJson() {
+    return this.config.isJson;
   }
   async read(path) {
     const config = await this.parser.read(path);
@@ -576,7 +990,7 @@ var _ConfigService = class _ConfigService {
     const iter = /* @__PURE__ */ __name(async (obj, parent) => {
       const data = await Promise.all(Object.entries(obj).map(async ([key, value]) => {
         const location = [
-          ..._nullishCoalesce(parent, () => ( [])),
+          ...parent ?? [],
           key
         ];
         if (typeof value === "string") {
@@ -625,7 +1039,7 @@ var _ConfigService = class _ConfigService {
         }
       }
       this.logger.trace("Overwriting config with environment variable: %s -> %s", variable.key.join("."), variable.env);
-      return _objectpathimmutable2.default.set(config2, variable.key, data);
+      return op.set(config2, variable.key, data);
     }, "cb");
     parsed.forEach((variable) => {
       let data;
@@ -664,38 +1078,120 @@ var _ConfigService = class _ConfigService {
   async write(path, data) {
     return this.parser.write(path, data);
   }
-  recalculate() {
-    this.isVerbose = isVerbose(this.logLevel);
-    this.isDebug = isDebug(this.logLevel);
-    this.isSilent = isSilent(this.logLevel);
-  }
-};
-__name(_ConfigService, "ConfigService");
-__publicField(_ConfigService, "instance");
-var ConfigService = _ConfigService;
-
-// src/lib/locker/locker.service.ts
+}, __name(_a10, "ConfigService"), _a10);
+ConfigService = _ts_decorate10([
+  Injectable8(),
+  _ts_param2(2, Inject2(TOKEN_CONFIG_MODULE_OPTIONS)),
+  _ts_metadata8("design:type", Function),
+  _ts_metadata8("design:paramtypes", [
+    typeof ParserService === "undefined" ? Object : ParserService,
+    typeof LoggerService === "undefined" ? Object : LoggerService,
+    typeof ConfigModuleOptions === "undefined" ? Object : ConfigModuleOptions
+  ])
+], ConfigService);
+
+// src/lib/config/config.module.ts
+import { Global as Global4, Module as Module4 } from "@nestjs/common";
+
+// src/lib/parser/parser.module.ts
+import { Global as Global3, Module as Module3 } from "@nestjs/common";
+function _ts_decorate11(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1; i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate11, "_ts_decorate");
+var _a11;
+var ParserModule = (_a11 = class {
+}, __name(_a11, "ParserModule"), _a11);
+ParserModule = _ts_decorate11([
+  Global3(),
+  Module3({
+    imports: [
+      FilesystemModule
+    ],
+    providers: [
+      ParserService
+    ],
+    exports: [
+      ParserService
+    ]
+  })
+], ParserModule);
+
+// src/lib/config/config.module.ts
+function _ts_decorate12(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1; i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate12, "_ts_decorate");
+var _a12;
+var ConfigModule = (_a12 = class {
+}, __name(_a12, "ConfigModule"), _a12);
+ConfigModule = _ts_decorate12([
+  Global4(),
+  Module4({
+    imports: [
+      ParserModule
+    ],
+    providers: [
+      ConfigService
+    ],
+    exports: [
+      ConfigService
+    ]
+  })
+], ConfigModule);
 
-var _LockerService = class _LockerService {
-  constructor(file, parser, root, context) {
-    __publicField(this, "file");
-    __publicField(this, "parser");
-    __publicField(this, "root");
-    __publicField(this, "toLock");
-    __publicField(this, "toUnlock");
+// src/lib/locker/locker.constants.ts
+var INSTANCE_LOCKER_SERVICE = Symbol("INSTANCE_LOCKER_SERVICE");
+
+// src/lib/locker/locker.service.ts
+import { Injectable as Injectable9 } from "@nestjs/common";
+import op2 from "object-path-immutable";
+function _ts_decorate13(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1; i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate13, "_ts_decorate");
+function _ts_metadata9(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+}
+__name(_ts_metadata9, "_ts_metadata");
+var _a13;
+var LockerService = (_a13 = class {
+  constructor(logger, fs2, options) {
     __publicField(this, "logger");
     __publicField(this, "fs");
-    this.file = file;
-    this.parser = parser;
-    this.root = root;
+    __publicField(this, "options");
+    __publicField(this, "op");
+    __publicField(this, "toLock");
+    __publicField(this, "toUnlock");
+    this.logger = logger;
+    this.fs = fs2;
+    this.options = options;
+    this.op = op2;
     this.toLock = [];
     this.toUnlock = [];
-    this.fs = new FileSystemService();
-    this.logger = new Logger(_nullishCoalesce(context, () => ( this.constructor.name)));
-    if (!this.parser) {
-      const parser2 = new ParserService();
-      this.parser = parser2.getParser(file);
-    }
+    this.logger.setup(this.constructor.name);
   }
   hasLock() {
     return this.toLock.length > 0;
@@ -732,26 +1228,26 @@ var _LockerService = class _LockerService {
     await this.lockAll();
   }
   async lock(...data) {
-    let lock = await _asyncNullishCoalesce(await this.tryRead(), async () => ( {}));
+    let lock = await this.tryRead() ?? {};
     data.forEach((d) => {
-      if (_optionalChain([d, 'optionalAccess', _9 => _9.enabled]) === false) {
+      if (d?.enabled === false) {
         return;
-      } 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) {
+      } 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 (_optionalChain([d, 'optionalAccess', _13 => _13.merge])) {
+      if (d?.merge) {
         let parsed;
         if (typeof d.data === "object") {
-          parsed = merge(d.merge, _objectpathimmutable2.default.get(lock, path, Array.isArray(d.data) ? [] : {}), d.data);
+          parsed = merge(d.merge, this.op.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 = _objectpathimmutable2.default.set(lock, path, parsed);
+        lock = this.op.set(lock, path, parsed);
         this.logger.verbose("Merge lock: %s -> %o", path, d.data);
       } else {
-        lock = _objectpathimmutable2.default.set(lock, path, d.data);
+        lock = this.op.set(lock, path, d.data);
         this.logger.verbose("Override lock: %s -> %o", path, d.data);
       }
     });
@@ -765,50 +1261,50 @@ var _LockerService = class _LockerService {
     }
     if (data.length > 0) {
       data.forEach((d) => {
-        if (_optionalChain([d, 'optionalAccess', _14 => _14.enabled]) === false) {
+        if (d?.enabled === false) {
           return;
         }
         const path = this.buildPath(d);
-        lock = _objectpathimmutable2.default.del(lock, path);
+        lock = op2.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 = _objectpathimmutable2.default.get(lock, parentPath);
+          const parent = this.op.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 = _objectpathimmutable2.default.del(lock, parentPath);
+            lock = op2.del(lock, parentPath);
           } else {
             break;
           }
         }
       });
     } else {
-      lock = _objectpathimmutable2.default.del(lock, this.root);
-      this.logger.verbose("Unlocked module: %s", this.root);
+      lock = op2.del(lock, this.options.root);
+      this.logger.verbose("Unlocked module: %s", this.options.root);
     }
-    await this.write(_nullishCoalesce(lock, () => ( {})));
+    await this.write(lock ?? {});
   }
   async read() {
-    return this.parser.parse(await this.fs.read(this.file));
+    return this.options.parser.parse(await this.fs.read(this.options.file));
   }
   async tryRead() {
     try {
-      return this.parser.parse(await this.fs.read(this.file));
-    } catch (e2) {
-      this.logger.trace("Can not read lockfile: %s", this.file);
+      return this.options.parser.parse(await this.fs.read(this.options.file));
+    } catch {
+      this.logger.trace("Can not read lockfile: %s", this.options.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);
+      this.logger.trace("Trying to write empty lock file, deleting it instead: %s", this.options.file);
+      return this.fs.remove(this.options.file);
     }
-    return this.fs.write(this.file, this.parser.stringify(data));
+    return this.fs.write(this.options.file, await this.options.parser.stringify(data));
   }
   buildPath(d) {
-    if (_optionalChain([d, 'optionalAccess', _15 => _15.root]) !== true && _optionalChain([this, 'access', _16 => _16.root, 'optionalAccess', _17 => _17.length])) {
+    if (d?.root !== true && this.options.root?.length) {
       return [
-        ...this.root,
+        ...this.options.root,
         ...this.normalizePath(d.path)
       ];
     }
@@ -822,70 +1318,203 @@ var _LockerService = class _LockerService {
     }
     return [];
   }
-};
-__name(_LockerService, "LockerService");
-var LockerService = _LockerService;
-
-// src/lib/store/store.service.ts
-var _StoreService = class _StoreService {
-  constructor() {
-    __publicField(this, "store", {});
-    if (_StoreService.instance) {
-      return _StoreService.instance;
-    } else {
-      _StoreService.instance = this;
-    }
-  }
-  has(key) {
-    return !!this.store[key];
-  }
-  get(key) {
-    return this.store[key];
+}, __name(_a13, "LockerService"), _a13);
+LockerService = _ts_decorate13([
+  Injectable9(),
+  _ts_metadata9("design:type", Function),
+  _ts_metadata9("design:paramtypes", [
+    typeof LoggerService === "undefined" ? Object : LoggerService,
+    typeof FileSystemService === "undefined" ? Object : FileSystemService,
+    typeof LockerServiceOptions === "undefined" ? Object : LockerServiceOptions
+  ])
+], LockerService);
+
+// src/lib/locker/locker.module.ts
+import { Module as Module5 } from "@nestjs/common";
+function _ts_decorate14(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1; i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate14, "_ts_decorate");
+var _a14;
+var LockerModule = (_a14 = class {
+  static forFeature(options) {
+    const token = options.token ?? INSTANCE_LOCKER_SERVICE;
+    return {
+      module: _a14,
+      providers: [
+        {
+          provide: token,
+          useFactory: (logger, fs2) => new LockerService(logger, fs2, options),
+          inject: [
+            LoggerService,
+            FileSystemService
+          ]
+        }
+      ]
+    };
   }
-  set(key, data) {
-    this.store[key] = data;
-    return data;
+}, __name(_a14, "LockerModule"), _a14);
+LockerModule = _ts_decorate14([
+  Module5({})
+], LockerModule);
+
+// src/lib/logo/logo.constants.ts
+var TOKEN_LOGO_GENERATOR = Symbol("TOKEN_LOGO_GENERATOR");
+
+// src/lib/logo/logo.module.ts
+import { Module as Module6 } from "@nestjs/common";
+
+// src/lib/logo/logo.service.ts
+import { Injectable as Injectable10 } from "@nestjs/common";
+import { ModuleRef as ModuleRef2 } from "@nestjs/core";
+import { EOL as EOL3 } from "os";
+function _ts_decorate15(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1; i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate15, "_ts_decorate");
+function _ts_metadata10(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+}
+__name(_ts_metadata10, "_ts_metadata");
+var _a15;
+var LogoService = (_a15 = class {
+  constructor(cs, moduleRef) {
+    __publicField(this, "cs");
+    __publicField(this, "generator");
+    this.cs = cs;
+    try {
+      this.generator = moduleRef.get(TOKEN_LOGO_GENERATOR, {
+        strict: false
+      });
+    } catch (e) {
+      this.generator = function() {
+        if (this.shouldBeSilent()) {
+          return;
+        }
+        this.write(this.cs.oclif.name, "v" + this.cs.oclif.version);
+      };
+    }
   }
-};
-__name(_StoreService, "StoreService");
-__publicField(_StoreService, "instance");
-var StoreService = _StoreService;
+  generate() {
+    return this.generator.call(this);
+  }
+  shouldBeSilent() {
+    return this.cs.isJson || this.cs.isSilent;
+  }
+  write(...data) {
+    process.stdout.write(data.join(" ") + EOL3);
+  }
+}, __name(_a15, "LogoService"), _a15);
+LogoService = _ts_decorate15([
+  Injectable10(),
+  _ts_metadata10("design:type", Function),
+  _ts_metadata10("design:paramtypes", [
+    typeof ConfigService === "undefined" ? Object : ConfigService,
+    typeof ModuleRef2 === "undefined" ? Object : ModuleRef2
+  ])
+], LogoService);
+
+// src/lib/logo/logo.module.ts
+function _ts_decorate16(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1; i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate16, "_ts_decorate");
+var _a16;
+var LogoModule = (_a16 = class {
+}, __name(_a16, "LogoModule"), _a16);
+LogoModule = _ts_decorate16([
+  Module6({
+    providers: [
+      LogoService
+    ],
+    exports: [
+      LogoService
+    ]
+  })
+], LogoModule);
+
+// src/lib/validator/validator.constants.ts
+var TOKEN_VALIDATOR_SERVICE_OPTIONS = Symbol("TOKEN_VALIDATOR_SERVICE_OPTIONS");
+
+// src/lib/validator/validator.module.ts
+import { Global as Global5, Module as Module7 } from "@nestjs/common";
 
 // src/lib/validator/validator.service.ts
-var _classtransformer = require('class-transformer');
-var _classvalidator = require('class-validator');
-var _ValidatorService = class _ValidatorService {
-  constructor(options) {
-    __publicField(this, "options");
+import { Injectable as Injectable11 } from "@nestjs/common";
+import { ModuleRef as ModuleRef3 } from "@nestjs/core";
+import { plainToClass } from "class-transformer";
+import { validate, validateSync } from "class-validator";
+function _ts_decorate17(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1; i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate17, "_ts_decorate");
+function _ts_metadata11(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+}
+__name(_ts_metadata11, "_ts_metadata");
+var _a17;
+var ValidatorService = (_a17 = class {
+  constructor(logger, moduleRef) {
     __publicField(this, "logger");
-    this.options = options;
-    if (_ValidatorService.instance) {
-      return _ValidatorService.instance;
+    __publicField(this, "options");
+    this.logger = logger;
+    this.logger.setup(this.constructor.name);
+    try {
+      this.options = moduleRef.get(TOKEN_VALIDATOR_SERVICE_OPTIONS, {
+        strict: false
+      });
+    } catch {
+      this.options = {
+        validator: {
+          skipMissingProperties: true,
+          whitelist: false,
+          always: true,
+          enableDebugMessages: true
+        },
+        transformer: {
+          enableImplicitConversion: true
+        }
+      };
     }
-    this.options = {
-      validator: {
-        skipMissingProperties: true,
-        whitelist: false,
-        always: true,
-        enableDebugMessages: true
-      },
-      transformer: {
-        enableImplicitConversion: true
-      },
-      ..._nullishCoalesce(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 = _classtransformer.plainToClass.call(void 0, classType, object, {
+    const classObject = plainToClass(classType, object, {
       ...this.options.transformer,
-      ..._nullishCoalesce(_optionalChain([options, 'optionalAccess', _18 => _18.transformer]), () => ( {}))
+      ...options?.transformer ?? {}
     });
-    const errors = await _classvalidator.validate.call(void 0, classObject, {
+    const errors = await validate(classObject, {
       ...this.options.validator,
-      ..._nullishCoalesce(_optionalChain([options, 'optionalAccess', _19 => _19.validator]), () => ( {}))
+      ...options?.validator ?? {}
     });
     if (errors.length) {
       errors.forEach((error) => {
@@ -896,13 +1525,13 @@ var _ValidatorService = class _ValidatorService {
     return classObject;
   }
   validateSync(classType, object, options) {
-    const classObject = _classtransformer.plainToClass.call(void 0, classType, object, {
+    const classObject = plainToClass(classType, object, {
       ...this.options.transformer,
-      ..._nullishCoalesce(_optionalChain([options, 'optionalAccess', _20 => _20.transformer]), () => ( {}))
+      ...options?.transformer ?? {}
     });
-    const errors = _classvalidator.validateSync.call(void 0, classObject, {
+    const errors = validateSync(classObject, {
       ...this.options.validator,
-      ..._nullishCoalesce(_optionalChain([options, 'optionalAccess', _21 => _21.validator]), () => ( {}))
+      ...options?.validator ?? {}
     });
     if (errors.length) {
       errors.forEach((error) => {
@@ -915,10 +1544,42 @@ var _ValidatorService = class _ValidatorService {
   logValidationError(err) {
     this.logger.error('Field "%s" failed validation with value "%s": %o', err.property, err.value, err.constraints);
   }
-};
-__name(_ValidatorService, "ValidatorService");
-__publicField(_ValidatorService, "instance");
-var ValidatorService = _ValidatorService;
+}, __name(_a17, "ValidatorService"), _a17);
+ValidatorService = _ts_decorate17([
+  Injectable11(),
+  _ts_metadata11("design:type", Function),
+  _ts_metadata11("design:paramtypes", [
+    typeof LoggerService === "undefined" ? Object : LoggerService,
+    typeof ModuleRef3 === "undefined" ? Object : ModuleRef3
+  ])
+], ValidatorService);
+
+// src/lib/validator/validator.module.ts
+function _ts_decorate18(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1; i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate18, "_ts_decorate");
+var _a18;
+var ValidatorModule = (_a18 = class {
+}, __name(_a18, "ValidatorModule"), _a18);
+ValidatorModule = _ts_decorate18([
+  Global5(),
+  Module7({
+    providers: [
+      ValidatorService
+    ],
+    exports: [
+      ValidatorService
+    ]
+  })
+], ValidatorModule);
 
 // src/lib/setup.ts
 function setup() {
@@ -955,294 +1616,86 @@ function setup() {
 }
 __name(setup, "setup");
 
-// src/utils/logger/logger.ts
-var _Logger = class _Logger {
-  constructor(context, options) {
-    __publicField(this, "context");
-    __publicField(this, "options");
-    __publicField(this, "logger");
-    this.context = context;
-    this.options = options;
-    if (_Logger.instance && context !== ConfigService.name) {
-      this.logger = _Logger.instance;
-      return this;
-    }
-    const l = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _22 => _22.level]), () => ( process.env.LOG_LEVEL));
-    const level = Object.values(LogLevels).includes(l) ? l : LogLevels.INFO;
-    this.options = {
-      useIcons: true,
-      ...options,
-      level
+// src/lib/cli.module.ts
+import { NestFactory } from "@nestjs/core";
+var _CliModule = class _CliModule {
+  static forRoot(options) {
+    return {
+      module: _CliModule,
+      global: true,
+      imports: [
+        ConfigModule,
+        LoggerModule,
+        FilesystemModule,
+        ParserModule,
+        LogoModule
+      ],
+      providers: [
+        {
+          provide: TOKEN_CONFIG_MODULE_OPTIONS,
+          useValue: options.config
+        }
+      ],
+      exports: [
+        TOKEN_CONFIG_MODULE_OPTIONS
+      ]
     };
-    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(LogLevels.DIRECT, data, args);
-  }
-  fatal(data, ...args) {
-    return this.parseMessage(LogLevels.FATAL, data, args);
-  }
-  error(data, ...args) {
-    return this.parseMessage(LogLevels.ERROR, data, args);
-  }
-  warn(data, ...args) {
-    return this.parseMessage(LogLevels.WARN, data, args);
-  }
-  info(data, ...args) {
-    return this.parseMessage(LogLevels.INFO, data, args);
-  }
-  debug(data, ...args) {
-    return this.parseMessage(LogLevels.DEBUG, data, args);
-  }
-  verbose(data, ...args) {
-    return this.parseMessage(LogLevels.VERBOSE, data, args);
-  }
-  trace(data, ...args) {
-    return this.parseMessage(LogLevels.TRACE, data, args);
   }
-  // status levels
-  run(data, ...args) {
-    return this.parseMessage(LogLevels.INFO, data, args, {
-      status: LogFieldStatus.RUN
-    });
-  }
-  end(data, ...args) {
-    return this.parseMessage(LogLevels.INFO, data, args, {
-      status: LogFieldStatus.END
-    });
-  }
-  stage(data, ...args) {
-    return this.parseMessage(LogLevels.TRACE, data, args, {
-      status: LogFieldStatus.STAGE
-    });
-  }
-  splat(...args) {
-    const message = args.shift();
-    if (typeof message === "undefined") {
-      return "";
-    }
-    if (args.length === 0) {
-      return message;
-    }
-    return _listr2.splat.call(void 0, message, args);
-  }
-  initiateLogger() {
-    const logFormat = _winston.format.printf(({ level, message, context, status }) => {
-      return message.split(_os.EOL).filter((msg) => !msg || msg.trim() !== "").map((msg) => {
-        return this.logColoring({
-          level,
-          message: msg,
-          context,
-          status
-        });
-      }).join(_os.EOL);
-    });
-    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),
-      levels: Object.fromEntries(Object.values(LogLevels).map((level, i) => {
-        return [
-          level,
-          i
-        ];
-      })),
-      silent: this.options.level === LogLevels.SILENT,
-      transports: [
-        new _winston.transports.Console({
-          stderrLevels: [
-            LogLevels.FATAL,
-            LogLevels.ERROR
-          ]
-        })
+  static forMinimum() {
+    return {
+      module: _CliModule,
+      global: true,
+      imports: [
+        LoggerModule
+      ],
+      providers: [
+        {
+          provide: TOKEN_CONFIG_MODULE_OPTIONS,
+          useValue: {
+            config: {
+              logLevel: LogLevels.INFO,
+              isJson: false
+            }
+          }
+        }
+      ],
+      exports: [
+        TOKEN_CONFIG_MODULE_OPTIONS
       ]
-    });
-    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) {
-      return;
-    } else if (_Logger.instance) {
-      this.logger = _Logger.instance;
-    }
-    this.logger.log(level, data.toString(), ..._nullishCoalesce(args, () => ( [])), {
-      context: this.context,
-      ..._nullishCoalesce(format2, () => ( {}))
+  static create(cls) {
+    return NestFactory.createApplicationContext(cls, {
+      logger: [
+        "error"
+      ]
     });
   }
-  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 LogLevels.DIRECT:
-        return message;
-      case LogLevels.FATAL:
-        coloring = /* @__PURE__ */ __name((input) => _listr2.color.red(input), "coloring");
-        if (_optionalChain([this, 'access', _23 => _23.options, 'optionalAccess', _24 => _24.useIcons])) {
-          icon = _listr2.figures.checkboxOn;
-        }
-        break;
-      case LogLevels.ERROR:
-        coloring = _listr2.color.red;
-        if (_optionalChain([this, 'access', _25 => _25.options, 'optionalAccess', _26 => _26.useIcons])) {
-          icon = _listr2.figures.cross;
-        }
-        break;
-      case LogLevels.WARN:
-        coloring = _listr2.color.yellow;
-        if (_optionalChain([this, 'access', _27 => _27.options, 'optionalAccess', _28 => _28.useIcons])) {
-          icon = _listr2.figures.warning;
-        }
-        break;
-      case LogLevels.INFO:
-        coloring = _listr2.color.green;
-        if (_optionalChain([this, 'access', _29 => _29.options, 'optionalAccess', _30 => _30.useIcons])) {
-          icon = _listr2.figures.pointerSmall;
-        }
-        break;
-      case LogLevels.VERBOSE:
-        coloring = _listr2.color.dim;
-        if (_optionalChain([this, 'access', _31 => _31.options, 'optionalAccess', _32 => _32.useIcons])) {
-          icon = "\u2607";
-        }
-        break;
-      case LogLevels.DEBUG:
-        coloring = _listr2.color.cyan;
-        msgColoring = _listr2.color.dim;
-        if (_optionalChain([this, 'access', _33 => _33.options, 'optionalAccess', _34 => _34.useIcons])) {
-          icon = "\uF188";
-        }
-        break;
-      case LogLevels.TRACE:
-        coloring = _listr2.color.magenta;
-        msgColoring = _listr2.color.dim;
-        if (_optionalChain([this, 'access', _35 => _35.options, 'optionalAccess', _36 => _36.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");
-__publicField(_Logger, "instance");
-var Logger = _Logger;
-
-// src/constants/global-flags.constants.ts
-var CLI_FLAGS = {
-  ["log-level"]: _core.Flags.string({
-    default: LogLevels.INFO,
-    env: "LOG_LEVEL",
-    description: "Set the log level of the application.",
-    options: Object.values(LogLevels).map((level) => level.toLowerCase()),
-    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: HelpGroups.CLI
-  }),
-  json: _core.Flags.boolean({
-    default: false,
-    hidden: true,
-    env: "JSON",
-    description: "Put the CLI to respond in JSON.",
-    helpGroup: HelpGroups.CLI
-  })
 };
+__name(_CliModule, "CliModule");
+var CliModule = _CliModule;
 
 // src/commands/base.command.ts
-var _Command = class _Command extends _core.Command {
+import "reflect-metadata";
+var _Command = class _Command extends BaseCommand {
   constructor() {
     super(...arguments);
-    __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;
-  }
-  static set baseFlags(flags) {
-    this._baseFlags = Object.assign(CLI_FLAGS, this.baseFlags, flags);
-    this.flags = {};
-  }
-  /**
-  * 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.
-  */
-  // eslint-disable-next-line @typescript-eslint/no-empty-function, @typescript-eslint/no-unused-vars
-  shouldRunAfter(_ctx) {
-  }
-  // make run non-abstract for other classes
-  run() {
-    throw new Error("The command should have a run function to do something!");
-  }
-  // eslint-disable-next-line @typescript-eslint/naming-convention
-  async _run() {
-    this.constructor.prototype.baseFlags = {};
-    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()) {
-      _core.ux.styledJSON(this.toSuccessJson(result));
-    }
-    return result;
+    __publicField(this, "app");
+    __publicField(this, "flags");
+    __publicField(this, "args");
   }
   exit(code) {
     this.logger.trace("Code -> %d", code, {
       status: LogFieldStatus.EXIT
     });
-    process.exit(_nullishCoalesce(code, () => ( 0)));
+    super.exit(code ?? 0);
   }
   /** Run all tasks from task manager. */
   runTasks() {
     return this.tasks.runAll();
   }
-  /** Gets prompt from user. */
-  prompt(options) {
-    return _listr2.createPrompt.call(void 0, 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, {
@@ -1258,47 +1711,54 @@ var _Command = class _Command extends _core.Command {
   pipeProcessToLogger(instance, options) {
     return pipeProcessToLogger(this.logger, instance, options);
   }
-  pipeProcessThroughListr(task, instance) {
+  pipeProcessThroughListr(instance, task) {
     return pipeProcessThroughListr(task, instance);
   }
   /** Initial functions / constructor */
   // can not override constructor, init function is defined by oclif
   async init() {
-    this.constructor.flags = Object.assign({}, CLI_FLAGS, this.constructor.flags);
     await super.init();
     let err;
     try {
-      const { flags, args } = await this.parse();
+      const { args, flags } = await this.parse({
+        flags: this.ctor.flags,
+        baseFlags: super.ctor.baseFlags,
+        enableJsonFlag: this.ctor.enableJsonFlag,
+        args: this.ctor.args,
+        strict: this.ctor.strict
+      });
       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
-    });
-    this.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();
+    const options = {
+      config: {
+        oclif: this.config,
+        command: this.ctor,
+        config: {
+          logLevel: this.flags["log-level"],
+          isJson: this.flags.json
+        }
+      }
+    };
+    const cli = CliModule.forRoot(options);
+    this.app = await CliModule.create(isHookedWithRegister(this) ? this.register(cli, options) : cli);
+    const cs = this.app.get(ConfigService);
+    this.logger = await this.app.resolve(LoggerService);
+    this.app.useLogger(this.logger);
+    this.app.get(LogoService).generate();
     if (err) {
       throw err;
     }
-    this.logger.stage("Initiating services.");
-    this.parser = new ParserService();
-    this.fs = new FileSystemService();
-    this.validator = new ValidatorService();
-    this.tasks = new (0, _listr2.Manager)({
-      fallbackRendererCondition: this.cs.isDebug,
-      silentRendererCondition: this.cs.isSilent,
+    this.logger.stage("Created application context.");
+    this.tasks = new Manager({
+      fallbackRendererCondition: cs.isDebug,
+      silentRendererCondition: cs.isSilent || cs.isJson,
       ctx: {}
     });
-    if (this.cs.oclif.windows) {
-      _readline.createInterface.call(void 0, {
+    if (cs.oclif.windows) {
+      createInterface({
         input: process.stdin,
         output: process.stdout
       }).on("SIGINT", () => {
@@ -1313,29 +1773,35 @@ var _Command = class _Command extends _core.Command {
     }, "terminate");
     process.on("SIGINT", terminate);
     process.on("SIGTERM", terminate);
-    this.logger.stage("Running shouldRunBefore.");
-    await this.shouldRunBefore();
-    this.logger.stage("Finished shouldRunBefore.");
+    if (isHookedWithShouldRunBefore(this)) {
+      this.logger.stage("Running hook should-run-before.");
+      await this.shouldRunBefore();
+      this.logger.stage("Finished hook should-run-before.");
+    }
   }
   /** Tasks to run before end of the command. */
   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.");
+    let ctx;
+    if (this.tasks?.tasks?.length > 0) {
+      this.logger.stage("Running tasks.");
+      ctx = await this.runTasks();
+      this.logger.stage("Finished tasks.");
+    }
+    if (isHookedWithShouldRunAfter(this)) {
+      this.logger.stage("Running hook should-run-after.");
+      await this.shouldRunAfter(ctx);
+      this.logger.stage("Finished hook should-run-after.");
+    }
     return {
       ctx
     };
   }
   /** Catch any error occurred during command. */
   // catch all those errors, not verbose
-  catch(e, exit) {
+  async catch(e, exit) {
     if (!this.logger) {
-      console.error("Logger has not been initiated yet!");
-      console.error(e.message);
-      console.debug(e.stack);
+      this.app = await CliModule.create(CliModule.forMinimum());
+      this.logger = await this.app.resolve(LoggerService);
     }
     this.logger.fatal(e.message);
     this.logger.debug(e.stack, {
@@ -1346,73 +1812,51 @@ var _Command = class _Command extends _core.Command {
     }
     return;
   }
-  greet() {
-    if (this.cs.isSilent || this.cs.json) {
-      return;
-    }
-    const logo = _nullishCoalesce(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");
+__publicField(_Command, "baseFlags", {
+  ["log-level"]: Flags.string({
+    default: LogLevels.INFO,
+    env: "LOG_LEVEL",
+    description: "Set the log level of the application.",
+    options: Object.values(LogLevels).map((level) => level.toLowerCase()),
+    helpGroup: HelpGroups.CLI,
+    parse: async (input) => input?.toUpperCase()
+  }),
+  ci: Flags.boolean({
+    default: false,
+    hidden: true,
+    env: "CI",
+    description: "Instruct whether this is running the CI/CD configuration.",
+    helpGroup: HelpGroups.CLI
+  }),
+  json: Flags.boolean({
+    default: false,
+    hidden: true,
+    env: "JSON",
+    description: "Put the CLI to respond in JSON.",
+    helpGroup: HelpGroups.CLI
+  })
+});
 var Command = _Command;
 
-// src/commands/config.command.ts
-var _ConfigCommand = class _ConfigCommand 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();
-    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) {
-    _core.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");
-var ConfigCommand = _ConfigCommand;
-
 // src/hooks/not-found.hook.ts
-
+import { Help } from "@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
-  });
+  const app = await CliModule.create(CliModule.forMinimum());
+  const logger = await app.resolve(LoggerService);
+  logger.error("Command not found. Take a look at help. You can also use --[h]elp flag for subcommands.");
   logger.direct("");
-  const help = new (0, _core.Help)(opts.config);
+  const help = new Help(opts.config);
   await help.showHelp([
     "--all"
   ]);
-  process.exit(127);
+  opts.context.exit(127);
 }, "notFoundHook");
 
 // src/hooks/update-notifier.hook.ts
 var updateNotifierHook = /* @__PURE__ */ __name(async (opts) => {
-  const { default: notifier } = await Promise.resolve().then(() => _interopRequireWildcard(require("update-notifier")));
+  const { default: notifier } = await import("update-notifier");
   notifier({
     pkg: {
       name: opts.config.name,
@@ -1423,44 +1867,54 @@ var updateNotifierHook = /* @__PURE__ */ __name(async (opts) => {
   });
 }, "updateNotifierHook");
 
-// src/hooks/store.hook.ts
-var storeHook = /* @__PURE__ */ __name((cb) => async (opts) => {
-  cb(opts, new StoreService());
-}, "storeHook");
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-exports.Args = _core.Args; 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.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;
+// src/interfaces/oclif.interface.ts
+import { Flags as Flags2, Args } from "@oclif/core";
+export {
+  Args,
+  CliModule,
+  Command,
+  ConfigModule,
+  ConfigService,
+  EnvironmentVariableParser,
+  FileConstants,
+  FileSystemService,
+  FilesystemModule,
+  Flags2 as Flags,
+  HelpGroups,
+  INSTANCE_LOCKER_SERVICE,
+  Inject3 as Inject,
+  JsonParser,
+  LockerModule,
+  LockerService,
+  LogFieldStatus,
+  LogLevels,
+  LoggerModule,
+  LoggerService,
+  LogoModule,
+  LogoService,
+  MergeStrategy,
+  ParserModule,
+  ParserService,
+  TOKEN_LOGO_GENERATOR,
+  TOKEN_VALIDATOR_SERVICE_OPTIONS,
+  ValidatorModule,
+  ValidatorService,
+  WinstonService,
+  YamlParser,
+  isDebug,
+  isHookedWithRegister,
+  isHookedWithShouldRunAfter,
+  isHookedWithShouldRunBefore,
+  isSilent,
+  isVerbose,
+  merge,
+  notFoundHook,
+  pipeProcessThroughListr,
+  pipeProcessToLogger,
+  setCtxAssign,
+  setCtxDefaults,
+  setup,
+  uniqueArrayFilter,
+  updateNotifierHook,
+  ux
+};