@cenk1cenk2/oclif-common 3.9.6 → 3.9.8

package/dist/lib/parser/yaml-parser.service.js

@@ -0,0 +1,53 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var yaml_parser_service_exports = {};
+__export(yaml_parser_service_exports, {
+  YamlParser: () => YamlParser
+});
+module.exports = __toCommonJS(yaml_parser_service_exports);
+var import_yaml = require("yaml");
+var import_logger = require("../../utils/logger");
+const _YamlParser = class {
+  constructor() {
+    if (_YamlParser.instance) {
+      return _YamlParser.instance;
+    }
+    _YamlParser.instance = this;
+    this.logger = new import_logger.Logger(this.constructor.name);
+    this.logger.trace("Created a new instance.");
+  }
+  parse(data) {
+    try {
+      return (0, import_yaml.parse)(data.toString());
+    } catch (e) {
+      this.logger.trace("Error during parsing YAML file: %s", e.message);
+      throw e;
+    }
+  }
+  stringify(data) {
+    return (0, import_yaml.stringify)(data, { prettyErrors: true });
+  }
+};
+let YamlParser = _YamlParser;
+__name(YamlParser, "YamlParser");
+YamlParser.extensions = ["yaml", "yml"];
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  YamlParser
+});

package/dist/lib/setup.d.ts

@@ -0,0 +1,3 @@
+declare function setup(): void;
+
+export { setup };

package/dist/lib/setup.js

@@ -0,0 +1,60 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var setup_exports = {};
+__export(setup_exports, {
+  setup: () => setup
+});
+module.exports = __toCommonJS(setup_exports);
+function setup() {
+  const inspect = process.argv.indexOf("--inspect");
+  if (inspect !== -1) {
+    require("inspector").open();
+    process.argv.splice(inspect, 1);
+  }
+  const verbose = process.argv.indexOf("--verbose");
+  if (verbose !== -1) {
+    process.env.LOG_LEVEL = "verbose";
+    process.argv.splice(verbose, 1);
+  }
+  const debug = process.argv.indexOf("--debug");
+  if (debug !== -1) {
+    process.env.LOG_LEVEL = "debug";
+    process.argv.splice(debug, 1);
+  }
+  const trace = process.argv.indexOf("--trace");
+  if (trace !== -1) {
+    process.env.LOG_LEVEL = "trace";
+    process.argv.splice(trace, 1);
+  }
+  const silent = process.argv.indexOf("--silent");
+  if (silent !== -1) {
+    process.env.LOG_LEVEL = "silent";
+    process.argv.splice(silent, 1);
+  }
+  const sourceMaps = process.argv.indexOf("--source-map");
+  if (sourceMaps !== -1) {
+    require("source-map-support").install();
+    process.argv.splice(sourceMaps, 1);
+  }
+}
+__name(setup, "setup");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  setup
+});

package/dist/lib/store/index.d.ts

@@ -0,0 +1,2 @@
+export { DataStore } from './store.interface.js';
+export { StoreService } from './store.service.js';

package/dist/lib/store/index.js

@@ -0,0 +1,18 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var store_exports = {};
+module.exports = __toCommonJS(store_exports);
+__reExport(store_exports, require("./store.interface"), module.exports);
+__reExport(store_exports, require("./store.service"), module.exports);

package/dist/lib/store/store.interface.d.ts

@@ -0,0 +1,5 @@
+type DataStore<T extends Record<PropertyKey, any> = Record<PropertyKey, any>> = {
+    logo?: string;
+} & T;
+
+export { DataStore };

package/dist/lib/store/store.interface.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var store_interface_exports = {};
+module.exports = __toCommonJS(store_interface_exports);

package/dist/lib/store/store.service.d.ts

