@decaf-ts/utils 0.1.7 → 0.2.1

package/lib/utils/types.d.ts

@@ -0,0 +1,81 @@
+import { ChildProcessWithoutNullStreams } from "child_process";
+import { Environment } from "./environment";
+/**
+ * @description Defines the structure for promise resolution and rejection.
+ * @summary Provides methods to resolve or reject a promise.
+ * @template R - The type of the resolved value.
+ * @template E - The type of the error value, defaulting to Error.
+ * @typedef {Object} PromiseExecutor
+ * @property {function(R): void} resolve - Function to resolve the promise.
+ * @property {function(E): void} reject - Function to reject the promise.
+ * @memberOf @decaf-ts/utils
+ */
+export interface PromiseExecutor<R, E = Error> {
+    resolve: (value: R | PromiseLike<R>) => void;
+    reject: (error: E) => void;
+}
+/**
+ * @description Represents the result of a command execution.
+ * @summary Extends Promise with additional properties related to the command execution.
+ * This interface provides a comprehensive way to handle and interact with the results
+ * of an asynchronous command execution, including access to the command details,
+ * output logs, and the ability to abort the execution.
+ *
+ * @template R - The type of the resolved value, defaulting to void.
+ * @interface CommandResult
+ * @extends Promise<R>
+ * @memberOf @decaf-ts/utils
+ */
+export interface CommandResult<R = void> {
+    promise: Promise<R>;
+    /**
+     * @description Controller to abort the command execution.
+     * @summary Provides a mechanism to cancel the ongoing command execution.
+     */
+    abort: AbortController;
+    /**
+     * @description The executed command string.
+     * @summary Contains the actual command that was executed.
+     */
+    command: string;
+    /**
+     * @description The child process object.
+     * @summary Represents the Node.js child process that was spawned to execute the command.
+     */
+    cmd?: ChildProcessWithoutNullStreams;
+    /**
+     * @description Array of stdout logs.
+     * @summary Contains all the standard output messages produced during the command execution.
+     */
+    logs: string[];
+    /**
+     * @description Array of stderr logs.
+     * @summary Contains all the standard error messages produced during the command execution.
+     */
+    errs: string[];
+    /**
+     * @description allows chaining commands.
+     * @summary allows chaining commands (or piping).
+     */
+    pipe: <E>(cb: (r: R) => E) => Promise<E>;
+}
+export type EnvironmentFactory<T extends object, E extends Environment<T>> = (...args: unknown[]) => E;
+export type DependencyMap = {
+    prod: {
+        name: string;
+        version: string;
+    }[];
+    dev: {
+        name: string;
+        version: string;
+    }[];
+    peer: {
+        name: string;
+        version: string;
+    }[];
+};
+export type SimpleDependencyMap = {
+    prod?: string[];
+    dev?: string[];
+    peer?: string[];
+};

package/lib/utils/utils.cjs

