@decaf-ts/utils 0.1.6

package/lib/utils/utils.cjs

@@ -0,0 +1,226 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lockify = lockify;
+exports.chainAbortController = chainAbortController;
+exports.spawnCommand = spawnCommand;
+exports.runCommand = runCommand;
+const child_process_1 = require("child_process");
+const StandardOutputWriter_1 = require("../writers/StandardOutputWriter.cjs");
+const logging_1 = require("../output/logging.cjs");
+const constants_1 = require("./constants.cjs");
+/**
+ * @description Creates a locked version of a function.
+ * @summary This higher-order function takes a function and returns a new function that ensures
+ * sequential execution of the original function, even when called multiple times concurrently.
+ * It uses a Promise-based locking mechanism to queue function calls.
+ *
+ * @template R - The return type of the input function.
+ *
+ * @param f - The function to be locked. It can take any number of parameters and return a value of type R.
+ * @return A new function with the same signature as the input function, but with sequential execution guaranteed.
+ *
+ * @function lockify
+ *
+ * @mermaid
+ * sequenceDiagram
+ *   participant Caller
+ *   participant LockedFunction
+ *   participant OriginalFunction
+ *   Caller->>LockedFunction: Call with params
+ *   LockedFunction->>LockedFunction: Check current lock
+ *   alt Lock is resolved
+ *     LockedFunction->>OriginalFunction: Execute with params
+ *     OriginalFunction-->>LockedFunction: Return result
+ *     LockedFunction-->>Caller: Return result
+ *   else Lock is pending
+ *     LockedFunction->>LockedFunction: Queue execution
+ *     LockedFunction-->>Caller: Return promise
+ *     Note over LockedFunction: Wait for previous execution
+ *     LockedFunction->>OriginalFunction: Execute with params
+ *     OriginalFunction-->>LockedFunction: Return result
+ *     LockedFunction-->>Caller: Resolve promise with result
+ *   end
+ *   LockedFunction->>LockedFunction: Update lock
+ *
+ * @memberOf @decaf-ts/utils
+ */
+function lockify(f) {
+    let lock = Promise.resolve();
+    return (...params) => {
+        const result = lock.then(() => f(...params));
+        lock = result.catch(() => { });
+        return result;
+    };
+}
+function chainAbortController(argument0, ...remainder) {
+    let signals;
+    let controller;
+    // normalize args
+    if (argument0 instanceof AbortSignal) {
+        controller = new AbortController();
+        signals = [argument0, ...remainder];
+    }
+    else {
+        controller = argument0;
+        signals = remainder;
+    }
+    // if the controller is already aborted, exit early
+    if (controller.signal.aborted) {
+        return controller;
+    }
+    const handler = () => controller.abort();
+    for (const signal of signals) {
+        // check before adding! (and assume there is no possible way that the signal could
+        // abort between the `if` check and adding the event listener)
+        if (signal.aborted) {
+            controller.abort();
+            break;
+        }
+        signal.addEventListener("abort", handler, {
+            once: true,
+            signal: controller.signal,
+        });
+    }
+    return controller;
+}
+function spawnCommand(output, command, opts, abort, logger) {
+    function spawnInner(command, controller) {
+        const [cmd, argz] = output.parseCommand(command);
+        logger.info(`Running command: ${cmd}`);
+        logger.debug(`with args: ${argz.join(" ")}`);
+        const childProcess = (0, child_process_1.spawn)(cmd, argz, {
+            ...opts,
+            cwd: opts.cwd || process.cwd(),
+            env: Object.assign({}, process.env, opts.env, { PATH: process.env.PATH }),
+            shell: opts.shell || false,
+            signal: controller.signal,
+        });
+        logger.verbose(`pid : ${childProcess.pid}`);
+        return childProcess;
+    }
+    const m = command.match(/[<>$#]/g);
+    if (m)
+        throw new Error(`Invalid command: ${command}. contains invalid characters: ${m}`);
+    if (command.includes(" | ")) {
+        const cmds = command.split(" | ");
+        const spawns = [];
+        const controllers = new Array(cmds.length);
+        controllers[0] = abort;
+        for (let i = 0; i < cmds.length; i++) {
+            if (i !== 0)
+                controllers[i] = chainAbortController(controllers[i - 1].signal);
+            spawns.push(spawnInner(cmds[i], controllers[i]));
+            if (i === 0)
+                continue;
+            spawns[i - 1].stdout.pipe(spawns[i].stdin);
+        }
+        return spawns[cmds.length - 1];
+    }
+    return spawnInner(command, abort);
+}
+/**
+ * @description Executes a command asynchronously with customizable output handling.
+ * @summary This function runs a shell command as a child process, providing fine-grained
+ * control over its execution and output handling. It supports custom output writers,
+ * allows for command abortion, and captures both stdout and stderr.
+ *
+ * @template R - The type of the resolved value from the command execution.
+ *
+ * @param command - The command to run, either as a string or an array of strings.
+ * @param opts - Spawn options for the child process. Defaults to an empty object.
+ * @param outputConstructor - Constructor for the output writer. Defaults to StandardOutputWriter.
+ * @param args - Additional arguments to pass to the output constructor.
+ * @return {CommandResult} A promise that resolves to the command result of type R.
+ *
+ * @function runCommand
+ *
+ * @mermaid
+ * sequenceDiagram
+ *   participant Caller
+ *   participant runCommand
+ *   participant OutputWriter
+ *   participant ChildProcess
+ *   Caller->>runCommand: Call with command and options
+ *   runCommand->>OutputWriter: Create new instance
+ *   runCommand->>OutputWriter: Parse command
+ *   runCommand->>ChildProcess: Spawn process
+ *   ChildProcess-->>runCommand: Return process object
+ *   runCommand->>ChildProcess: Set up event listeners
+ *   loop For each stdout data
+ *     ChildProcess->>runCommand: Emit stdout data
+ *     runCommand->>OutputWriter: Handle stdout data
+ *   end
+ *   loop For each stderr data
+ *     ChildProcess->>runCommand: Emit stderr data
+ *     runCommand->>OutputWriter: Handle stderr data
+ *   end
+ *   ChildProcess->>runCommand: Emit error (if any)
+ *   runCommand->>OutputWriter: Handle error
+ *   ChildProcess->>runCommand: Emit exit
+ *   runCommand->>OutputWriter: Handle exit
+ *   OutputWriter-->>runCommand: Resolve or reject promise
+ *   runCommand-->>Caller: Return CommandResult
+ *
+ * @memberOf @decaf-ts/utils
+ */
+function runCommand(command, opts = {}, outputConstructor = (StandardOutputWriter_1.StandardOutputWriter), ...args) {
+    const logger = logging_1.Logging.for(runCommand);
+    const abort = new AbortController();
+    const result = {
+        abort: abort,
+        command: command,
+        logs: [],
+        errs: [],
+    };
+    const lock = new Promise((resolve, reject) => {
+        let output;
+        try {
+            output = new outputConstructor(command, {
+                resolve,
+                reject,
+            }, ...args);
+            result.cmd = spawnCommand(output, command, opts, abort, logger);
+        }
+        catch (e) {
+            return reject(new Error(`Error running command ${command}: ${e}`));
+        }
+        result.cmd.stdout.setEncoding("utf8");
+        result.cmd.stdout.on("data", (chunk) => {
+            chunk = chunk.toString();
+            result.logs.push(chunk);
+            output.data(chunk);
+        });
+        result.cmd.stderr.on("data", (data) => {
+            data = data.toString();
+            result.errs.push(data);
+            output.error(data);
+        });
+        result.cmd.once("error", (err) => {
+            output.exit(err.message, result.errs);
+        });
+        result.cmd.once("exit", (code = 0) => {
+            if (abort.signal.aborted && code === null)
+                code = constants_1.AbortCode;
+            output.exit(code, code === 0 ? result.logs : result.errs);
+        });
+    });
+    Object.assign(result, {
+        promise: lock,
+        pipe: async (cb) => {
+            const l = logger.for("pipe");
+            try {
+                l.verbose(`Executing pipe function ${command}...`);
+                const result = await lock;
+                l.verbose(`Piping output to ${cb.name}: ${result}`);
+                return cb(result);
+            }
+            catch (e) {
+                l.error(`Error piping command output: ${e}`);
+                throw e;
+            }
+        },
+    });
+    return result;
+}
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["src/utils/utils.ts"],"names":[],"mappings":"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","file":"utils/utils.js","sourcesContent":["import {\n  ChildProcessWithoutNullStreams,\n  spawn,\n  SpawnOptionsWithoutStdio,\n} from \"child_process\";\nimport { StandardOutputWriter } from \"../writers/StandardOutputWriter\";\nimport { CommandResult } from \"./types\";\nimport { Logging } from \"../output/logging\";\nimport { OutputWriterConstructor } from \"../writers/types\";\nimport { VerbosityLogger } from \"../output/types\";\nimport { AbortCode } from \"./constants\";\n\n/**\n * @description Creates a locked version of a function.\n * @summary This higher-order function takes a function and returns a new function that ensures\n * sequential execution of the original function, even when called multiple times concurrently.\n * It uses a Promise-based locking mechanism to queue function calls.\n *\n * @template R - The return type of the input function.\n *\n * @param f - The function to be locked. It can take any number of parameters and return a value of type R.\n * @return A new function with the same signature as the input function, but with sequential execution guaranteed.\n *\n * @function lockify\n *\n * @mermaid\n * sequenceDiagram\n *   participant Caller\n *   participant LockedFunction\n *   participant OriginalFunction\n *   Caller->>LockedFunction: Call with params\n *   LockedFunction->>LockedFunction: Check current lock\n *   alt Lock is resolved\n *     LockedFunction->>OriginalFunction: Execute with params\n *     OriginalFunction-->>LockedFunction: Return result\n *     LockedFunction-->>Caller: Return result\n *   else Lock is pending\n *     LockedFunction->>LockedFunction: Queue execution\n *     LockedFunction-->>Caller: Return promise\n *     Note over LockedFunction: Wait for previous execution\n *     LockedFunction->>OriginalFunction: Execute with params\n *     OriginalFunction-->>LockedFunction: Return result\n *     LockedFunction-->>Caller: Resolve promise with result\n *   end\n *   LockedFunction->>LockedFunction: Update lock\n *\n * @memberOf @decaf-ts/utils\n */\nexport function lockify<R>(f: (...params: unknown[]) => R) {\n  let lock: Promise<R | void> = Promise.resolve();\n  return (...params: unknown[]) => {\n    const result = lock.then(() => f(...params));\n    lock = result.catch(() => {});\n    return result;\n  };\n}\n\nexport function chainAbortController(\n  controller: AbortController,\n  ...signals: AbortSignal[]\n): AbortController;\nexport function chainAbortController(\n  ...signals: AbortSignal[]\n): AbortController;\nexport function chainAbortController(\n  argument0: AbortController | AbortSignal,\n  ...remainder: AbortSignal[]\n): AbortController {\n  let signals: AbortSignal[];\n  let controller: AbortController;\n\n  // normalize args\n  if (argument0 instanceof AbortSignal) {\n    controller = new AbortController();\n    signals = [argument0, ...remainder];\n  } else {\n    controller = argument0;\n    signals = remainder;\n  }\n\n  // if the controller is already aborted, exit early\n  if (controller.signal.aborted) {\n    return controller;\n  }\n\n  const handler = () => controller.abort();\n\n  for (const signal of signals) {\n    // check before adding! (and assume there is no possible way that the signal could\n    // abort between the `if` check and adding the event listener)\n    if (signal.aborted) {\n      controller.abort();\n      break;\n    }\n    signal.addEventListener(\"abort\", handler, {\n      once: true,\n      signal: controller.signal,\n    });\n  }\n\n  return controller;\n}\n\nexport function spawnCommand<R = string>(\n  output: StandardOutputWriter<R>,\n  command: string,\n  opts: SpawnOptionsWithoutStdio,\n  abort: AbortController,\n  logger: VerbosityLogger\n): ChildProcessWithoutNullStreams {\n  function spawnInner(command: string, controller: AbortController) {\n    const [cmd, argz] = output.parseCommand(command);\n    logger.info(`Running command: ${cmd}`);\n    logger.debug(`with args: ${argz.join(\" \")}`);\n    const childProcess = spawn(cmd, argz, {\n      ...opts,\n      cwd: opts.cwd || process.cwd(),\n      env: Object.assign({}, process.env, opts.env, { PATH: process.env.PATH }),\n      shell: opts.shell || false,\n      signal: controller.signal,\n    });\n    logger.verbose(`pid : ${childProcess.pid}`);\n    return childProcess;\n  }\n\n  const m = command.match(/[<>$#]/g);\n  if (m)\n    throw new Error(\n      `Invalid command: ${command}. contains invalid characters: ${m}`\n    );\n  if (command.includes(\" | \")) {\n    const cmds = command.split(\" | \");\n    const spawns = [];\n    const controllers = new Array(cmds.length);\n    controllers[0] = abort;\n    for (let i = 0; i < cmds.length; i++) {\n      if (i !== 0)\n        controllers[i] = chainAbortController(controllers[i - 1].signal);\n      spawns.push(spawnInner(cmds[i], controllers[i]));\n      if (i === 0) continue;\n      spawns[i - 1].stdout.pipe(spawns[i].stdin);\n    }\n    return spawns[cmds.length - 1];\n  }\n\n  return spawnInner(command, abort);\n}\n\n/**\n * @description Executes a command asynchronously with customizable output handling.\n * @summary This function runs a shell command as a child process, providing fine-grained\n * control over its execution and output handling. It supports custom output writers,\n * allows for command abortion, and captures both stdout and stderr.\n *\n * @template R - The type of the resolved value from the command execution.\n *\n * @param command - The command to run, either as a string or an array of strings.\n * @param opts - Spawn options for the child process. Defaults to an empty object.\n * @param outputConstructor - Constructor for the output writer. Defaults to StandardOutputWriter.\n * @param args - Additional arguments to pass to the output constructor.\n * @return {CommandResult} A promise that resolves to the command result of type R.\n *\n * @function runCommand\n *\n * @mermaid\n * sequenceDiagram\n *   participant Caller\n *   participant runCommand\n *   participant OutputWriter\n *   participant ChildProcess\n *   Caller->>runCommand: Call with command and options\n *   runCommand->>OutputWriter: Create new instance\n *   runCommand->>OutputWriter: Parse command\n *   runCommand->>ChildProcess: Spawn process\n *   ChildProcess-->>runCommand: Return process object\n *   runCommand->>ChildProcess: Set up event listeners\n *   loop For each stdout data\n *     ChildProcess->>runCommand: Emit stdout data\n *     runCommand->>OutputWriter: Handle stdout data\n *   end\n *   loop For each stderr data\n *     ChildProcess->>runCommand: Emit stderr data\n *     runCommand->>OutputWriter: Handle stderr data\n *   end\n *   ChildProcess->>runCommand: Emit error (if any)\n *   runCommand->>OutputWriter: Handle error\n *   ChildProcess->>runCommand: Emit exit\n *   runCommand->>OutputWriter: Handle exit\n *   OutputWriter-->>runCommand: Resolve or reject promise\n *   runCommand-->>Caller: Return CommandResult\n *\n * @memberOf @decaf-ts/utils\n */\nexport function runCommand<R = string>(\n  command: string,\n  opts: SpawnOptionsWithoutStdio = {},\n  outputConstructor: OutputWriterConstructor<\n    R,\n    StandardOutputWriter<R>,\n    Error\n  > = StandardOutputWriter<R>,\n  ...args: unknown[]\n): CommandResult<R> {\n  const logger = Logging.for(runCommand);\n  const abort = new AbortController();\n\n  const result: Omit<CommandResult, \"promise\" | \"pipe\"> = {\n    abort: abort,\n    command: command,\n    logs: [],\n    errs: [],\n  };\n\n  const lock = new Promise<R>((resolve, reject) => {\n    let output;\n    try {\n      output = new outputConstructor(\n        command,\n        {\n          resolve,\n          reject,\n        },\n        ...args\n      );\n\n      result.cmd = spawnCommand<R>(output, command, opts, abort, logger);\n    } catch (e: unknown) {\n      return reject(new Error(`Error running command ${command}: ${e}`));\n    }\n\n    result.cmd.stdout.setEncoding(\"utf8\");\n\n    result.cmd.stdout.on(\"data\", (chunk: any) => {\n      chunk = chunk.toString();\n      result.logs.push(chunk);\n      output.data(chunk);\n    });\n\n    result.cmd.stderr.on(\"data\", (data: any) => {\n      data = data.toString();\n      result.errs.push(data);\n      output.error(data);\n    });\n\n    result.cmd.once(\"error\", (err: Error) => {\n      output.exit(err.message, result.errs);\n    });\n\n    result.cmd.once(\"exit\", (code: number = 0) => {\n      if (abort.signal.aborted && code === null) code = AbortCode as any;\n      output.exit(code, code === 0 ? result.logs : result.errs);\n    });\n  });\n\n  Object.assign(result, {\n    promise: lock,\n    pipe: async <E>(cb: (r: R) => E) => {\n      const l = logger.for(\"pipe\");\n      try {\n        l.verbose(`Executing pipe function ${command}...`);\n        const result: R = await lock;\n        l.verbose(`Piping output to ${cb.name}: ${result}`);\n        return cb(result);\n      } catch (e: unknown) {\n        l.error(`Error piping command output: ${e}`);\n        throw e;\n      }\n    },\n  });\n\n  return result as CommandResult<R>;\n}\n"]}

package/lib/utils/web.cjs

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBrowser = isBrowser;
+/**
+ * @function isBrowser
+ * @description Determines if the current environment is a browser by checking the prototype chain of the global object.
+ * @summary Checks if the code is running in a browser environment.
+ * @returns {boolean} True if the environment is a browser, false otherwise.
+ */
+function isBrowser() {
+    return (Object.getPrototypeOf(Object.getPrototypeOf(globalThis)) !==
+        Object.prototype);
+}
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNyYy91dGlscy93ZWIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFNQSw4QkFLQztBQVhEOzs7OztHQUtHO0FBQ0gsU0FBZ0IsU0FBUztJQUN2QixPQUFPLENBQ0wsTUFBTSxDQUFDLGNBQWMsQ0FBQyxNQUFNLENBQUMsY0FBYyxDQUFDLFVBQVUsQ0FBQyxDQUFDO1FBQ3hELE1BQU0sQ0FBQyxTQUFTLENBQ2pCLENBQUM7QUFDSixDQUFDIiwiZmlsZSI6InV0aWxzL3dlYi5qcyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGZ1bmN0aW9uIGlzQnJvd3NlclxuICogQGRlc2NyaXB0aW9uIERldGVybWluZXMgaWYgdGhlIGN1cnJlbnQgZW52aXJvbm1lbnQgaXMgYSBicm93c2VyIGJ5IGNoZWNraW5nIHRoZSBwcm90b3R5cGUgY2hhaW4gb2YgdGhlIGdsb2JhbCBvYmplY3QuXG4gKiBAc3VtbWFyeSBDaGVja3MgaWYgdGhlIGNvZGUgaXMgcnVubmluZyBpbiBhIGJyb3dzZXIgZW52aXJvbm1lbnQuXG4gKiBAcmV0dXJucyB7Ym9vbGVhbn0gVHJ1ZSBpZiB0aGUgZW52aXJvbm1lbnQgaXMgYSBicm93c2VyLCBmYWxzZSBvdGhlcndpc2UuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBpc0Jyb3dzZXIoKTogYm9vbGVhbiB7XG4gIHJldHVybiAoXG4gICAgT2JqZWN0LmdldFByb3RvdHlwZU9mKE9iamVjdC5nZXRQcm90b3R5cGVPZihnbG9iYWxUaGlzKSkgIT09XG4gICAgT2JqZWN0LnByb3RvdHlwZVxuICApO1xufVxuIl19

package/lib/writers/OutputWriter.cjs

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/lib/writers/RegexpOutputWriter.cjs

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RegexpOutputWriter = void 0;
+const StandardOutputWriter_1 = require("./StandardOutputWriter.cjs");
+/**
+ * @description A specialized output writer that uses regular expressions to process output.
+ * @summary This class extends StandardOutputWriter to provide regex-based output processing.
+ * It allows for pattern matching in the output stream and can trigger specific actions
+ * based on matched patterns.
+ *
+ * @template T - The type of the resolved value, defaulting to string.
+ *
+ * @param lock - A PromiseExecutor to control the asynchronous flow.
+ * @param regexp - A string or RegExp to match against the output.
+ * @param flags - Optional flags for the RegExp constructor.
+ *
+ * @class
+ */
+class RegexpOutputWriter extends StandardOutputWriter_1.StandardOutputWriter {
+    /**
+     * @description Initializes a new instance of RegexpOutputWriter.
+     * @summary Constructs the RegexpOutputWriter with a lock mechanism and a regular expression.
+     *
+     * @param cmd
+     * @param lock - A PromiseExecutor to control the asynchronous flow.
+     * @param regexp - A string or RegExp to match against the output.
+     * @param flags - Optional flags for the RegExp constructor, defaults to "g".
+     */
+    constructor(cmd, lock, regexp, flags = "g") {
+        super(cmd, lock);
+        try {
+            this.regexp =
+                typeof regexp === "string" ? new RegExp(regexp, flags) : regexp;
+        }
+        catch (e) {
+            throw new Error(`Invalid regular expression: ${e}`);
+        }
+    }
+    /**
+     * @description Tests the input data against the stored regular expression.
+     * @summary Executes the regular expression on the input data and returns the match result.
+     *
+     * @param data - The string to test against the regular expression.
+     * @return The result of the regular expression execution, or undefined if an error occurs.
+     */
+    test(data) {
+        this.regexp.lastIndex = 0;
+        let match;
+        try {
+            match = this.regexp.exec(data);
+        }
+        catch (e) {
+            return console.debug(`Failed to parse chunk: ${data}\nError: ${e} `);
+        }
+        return match;
+    }
+    /**
+     * @description Tests the data and resolves the promise if a match is found.
+     * @summary Executes the test method and resolves the promise with the first match group if successful.
+     *
+     * @param data - The string to test against the regular expression.
+     */
+    testAndResolve(data) {
+        const match = this.test(data);
+        if (match)
+            this.resolve(match[0]);
+    }
+    /**
+     * @description Tests the data and rejects the promise if a match is found.
+     * @summary Executes the test method and rejects the promise with the first match group if successful.
+     *
+     * @param data - The string to test against the regular expression.
+     */
+    testAndReject(data) {
+        const match = this.test(data);
+        if (match)
+            this.reject(match[0]);
+    }
+    /**
+     * @description Processes incoming data chunks.
+     * @summary Calls the parent class data method and then tests the data for a match to potentially resolve the promise.
+     *
+     * @param chunk - The data chunk to process.
+     */
+    data(chunk) {
+        super.data(chunk);
+        this.testAndResolve(String(chunk));
+    }
+    /**
+     * @description Processes incoming error chunks.
+     * @summary Calls the parent class error method and then tests the data for a match to potentially reject the promise.
+     *
+     * @param chunk - The error chunk to process.
+     */
+    error(chunk) {
+        super.error(chunk);
+        this.testAndReject(String(chunk));
+    }
+}
+exports.RegexpOutputWriter = RegexpOutputWriter;
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/lib/writers/StandardOutputWriter.cjs

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StandardOutputWriter = void 0;
+const constants_1 = require("../utils/constants.cjs");
+const logging_1 = require("../output/logging.cjs");
+const styled_string_builder_1 = require("styled-string-builder");
+/**
+ * @description A standard output writer for handling command execution output.
+ * @summary This class implements the OutputWriter interface and provides methods for
+ * handling various types of output from command execution, including standard output,
+ * error output, and exit codes. It also includes utility methods for parsing commands
+ * and resolving or rejecting promises based on execution results.
+ *
+ * @template R - The type of the resolved value, defaulting to number.
+ *
+ * @param lock - A PromiseExecutor to control the asynchronous flow.
+ * @param args - Additional arguments (unused in the current implementation).
+ *
+ * @class
+ */
+class StandardOutputWriter {
+    /**
+     * @description Initializes a new instance of StandardOutputWriter.
+     * @summary Constructs the StandardOutputWriter with a lock mechanism and optional arguments.
+     *
+     * @param cmd
+     * @param lock - A PromiseExecutor to control the asynchronous flow.
+     * @param args - Additional arguments (currently unused).
+     */
+    constructor(cmd, lock, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    ...args) {
+        this.cmd = cmd;
+        this.lock = lock;
+        this.logger = logging_1.Logging.for(this.cmd);
+    }
+    /**
+     * @description Logs output to the console.
+     * @summary Formats and logs the given data with a timestamp and type indicator.
+     *
+     * @param type - The type of output (stdout or stderr).
+     * @param data - The data to be logged.
+     */
+    log(type, data) {
+        data = Buffer.isBuffer(data) ? data.toString(constants_1.Encoding) : data;
+        const formatedType = type === "stderr" ? (0, styled_string_builder_1.style)("ERROR").red.text : type;
+        const log = `${formatedType}: ${data}`;
+        this.logger.info(log);
+    }
+    /**
+     * @description Handles standard output data.
+     * @summary Logs the given chunk as standard output.
+     *
+     * @param chunk - The data chunk to be logged.
+     */
+    data(chunk) {
+        this.log("stdout", String(chunk));
+    }
+    /**
+     * @description Handles error output data.
+     * @summary Logs the given chunk as error output.
+     *
+     * @param chunk - The error data chunk to be logged.
+     */
+    error(chunk) {
+        this.log("stderr", String(chunk));
+    }
+    /**
+     * @description Handles error objects.
+     * @summary Logs the error message from the given Error object.
+     *
+     * @param err - The Error object to be logged.
+     */
+    errors(err) {
+        this.log("stderr", `Error executing command exited : ${err}`);
+    }
+    /**
+     * @description Handles the exit of a command.
+     * @summary Logs the exit code and resolves or rejects the promise based on the code.
+     *
+     * @param code - The exit code of the command.
+     * @param logs
+     */
+    exit(code, logs) {
+        this.log("stdout", `command exited code : ${code === 0 ? (0, styled_string_builder_1.style)(code.toString()).green.text : (0, styled_string_builder_1.style)(code === null ? "null" : code.toString()).red.text}`);
+        if (code === 0) {
+            this.resolve(logs.map((l) => l.trim()).join("\n"));
+        }
+        else {
+            this.reject(new Error(logs.length ? logs.join("\n") : code.toString()));
+        }
+    }
+    /**
+     * @description Parses a command string or array into components.
+     * @summary Converts the command into a consistent format and stores it, then returns it split into command and arguments.
+     *
+     * @param command - The command as a string or array of strings.
+     * @return A tuple containing the command and its arguments as separate elements.
+     */
+    parseCommand(command) {
+        command = typeof command === "string" ? command.split(" ") : command;
+        this.cmd = command.join(" ");
+        return [command[0], command.slice(1)];
+    }
+    /**
+     * @description Resolves the promise with a success message.
+     * @summary Logs a success message and resolves the promise with the given reason.
+     *
+     * @param reason - The reason for resolving the promise.
+     */
+    resolve(reason) {
+        this.log("stdout", `${this.cmd} executed successfully: ${(0, styled_string_builder_1.style)(reason ? "ran to completion" : reason).green}`);
+        this.lock.resolve(reason);
+    }
+    /**
+     * @description Rejects the promise with an error message.
+     * @summary Logs an error message and rejects the promise with the given reason.
+     *
+     * @param reason - The reason for rejecting the promise, either a number (exit code) or a string.
+     */
+    reject(reason) {
+        if (!(reason instanceof Error)) {
+            reason = new Error(typeof reason === "number" ? `Exit code ${reason}` : reason);
+        }
+        this.log("stderr", `${this.cmd} failed to execute: ${(0, styled_string_builder_1.style)(reason.message).red}`);
+        this.lock.reject(reason);
+    }
+}
+exports.StandardOutputWriter = StandardOutputWriter;
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["src/writers/StandardOutputWriter.ts"],"names":[],"mappings":"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","file":"writers/StandardOutputWriter.js","sourcesContent":["import { Encoding } from \"../utils/constants\";\nimport { OutputWriter } from \"./OutputWriter\";\nimport { PromiseExecutor } from \"../utils/types\";\nimport { OutputType } from \"./types\";\nimport { Logging } from \"../output/logging\";\nimport { VerbosityLogger } from \"../output/types\";\nimport { style } from \"styled-string-builder\";\n\n/**\n * @description A standard output writer for handling command execution output.\n * @summary This class implements the OutputWriter interface and provides methods for\n * handling various types of output from command execution, including standard output,\n * error output, and exit codes. It also includes utility methods for parsing commands\n * and resolving or rejecting promises based on execution results.\n *\n * @template R - The type of the resolved value, defaulting to number.\n *\n * @param lock - A PromiseExecutor to control the asynchronous flow.\n * @param args - Additional arguments (unused in the current implementation).\n *\n * @class\n */\nexport class StandardOutputWriter<R = string> implements OutputWriter {\n  protected logger: VerbosityLogger;\n\n  /**\n   * @description Initializes a new instance of StandardOutputWriter.\n   * @summary Constructs the StandardOutputWriter with a lock mechanism and optional arguments.\n   *\n   * @param cmd\n   * @param lock - A PromiseExecutor to control the asynchronous flow.\n   * @param args - Additional arguments (currently unused).\n   */\n  constructor(\n    protected cmd: string,\n    protected lock: PromiseExecutor<R>,\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    ...args: unknown[]\n  ) {\n    this.logger = Logging.for(this.cmd);\n  }\n\n  /**\n   * @description Logs output to the console.\n   * @summary Formats and logs the given data with a timestamp and type indicator.\n   *\n   * @param type - The type of output (stdout or stderr).\n   * @param data - The data to be logged.\n   */\n  protected log(type: OutputType, data: string | Buffer) {\n    data = Buffer.isBuffer(data) ? data.toString(Encoding) : data;\n    const formatedType = type === \"stderr\" ? style(\"ERROR\").red.text : type;\n    const log = `${formatedType}: ${data}`;\n    this.logger.info(log);\n  }\n\n  /**\n   * @description Handles standard output data.\n   * @summary Logs the given chunk as standard output.\n   *\n   * @param chunk - The data chunk to be logged.\n   */\n  data(chunk: any) {\n    this.log(\"stdout\", String(chunk));\n  }\n\n  /**\n   * @description Handles error output data.\n   * @summary Logs the given chunk as error output.\n   *\n   * @param chunk - The error data chunk to be logged.\n   */\n  error(chunk: any) {\n    this.log(\"stderr\", String(chunk));\n  }\n\n  /**\n   * @description Handles error objects.\n   * @summary Logs the error message from the given Error object.\n   *\n   * @param err - The Error object to be logged.\n   */\n  errors(err: Error) {\n    this.log(\"stderr\", `Error executing command exited : ${err}`);\n  }\n\n  /**\n   * @description Handles the exit of a command.\n   * @summary Logs the exit code and resolves or rejects the promise based on the code.\n   *\n   * @param code - The exit code of the command.\n   * @param logs\n   */\n  exit(code: number | string, logs: string[]) {\n    this.log(\n      \"stdout\",\n      `command exited code : ${code === 0 ? style(code.toString()).green.text : style(code === null ? \"null\" : code.toString()).red.text}`\n    );\n    if (code === 0) {\n      this.resolve(logs.map((l) => l.trim()).join(\"\\n\") as R);\n    } else {\n      this.reject(new Error(logs.length ? logs.join(\"\\n\") : code.toString()));\n    }\n  }\n\n  /**\n   * @description Parses a command string or array into components.\n   * @summary Converts the command into a consistent format and stores it, then returns it split into command and arguments.\n   *\n   * @param command - The command as a string or array of strings.\n   * @return A tuple containing the command and its arguments as separate elements.\n   */\n  parseCommand(command: string | string[]): [string, string[]] {\n    command = typeof command === \"string\" ? command.split(\" \") : command;\n    this.cmd = command.join(\" \");\n    return [command[0], command.slice(1)];\n  }\n\n  /**\n   * @description Resolves the promise with a success message.\n   * @summary Logs a success message and resolves the promise with the given reason.\n   *\n   * @param reason - The reason for resolving the promise.\n   */\n  protected resolve(reason: R) {\n    this.log(\n      \"stdout\",\n      `${this.cmd} executed successfully: ${style(reason ? \"ran to completion\" : (reason as string)).green}`\n    );\n    this.lock.resolve(reason);\n  }\n\n  /**\n   * @description Rejects the promise with an error message.\n   * @summary Logs an error message and rejects the promise with the given reason.\n   *\n   * @param reason - The reason for rejecting the promise, either a number (exit code) or a string.\n   */\n  protected reject(reason: number | string | Error) {\n    if (!(reason instanceof Error)) {\n      reason = new Error(\n        typeof reason === \"number\" ? `Exit code ${reason}` : reason\n      );\n    }\n    this.log(\n      \"stderr\",\n      `${this.cmd} failed to execute: ${style(reason.message).red}`\n    );\n    this.lock.reject(reason);\n  }\n}\n"]}

package/lib/writers/index.cjs

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./OutputWriter.cjs"), exports);
+__exportStar(require("./RegexpOutputWriter.cjs"), exports);
+__exportStar(require("./StandardOutputWriter.cjs"), exports);
+__exportStar(require("./types.cjs"), exports);
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNyYy93cml0ZXJzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSxpREFBK0I7QUFDL0IsdURBQXFDO0FBQ3JDLHlEQUF1QztBQUN2QywwQ0FBd0IiLCJmaWxlIjoid3JpdGVycy9pbmRleC5qcyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vT3V0cHV0V3JpdGVyJztcbmV4cG9ydCAqIGZyb20gJy4vUmVnZXhwT3V0cHV0V3JpdGVyJztcbmV4cG9ydCAqIGZyb20gJy4vU3RhbmRhcmRPdXRwdXRXcml0ZXInO1xuZXhwb3J0ICogZnJvbSAnLi90eXBlcyc7XG4iXX0=

package/lib/writers/types.cjs

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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