@@ -0,0 +1,12 @@
+import { DataStore } from './store.interface.js';
+
+declare class StoreService<T extends Record<PropertyKey, any> = Record<PropertyKey, any>> {
+    private static instance;
+    private store;
+    constructor();
+    has<K extends keyof DataStore<T>>(key: K): boolean;
+    get<K extends keyof DataStore<T>>(key: K): DataStore<T>[K];
+    set<K extends keyof DataStore<T>>(key: K, data: DataStore<T>[K]): DataStore<T>[K];
+}
+
+export { StoreService };

package/dist/lib/store/store.service.js

@@ -0,0 +1,48 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var store_service_exports = {};
+__export(store_service_exports, {
+  StoreService: () => StoreService
+});
+module.exports = __toCommonJS(store_service_exports);
+class StoreService {
+  constructor() {
+    this.store = {};
+    if (StoreService.instance) {
+      return StoreService.instance;
+    } else {
+      StoreService.instance = this;
+    }
+  }
+  has(key) {
+    return !!this.store[key];
+  }
+  get(key) {
+    return this.store[key];
+  }
+  set(key, data) {
+    this.store[key] = data;
+    return data;
+  }
+}
+__name(StoreService, "StoreService");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  StoreService
+});

package/dist/lib/validator/index.d.ts

@@ -0,0 +1,5 @@
+export { ValidatorServiceOptions } from './validator.interface.js';
+export { ValidatorService } from './validator.service.js';
+import 'class-transformer';
+import 'class-validator';
+import '../../interfaces/class.interface.js';

package/dist/lib/validator/index.js

@@ -0,0 +1,18 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var validator_exports = {};
+module.exports = __toCommonJS(validator_exports);
+__reExport(validator_exports, require("./validator.interface"), module.exports);
+__reExport(validator_exports, require("./validator.service"), module.exports);

package/dist/lib/validator/validator.interface.d.ts

@@ -0,0 +1,9 @@
+import { ClassTransformOptions } from 'class-transformer';
+import { ValidatorOptions } from 'class-validator';
+
+interface ValidatorServiceOptions {
+    validator?: ValidatorOptions;
+    transformer?: ClassTransformOptions;
+}
+
+export { ValidatorServiceOptions };

package/dist/lib/validator/validator.interface.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var validator_interface_exports = {};
+module.exports = __toCommonJS(validator_interface_exports);

package/dist/lib/validator/validator.service.d.ts

@@ -0,0 +1,16 @@
+import { ValidatorServiceOptions } from './validator.interface.js';
+import { ClassType } from '../../interfaces/class.interface.js';
+import 'class-transformer';
+import 'class-validator';
+
+declare class ValidatorService {
+    options?: ValidatorServiceOptions;
+    private static instance;
+    private logger;
+    constructor(options?: ValidatorServiceOptions);
+    validate<T extends Record<PropertyKey, any>>(classType: ClassType<T>, object: T, options?: ValidatorServiceOptions): Promise<T>;
+    validateSync<T extends Record<PropertyKey, any>>(classType: ClassType<T>, object: T, options?: ValidatorServiceOptions): T;
+    private logValidationError;
+}
+
+export { ValidatorService };

package/dist/lib/validator/validator.service.js