@@ -222,5 +222,4 @@ function runCommand(command, opts = {}, outputConstructor = (StandardOutputWrite
     });
     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"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../src/utils/utils.ts"],"names":[],"mappings":";;AAgDA,0BAOC;AASD,oDAqCC;AAED,oCA2CC;AA+CD,gCA8EC;AA/QD,iDAIuB;AACvB,0EAAuE;AAEvE,+CAA4C;AAG5C,2CAAwC;AAExC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,SAAgB,OAAO,CAAI,CAA8B;IACvD,IAAI,IAAI,GAAsB,OAAO,CAAC,OAAO,EAAE,CAAC;IAChD,OAAO,CAAC,GAAG,MAAiB,EAAE,EAAE;QAC9B,MAAM,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC;QAC7C,IAAI,GAAG,MAAM,CAAC,KAAK,CAAC,GAAG,EAAE,GAAE,CAAC,CAAC,CAAC;QAC9B,OAAO,MAAM,CAAC;IAChB,CAAC,CAAC;AACJ,CAAC;AASD,SAAgB,oBAAoB,CAClC,SAAwC,EACxC,GAAG,SAAwB;IAE3B,IAAI,OAAsB,CAAC;IAC3B,IAAI,UAA2B,CAAC;IAEhC,iBAAiB;IACjB,IAAI,SAAS,YAAY,WAAW,EAAE,CAAC;QACrC,UAAU,GAAG,IAAI,eAAe,EAAE,CAAC;QACnC,OAAO,GAAG,CAAC,SAAS,EAAE,GAAG,SAAS,CAAC,CAAC;IACtC,CAAC;SAAM,CAAC;QACN,UAAU,GAAG,SAAS,CAAC;QACvB,OAAO,GAAG,SAAS,CAAC;IACtB,CAAC;IAED,mDAAmD;IACnD,IAAI,UAAU,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;QAC9B,OAAO,UAAU,CAAC;IACpB,CAAC;IAED,MAAM,OAAO,GAAG,GAAG,EAAE,CAAC,UAAU,CAAC,KAAK,EAAE,CAAC;IAEzC,KAAK,MAAM,MAAM,IAAI,OAAO,EAAE,CAAC;QAC7B,kFAAkF;QAClF,8DAA8D;QAC9D,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;YACnB,UAAU,CAAC,KAAK,EAAE,CAAC;YACnB,MAAM;QACR,CAAC;QACD,MAAM,CAAC,gBAAgB,CAAC,OAAO,EAAE,OAAO,EAAE;YACxC,IAAI,EAAE,IAAI;YACV,MAAM,EAAE,UAAU,CAAC,MAAM;SAC1B,CAAC,CAAC;IACL,CAAC;IAED,OAAO,UAAU,CAAC;AACpB,CAAC;AAED,SAAgB,YAAY,CAC1B,MAA+B,EAC/B,OAAe,EACf,IAA8B,EAC9B,KAAsB,EACtB,MAAuB;IAEvB,SAAS,UAAU,CAAC,OAAe,EAAE,UAA2B;QAC9D,MAAM,CAAC,GAAG,EAAE,IAAI,CAAC,GAAG,MAAM,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;QACjD,MAAM,CAAC,IAAI,CAAC,oBAAoB,GAAG,EAAE,CAAC,CAAC;QACvC,MAAM,CAAC,KAAK,CAAC,cAAc,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;QAC7C,MAAM,YAAY,GAAG,IAAA,qBAAK,EAAC,GAAG,EAAE,IAAI,EAAE;YACpC,GAAG,IAAI;YACP,GAAG,EAAE,IAAI,CAAC,GAAG,IAAI,OAAO,CAAC,GAAG,EAAE;YAC9B,GAAG,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,OAAO,CAAC,GAAG,EAAE,IAAI,CAAC,GAAG,EAAE,EAAE,IAAI,EAAE,OAAO,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC;YACzE,KAAK,EAAE,IAAI,CAAC,KAAK,IAAI,KAAK;YAC1B,MAAM,EAAE,UAAU,CAAC,MAAM;SAC1B,CAAC,CAAC;QACH,MAAM,CAAC,OAAO,CAAC,SAAS,YAAY,CAAC,GAAG,EAAE,CAAC,CAAC;QAC5C,OAAO,YAAY,CAAC;IACtB,CAAC;IAED,MAAM,CAAC,GAAG,OAAO,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;IACnC,IAAI,CAAC;QACH,MAAM,IAAI,KAAK,CACb,oBAAoB,OAAO,kCAAkC,CAAC,EAAE,CACjE,CAAC;IACJ,IAAI,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;QAC5B,MAAM,IAAI,GAAG,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QAClC,MAAM,MAAM,GAAG,EAAE,CAAC;QAClB,MAAM,WAAW,GAAG,IAAI,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAC3C,WAAW,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC;QACvB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACrC,IAAI,CAAC,KAAK,CAAC;gBACT,WAAW,CAAC,CAAC,CAAC,GAAG,oBAAoB,CAAC,WAAW,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;YACnE,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YACjD,IAAI,CAAC,KAAK,CAAC;gBAAE,SAAS;YACtB,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;QAC7C,CAAC;QACD,OAAO,MAAM,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IACjC,CAAC;IAED,OAAO,UAAU,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;AACpC,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,SAAgB,UAAU,CACxB,OAAe,EACf,OAAiC,EAAE,EACnC,oBAII,CAAA,2CAAuB,CAAA,EAC3B,GAAG,IAAe;IAElB,MAAM,MAAM,GAAG,iBAAO,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;IACvC,MAAM,KAAK,GAAG,IAAI,eAAe,EAAE,CAAC;IAEpC,MAAM,MAAM,GAA4C;QACtD,KAAK,EAAE,KAAK;QACZ,OAAO,EAAE,OAAO;QAChB,IAAI,EAAE,EAAE;QACR,IAAI,EAAE,EAAE;KACT,CAAC;IAEF,MAAM,IAAI,GAAG,IAAI,OAAO,CAAI,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;QAC9C,IAAI,MAAM,CAAC;QACX,IAAI,CAAC;YACH,MAAM,GAAG,IAAI,iBAAiB,CAC5B,OAAO,EACP;gBACE,OAAO;gBACP,MAAM;aACP,EACD,GAAG,IAAI,CACR,CAAC;YAEF,MAAM,CAAC,GAAG,GAAG,YAAY,CAAI,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC;QACrE,CAAC;QAAC,OAAO,CAAU,EAAE,CAAC;YACpB,OAAO,MAAM,CAAC,IAAI,KAAK,CAAC,yBAAyB,OAAO,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC;QACrE,CAAC;QAED,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;QAEtC,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,KAAU,EAAE,EAAE;YAC1C,KAAK,GAAG,KAAK,CAAC,QAAQ,EAAE,CAAC;YACzB,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACxB,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACrB,CAAC,CAAC,CAAC;QAEH,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,IAAS,EAAE,EAAE;YACzC,IAAI,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC;YACvB,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACvB,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QACrB,CAAC,CAAC,CAAC;QAEH,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,GAAU,EAAE,EAAE;YACtC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,MAAM,CAAC,IAAI,CAAC,CAAC;QACxC,CAAC,CAAC,CAAC;QAEH,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,OAAe,CAAC,EAAE,EAAE;YAC3C,IAAI,KAAK,CAAC,MAAM,CAAC,OAAO,IAAI,IAAI,KAAK,IAAI;gBAAE,IAAI,GAAG,qBAAgB,CAAC;YACnE,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QAC5D,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE;QACpB,OAAO,EAAE,IAAI;QACb,IAAI,EAAE,KAAK,EAAK,EAAe,EAAE,EAAE;YACjC,MAAM,CAAC,GAAG,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;YAC7B,IAAI,CAAC;gBACH,CAAC,CAAC,OAAO,CAAC,2BAA2B,OAAO,KAAK,CAAC,CAAC;gBACnD,MAAM,MAAM,GAAM,MAAM,IAAI,CAAC;gBAC7B,CAAC,CAAC,OAAO,CAAC,oBAAoB,EAAE,CAAC,IAAI,KAAK,MAAM,EAAE,CAAC,CAAC;gBACpD,OAAO,EAAE,CAAC,MAAM,CAAC,CAAC;YACpB,CAAC;YAAC,OAAO,CAAU,EAAE,CAAC;gBACpB,CAAC,CAAC,KAAK,CAAC,gCAAgC,CAAC,EAAE,CAAC,CAAC;gBAC7C,MAAM,CAAC,CAAC;YACV,CAAC;QACH,CAAC;KACF,CAAC,CAAC;IAEH,OAAO,MAA0B,CAAC;AACpC,CAAC","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/utils.d.ts

