@cenk1cenk2/oclif-common 3.9.6 → 3.9.7

package/dist/utils/logger/listr-logger.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 listr_logger_exports = {};
+__export(listr_logger_exports, {
+  ListrLogger: () => ListrLogger
+});
+module.exports = __toCommonJS(listr_logger_exports);
+var import_listr2 = require("listr2");
+var import_logger = require("./logger");
+class ListrLogger extends import_listr2.Logger {
+  constructor(context) {
+    super();
+    this.logger = new import_logger.Logger(context);
+  }
+  fail(message) {
+    this.logger.error(message);
+  }
+  skip(message) {
+    this.logger.warn(message, { status: "skip" });
+  }
+  success(message) {
+    this.logger.info(message, { status: "end" });
+  }
+  data(message) {
+    this.logger.info(message);
+  }
+  start(message) {
+    this.logger.info(message, { status: "run" });
+  }
+  title(message) {
+    this.logger.info(message);
+  }
+  retry(message) {
+    this.logger.warn(message, { status: "retry" });
+  }
+  rollback(message) {
+    this.logger.error(message, { status: "rollback" });
+  }
+}
+__name(ListrLogger, "ListrLogger");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ListrLogger
+});

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

@@ -0,0 +1,20 @@
+declare enum LogLevels {
+    SILENT = "SILENT",
+    DIRECT = "DIRECT",
+    FATAL = "FATAL",
+    ERROR = "ERROR",
+    WARN = "WARN",
+    INFO = "INFO",
+    VERBOSE = "VERBOSE",
+    DEBUG = "DEBUG",
+    TRACE = "TRACE"
+}
+declare enum LogFieldStatus {
+    RUN = "run",
+    END = "end",
+    STAGE = "stage",
+    EXIT = "exit",
+    TERMINATE = "terminate"
+}
+
+export { LogFieldStatus, LogLevels };

package/dist/utils/logger/logger.constants.js

@@ -0,0 +1,48 @@
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var logger_constants_exports = {};
+__export(logger_constants_exports, {
+  LogFieldStatus: () => LogFieldStatus,
+  LogLevels: () => LogLevels
+});
+module.exports = __toCommonJS(logger_constants_exports);
+var LogLevels = /* @__PURE__ */ ((LogLevels2) => {
+  LogLevels2["SILENT"] = "SILENT";
+  LogLevels2["DIRECT"] = "DIRECT";
+  LogLevels2["FATAL"] = "FATAL";
+  LogLevels2["ERROR"] = "ERROR";
+  LogLevels2["WARN"] = "WARN";
+  LogLevels2["INFO"] = "INFO";
+  LogLevels2["VERBOSE"] = "VERBOSE";
+  LogLevels2["DEBUG"] = "DEBUG";
+  LogLevels2["TRACE"] = "TRACE";
+  return LogLevels2;
+})(LogLevels || {});
+var LogFieldStatus = /* @__PURE__ */ ((LogFieldStatus2) => {
+  LogFieldStatus2["RUN"] = "run";
+  LogFieldStatus2["END"] = "end";
+  LogFieldStatus2["STAGE"] = "stage";
+  LogFieldStatus2["EXIT"] = "exit";
+  LogFieldStatus2["TERMINATE"] = "terminate";
+  return LogFieldStatus2;
+})(LogFieldStatus || {});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LogFieldStatus,
+  LogLevels
+});

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

@@ -0,0 +1,31 @@
+import { LogLevels } from './logger.constants.js';
+import { Winston, LoggerOptions } from './logger.interface.js';
+import 'winston';
+
+/**
+ * A general logger for the the CLI applications.
+ */
+declare class Logger {
+    private context?;
+    private options?;
+    static instance: Winston;
+    private logger;
+    constructor(context?: string, options?: LoggerOptions);
+    log(level: LogLevels, data: string | Buffer, ...args: any): void;
+    direct(data: string | Buffer, ...args: any): void;
+    fatal(data: string | Buffer, ...args: any): void;
+    error(data: string | Buffer, ...args: any): void;
+    warn(data: string | Buffer, ...args: any): void;
+    info(data: string | Buffer, ...args: any): void;
+    debug(data: string | Buffer, ...args: any): void;
+    verbose(data: string | Buffer, ...args: any): void;
+    trace(data: string | Buffer, ...args: any): void;
+    run(data: string | Buffer, ...args: any): void;
+    end(data: string | Buffer, ...args: any): void;
+    stage(data: string | Buffer, ...args: any): void;
+    private initiateLogger;
+    private parseMessage;
+    private logColoring;
+}
+
+export { Logger };

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

