@decaf-ts/utils 0.1.6

package/lib/esm/utils/utils.js

@@ -0,0 +1,220 @@
+import { spawn, } from "child_process";
+import { StandardOutputWriter } from "../writers/StandardOutputWriter";
+import { Logging } from "../output/logging";
+import { AbortCode } from "./constants";
+/**
+ * @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
+ */
+export function lockify(f) {
+    let lock = Promise.resolve();
+    return (...params) => {
+        const result = lock.then(() => f(...params));
+        lock = result.catch(() => { });
+        return result;
+    };
+}
+export 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;
+}
+export 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 = 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
+ */
+export function runCommand(command, opts = {}, outputConstructor = (StandardOutputWriter), ...args) {
+    const logger = 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 = 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/esm/utils/web.js

@@ -0,0 +1,12 @@
+/**
+ * @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.
+ */
+export function isBrowser() {
+    return (Object.getPrototypeOf(Object.getPrototypeOf(globalThis)) !==
+        Object.prototype);
+}
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNyYy91dGlscy93ZWIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7O0dBS0c7QUFDSCxNQUFNLFVBQVUsU0FBUztJQUN2QixPQUFPLENBQ0wsTUFBTSxDQUFDLGNBQWMsQ0FBQyxNQUFNLENBQUMsY0FBYyxDQUFDLFVBQVUsQ0FBQyxDQUFDO1FBQ3hELE1BQU0sQ0FBQyxTQUFTLENBQ2pCLENBQUM7QUFDSixDQUFDIiwiZmlsZSI6InV0aWxzL3dlYi5qcyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGZ1bmN0aW9uIGlzQnJvd3NlclxuICogQGRlc2NyaXB0aW9uIERldGVybWluZXMgaWYgdGhlIGN1cnJlbnQgZW52aXJvbm1lbnQgaXMgYSBicm93c2VyIGJ5IGNoZWNraW5nIHRoZSBwcm90b3R5cGUgY2hhaW4gb2YgdGhlIGdsb2JhbCBvYmplY3QuXG4gKiBAc3VtbWFyeSBDaGVja3MgaWYgdGhlIGNvZGUgaXMgcnVubmluZyBpbiBhIGJyb3dzZXIgZW52aXJvbm1lbnQuXG4gKiBAcmV0dXJucyB7Ym9vbGVhbn0gVHJ1ZSBpZiB0aGUgZW52aXJvbm1lbnQgaXMgYSBicm93c2VyLCBmYWxzZSBvdGhlcndpc2UuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBpc0Jyb3dzZXIoKTogYm9vbGVhbiB7XG4gIHJldHVybiAoXG4gICAgT2JqZWN0LmdldFByb3RvdHlwZU9mKE9iamVjdC5nZXRQcm90b3R5cGVPZihnbG9iYWxUaGlzKSkgIT09XG4gICAgT2JqZWN0LnByb3RvdHlwZVxuICApO1xufVxuIl19

package/lib/esm/writers/OutputWriter.js

@@ -0,0 +1,3 @@
+export {};
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/lib/esm/writers/RegexpOutputWriter.js

@@ -0,0 +1,98 @@
+import { StandardOutputWriter } from "./StandardOutputWriter";
+/**
+ * @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
+ */
+export class RegexpOutputWriter extends 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));
+    }
+}
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/lib/esm/writers/StandardOutputWriter.js

@@ -0,0 +1,127 @@
+import { Encoding } from "../utils/constants";
+import { Logging } from "../output/logging";
+import { style } from "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
+ */
+export 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.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(Encoding) : data;
+        const formatedType = type === "stderr" ? 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 ? style(code.toString()).green.text : 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: ${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: ${style(reason.message).red}`);
+        this.lock.reject(reason);
+    }
+}
+
+//# 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/esm/writers/index.js

@@ -0,0 +1,6 @@
+export * from './OutputWriter';
+export * from './RegexpOutputWriter';
+export * from './StandardOutputWriter';
+export * from './types';
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNyYy93cml0ZXJzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsZ0JBQWdCLENBQUM7QUFDL0IsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMsU0FBUyxDQUFDIiwiZmlsZSI6IndyaXRlcnMvaW5kZXguanMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL091dHB1dFdyaXRlcic7XG5leHBvcnQgKiBmcm9tICcuL1JlZ2V4cE91dHB1dFdyaXRlcic7XG5leHBvcnQgKiBmcm9tICcuL1N0YW5kYXJkT3V0cHV0V3JpdGVyJztcbmV4cG9ydCAqIGZyb20gJy4vdHlwZXMnO1xuIl19

package/lib/esm/writers/types.js

@@ -0,0 +1,3 @@
+export {};
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/lib/index.cjs

@@ -0,0 +1,58 @@
+"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 });
+exports.VERSION = void 0;
+__exportStar(require("./cli/index.cjs"), exports);
+__exportStar(require("./input/index.cjs"), exports);
+__exportStar(require("./output/index.cjs"), exports);
+__exportStar(require("./utils/index.cjs"), exports);
+__exportStar(require("./writers/index.cjs"), exports);
+/**
+ * @module @decaf-ts/utils
+ * @description
+ * This module serves a light version of Decaf CLI tool, providing a comprehensive set of utilities
+ * and functionalities for command-line interface operations. It encompasses several key components:
+ *
+ * 1. Input Handling: Manages user input and command-line arguments processing.
+ * 2. Utility Functions: Offers a collection of helper functions and constants for various operations.
+ * 3. Type Definitions: Defines custom types and interfaces used throughout the module.
+ * 4. Output Management: Provides different output writing strategies for flexible console output handling.
+ *
+ * The module is designed to facilitate the creation of robust CLI applications by offering:
+ * - Standardized input parsing and validation
+ * - Consistent output formatting and handling
+ * - Reusable utility functions for common CLI tasks
+ * - Extensible architecture for adding new commands and features
+ *
+ * It supports various output modes, including standard console output and regular expression-based output,
+ * allowing for versatile data presentation and processing. The modular structure enables easy maintenance
+ * and extension of the CLI functionality.
+ *
+ * This module is particularly useful for developers building complex command-line tools that require
+ * structured input handling, flexible output formatting, and a rich set of utility functions.
+ */
+/**
+ * @description Represents the current version of the module.
+ * @summary This constant stores the version number of the @asdasdasd/utils module.
+ * The actual version number is replaced during the build process,
+ * with the placeholder "0.1.6" being substituted with the current version.
+ *
+ * @const VERSION
+ * @memberOf module:@decaf-ts/utils
+ */
+exports.VERSION = "0.1.6";
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/lib/input/index.cjs

@@ -0,0 +1,20 @@
+"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("./input.cjs"), exports);
+__exportStar(require("./types.cjs"), exports);
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNyYy9pbnB1dC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsMENBQXdCO0FBQ3hCLDBDQUF3QiIsImZpbGUiOiJpbnB1dC9pbmRleC5qcyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vaW5wdXQnO1xuZXhwb3J0ICogZnJvbSAnLi90eXBlcyc7XG4iXX0=