@goodbyenjn/utils 26.3.0 → 26.4.0

package/dist/chunks/chunk-d1860346.d.ts

@@ -1,154 +0,0 @@
-import { jn as NonEmptyTuple, ri as AsyncFn, si as SyncFn } from "./chunk-e931fe39.js";
-
-//#region src/result/error.d.ts
-declare class ResultError extends Error {
-  #private;
-  static isResultError(value: unknown): value is ResultError;
-  constructor(message: string | undefined, error: unknown, contexts: string[], caller?: Function);
-  get msg(): string;
-  get ctx(): string[];
-  toString(): string;
-}
-//#endregion
-//#region src/result/types.d.ts
-type ExtractOkTypes<T extends readonly Result[]> = { [K in keyof T]: T[K] extends Result<infer U, unknown> ? U : never };
-type ExtractErrTypes<T extends readonly Result[]> = { [K in keyof T]: T[K] extends Result<unknown, infer E> ? E : never };
-type InferOkType<R$1> = R$1 extends Result<infer T, unknown> ? T : never;
-type InferErrType<R$1> = R$1 extends Result<unknown, infer E> ? E : never;
-type ResultAll<T extends readonly Result[]> = IsLiteralArray<T> extends 1 ? Traverse<T> : Result<ExtractOkTypes<T>, ExtractErrTypes<T>[number]>;
-type Prev = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, ...0[]];
-type CollectResults<T, Collected extends unknown[] = [], Depth extends number = 50> = [Depth] extends [never] ? [] : T extends [infer H, ...infer Rest] ? H extends Result<infer L, infer R> ? CollectResults<Rest, [...Collected, [L, R]], Prev[Depth]> : never : Collected;
-type Transpose<A, Transposed extends unknown[][] = [], Depth extends number = 10> = A extends [infer T, ...infer Rest] ? T extends [infer L, infer R] ? Transposed extends [infer PL, infer PR] ? PL extends unknown[] ? PR extends unknown[] ? Transpose<Rest, [[...PL, L], [...PR, R]], Prev[Depth]> : never : never : Transpose<Rest, [[L], [R]], Prev[Depth]> : Transposed : Transposed;
-type Combine<T, Depth extends number = 5> = Transpose<CollectResults<T>, [], Depth> extends [infer L, infer R] ? [UnknownMembersToNever<L>, UnknownMembersToNever<R>] : Transpose<CollectResults<T>, [], Depth> extends [] ? [[], []] : never;
-type EmptyArrayToNever<T, NeverArrayToNever extends number = 0> = T extends [] ? never : NeverArrayToNever extends 1 ? T extends [never, ...infer Rest] ? [EmptyArrayToNever<Rest>] extends [never] ? never : T : T : T;
-type UnknownMembersToNever<T> = T extends [infer H, ...infer R] ? [[unknown] extends [H] ? never : H, ...UnknownMembersToNever<R>] : T;
-type MembersToUnion<T> = T extends unknown[] ? T[number] : never;
-type IsLiteralArray<T> = T extends {
-  length: infer L;
-} ? L extends number ? number extends L ? 0 : 1 : 0 : 0;
-type Traverse<T, Depth extends number = 5> = Combine<T, Depth> extends [infer Oks, infer Errs] ? Result<EmptyArrayToNever<Oks, 1>, MembersToUnion<Errs>> : never;
-//#endregion
-//#region src/result/result.d.ts
-type Ok<T = unknown> = Result<T, never>;
-type Err<E = unknown> = Result<never, E>;
-declare class Result<T = unknown, E = unknown> {
-  #private;
-  static ok(): Ok<void>;
-  static ok<T>(value: T): Ok<T>;
-  static err(): Err<void>;
-  static err<E>(error: E): Err<E>;
-  /**
-   * Creates a `Result` from a callable that may throw or return a promise that may reject
-   */
-  static fromCallable<T, E = unknown>(callable: SyncFn<T>): Result<T, E>;
-  static fromCallable<T>(callable: SyncFn<T>, onThrow: ErrorConstructor): Result<T, Error>;
-  static fromCallable<T, E>(callable: SyncFn<T>, onThrow: (error: unknown) => E): Result<T, E>;
-  static fromCallable<T, E = unknown>(callable: AsyncFn<T>): Promise<Result<Awaited<T>, E>>;
-  static fromCallable<T>(callable: AsyncFn<T>, onThrowOrReject: ErrorConstructor): Promise<Result<Awaited<T>, Error>>;
-  static fromCallable<T, E>(callable: AsyncFn<T>, onThrowOrReject: (error: unknown) => E): Promise<Result<Awaited<T>, E>>;
-  /**
-   * Creates a safe callable that always returns a `Result`, catching any thrown errors or rejected promises
-   */
-  static toSafeCallable<A extends any[], T, E = unknown>(callable: SyncFn<T, A>): SyncFn<Result<T, E>, A>;
-  static toSafeCallable<A extends any[], T>(callable: SyncFn<T, A>, onThrow: ErrorConstructor): SyncFn<Result<T, Error>, A>;
-  static toSafeCallable<A extends any[], T, E>(callable: SyncFn<T, A>, onThrow: (error: unknown) => E): SyncFn<Result<T, E>, A>;
-  static toSafeCallable<A extends any[], T, E = unknown>(callable: AsyncFn<T, A>): AsyncFn<Result<Awaited<T>, E>, A>;
-  static toSafeCallable<A extends any[], T>(callable: AsyncFn<T, A>, onThrowOrReject: ErrorConstructor): AsyncFn<Result<Awaited<T>, Error>, A>;
-  static toSafeCallable<A extends any[], T, E>(callable: AsyncFn<T, A>, onThrowOrReject: (error: unknown) => E): AsyncFn<Result<Awaited<T>, E>, A>;
-  /**
-   * Combines multiple `Result` instances into one `Result` containing an array of all `Ok` values,
-   * or the first `Err` encountered
-   */
-  static all<T extends NonEmptyTuple<Result>>(results: T): ResultAll<T>;
-  static all<T extends readonly Result[]>(results: T): ResultAll<T>;
-  private constructor();
-  /**
-   * Check if `Result` is `OK`
-   */
-  isOk(): this is Ok<T>;
-  /**
-   * Check if `Result` is `OK` and the value matches the predicate
-   */
-  isOkAnd(predicate: (value: T) => boolean): this is Ok<T>;
-  /**
-   * Check if `Result` is `Err`
-   */
-  isErr(): this is Err<E>;
-  /**
-   * Check if `Result` is `Err` and the error matches the predicate
-   */
-  isErrAnd(predicate: (error: E) => boolean): this is Err<E>;
-  /**
-   * Maps `Result<T, E>` to `Result<U, E>`
-   */
-  map<U$1>(fn: (value: T) => U$1): Result<U$1, E>;
-  /**
-   * Maps `Result<T, E>` to `Result<T, F>`
-   */
-  mapErr<F>(fn: (error: E) => F): Result<T, F>;
-  /**
-   * Returns a new `Result` by combining the current `Result` with another `Result`
-   */
-  and<R$1 extends Result<unknown, E>>(result: R$1): Result<InferOkType<R$1>, E>;
-  and<U$1>(result: Result<U$1, E>): Result<U$1, E>;
-  /**
-   * Maps `Result<T, E>` to `Result<U, E | F>` with a function that returns a `Result`
-   */
-  andThen<R$1 extends Result>(fn: (value: T) => R$1): Result<InferOkType<R$1>, InferErrType<R$1> | E>;
-  andThen<U$1, F>(fn: (value: T) => Result<U$1, F>): Result<U$1, E | F>;
-  /**
-   * Returns a new `Result` by combining the current `Result` with another `Result`
-   */
-  or<R$1 extends Result<T, unknown>>(result: R$1): Result<T, InferErrType<R$1>>;
-  or<F>(result: Result<T, F>): Result<T, F>;
-  /**
-   * Maps `Result<T, E>` to `Result<T | U, F>` with a function that returns a `Result`
-   */
-  orElse<R$1 extends Result>(fn: (error: E) => R$1): Result<InferOkType<R$1> | T, InferErrType<R$1>>;
-  orElse<U$1, F>(fn: (error: E) => Result<U$1, F>): Result<T | U$1, F>;
-  /**
-   * Calls the function with the value if `Result` is `Ok` and returns the result unchanged
-   */
-  inspect(fn: (value: T) => unknown): Result<T, E>;
-  /**
-   * Calls the function with the error if `Result` is `Err` and returns the result unchanged
-   */
-  inspectErr(fn: (error: E) => unknown): Result<T, E>;
-  /**
-   * Unwrap the `Ok` value, or throw an error if `Result` is `Err`
-   */
-  unwrap(message?: string | null): T;
-  /**
-   * Unwrap the `Err` value, or throw an error if `Result` is `Ok`
-   */
-  unwrapErr(message?: string | null): E;
-  /**
-   * Unwrap the `Ok` value, or return the provided value if `Result` is `Err`
-   */
-  unwrapOr(defaultValue: T): T;
-  /**
-   * Unwrap the `Ok` value, or compute it from a function if `Result` is `Err`
-   */
-  unwrapOrElse(defaultValueGetter: (error: E) => T): T;
-  /**
-   * Matches the `Result` variant and executes the corresponding function
-   */
-  match<U$1, F = U$1>(ok: (value: T) => U$1, err: (error: E) => F): U$1 | F;
-  /**
-   * Returns an iterable object that yields the `Ok` value and `Err` value
-   */
-  iter(): [ok: boolean, error: E, value: T];
-  [Symbol.iterator](): Generator<Err<E>, T>;
-  context(context: string): this;
-  toString(): string;
-}
-declare const ok: typeof Result.ok;
-declare const err: typeof Result.err;
-//#endregion
-//#region src/result/helper.d.ts
-declare function safeTry<T, E, This>(body: (this: This) => Generator<Err<E>, Result<T, E>>, self?: This): Result<T, E>;
-declare function safeTry<YieldErr extends Err, GeneratorReturnResult extends Result, This>(body: (this: This) => Generator<YieldErr, GeneratorReturnResult>, self?: This): Result<InferOkType<GeneratorReturnResult>, InferErrType<YieldErr> | InferErrType<GeneratorReturnResult>>;
-declare function safeTry<T, E, This>(body: (this: This) => AsyncGenerator<Err<E>, Result<T, E>>, self?: This): Promise<Result<T, E>>;
-declare function safeTry<YieldErr extends Err, GeneratorReturnResult extends Result, This>(body: (this: This) => AsyncGenerator<YieldErr, GeneratorReturnResult>, self?: This): Promise<Result<InferOkType<GeneratorReturnResult>, InferErrType<YieldErr> | InferErrType<GeneratorReturnResult>>>;
-//#endregion
-export { err as a, ExtractOkTypes as c, ResultAll as d, ResultError as f, Result as i, InferErrType as l, Err as n, ok as o, Ok as r, ExtractErrTypes as s, safeTry as t, InferOkType as u };