@@ -0,0 +1,16 @@
+import { Logger, LeveledLogMethod } from 'winston';
+import { LogLevels } from './logger.constants.js';
+
+interface LoggerOptions {
+    useIcons?: boolean;
+    level?: LogLevels;
+}
+interface LoggerFormat {
+    level: LogLevels;
+    message: string;
+    context: string;
+    status: string;
+}
+type Winston = Logger & Record<keyof typeof LogLevels, LeveledLogMethod>;
+
+export { LoggerFormat, LoggerOptions, Winston };

package/dist/utils/logger/logger.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 logger_interface_exports = {};
+module.exports = __toCommonJS(logger_interface_exports);

package/dist/utils/logger/logger.js

@@ -0,0 +1,200 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      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 logger_exports = {};
+__export(logger_exports, {
+  Logger: () => Logger
+});
+module.exports = __toCommonJS(logger_exports);
+var import_listr2 = require("listr2");
+var import_os = require("os");
+var import_winston = __toESM(require("winston"));
+var import_logger = require("./logger.constants");
+var import_lib = require("../../lib");
+var import_color = require("../color");
+class Logger {
+  constructor(context, options) {
+    this.context = context;
+    this.options = options;
+    if (Logger.instance) {
+      this.logger = Logger.instance;
+    } else if (context === import_lib.ConfigService.name) {
+      const level = Object.values(import_logger.LogLevels).includes(options?.level) ? options.level : import_logger.LogLevels.INFO;
+      this.options = {
+        useIcons: true,
+        ...options,
+        level
+      };
+      this.logger = this.initiateLogger();
+      this.trace("Logger singleton initiated from context: %s", context);
+      Logger.instance = this.logger;
+    } else {
+      throw new Error("Logger can only be initiated inside the config service context!");
+    }
+  }
+  log(level, data, ...args) {
+    return this.parseMessage(level, data, args);
+  }
+  direct(data, ...args) {
+    return this.parseMessage(import_logger.LogLevels.DIRECT, data, args);
+  }
+  fatal(data, ...args) {
+    return this.parseMessage(import_logger.LogLevels.FATAL, data, args);
+  }
+  error(data, ...args) {
+    return this.parseMessage(import_logger.LogLevels.ERROR, data, args);
+  }
+  warn(data, ...args) {
+    return this.parseMessage(import_logger.LogLevels.WARN, data, args);
+  }
+  info(data, ...args) {
+    return this.parseMessage(import_logger.LogLevels.INFO, data, args);
+  }
+  debug(data, ...args) {
+    return this.parseMessage(import_logger.LogLevels.DEBUG, data, args);
+  }
+  verbose(data, ...args) {
+    return this.parseMessage(import_logger.LogLevels.VERBOSE, data, args);
+  }
+  trace(data, ...args) {
+    return this.parseMessage(import_logger.LogLevels.TRACE, data, args);
+  }
+  run(data, ...args) {
+    return this.parseMessage(import_logger.LogLevels.INFO, data, args, { status: import_logger.LogFieldStatus.RUN });
+  }
+  end(data, ...args) {
+    return this.parseMessage(import_logger.LogLevels.INFO, data, args, { status: import_logger.LogFieldStatus.END });
+  }
+  stage(data, ...args) {
+    return this.parseMessage(import_logger.LogLevels.TRACE, data, args, { status: import_logger.LogFieldStatus.STAGE });
+  }
+  initiateLogger() {
+    const logFormat = import_winston.format.printf(({ level, message, context, status }) => {
+      let multiLineMessage;
+      multiLineMessage = message.split(import_os.EOL);
+      multiLineMessage = multiLineMessage.filter((msg) => msg.trim() !== "").filter(Boolean);
+      multiLineMessage = multiLineMessage.map((msg) => {
+        return this.logColoring({
+          level,
+          message: msg,
+          context,
+          status
+        });
+      });
+      return multiLineMessage.join(import_os.EOL);
+    });
+    const logger = import_winston.default.createLogger({
+      level: this.options.level,
+      format: import_winston.format.combine(import_winston.format.splat(), import_winston.format.json({ space: 2 }), import_winston.format.prettyPrint(), logFormat),
+      levels: Object.values(import_logger.LogLevels).reduce((o, level, i) => {
+        return {
+          ...o,
+          [level]: i
+        };
+      }, {}),
+      silent: this.options.level === import_logger.LogLevels.SILENT,
+      transports: [
+        new import_winston.transports.Console({
+          stderrLevels: [import_logger.LogLevels.FATAL, import_logger.LogLevels.ERROR]
+        })
+      ]
+    });
+    logger.log(import_logger.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(), ...args ?? [], { context: this.context, ...format2 ?? {} });
+  }
+  logColoring({ level, message, context, status }) {
+    let icon;
+    let coloring = /* @__PURE__ */ __name((input) => {
+      return input;
+    }, "coloring");
+    let msgColoring = /* @__PURE__ */ __name((input) => {
+      return input;
+    }, "msgColoring");
+    switch (level) {
+      case import_logger.LogLevels.DIRECT:
+        return message;
+      case import_logger.LogLevels.FATAL:
+        coloring = /* @__PURE__ */ __name((input) => import_color.color.red(input), "coloring");
+        if (this.options?.useIcons) {
+          icon = import_listr2.figures.checkboxOn;
+        }
+        break;
+      case import_logger.LogLevels.ERROR:
+        coloring = import_color.color.red;
+        if (this.options?.useIcons) {
+          icon = import_listr2.figures.cross;
+        }
+        break;
+      case import_logger.LogLevels.WARN:
+        coloring = import_color.color.yellow;
+        if (this.options?.useIcons) {
+          icon = import_listr2.figures.warning;
+        }
+        break;
+      case import_logger.LogLevels.INFO:
+        coloring = import_color.color.green;
+        if (this.options?.useIcons) {
+          icon = import_listr2.figures.pointerSmall;
+        }
+        break;
+      case import_logger.LogLevels.VERBOSE:
+        coloring = import_color.color.dim;
+        if (this.options?.useIcons) {
+          icon = "\u2607";
+        }
+        break;
+      case import_logger.LogLevels.DEBUG:
+        coloring = import_color.color.cyan;
+        msgColoring = import_color.color.dim;
+        if (this.options?.useIcons) {
+          icon = "\uF188";
+        }
+        break;
+      case import_logger.LogLevels.TRACE:
+        coloring = import_color.color.magenta;
+        msgColoring = import_color.color.dim;
+        if (this.options?.useIcons) {
+          icon = "\u26B1";
+        }
+        break;
+    }
+    if (!icon) {
+      icon = `[${level.at(0).toUpperCase()}]`;
+    }
+    return `${coloring(icon)}${context ? " " + coloring(`[${context}]`) : ""}${status ? " " + coloring(`[${status}]`) : ""} ${msgColoring(message)}`;
+  }
+}
+__name(Logger, "Logger");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Logger
+});

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