@@ -0,0 +1,91 @@
+import { ChildProcessWithoutNullStreams, SpawnOptionsWithoutStdio } from "child_process";
+import { StandardOutputWriter } from "../writers/StandardOutputWriter";
+import { CommandResult } from "./types";
+import { OutputWriterConstructor } from "../writers/types";
+import { VerbosityLogger } from "../output/types";
+/**
+ * @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 declare function lockify<R>(f: (...params: unknown[]) => R): (...params: unknown[]) => Promise<R>;
+export declare function chainAbortController(controller: AbortController, ...signals: AbortSignal[]): AbortController;
+export declare function chainAbortController(...signals: AbortSignal[]): AbortController;
+export declare function spawnCommand<R = string>(output: StandardOutputWriter<R>, command: string, opts: SpawnOptionsWithoutStdio, abort: AbortController, logger: VerbosityLogger): ChildProcessWithoutNullStreams;
+/**
+ * @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 declare function runCommand<R = string>(command: string, opts?: SpawnOptionsWithoutStdio, outputConstructor?: OutputWriterConstructor<R, StandardOutputWriter<R>, Error>, ...args: unknown[]): CommandResult<R>;

package/lib/utils/web.cjs

@@ -11,5 +11,4 @@ function isBrowser() {
     return (Object.getPrototypeOf(Object.getPrototypeOf(globalThis)) !==
         Object.prototype);
 }
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNyYy91dGlscy93ZWIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFNQSw4QkFLQztBQVhEOzs7OztHQUtHO0FBQ0gsU0FBZ0IsU0FBUztJQUN2QixPQUFPLENBQ0wsTUFBTSxDQUFDLGNBQWMsQ0FBQyxNQUFNLENBQUMsY0FBYyxDQUFDLFVBQVUsQ0FBQyxDQUFDO1FBQ3hELE1BQU0sQ0FBQyxTQUFTLENBQ2pCLENBQUM7QUFDSixDQUFDIiwiZmlsZSI6InV0aWxzL3dlYi5qcyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGZ1bmN0aW9uIGlzQnJvd3NlclxuICogQGRlc2NyaXB0aW9uIERldGVybWluZXMgaWYgdGhlIGN1cnJlbnQgZW52aXJvbm1lbnQgaXMgYSBicm93c2VyIGJ5IGNoZWNraW5nIHRoZSBwcm90b3R5cGUgY2hhaW4gb2YgdGhlIGdsb2JhbCBvYmplY3QuXG4gKiBAc3VtbWFyeSBDaGVja3MgaWYgdGhlIGNvZGUgaXMgcnVubmluZyBpbiBhIGJyb3dzZXIgZW52aXJvbm1lbnQuXG4gKiBAcmV0dXJucyB7Ym9vbGVhbn0gVHJ1ZSBpZiB0aGUgZW52aXJvbm1lbnQgaXMgYSBicm93c2VyLCBmYWxzZSBvdGhlcndpc2UuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBpc0Jyb3dzZXIoKTogYm9vbGVhbiB7XG4gIHJldHVybiAoXG4gICAgT2JqZWN0LmdldFByb3RvdHlwZU9mKE9iamVjdC5nZXRQcm90b3R5cGVPZihnbG9iYWxUaGlzKSkgIT09XG4gICAgT2JqZWN0LnByb3RvdHlwZVxuICApO1xufVxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2ViLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3V0aWxzL3dlYi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQU1BLDhCQUtDO0FBWEQ7Ozs7O0dBS0c7QUFDSCxTQUFnQixTQUFTO0lBQ3ZCLE9BQU8sQ0FDTCxNQUFNLENBQUMsY0FBYyxDQUFDLE1BQU0sQ0FBQyxjQUFjLENBQUMsVUFBVSxDQUFDLENBQUM7UUFDeEQsTUFBTSxDQUFDLFNBQVMsQ0FDakIsQ0FBQztBQUNKLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBmdW5jdGlvbiBpc0Jyb3dzZXJcbiAqIEBkZXNjcmlwdGlvbiBEZXRlcm1pbmVzIGlmIHRoZSBjdXJyZW50IGVudmlyb25tZW50IGlzIGEgYnJvd3NlciBieSBjaGVja2luZyB0aGUgcHJvdG90eXBlIGNoYWluIG9mIHRoZSBnbG9iYWwgb2JqZWN0LlxuICogQHN1bW1hcnkgQ2hlY2tzIGlmIHRoZSBjb2RlIGlzIHJ1bm5pbmcgaW4gYSBicm93c2VyIGVudmlyb25tZW50LlxuICogQHJldHVybnMge2Jvb2xlYW59IFRydWUgaWYgdGhlIGVudmlyb25tZW50IGlzIGEgYnJvd3NlciwgZmFsc2Ugb3RoZXJ3aXNlLlxuICovXG5leHBvcnQgZnVuY3Rpb24gaXNCcm93c2VyKCk6IGJvb2xlYW4ge1xuICByZXR1cm4gKFxuICAgIE9iamVjdC5nZXRQcm90b3R5cGVPZihPYmplY3QuZ2V0UHJvdG90eXBlT2YoZ2xvYmFsVGhpcykpICE9PVxuICAgIE9iamVjdC5wcm90b3R5cGVcbiAgKTtcbn1cbiJdfQ==

package/lib/utils/web.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @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 declare function isBrowser(): boolean;

package/lib/writers/OutputWriter.cjs

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

package/lib/writers/OutputWriter.d.ts

@@ -0,0 +1,49 @@
+/**
+ * @description Defines the structure for output writing operations.
+ * @summary The OutputWriter interface provides a standardized set of methods for handling
+ * various types of output in a command-line interface (CLI) application. It includes
+ * methods for writing data, handling errors, and managing the program's exit process.
+ * This interface allows for consistent output handling across different parts of the application.
+ *
+ * @interface OutputWriter
+ * @memberOf @decaf-ts/utils
+ */
+export interface OutputWriter {
+    /**
+     * @description Handles the output of data chunks.
+     * @summary Processes and writes a chunk of data to the output stream.
+     * This method is typically used for standard output operations.
+     *
+     * @param chunk - The data to be written. Can be of any type.
+     * @return void
+     */
+    data(chunk: any): void;
+    /**
+     * @description Handles error output.
+     * @summary Processes and writes error information to the error output stream.
+     * This method is used for non-critical errors or warnings.
+     *
+     * @param chunk - The error data to be written. Can be of any type.
+     * @return void
+     */
+    error(chunk: any): void;
+    /**
+     * @description Handles critical errors.
+     * @summary Processes and writes critical error information.
+     * This method is used for handling and reporting Error objects.
+     *
+     * @param err - The Error object to be processed and written.
+     * @return void
+     */
+    errors(err: Error): void;
+    /**
+     * @description Manages the program exit process.
+     * @summary Handles the termination of the program with a specified exit code.
+     * This method is called when the program needs to exit, either successfully or due to an error.
+     *
+     * @param code - The exit code to be used when terminating the program.
+     * @param logs
+     * @return void
+     */
+    exit(code: number, logs: string[]): void;
+}

