@goodbyenjn/utils 26.3.0 → 26.4.1

package/dist/exec.d.ts

@@ -0,0 +1,129 @@
+import { o as Nullable, p as TemplateFn, t as index_d_exports } from "./chunks/chunk-3c6f28c7.js";
+import { i as Result } from "./chunks/chunk-bd9f56dd.js";
+import { ChildProcess, SpawnOptions } from "node:child_process";
+import { Readable } from "node:stream";
+
+//#region src/exec/types.d.ts
+type KillSignal = Parameters<ChildProcess["kill"]>[0];
+interface Output {
+  stdout: string;
+  stderr: string;
+  exitCode: number | undefined;
+}
+interface BaseProcessOptions {
+  stdin: BaseProcessInstance | string;
+  signal: AbortSignal;
+  spawnOptions: SpawnOptions;
+  timeout: number;
+  persist: boolean;
+  throwOnError: boolean;
+}
+interface BaseProcessInstance extends PromiseLike<any>, AsyncIterable<any> {
+  get process(): ChildProcess | undefined;
+  get aborted(): boolean;
+  get killed(): boolean;
+  get pid(): number | undefined;
+  get exitCode(): number | undefined;
+  exec: (...params: any[]) => any;
+  pipe: (...params: any[]) => any;
+  kill: (signal?: KillSignal) => boolean;
+}
+type ExecParams = ExecSpawnParams | ExecCommandTemplateParams | ExecCommandStringParams | ExecFactoryParams;
+type BaseExec = BaseExecSpawn & BaseExecCommandTemplate & BaseExecCommandString & BaseExecFactory;
+type ExecSpawnParams = [command: string, args?: string[], options?: Partial<BaseProcessOptions>];
+type BaseExecSpawn = (...params: ExecSpawnParams) => unknown;
+type ExecCommandTemplateParams = Parameters<TemplateFn>;
+type BaseExecCommandTemplate = (...params: ExecCommandTemplateParams) => unknown;
+type ExecCommandStringParams = [command: string];
+type BaseExecCommandString = (...params: ExecCommandStringParams) => unknown;
+type ExecFactoryParams = [options: Partial<BaseProcessOptions>];
+type BaseExecFactory = (...params: ExecFactoryParams) => BaseExecCommandTemplate & BaseExecCommandString;
+//#endregion
+//#region src/exec/error.d.ts
+declare class NonZeroExitError extends Error {
+  static is(value: unknown): value is NonZeroExitError;
+  readonly result: BaseProcessInstance;
+  readonly output?: Output;
+  get exitCode(): number | undefined;
+  constructor(result: BaseProcessInstance, output?: Output);
+}
+//#endregion
+//#region src/exec/process.d.ts
+declare abstract class BaseProcess implements BaseProcessInstance {
+  protected static execImpl(self: BaseProcess, params: ExecParams): BaseExec;
+  protected _process: ChildProcess | undefined;
+  protected _aborted: boolean;
+  protected options: Partial<BaseProcessOptions>;
+  protected streamOut: Nullable<Readable>;
+  protected streamErr: Nullable<Readable>;
+  protected thrownError?: Error;
+  protected closeProcess: () => void;
+  protected processClosed: Promise<void>;
+  get process(): ChildProcess | undefined;
+  get aborted(): boolean;
+  get killed(): boolean;
+  get pid(): number | undefined;
+  get exitCode(): number | undefined;
+  constructor(options?: Partial<BaseProcessOptions>);
+  exec: any;
+  pipe: any;
+  kill(signal?: KillSignal): boolean;
+  then<TResult1 = any, TResult2 = never>(onfulfilled?: ((value: any) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
+  protected spawn(command: string, args: string[]): this;
+  protected cleanup(): Promise<void>;
+  abstract [Symbol.asyncIterator](): AsyncIterator<any>;
+  protected abstract thenImpl(): Promise<any>;
+  protected abstract construct(): BaseProcess;
+}
+//#endregion
+//#region src/exec/safe/types.d.ts
+type ProcessOptions$1 = BaseProcessOptions & ExtendProcessOptions$1;
+interface ExtendProcessOptions$1 {
+  stdin: ProcessInstance$1 | string;
+}
+type ProcessInstance$1 = BaseProcessInstance & ExtendProcessInstance$1;
+interface ExtendProcessInstance$1 extends PromiseLike<Result<Output, Error>>, AsyncIterable<Result<string, Error>> {
+  exec: Exec$1;
+  pipe: Exec$1;
+}
+type Exec$1 = index_d_exports.SetReturnType<BaseExecSpawn, ProcessInstance$1> & index_d_exports.SetReturnType<BaseExecCommandTemplate, ProcessInstance$1> & index_d_exports.SetReturnType<BaseExecCommandString, ProcessInstance$1> & index_d_exports.SetReturnType<BaseExecFactory, index_d_exports.SetReturnType<BaseExecCommandTemplate, ProcessInstance$1> & index_d_exports.SetReturnType<BaseExecCommandString, ProcessInstance$1>>;
+//#endregion
+//#region src/exec/safe/index.d.ts
+declare class Process$1 extends BaseProcess implements ProcessInstance$1 {
+  exec: Exec$1;
+  pipe: Exec$1;
+  protected options: Partial<ProcessOptions$1>;
+  constructor(options?: Partial<ProcessOptions$1>);
+  [Symbol.asyncIterator](): AsyncIterator<Result<string, Error>>;
+  protected thenImpl(): Promise<Result<Output, Error>>;
+  protected maybeThrow(output?: Output): Result<void, Error>;
+  protected construct(): Process$1;
+}
+declare const exec$1: Exec$1;
+//#endregion
+//#region src/exec/unsafe/types.d.ts
+type ProcessOptions = BaseProcessOptions & ExtendProcessOptions;
+interface ExtendProcessOptions {
+  stdin: ProcessInstance;
+}
+type ProcessInstance = BaseProcessInstance & ExtendProcessInstance;
+interface ExtendProcessInstance extends PromiseLike<Output>, AsyncIterable<string> {
+  exec: Exec;
+  pipe: Exec;
+}
+type Exec = index_d_exports.SetReturnType<BaseExecSpawn, ProcessInstance> & index_d_exports.SetReturnType<BaseExecCommandTemplate, ProcessInstance> & index_d_exports.SetReturnType<BaseExecCommandString, ProcessInstance> & index_d_exports.SetReturnType<BaseExecFactory, index_d_exports.SetReturnType<BaseExecCommandTemplate, ProcessInstance> & index_d_exports.SetReturnType<BaseExecCommandString, ProcessInstance>>;
+//#endregion
+//#region src/exec/unsafe/index.d.ts
+declare class Process extends BaseProcess implements ProcessInstance {
+  exec: Exec;
+  pipe: Exec;
+  protected options: Partial<ProcessOptions>;
+  constructor(options?: Partial<ProcessOptions>);
+  [Symbol.asyncIterator](): AsyncIterator<string>;
+  protected thenImpl(): Promise<Output>;
+  protected maybeThrow(output?: Output): void;
+  protected construct(): Process;
+}
+declare const exec: Exec;
+//#endregion
+export { type Exec, NonZeroExitError, type Output, Process, type ProcessInstance, type ProcessOptions, type Exec$1 as SafeExec, Process$1 as SafeProcess, type ProcessInstance$1 as SafeProcessInstance, type ProcessOptions$1 as SafeProcessOptions, exec, exec$1 as safeExec };