@@ -0,0 +1,9 @@
+export { pipeProcessThroughListr } from './pipe-process-to-listr.js';
+export { pipeProcessToLogger } from './pipe-process-to-logger.js';
+export { PipeProcessToLoggerOptions } from './pipe-process-to-logger.interface.js';
+import 'execa';
+import 'listr2';
+import '../logger.js';
+import '../logger.constants.js';
+import '../logger.interface.js';
+import 'winston';

package/dist/utils/logger/pipe/index.js

@@ -0,0 +1,19 @@
+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 pipe_exports = {};
+module.exports = __toCommonJS(pipe_exports);
+__reExport(pipe_exports, require("./pipe-process-to-listr"), module.exports);
+__reExport(pipe_exports, require("./pipe-process-to-logger"), module.exports);
+__reExport(pipe_exports, require("./pipe-process-to-logger.interface"), module.exports);

package/dist/utils/logger/pipe/pipe-process-to-listr.d.ts

@@ -0,0 +1,6 @@
+import { ExecaChildProcess } from 'execa';
+import { ListrTaskWrapper } from 'listr2';
+
+declare function pipeProcessThroughListr(task: ListrTaskWrapper<any, any>, instance: ExecaChildProcess): ExecaChildProcess;
+
+export { pipeProcessThroughListr };

package/dist/utils/logger/pipe/pipe-process-to-listr.js

@@ -0,0 +1,43 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      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 pipe_process_to_listr_exports = {};
+__export(pipe_process_to_listr_exports, {
+  pipeProcessThroughListr: () => pipeProcessThroughListr
+});
+module.exports = __toCommonJS(pipe_process_to_listr_exports);
+var import_through = __toESM(require("through"));
+function pipeProcessThroughListr(task, instance) {
+  const logOut = (0, import_through.default)((chunk) => {
+    task.output = chunk?.toString("utf-8").trim();
+  });
+  instance.stdout.pipe(logOut);
+  instance.stderr.pipe(logOut);
+  return instance;
+}
+__name(pipeProcessThroughListr, "pipeProcessThroughListr");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pipeProcessThroughListr
+});

package/dist/utils/logger/pipe/pipe-process-to-logger.d.ts