@@ -0,0 +1,77 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var validator_service_exports = {};
+__export(validator_service_exports, {
+  ValidatorService: () => ValidatorService
+});
+module.exports = __toCommonJS(validator_service_exports);
+var import_class_transformer = require("class-transformer");
+var import_class_validator = require("class-validator");
+var import_logger = require("../../utils/logger");
+class ValidatorService {
+  constructor(options) {
+    this.options = options;
+    if (ValidatorService.instance) {
+      return ValidatorService.instance;
+    }
+    this.options = {
+      validator: {
+        skipMissingProperties: true,
+        whitelist: false,
+        always: true,
+        enableDebugMessages: true
+      },
+      transformer: { enableImplicitConversion: true },
+      ...options ?? {}
+    };
+    this.logger = new import_logger.Logger(this.constructor.name);
+    ValidatorService.instance = this;
+    this.logger.trace("Created a new instance.");
+  }
+  async validate(classType, object, options) {
+    const classObject = (0, import_class_transformer.plainToClass)(classType, object, { ...this.options.transformer, ...options?.transformer ?? {} });
+    const errors = await (0, import_class_validator.validate)(classObject, { ...this.options.validator, ...options?.validator ?? {} });
+    if (errors.length) {
+      errors.forEach((error) => {
+        this.logValidationError(error);
+      });
+      throw new Error("Validation failed.");
+    }
+    return classObject;
+  }
+  validateSync(classType, object, options) {
+    const classObject = (0, import_class_transformer.plainToClass)(classType, object, { ...this.options.transformer, ...options?.transformer ?? {} });
+    const errors = (0, import_class_validator.validateSync)(classObject, { ...this.options.validator, ...options?.validator ?? {} });
+    if (errors.length) {
+      errors.forEach((error) => {
+        this.logValidationError(error);
+      });
+      throw new Error("Validation failed.");
+    }
+    return classObject;
+  }
+  logValidationError(err) {
+    this.logger.error('Field "%s" failed validation with value "%s": %o', err.property, err.value, err.constraints);
+  }
+}
+__name(ValidatorService, "ValidatorService");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ValidatorService
+});

package/dist/utils/color.d.ts

@@ -0,0 +1,5 @@
+import * as colorette from 'colorette';
+
+declare const color: colorette.Colorette;
+
+export { color };

package/dist/utils/color.js

@@ -0,0 +1,34 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var color_exports = {};
+__export(color_exports, {
+  color: () => color
+});
+module.exports = __toCommonJS(color_exports);
+var colorette = __toESM(require("colorette"));
+const color = colorette.createColors({ useColor: true });
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  color
+});

package/dist/utils/defaults.d.ts

@@ -0,0 +1,11 @@
+import { ListrContext } from 'listr2';
+
+type SetCtxDefaultsOptions<T extends ListrContext = ListrContext> = Partial<T>;
+interface SetCtxAssignOptions<K = Record<PropertyKey, any>> {
+    from: K;
+    keys: (keyof K)[];
+}
+declare function setCtxDefaults<T extends ListrContext = ListrContext>(ctx: T, ...defaults: SetCtxDefaultsOptions<T>[]): void;
+declare function setCtxAssign<T extends ListrContext = ListrContext, K = Record<PropertyKey, any>>(ctx: T, ...assigns: SetCtxAssignOptions<K>[]): void;
+
+export { SetCtxAssignOptions, SetCtxDefaultsOptions, setCtxAssign, setCtxDefaults };

package/dist/utils/defaults.js

@@ -0,0 +1,47 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var defaults_exports = {};
+__export(defaults_exports, {
+  setCtxAssign: () => setCtxAssign,
+  setCtxDefaults: () => setCtxDefaults
+});
+module.exports = __toCommonJS(defaults_exports);
+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");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  setCtxAssign,
+  setCtxDefaults
+});

package/dist/utils/environment.d.ts

@@ -0,0 +1,7 @@
+import { LogLevels } from './logger/logger.constants.js';
+
+declare function isVerbose(logLevel: LogLevels): boolean;
+declare function isDebug(logLevel: LogLevels): boolean;
+declare function isSilent(logLevel: LogLevels): boolean;
+
+export { isDebug, isSilent, isVerbose };

package/dist/utils/environment.js

@@ -0,0 +1,44 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var environment_exports = {};
+__export(environment_exports, {
+  isDebug: () => isDebug,
+  isSilent: () => isSilent,
+  isVerbose: () => isVerbose
+});
+module.exports = __toCommonJS(environment_exports);
+var import_logger = require("./logger");
+function isVerbose(logLevel) {
+  return logLevel === import_logger.LogLevels.VERBOSE;
+}
+__name(isVerbose, "isVerbose");
+function isDebug(logLevel) {
+  return [import_logger.LogLevels.DEBUG, import_logger.LogLevels.TRACE].includes(logLevel);
+}
+__name(isDebug, "isDebug");
+function isSilent(logLevel) {
+  return logLevel === import_logger.LogLevels.SILENT;
+}
+__name(isSilent, "isSilent");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isDebug,
+  isSilent,
+  isVerbose
+});

