@decaf-ts/utils 0.2.12 → 0.3.0

package/lib/utils/types.d.ts

@@ -8,7 +8,7 @@ import { Environment } from "./environment";
  * @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
+ * @memberOf module:utils
  */
 export interface PromiseExecutor<R, E = Error> {
     resolve: (value: R | PromiseLike<R>) => void;
@@ -24,7 +24,7 @@ export interface PromiseExecutor<R, E = Error> {
  * @template R - The type of the resolved value, defaulting to void.
  * @interface CommandResult
  * @extends Promise<R>
- * @memberOf @decaf-ts/utils
+ * @memberOf module:utils
  */
 export interface CommandResult<R = void> {
     promise: Promise<R>;
@@ -59,7 +59,27 @@ export interface CommandResult<R = void> {
      */
     pipe: <E>(cb: (r: R) => E) => Promise<E>;
 }
+/**
+ * @description Factory type for creating Environment instances.
+ * @summary Defines a function type that creates and returns Environment instances.
+ *
+ * @template T - The type of object the Environment will accumulate.
+ * @template E - The specific Environment type to be created, extending Environment<T>.
+ * @typedef {function(...unknown[]): E} EnvironmentFactory
+ * @memberOf module:utils
+ */
 export type EnvironmentFactory<T extends object, E extends Environment<T>> = (...args: unknown[]) => E;
+/**
+ * @description Map of project dependencies with detailed information.
+ * @summary Represents the structure of project dependencies categorized by type (production, development, peer).
+ * Each category contains an array of objects with name and version information.
+ *
+ * @typedef {Object} DependencyMap
+ * @property {Array<{name: string, version: string}>} prod - Production dependencies with name and version.
+ * @property {Array<{name: string, version: string}>} dev - Development dependencies with name and version.
+ * @property {Array<{name: string, version: string}>} peer - Peer dependencies with name and version.
+ * @memberOf module:utils
+ */
 export type DependencyMap = {
     prod: {
         name: string;
@@ -74,6 +94,17 @@ export type DependencyMap = {
         version: string;
     }[];
 };
+/**
+ * @description Simplified map of project dependencies.
+ * @summary Represents a simplified structure of project dependencies categorized by type.
+ * Each category contains an optional array of dependency names without version information.
+ *
+ * @typedef {Object} SimpleDependencyMap
+ * @property {string[]} [prod] - Optional array of production dependency names.
+ * @property {string[]} [dev] - Optional array of development dependency names.
+ * @property {string[]} [peer] - Optional array of peer dependency names.
+ * @memberOf module:utils
+ */
 export type SimpleDependencyMap = {
     prod?: string[];
     dev?: string[];

package/lib/utils/utils.cjs

@@ -42,7 +42,7 @@ const logging_1 = require("@decaf-ts/logging");
  *   end
  *   LockedFunction->>LockedFunction: Update lock
  *
- * @memberOf @decaf-ts/utils
+ * @memberOf module:utils
  */
 function lockify(f) {
     let lock = Promise.resolve();
@@ -83,6 +83,24 @@ function chainAbortController(argument0, ...remainder) {
     }
     return controller;
 }
+/**
+ * @description Spawns a command as a child process with output handling.
+ * @summary Creates a child process to execute a command with support for piping multiple commands,
+ * custom output handling, and abort control. This function handles the low-level details of
+ * spawning processes and connecting their inputs/outputs when piping is used.
+ *
+ * @template R - The type of the processed output, defaulting to string.
+ * @param {StandardOutputWriter<R>} output - The output writer to handle command output.
+ * @param {string} command - The command to execute, can include pipe operators.
+ * @param {SpawnOptionsWithoutStdio} opts - Options for the spawned process.
+ * @param {AbortController} abort - Controller to abort the command execution.
+ * @param {Logger} logger - Logger for recording command execution details.
+ * @return {ChildProcessWithoutNullStreams} The spawned child process.
+ *
+ * @function spawnCommand
+ *
+ * @memberOf module:utils
+ */
 function spawnCommand(output, command, opts, abort, logger) {
     function spawnInner(command, controller) {
         const [cmd, argz] = output.parseCommand(command);
@@ -161,7 +179,7 @@ function spawnCommand(output, command, opts, abort, logger) {
  *   OutputWriter-->>runCommand: Resolve or reject promise
  *   runCommand-->>Caller: Return CommandResult
  *
- * @memberOf @decaf-ts/utils
+ * @memberOf module:utils
  */
 function runCommand(command, opts = {}, outputConstructor = (StandardOutputWriter_1.StandardOutputWriter), ...args) {
     const logger = logging_1.Logging.for(runCommand);
@@ -222,4 +240,4 @@ function runCommand(command, opts = {}, outputConstructor = (StandardOutputWrite
     });
     return result;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../src/utils/utils.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ChildProcessWithoutNullStreams,\n  spawn,\n  SpawnOptionsWithoutStdio,\n} from \"child_process\";\nimport { StandardOutputWriter } from \"../writers/StandardOutputWriter\";\nimport { CommandResult } from \"./types\";\nimport { OutputWriterConstructor } from \"../writers/types\";\nimport { AbortCode } from \"./constants\";\nimport { Logger, Logging } from \"@decaf-ts/logging\";\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: Logger\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":"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","sourcesContent":["import {\n  ChildProcessWithoutNullStreams,\n  spawn,\n  SpawnOptionsWithoutStdio,\n} from \"child_process\";\nimport { StandardOutputWriter } from \"../writers/StandardOutputWriter\";\nimport { CommandResult } from \"./types\";\nimport { OutputWriterConstructor } from \"../writers/types\";\nimport { AbortCode } from \"./constants\";\nimport { Logger, Logging } from \"@decaf-ts/logging\";\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 module: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\n/**\n * @description Chains multiple abort signals to a controller.\n * @summary Creates a mechanism where multiple abort signals can trigger a single abort controller.\n * This is useful for coordinating cancellation across multiple asynchronous operations.\n *\n * @param {AbortController} controller - The abort controller to be triggered by signals.\n * @param {...AbortSignal} signals - One or more abort signals that can trigger the controller.\n * @return {AbortController} The input controller, now connected to the signals.\n *\n * @function chainAbortController\n *\n * @memberOf module:utils\n */\nexport function chainAbortController(\n  controller: AbortController,\n  ...signals: AbortSignal[]\n): AbortController;\n\n/**\n * @description Creates a new controller chained to multiple abort signals.\n * @summary Creates a new abort controller that will be triggered if any of the provided signals are aborted.\n *\n * @param {...AbortSignal} signals - One or more abort signals that can trigger the new controller.\n * @return {AbortController} A new abort controller connected to the signals.\n *\n * @function chainAbortController\n *\n * @memberOf module:utils\n */\nexport function chainAbortController(\n  ...signals: AbortSignal[]\n): AbortController;\n\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\n/**\n * @description Spawns a command as a child process with output handling.\n * @summary Creates a child process to execute a command with support for piping multiple commands,\n * custom output handling, and abort control. This function handles the low-level details of\n * spawning processes and connecting their inputs/outputs when piping is used.\n *\n * @template R - The type of the processed output, defaulting to string.\n * @param {StandardOutputWriter<R>} output - The output writer to handle command output.\n * @param {string} command - The command to execute, can include pipe operators.\n * @param {SpawnOptionsWithoutStdio} opts - Options for the spawned process.\n * @param {AbortController} abort - Controller to abort the command execution.\n * @param {Logger} logger - Logger for recording command execution details.\n * @return {ChildProcessWithoutNullStreams} The spawned child process.\n *\n * @function spawnCommand\n *\n * @memberOf module:utils\n */\nexport function spawnCommand<R = string>(\n  output: StandardOutputWriter<R>,\n  command: string,\n  opts: SpawnOptionsWithoutStdio,\n  abort: AbortController,\n  logger: Logger\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 module: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

@@ -37,11 +37,53 @@ import { Logger } from "@decaf-ts/logging";
  *   end
  *   LockedFunction->>LockedFunction: Update lock
  *
- * @memberOf @decaf-ts/utils
+ * @memberOf module:utils
  */
 export declare function lockify<R>(f: (...params: unknown[]) => R): (...params: unknown[]) => Promise<R>;
+/**
+ * @description Chains multiple abort signals to a controller.
+ * @summary Creates a mechanism where multiple abort signals can trigger a single abort controller.
+ * This is useful for coordinating cancellation across multiple asynchronous operations.
+ *
+ * @param {AbortController} controller - The abort controller to be triggered by signals.
+ * @param {...AbortSignal} signals - One or more abort signals that can trigger the controller.
+ * @return {AbortController} The input controller, now connected to the signals.
+ *
+ * @function chainAbortController
+ *
+ * @memberOf module:utils
+ */
 export declare function chainAbortController(controller: AbortController, ...signals: AbortSignal[]): AbortController;
+/**
+ * @description Creates a new controller chained to multiple abort signals.
+ * @summary Creates a new abort controller that will be triggered if any of the provided signals are aborted.
+ *
+ * @param {...AbortSignal} signals - One or more abort signals that can trigger the new controller.
+ * @return {AbortController} A new abort controller connected to the signals.
+ *
+ * @function chainAbortController
+ *
+ * @memberOf module:utils
+ */
 export declare function chainAbortController(...signals: AbortSignal[]): AbortController;
+/**
+ * @description Spawns a command as a child process with output handling.
+ * @summary Creates a child process to execute a command with support for piping multiple commands,
+ * custom output handling, and abort control. This function handles the low-level details of
+ * spawning processes and connecting their inputs/outputs when piping is used.
+ *
+ * @template R - The type of the processed output, defaulting to string.
+ * @param {StandardOutputWriter<R>} output - The output writer to handle command output.
+ * @param {string} command - The command to execute, can include pipe operators.
+ * @param {SpawnOptionsWithoutStdio} opts - Options for the spawned process.
+ * @param {AbortController} abort - Controller to abort the command execution.
+ * @param {Logger} logger - Logger for recording command execution details.
+ * @return {ChildProcessWithoutNullStreams} The spawned child process.
+ *
+ * @function spawnCommand
+ *
+ * @memberOf module:utils
+ */
 export declare function spawnCommand<R = string>(output: StandardOutputWriter<R>, command: string, opts: SpawnOptionsWithoutStdio, abort: AbortController, logger: Logger): ChildProcessWithoutNullStreams;
 /**
  * @description Executes a command asynchronously with customizable output handling.
@@ -86,6 +128,6 @@ export declare function spawnCommand<R = string>(output: StandardOutputWriter<R>
  *   OutputWriter-->>runCommand: Resolve or reject promise
  *   runCommand-->>Caller: Return CommandResult
  *
- * @memberOf @decaf-ts/utils
+ * @memberOf module: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

@@ -2,13 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isBrowser = isBrowser;
 /**
- * @function isBrowser
  * @description Determines if the current environment is a browser by checking the prototype chain of the global object.
  * @summary Checks if the code is running in a browser environment.
- * @returns {boolean} True if the environment is a browser, false otherwise.
+ * @return {boolean} True if the environment is a browser, false otherwise.
+ * @function isBrowser
+ * @memberOf module:utils
  */
 function isBrowser() {
     return (Object.getPrototypeOf(Object.getPrototypeOf(globalThis)) !==
         Object.prototype);
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2ViLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3V0aWxzL3dlYi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQU1BLDhCQUtDO0FBWEQ7Ozs7O0dBS0c7QUFDSCxTQUFnQixTQUFTO0lBQ3ZCLE9BQU8sQ0FDTCxNQUFNLENBQUMsY0FBYyxDQUFDLE1BQU0sQ0FBQyxjQUFjLENBQUMsVUFBVSxDQUFDLENBQUM7UUFDeEQsTUFBTSxDQUFDLFNBQVMsQ0FDakIsQ0FBQztBQUNKLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBmdW5jdGlvbiBpc0Jyb3dzZXJcbiAqIEBkZXNjcmlwdGlvbiBEZXRlcm1pbmVzIGlmIHRoZSBjdXJyZW50IGVudmlyb25tZW50IGlzIGEgYnJvd3NlciBieSBjaGVja2luZyB0aGUgcHJvdG90eXBlIGNoYWluIG9mIHRoZSBnbG9iYWwgb2JqZWN0LlxuICogQHN1bW1hcnkgQ2hlY2tzIGlmIHRoZSBjb2RlIGlzIHJ1bm5pbmcgaW4gYSBicm93c2VyIGVudmlyb25tZW50LlxuICogQHJldHVybnMge2Jvb2xlYW59IFRydWUgaWYgdGhlIGVudmlyb25tZW50IGlzIGEgYnJvd3NlciwgZmFsc2Ugb3RoZXJ3aXNlLlxuICovXG5leHBvcnQgZnVuY3Rpb24gaXNCcm93c2VyKCk6IGJvb2xlYW4ge1xuICByZXR1cm4gKFxuICAgIE9iamVjdC5nZXRQcm90b3R5cGVPZihPYmplY3QuZ2V0UHJvdG90eXBlT2YoZ2xvYmFsVGhpcykpICE9PVxuICAgIE9iamVjdC5wcm90b3R5cGVcbiAgKTtcbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2ViLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3V0aWxzL3dlYi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQU9BLDhCQUtDO0FBWkQ7Ozs7OztHQU1HO0FBQ0gsU0FBZ0IsU0FBUztJQUN2QixPQUFPLENBQ0wsTUFBTSxDQUFDLGNBQWMsQ0FBQyxNQUFNLENBQUMsY0FBYyxDQUFDLFVBQVUsQ0FBQyxDQUFDO1FBQ3hELE1BQU0sQ0FBQyxTQUFTLENBQ2pCLENBQUM7QUFDSixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAZGVzY3JpcHRpb24gRGV0ZXJtaW5lcyBpZiB0aGUgY3VycmVudCBlbnZpcm9ubWVudCBpcyBhIGJyb3dzZXIgYnkgY2hlY2tpbmcgdGhlIHByb3RvdHlwZSBjaGFpbiBvZiB0aGUgZ2xvYmFsIG9iamVjdC5cbiAqIEBzdW1tYXJ5IENoZWNrcyBpZiB0aGUgY29kZSBpcyBydW5uaW5nIGluIGEgYnJvd3NlciBlbnZpcm9ubWVudC5cbiAqIEByZXR1cm4ge2Jvb2xlYW59IFRydWUgaWYgdGhlIGVudmlyb25tZW50IGlzIGEgYnJvd3NlciwgZmFsc2Ugb3RoZXJ3aXNlLlxuICogQGZ1bmN0aW9uIGlzQnJvd3NlclxuICogQG1lbWJlck9mIG1vZHVsZTp1dGlsc1xuICovXG5leHBvcnQgZnVuY3Rpb24gaXNCcm93c2VyKCk6IGJvb2xlYW4ge1xuICByZXR1cm4gKFxuICAgIE9iamVjdC5nZXRQcm90b3R5cGVPZihPYmplY3QuZ2V0UHJvdG90eXBlT2YoZ2xvYmFsVGhpcykpICE9PVxuICAgIE9iamVjdC5wcm90b3R5cGVcbiAgKTtcbn1cbiJdfQ==

package/lib/utils/web.d.ts

@@ -1,7 +1,8 @@
 /**
- * @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.
+ * @return {boolean} True if the environment is a browser, false otherwise.
+ * @function isBrowser
+ * @memberOf module:utils
  */
 export declare function isBrowser(): boolean;

package/lib/writers/OutputWriter.cjs

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

package/lib/writers/OutputWriter.d.ts

@@ -6,7 +6,7 @@
  * This interface allows for consistent output handling across different parts of the application.
  *
  * @interface OutputWriter
- * @memberOf @decaf-ts/utils
+ * @memberOf module:utils
  */
 export interface OutputWriter {
     /**
@@ -42,7 +42,7 @@ export interface OutputWriter {
      * 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
+     * @param logs - Array of log messages to be processed before exiting.
      * @return void
      */
     exit(code: number, logs: string[]): void;

package/lib/writers/RegexpOutputWriter.cjs

@@ -10,22 +10,63 @@ const StandardOutputWriter_1 = require("./StandardOutputWriter.cjs");
  *
  * @template T - The type of the resolved value, defaulting to string.
  *
+ * @param cmd - The command string to be executed.
  * @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.
+ * @param flags - Optional flags for the RegExp constructor, defaults to "g".
  *
  * @class
+ * @example
+ * ```typescript
+ * import { RegexpOutputWriter } from '@decaf-ts/utils';
+ * import { PromiseExecutor } from '@decaf-ts/utils';
+ *
+ * // Create a promise executor
+ * const executor: PromiseExecutor<string, Error> = {
+ *   resolve: (value) => console.log(`Resolved: ${value}`),
+ *   reject: (error) => console.error(`Rejected: ${error.message}`)
+ * };
+ *
+ * // Create a regexp output writer that matches version numbers
+ * const writer = new RegexpOutputWriter('node --version', executor, /v(\d+\.\d+\.\d+)/);
+ *
+ * // Use the writer to handle command output
+ * writer.data('v14.17.0');  // This will automatically resolve with "v14.17.0"
+ * ```
+ *
+ * @mermaid
+ * sequenceDiagram
+ *   participant Client
+ *   participant RegexpOutputWriter
+ *   participant StandardOutputWriter
+ *   participant Logger
+ *
+ *   Client->>RegexpOutputWriter: new RegexpOutputWriter(cmd, lock, regexp, flags)
+ *   RegexpOutputWriter->>StandardOutputWriter: super(cmd, lock)
+ *   StandardOutputWriter->>Logger: Logging.for(cmd)
+ *   RegexpOutputWriter->>RegexpOutputWriter: compile regexp
+ *
+ *   Client->>RegexpOutputWriter: data(chunk)
+ *   RegexpOutputWriter->>StandardOutputWriter: super.data(chunk)
+ *   StandardOutputWriter->>Logger: logger.info(log)
+ *   RegexpOutputWriter->>RegexpOutputWriter: testAndResolve(chunk)
+ *   RegexpOutputWriter->>RegexpOutputWriter: test(chunk)
+ *   alt match found
+ *     RegexpOutputWriter->>RegexpOutputWriter: resolve(match[0])
+ *     RegexpOutputWriter->>StandardOutputWriter: resolve(match[0])
+ *   end
+ *
+ *   Client->>RegexpOutputWriter: error(chunk)
+ *   RegexpOutputWriter->>StandardOutputWriter: super.error(chunk)
+ *   StandardOutputWriter->>Logger: logger.info(log)
+ *   RegexpOutputWriter->>RegexpOutputWriter: testAndReject(chunk)
+ *   RegexpOutputWriter->>RegexpOutputWriter: test(chunk)
+ *   alt match found
+ *     RegexpOutputWriter->>RegexpOutputWriter: reject(match[0])
+ *     RegexpOutputWriter->>StandardOutputWriter: reject(match[0])
+ *   end
  */
 class RegexpOutputWriter extends StandardOutputWriter_1.StandardOutputWriter {
-    /**
-     * @description Initializes a new instance of RegexpOutputWriter.
-     * @summary Constructs the RegexpOutputWriter with a lock mechanism and a regular expression.
-     *
-     * @param cmd
-     * @param lock - A PromiseExecutor to control the asynchronous flow.
-     * @param regexp - A string or RegExp to match against the output.
-     * @param flags - Optional flags for the RegExp constructor, defaults to "g".
-     */
     constructor(cmd, lock, regexp, flags = "g") {
         super(cmd, lock);
         try {
@@ -98,4 +139,4 @@ class RegexpOutputWriter extends StandardOutputWriter_1.StandardOutputWriter {
     }
 }
 exports.RegexpOutputWriter = RegexpOutputWriter;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"RegexpOutputWriter.js","sourceRoot":"","sources":["../../src/writers/RegexpOutputWriter.ts"],"names":[],"mappings":";;;AAAA,qEAA8D;AAG9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DG;AACH,MAAa,kBAAmB,SAAQ,2CAA4B;IAOlE,YACE,GAAW,EACX,IAAoC,EACpC,MAAuB,EACvB,KAAK,GAAG,GAAG;QAEX,KAAK,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;QACjB,IAAI,CAAC;YACH,IAAI,CAAC,MAAM;gBACT,OAAO,MAAM,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC;QACpE,CAAC;QAAC,OAAO,CAAU,EAAE,CAAC;YACpB,MAAM,IAAI,KAAK,CAAC,+BAA+B,CAAC,EAAE,CAAC,CAAC;QACtD,CAAC;IACH,CAAC;IAED;;;;;;OAMG;IACK,IAAI,CAAC,IAAY;QACvB,IAAI,CAAC,MAAM,CAAC,SAAS,GAAG,CAAC,CAAC;QAC1B,IAAI,KAAK,CAAC;QACV,IAAI,CAAC;YACH,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACjC,CAAC;QAAC,OAAO,CAAU,EAAE,CAAC;YACpB,OAAO,OAAO,CAAC,KAAK,CAAC,0BAA0B,IAAI,YAAY,CAAC,GAAG,CAAC,CAAC;QACvE,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;;;;OAKG;IACO,cAAc,CAAC,IAAY;QACnC,MAAM,KAAK,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAC9B,IAAI,KAAK;YAAE,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;IACpC,CAAC;IAED;;;;;OAKG;IACO,aAAa,CAAC,IAAY;QAClC,MAAM,KAAK,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAC9B,IAAI,KAAK;YAAE,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;IACnC,CAAC;IAED;;;;;OAKG;IACM,IAAI,CAAC,KAAU;QACtB,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAClB,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;IACrC,CAAC;IAED;;;;;OAKG;IACM,KAAK,CAAC,KAAU;QACvB,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QACnB,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;IACpC,CAAC;CACF;AAnFD,gDAmFC","sourcesContent":["import { StandardOutputWriter } from \"./StandardOutputWriter\";\nimport { PromiseExecutor } from \"../utils/types\";\n\n/**\n * @description A specialized output writer that uses regular expressions to process output.\n * @summary This class extends StandardOutputWriter to provide regex-based output processing.\n * It allows for pattern matching in the output stream and can trigger specific actions\n * based on matched patterns.\n *\n * @template T - The type of the resolved value, defaulting to string.\n *\n * @param cmd - The command string to be executed.\n * @param lock - A PromiseExecutor to control the asynchronous flow.\n * @param regexp - A string or RegExp to match against the output.\n * @param flags - Optional flags for the RegExp constructor, defaults to \"g\".\n *\n * @class\n * @example\n * ```typescript\n * import { RegexpOutputWriter } from '@decaf-ts/utils';\n * import { PromiseExecutor } from '@decaf-ts/utils';\n * \n * // Create a promise executor\n * const executor: PromiseExecutor<string, Error> = {\n *   resolve: (value) => console.log(`Resolved: ${value}`),\n *   reject: (error) => console.error(`Rejected: ${error.message}`)\n * };\n * \n * // Create a regexp output writer that matches version numbers\n * const writer = new RegexpOutputWriter('node --version', executor, /v(\\d+\\.\\d+\\.\\d+)/);\n * \n * // Use the writer to handle command output\n * writer.data('v14.17.0');  // This will automatically resolve with \"v14.17.0\"\n * ```\n *\n * @mermaid\n * sequenceDiagram\n *   participant Client\n *   participant RegexpOutputWriter\n *   participant StandardOutputWriter\n *   participant Logger\n *   \n *   Client->>RegexpOutputWriter: new RegexpOutputWriter(cmd, lock, regexp, flags)\n *   RegexpOutputWriter->>StandardOutputWriter: super(cmd, lock)\n *   StandardOutputWriter->>Logger: Logging.for(cmd)\n *   RegexpOutputWriter->>RegexpOutputWriter: compile regexp\n *   \n *   Client->>RegexpOutputWriter: data(chunk)\n *   RegexpOutputWriter->>StandardOutputWriter: super.data(chunk)\n *   StandardOutputWriter->>Logger: logger.info(log)\n *   RegexpOutputWriter->>RegexpOutputWriter: testAndResolve(chunk)\n *   RegexpOutputWriter->>RegexpOutputWriter: test(chunk)\n *   alt match found\n *     RegexpOutputWriter->>RegexpOutputWriter: resolve(match[0])\n *     RegexpOutputWriter->>StandardOutputWriter: resolve(match[0])\n *   end\n *   \n *   Client->>RegexpOutputWriter: error(chunk)\n *   RegexpOutputWriter->>StandardOutputWriter: super.error(chunk)\n *   StandardOutputWriter->>Logger: logger.info(log)\n *   RegexpOutputWriter->>RegexpOutputWriter: testAndReject(chunk)\n *   RegexpOutputWriter->>RegexpOutputWriter: test(chunk)\n *   alt match found\n *     RegexpOutputWriter->>RegexpOutputWriter: reject(match[0])\n *     RegexpOutputWriter->>StandardOutputWriter: reject(match[0])\n *   end\n */\nexport class RegexpOutputWriter extends StandardOutputWriter<string> {\n  /**\n   * @description The regular expression used for matching output.\n   * @summary This readonly property stores the compiled RegExp used for pattern matching.\n   */\n  protected readonly regexp: RegExp;\n\n  constructor(\n    cmd: string,\n    lock: PromiseExecutor<string, Error>,\n    regexp: string | RegExp,\n    flags = \"g\"\n  ) {\n    super(cmd, lock);\n    try {\n      this.regexp =\n        typeof regexp === \"string\" ? new RegExp(regexp, flags) : regexp;\n    } catch (e: unknown) {\n      throw new Error(`Invalid regular expression: ${e}`);\n    }\n  }\n\n  /**\n   * @description Tests the input data against the stored regular expression.\n   * @summary Executes the regular expression on the input data and returns the match result.\n   *\n   * @param data - The string to test against the regular expression.\n   * @return The result of the regular expression execution, or undefined if an error occurs.\n   */\n  private test(data: string) {\n    this.regexp.lastIndex = 0;\n    let match;\n    try {\n      match = this.regexp.exec(data);\n    } catch (e: unknown) {\n      return console.debug(`Failed to parse chunk: ${data}\\nError: ${e} `);\n    }\n    return match;\n  }\n\n  /**\n   * @description Tests the data and resolves the promise if a match is found.\n   * @summary Executes the test method and resolves the promise with the first match group if successful.\n   *\n   * @param data - The string to test against the regular expression.\n   */\n  protected testAndResolve(data: string) {\n    const match = this.test(data);\n    if (match) this.resolve(match[0]);\n  }\n\n  /**\n   * @description Tests the data and rejects the promise if a match is found.\n   * @summary Executes the test method and rejects the promise with the first match group if successful.\n   *\n   * @param data - The string to test against the regular expression.\n   */\n  protected testAndReject(data: string) {\n    const match = this.test(data);\n    if (match) this.reject(match[0]);\n  }\n\n  /**\n   * @description Processes incoming data chunks.\n   * @summary Calls the parent class data method and then tests the data for a match to potentially resolve the promise.\n   *\n   * @param chunk - The data chunk to process.\n   */\n  override data(chunk: any) {\n    super.data(chunk);\n    this.testAndResolve(String(chunk));\n  }\n\n  /**\n   * @description Processes incoming error chunks.\n   * @summary Calls the parent class error method and then tests the data for a match to potentially reject the promise.\n   *\n   * @param chunk - The error chunk to process.\n   */\n  override error(chunk: any) {\n    super.error(chunk);\n    this.testAndReject(String(chunk));\n  }\n}\n"]}

package/lib/writers/RegexpOutputWriter.d.ts

@@ -8,11 +8,61 @@ import { PromiseExecutor } from "../utils/types";
  *
  * @template T - The type of the resolved value, defaulting to string.
  *
+ * @param cmd - The command string to be executed.
  * @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.
+ * @param flags - Optional flags for the RegExp constructor, defaults to "g".
  *
  * @class
+ * @example
+ * ```typescript
+ * import { RegexpOutputWriter } from '@decaf-ts/utils';
+ * import { PromiseExecutor } from '@decaf-ts/utils';
+ *
+ * // Create a promise executor
+ * const executor: PromiseExecutor<string, Error> = {
+ *   resolve: (value) => console.log(`Resolved: ${value}`),
+ *   reject: (error) => console.error(`Rejected: ${error.message}`)
+ * };
+ *
+ * // Create a regexp output writer that matches version numbers
+ * const writer = new RegexpOutputWriter('node --version', executor, /v(\d+\.\d+\.\d+)/);
+ *
+ * // Use the writer to handle command output
+ * writer.data('v14.17.0');  // This will automatically resolve with "v14.17.0"
+ * ```
+ *
+ * @mermaid
+ * sequenceDiagram
+ *   participant Client
+ *   participant RegexpOutputWriter
+ *   participant StandardOutputWriter
+ *   participant Logger
+ *
+ *   Client->>RegexpOutputWriter: new RegexpOutputWriter(cmd, lock, regexp, flags)
+ *   RegexpOutputWriter->>StandardOutputWriter: super(cmd, lock)
+ *   StandardOutputWriter->>Logger: Logging.for(cmd)
+ *   RegexpOutputWriter->>RegexpOutputWriter: compile regexp
+ *
+ *   Client->>RegexpOutputWriter: data(chunk)
+ *   RegexpOutputWriter->>StandardOutputWriter: super.data(chunk)
+ *   StandardOutputWriter->>Logger: logger.info(log)
+ *   RegexpOutputWriter->>RegexpOutputWriter: testAndResolve(chunk)
+ *   RegexpOutputWriter->>RegexpOutputWriter: test(chunk)
+ *   alt match found
+ *     RegexpOutputWriter->>RegexpOutputWriter: resolve(match[0])
+ *     RegexpOutputWriter->>StandardOutputWriter: resolve(match[0])
+ *   end
+ *
+ *   Client->>RegexpOutputWriter: error(chunk)
+ *   RegexpOutputWriter->>StandardOutputWriter: super.error(chunk)
+ *   StandardOutputWriter->>Logger: logger.info(log)
+ *   RegexpOutputWriter->>RegexpOutputWriter: testAndReject(chunk)
+ *   RegexpOutputWriter->>RegexpOutputWriter: test(chunk)
+ *   alt match found
+ *     RegexpOutputWriter->>RegexpOutputWriter: reject(match[0])
+ *     RegexpOutputWriter->>StandardOutputWriter: reject(match[0])
+ *   end
  */
 export declare class RegexpOutputWriter extends StandardOutputWriter<string> {
     /**
@@ -20,15 +70,6 @@ export declare class RegexpOutputWriter extends StandardOutputWriter<string> {
      * @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.