@@ -0,0 +1,13 @@
+import { ExecaChildProcess } from 'execa';
+import { Logger } from '../logger.js';
+import { PipeProcessToLoggerOptions } from './pipe-process-to-logger.interface.js';
+import '../logger.constants.js';
+import '../logger.interface.js';
+import 'winston';
+
+/**
+ * Given the instance it will pipe process output through the logger to append prefixes such as the application name.
+ */
+declare function pipeProcessToLogger(logger: Logger, instance: ExecaChildProcess, options?: PipeProcessToLoggerOptions): ExecaChildProcess;
+
+export { pipeProcessToLogger };

package/dist/utils/logger/pipe/pipe-process-to-logger.interface.d.ts

@@ -0,0 +1,16 @@
+import { LogLevels } from '../logger.constants.js';
+
+interface PipeProcessToLoggerOptions {
+    /** Will log the command when the process starts. */
+    start?: LogLevels;
+    /** Will log the command when the process ends. */
+    end?: LogLevels;
+    /** enable/disable stdout */
+    stdout?: LogLevels;
+    /** enable/disable stderrr */
+    stderr?: LogLevels;
+    /** will callback on error in the instance */
+    callback?: (error?: Error) => void;
+}
+
+export { PipeProcessToLoggerOptions };

package/dist/utils/logger/pipe/pipe-process-to-logger.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 pipe_process_to_logger_interface_exports = {};
+module.exports = __toCommonJS(pipe_process_to_logger_interface_exports);

package/dist/utils/logger/pipe/pipe-process-to-logger.js

@@ -0,0 +1,80 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      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 pipe_process_to_logger_exports = {};
+__export(pipe_process_to_logger_exports, {
+  pipeProcessToLogger: () => pipeProcessToLogger
+});
+module.exports = __toCommonJS(pipe_process_to_logger_exports);
+var import_through = __toESM(require("through"));
+var import_logger = require("../logger.constants");
+function pipeProcessToLogger(logger, instance, options) {
+  options = {
+    start: import_logger.LogLevels.INFO,
+    end: import_logger.LogLevels.INFO,
+    stdout: import_logger.LogLevels.INFO,
+    stderr: import_logger.LogLevels.WARN,
+    ...options
+  };
+  if (options.start) {
+    logger.run(instance.spawnargs.join(" "), { level: options.start });
+  }
+  if (instance.stdout) {
+    instance.stdout.pipe(
+      (0, import_through.default)((chunk) => {
+        logger.log(options.stdout, chunk);
+      })
+    );
+  }
+  if (instance.stderr) {
+    instance.stderr.pipe(
+      (0, import_through.default)((chunk) => {
+        logger.log(options.stderr, chunk);
+      })
+    );
+  }
+  void instance.on("exit", (code, signal) => {
+    const message = `Process ended with code ${code}${signal ? ` and signal ${signal}` : ""}.`;
+    logger.debug(message);
+    if (options.end) {
+      logger.end(instance.spawnargs.join(" "), { level: options.end });
+    }
+    if (options?.callback) {
+      options.callback();
+    }
+  });
+  void instance.on("error", (error) => {
+    logger.fatal(error.message);
+    logger.debug(error.stack);
+    if (options?.callback) {
+      options.callback(error);
+    }
+  });
+  return instance;
+}
+__name(pipeProcessToLogger, "pipeProcessToLogger");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pipeProcessToLogger
+});

package/dist/utils/merge.constants.d.ts

@@ -0,0 +1,6 @@
+declare enum MergeStrategy {
+    OVERWRITE = "OVERWRITE",
+    EXTEND = "EXTEND"
+}
+
+export { MergeStrategy };

package/dist/utils/merge.constants.js

@@ -0,0 +1,31 @@
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var merge_constants_exports = {};
+__export(merge_constants_exports, {
+  MergeStrategy: () => MergeStrategy
+});
+module.exports = __toCommonJS(merge_constants_exports);
+var MergeStrategy = /* @__PURE__ */ ((MergeStrategy2) => {
+  MergeStrategy2["OVERWRITE"] = "OVERWRITE";
+  MergeStrategy2["EXTEND"] = "EXTEND";
+  return MergeStrategy2;
+})(MergeStrategy || {});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MergeStrategy
+});

package/dist/utils/merge.d.ts

@@ -0,0 +1,8 @@
+import { MergeStrategy } from './merge.constants.js';
+
+/** Merge objects deep from overwriting the properties from source to target.
+ * Does not mutate the object */
+declare function merge<T extends Record<PropertyKey, any> | any[]>(strategy: MergeStrategy, ...source: Partial<T>[]): T;
+declare function uniqueFilter(value: any, index: any, self: string | any[]): boolean;
+
+export { merge, uniqueFilter };