package/lib/writers/RegexpOutputWriter.cjs

@@ -98,5 +98,4 @@ class RegexpOutputWriter extends StandardOutputWriter_1.StandardOutputWriter {
     }
 }
 exports.RegexpOutputWriter = RegexpOutputWriter;
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/writers/RegexpOutputWriter.d.ts

@@ -0,0 +1,69 @@
+import { StandardOutputWriter } from "./StandardOutputWriter";
+import { PromiseExecutor } from "../utils/types";
+/**
+ * @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 declare class RegexpOutputWriter extends StandardOutputWriter<string> {
+    /**
+     * @description The regular expression used for matching output.
+     * @summary This readonly property stores the compiled RegExp used for pattern matching.
+     */
+    protected readonly regexp: RegExp;
+    /**
+     * @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: string, lock: PromiseExecutor<string, Error>, regexp: string | RegExp, flags?: string);
+    /**
+     * @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.
+     */
+    private test;
+    /**
+     * @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.
+     */
+    protected testAndResolve(data: string): void;
+    /**
+     * @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.
+     */
+    protected testAndReject(data: string): void;
+    /**
+     * @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: any): void;
+    /**
+     * @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: any): void;
+}

package/lib/writers/StandardOutputWriter.cjs

@@ -43,8 +43,7 @@ class StandardOutputWriter {
      */
     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}`;
+        const log = type === "stderr" ? (0, styled_string_builder_1.style)(data).red.text : data;
         this.logger.info(log);
     }
     /**
@@ -127,5 +126,4 @@ class StandardOutputWriter {
     }
 }
 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"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"StandardOutputWriter.js","sourceRoot":"","sources":["../../src/writers/StandardOutputWriter.ts"],"names":[],"mappings":"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","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 log = type === \"stderr\" ? style(data).red.text : 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/StandardOutputWriter.d.ts

@@ -0,0 +1,91 @@
+import { OutputWriter } from "./OutputWriter";
+import { PromiseExecutor } from "../utils/types";
+import { OutputType } from "./types";
+import { VerbosityLogger } from "../output/types";
+/**
+ * @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 declare class StandardOutputWriter<R = string> implements OutputWriter {
+    protected cmd: string;
+    protected lock: PromiseExecutor<R>;
+    protected logger: VerbosityLogger;
+    /**
+     * @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: string, lock: PromiseExecutor<R>, ...args: unknown[]);
+    /**
+     * @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.
+     */
+    protected log(type: OutputType, data: string | Buffer): void;
+    /**
+     * @description Handles standard output data.
+     * @summary Logs the given chunk as standard output.
+     *
+     * @param chunk - The data chunk to be logged.
+     */
+    data(chunk: any): void;
+    /**
+     * @description Handles error output data.
+     * @summary Logs the given chunk as error output.
+     *
+     * @param chunk - The error data chunk to be logged.
+     */
+    error(chunk: any): void;
+    /**
+     * @description Handles error objects.
+     * @summary Logs the error message from the given Error object.
+     *
+     * @param err - The Error object to be logged.
+     */
+    errors(err: Error): void;
+    /**
+     * @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: number | string, logs: string[]): void;
+    /**
+     * @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: string | string[]): [string, string[]];
+    /**
+     * @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.
+     */
+    protected resolve(reason: R): void;
+    /**
+     * @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.
+     */
+    protected reject(reason: number | string | Error): void;
+}

package/lib/writers/index.cjs

@@ -18,5 +18,4 @@ __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=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvd3JpdGVycy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsaURBQStCO0FBQy9CLHVEQUFxQztBQUNyQyx5REFBdUM7QUFDdkMsMENBQXdCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9PdXRwdXRXcml0ZXInO1xuZXhwb3J0ICogZnJvbSAnLi9SZWdleHBPdXRwdXRXcml0ZXInO1xuZXhwb3J0ICogZnJvbSAnLi9TdGFuZGFyZE91dHB1dFdyaXRlcic7XG5leHBvcnQgKiBmcm9tICcuL3R5cGVzJztcbiJdfQ==

package/lib/writers/index.d.ts

@@ -0,0 +1,4 @@
+export * from './OutputWriter';
+export * from './RegexpOutputWriter';
+export * from './StandardOutputWriter';
+export * from './types';