@goodbyenjn/utils 26.4.0 → 26.4.2

package/dist/chunks/{chunk-704a1835.d.ts → chunk-bd9f56dd.d.ts}

@@ -159,6 +159,7 @@ declare class Result<T = unknown, E = unknown> {
 }
 declare const ok: typeof Result.ok;
 declare const err: typeof Result.err;
+declare const isResult: typeof Result.is;
 //#endregion
 //#region src/result/error.d.ts
 declare class ResultError extends Error {
@@ -171,4 +172,4 @@ declare class ResultError extends Error {
   toString(): string;
 }
 //#endregion
-export { err as a, ExtractOkTypes as c, ResultAll as d, Result as i, InferErrType as l, Err as n, ok as o, Ok as r, ExtractErrTypes as s, ResultError as t, InferOkType as u };
+export { err as a, ExtractErrTypes as c, InferOkType as d, ResultAll as f, Result as i, ExtractOkTypes as l, Err as n, isResult as o, Ok as r, ok as s, ResultError as t, InferErrType as u };

package/dist/common.d.ts

@@ -1,187 +1,2 @@
-import { i as Result } from "./chunks/chunk-704a1835.js";
-import { l as Fn, p as TemplateFn, s as AsyncFn } from "./chunks/chunk-3c6f28c7.js";
-
-//#region src/common/error.d.ts
-declare const normalizeError: (error: unknown, caller?: Function) => Error;
-declare const getErrorMessage: (error: unknown, message?: string) => string;
-//#endregion
-//#region node_modules/.pnpm/safe-stable-stringify@2.5.0/node_modules/safe-stable-stringify/index.d.ts
-type Replacer = (number | string)[] | null | undefined | ((key: string, value: unknown) => string | number | boolean | null | object);
-declare function stringify$1(value: undefined | symbol | ((...args: unknown[]) => unknown), replacer?: Replacer, space?: string | number): undefined;
-declare function stringify$1(value: string | number | unknown[] | null | boolean | object, replacer?: Replacer, space?: string | number): string;
-declare function stringify$1(value: unknown, replacer?: ((key: string, value: unknown) => unknown) | (number | string)[] | null | undefined, space?: string | number): string | undefined;
-interface StringifyOptions {
-  bigint?: boolean;
-  circularValue?: string | null | TypeErrorConstructor | ErrorConstructor;
-  deterministic?: boolean | ((a: string, b: string) => number);
-  maximumBreadth?: number;
-  maximumDepth?: number;
-  strict?: boolean;
-}
-declare namespace stringify$1 {
-  export function configure(options: StringifyOptions): typeof stringify$1;
-}
-//#endregion
-//#region src/common/json.d.ts
-type Stringify = typeof stringify$1;
-declare const stringify: Stringify;
-declare const safeParse: <T = any>(text: string, reviver?: (this: any, key: string, value: any) => any) => Result<T, Error>;
-declare const unsafeParse: <T = any>(text: string, reviver?: (this: any, key: string, value: any) => any) => T | undefined;
-//#endregion
-//#region src/common/math.d.ts
-/**
- * @example
- * ```
- * const value = linear(0.5, [0, 2]) // value: 1
- * ```
- */
-declare const linear: (value: number, range: [min: number, max: number]) => number;
-/**
- * @example
- * ```
- * const value = scale(0.5, [0, 1], [200, 400]) // value: 300
- * ```
- */
-declare const scale: (value: number, inRange: [min: number, max: number], outRange: [min: number, max: number]) => number;
-//#endregion
-//#region src/common/parse.d.ts
-declare const parseKeyValuePairs: (input: string) => Record<string, string>;
-declare const parseValueToBoolean: <T>(value: unknown, defaultValue: T | boolean) => T | boolean;
-//#endregion
-//#region src/common/promise.d.ts
-interface Singleton<T> {
-  (): Promise<T>;
-  reset: () => Promise<void>;
-}
-interface Lock {
-  run: <T = void>(fn: AsyncFn<T>) => Promise<T>;
-  wait: () => Promise<void>;
-  isWaiting: () => boolean;
-  clear: () => void;
-}
-interface PromiseWithResolvers<T> {
-  promise: Promise<T>;
-  resolve: (value: T | PromiseLike<T>) => void;
-  reject: (reason?: any) => void;
-}
-declare const sleep: (ms: number, callback?: Fn) => Promise<void>;
-declare const createSingleton: <T>(fn: AsyncFn<T>) => Singleton<T>;
-/**
- * @example
- * ```
- * const lock = createLock()
- *
- * lock.run(async () => {
- *   await doSomething()
- * })
- *
- * // in anther context:
- * await lock.wait() // it will wait all tasking finished
- * ```
- */
-declare const createLock: () => Lock;
-declare const createPromiseWithResolvers: <T>() => PromiseWithResolvers<T>;
-//#endregion
-//#region src/common/string.d.ts
-declare const addPrefix: (prefix: string, str: string) => string;
-declare const addSuffix: (suffix: string, str: string) => string;
-declare const removePrefix: (prefix: string, str: string) => string;
-declare const removeSuffix: (suffix: string, str: string) => string;
-declare const join: (separator: string, ...paths: string[]) => string;
-declare const split: (separator: string, path: string) => string[];
-declare const toForwardSlash: (str: string) => string;
-declare const joinWithSlash: (...paths: string[]) => string;
-declare const splitWithSlash: (path: string) => string[];
-declare const splitByLineBreak: (str: string) => string[];
-declare const concatTemplateStrings: (template: TemplateStringsArray, values: any[]) => string;
-/**
- * @example
- * ```ts
- * // Default behavior: trim both start and end
- * const str1 = unindent`
- *   if (a) {
- *     b()
- *   }
- * `;
- *
- * // Factory function: custom trim behavior
- * const str2 = unindent(false, false)`
- *   if (a) {
- *     b()
- *   }
- * `;
- *
- * // Only trim start, keep end
- * const str3 = unindent(true, false)("  hello\n  world\n");
- * ```
- */
-declare function unindent(str: string): string;
-declare function unindent(template: TemplateStringsArray, ...values: any[]): string;
-declare function unindent(trimStart?: boolean, trimEnd?: boolean): TemplateFn<string> & ((str: string) => string);
-/**
- * @example
- * ```ts
- * // Using indent count with default space character
- * const str1 = indent(2)`
- *   if (a) {
- *     b()
- *   }
- * `;
- *
- * // Using custom indent string directly
- * const str2 = indent(">>")`
- *   if (a) {
- *     b()
- *   }
- * `;
- *
- * // Only trim start, keep end
- * const str3 = indent(2, true, false)("hello\nworld\n");
- * ```
- */
-declare function indent(indentNumber: number, trimStart?: boolean, trimEnd?: boolean): TemplateFn<string> & ((str: string) => string);
-declare function indent(indentString: string, trimStart?: boolean, trimEnd?: boolean): TemplateFn<string> & ((str: string) => string);
-/**
- * @example
- * ```
- * const result = template(
- *   'Hello {0}! My name is {1}.',
- *   'World',
- *   'Alice'
- * ) // Hello World! My name is Alice.
- * ```
- *
- * ```
- * const result = template(
- *   '{greet}! My name is {name}.',
- *   { greet: 'Hello', name: 'Alice' }
- * ) // Hello! My name is Alice.
- * ```
- *
- * const result = template(
- *   '{greet}! My name is {name}.',
- *   { greet: 'Hello' }, // name isn't passed hence fallback will be used for name
- *   'placeholder'
- * ) // Hello! My name is placeholder.
- * ```
- */
-declare function template(str: string, mapping: Record<string | number, any>, fallback?: string | ((key: string) => string)): string;
-declare function template(str: string, ...args: (string | number | bigint | undefined | null)[]): string;
-//#endregion
-//#region src/common/throttle.d.ts
-interface WrappedFn<T extends Fn> {
-  (...args: Parameters<T>): void;
-  cancel: Fn<void>;
-}
-interface Options {
-  leading?: boolean;
-  trailing?: boolean;
-}
-type DebouncedFn<T extends Fn> = WrappedFn<T>;
-type ThrottledFn<T extends Fn> = WrappedFn<T>;
-type DebounceOptions = Options;
-type ThrottleOptions = Options;
-declare const debounce: <T extends Fn>(fn: T, wait?: number, options?: DebounceOptions) => DebouncedFn<T>;
-declare const throttle: <T extends Fn>(fn: T, wait?: number, options?: ThrottleOptions) => ThrottledFn<T>;
-//#endregion
-export { type DebounceOptions, type DebouncedFn, type Lock, type PromiseWithResolvers, type Singleton, type Stringify, type ThrottleOptions, type ThrottledFn, addPrefix, addSuffix, concatTemplateStrings, createLock, createPromiseWithResolvers, createSingleton, debounce, getErrorMessage, indent, join, joinWithSlash, linear, normalizeError, unsafeParse as parse, parseKeyValuePairs, parseValueToBoolean, removePrefix, removeSuffix, safeParse, scale, sleep, split, splitByLineBreak, splitWithSlash, stringify, template, throttle, toForwardSlash, unindent };
+import { A as Nil, C as Singleton, D as sleep, E as createSingleton, F as getErrorMessage, I as normalizeError, M as nil, N as linear, O as parseKeyValuePairs, P as scale, S as PromiseWithResolvers, T as createPromiseWithResolvers, _ as splitWithSlash, a as debounce, b as unindent, c as addSuffix, d as join, f as joinWithSlash, g as splitByLineBreak, h as split, i as ThrottledFn, j as isNil, k as parseValueToBoolean, l as concatTemplateStrings, m as removeSuffix, n as DebouncedFn, o as throttle, p as removePrefix, r as ThrottleOptions, s as addPrefix, t as DebounceOptions, u as indent, v as template, w as createLock, x as Lock, y as toForwardSlash } from "./chunks/chunk-71e0c144.js";
+export { DebounceOptions, DebouncedFn, Lock, Nil, PromiseWithResolvers, Singleton, ThrottleOptions, ThrottledFn, addPrefix, addSuffix, concatTemplateStrings, createLock, createPromiseWithResolvers, createSingleton, debounce, getErrorMessage, indent, isNil, join, joinWithSlash, linear, nil, normalizeError, parseKeyValuePairs, parseValueToBoolean, removePrefix, removeSuffix, scale, sleep, split, splitByLineBreak, splitWithSlash, template, throttle, toForwardSlash, unindent };

package/dist/common.js

@@ -1,3 +1,2 @@
-import { C as linear, D as safeParse, E as normalizeError, O as stringify, S as parseValueToBoolean, T as getErrorMessage, _ as createLock, a as concatTemplateStrings, b as sleep, c as joinWithSlash, d as split, f as splitByLineBreak, g as unindent, h as toForwardSlash, i as addSuffix, k as unsafeParse, l as removePrefix, m as template, n as throttle, o as indent, p as splitWithSlash, r as addPrefix, s as join, t as debounce, u as removeSuffix, v as createPromiseWithResolvers, w as scale, x as parseKeyValuePairs, y as createSingleton } from "./chunks/chunk-486f65b0.js";
-
-export { addPrefix, addSuffix, concatTemplateStrings, createLock, createPromiseWithResolvers, createSingleton, debounce, getErrorMessage, indent, join, joinWithSlash, linear, normalizeError, unsafeParse as parse, parseKeyValuePairs, parseValueToBoolean, removePrefix, removeSuffix, safeParse, scale, sleep, split, splitByLineBreak, splitWithSlash, stringify, template, throttle, toForwardSlash, unindent };
+import { C as isNil, D as getErrorMessage, E as scale, O as normalizeError, S as parseValueToBoolean, T as linear, _ as createLock, a as concatTemplateStrings, b as sleep, c as joinWithSlash, d as split, f as splitByLineBreak, g as unindent, h as toForwardSlash, i as addSuffix, l as removePrefix, m as template, n as throttle, o as indent, p as splitWithSlash, r as addPrefix, s as join, t as debounce, u as removeSuffix, v as createPromiseWithResolvers, w as nil, x as parseKeyValuePairs, y as createSingleton } from "./chunks/chunk-11b9216b.js";
+export { addPrefix, addSuffix, concatTemplateStrings, createLock, createPromiseWithResolvers, createSingleton, debounce, getErrorMessage, indent, isNil, join, joinWithSlash, linear, nil, normalizeError, parseKeyValuePairs, parseValueToBoolean, removePrefix, removeSuffix, scale, sleep, split, splitByLineBreak, splitWithSlash, template, throttle, toForwardSlash, unindent };

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 };