package/dist/utils/index.d.ts

@@ -0,0 +1,17 @@
+export { ListrLogger } from './logger/listr-logger.js';
+export { pipeProcessThroughListr } from './logger/pipe/pipe-process-to-listr.js';
+export { pipeProcessToLogger } from './logger/pipe/pipe-process-to-logger.js';
+export { PipeProcessToLoggerOptions } from './logger/pipe/pipe-process-to-logger.interface.js';
+export { LogFieldStatus, LogLevels } from './logger/logger.constants.js';
+export { LoggerFormat, LoggerOptions, Winston } from './logger/logger.interface.js';
+export { Logger } from './logger/logger.js';
+export { color } from './color.js';
+export { isDebug, isSilent, isVerbose } from './environment.js';
+export { MergeStrategy } from './merge.constants.js';
+export { merge, uniqueFilter } from './merge.js';
+export { SetCtxAssignOptions, SetCtxDefaultsOptions, setCtxAssign, setCtxDefaults } from './defaults.js';
+export { CliUx } from '@oclif/core';
+import 'listr2';
+import 'winston';
+import 'execa';
+import 'colorette';

package/dist/utils/index.js

@@ -0,0 +1,34 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var utils_exports = {};
+__export(utils_exports, {
+  CliUx: () => import_core.CliUx
+});
+module.exports = __toCommonJS(utils_exports);
+__reExport(utils_exports, require("./logger"), module.exports);
+__reExport(utils_exports, require("./color"), module.exports);
+__reExport(utils_exports, require("./environment"), module.exports);
+__reExport(utils_exports, require("./merge.constants"), module.exports);
+__reExport(utils_exports, require("./merge"), module.exports);
+__reExport(utils_exports, require("./defaults"), module.exports);
+var import_core = require("@oclif/core");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CliUx
+});

package/dist/utils/logger/index.d.ts

@@ -0,0 +1,10 @@
+export { ListrLogger } from './listr-logger.js';
+export { pipeProcessThroughListr } from './pipe/pipe-process-to-listr.js';
+export { pipeProcessToLogger } from './pipe/pipe-process-to-logger.js';
+export { PipeProcessToLoggerOptions } from './pipe/pipe-process-to-logger.interface.js';
+export { LogFieldStatus, LogLevels } from './logger.constants.js';
+export { LoggerFormat, LoggerOptions, Winston } from './logger.interface.js';
+export { Logger } from './logger.js';
+import 'listr2';
+import 'winston';
+import 'execa';

package/dist/utils/logger/index.js

@@ -0,0 +1,21 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var logger_exports = {};
+module.exports = __toCommonJS(logger_exports);
+__reExport(logger_exports, require("./listr-logger"), module.exports);
+__reExport(logger_exports, require("./pipe"), module.exports);
+__reExport(logger_exports, require("./logger.constants"), module.exports);
+__reExport(logger_exports, require("./logger.interface"), module.exports);
+__reExport(logger_exports, require("./logger"), module.exports);

package/dist/utils/logger/listr-logger.d.ts

@@ -0,0 +1,20 @@
+import { Logger } from 'listr2';
+import { Logger as Logger$1 } from './logger.js';
+import './logger.constants.js';
+import './logger.interface.js';
+import 'winston';
+
+declare class ListrLogger extends Logger {
+    logger: Logger$1;
+    constructor(context?: string);
+    fail(message: string): void;
+    skip(message: string): void;
+    success(message: string): void;
+    data(message: string): void;
+    start(message: string): void;
+    title(message: string): void;
+    retry(message: string): void;
+    rollback(message: string): void;
+}
+
+export { ListrLogger };