@goodbyenjn/utils 1.3.1 → 26.1.0

package/dist/{libs/result-c7c586dd.d.ts → chunks/chunk-4b76d1c4.d.ts}

@@ -1,40 +1,21 @@
-import { AsyncFn, Fn, NonEmptyTuple, SyncFn } from "./types-92e74e19.js";
+import { jn as NonEmptyTuple, ri as AsyncFn, si as SyncFn } from "./chunk-a07ed28f.js";
 
-//#region src/result/types.d.ts
-
-/**
- * Presets for printing the `Err` result
- *
- * - "full" - Prints full details including context and stack trace.
- * - "standard" - Prints error message and context, but omits stack trace.
- * - "minimal" - Prints only the error message without context or stack trace.
- *
- * Default is "standard".
- */
-type PrintPresets = "full" | "standard" | "minimal";
-/**
- * Options for printing the `Err` result
- */
-interface PrintOptions {
-  /**
-   * The log level to use. Default is "error".
-   */
-  level?: "error" | "warn" | "info";
-  /**
-   * Whether to include the context messages. Default is `true`.
-   */
-  context?: boolean;
-  /**
-   * Whether to include the stack trace. Default is `false`.
-   */
-  stack?: boolean;
+//#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> = R extends Result<infer T, unknown> ? T : never;
-type InferErrType<R> = R 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 ResultAllSettled<T extends readonly Result[]> = IsLiteralArray<T> extends 1 ? TraverseWithAllErrors<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;
@@ -46,28 +27,41 @@ 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;
-type TraverseWithAllErrors<T, Depth extends number = 5> = Traverse<T, Depth> extends Result<infer Oks, infer Errs> ? Result<Oks, Errs[]> : never;
 //#endregion
 //#region src/result/result.d.ts
-declare abstract class Result<T = unknown, E = unknown> {
+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>;
-  static try<T, E = unknown>(fn: SyncFn<T>): Result<T, E>;
-  static try<T, E>(fn: SyncFn<T>, onThrow: (error: unknown) => E): Result<T, E>;
-  static try<T, E = unknown>(fn: AsyncFn<T>): Promise<Result<Awaited<T>, E>>;
-  static try<T, E>(fn: AsyncFn<T>, onThrowOrReject: (error: unknown) => E): Promise<Result<Awaited<T>, E>>;
-  static try<T, E = unknown>(data: Promise<T>): Promise<Result<Awaited<T>, E>>;
-  static try<T, E>(data: Promise<T>, onThrow: (error: unknown) => E): Promise<Result<Awaited<T>, E>>;
-  static try<T, E = unknown>(data: T): Result<T, E>;
-  static try<T, E>(data: T, onThrow: (error: unknown) => E): Result<T, 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>;
-  static allSettled<T extends NonEmptyTuple<Result>>(results: T): ResultAllSettled<T>;
-  static allSettled<T extends readonly Result[]>(results: T): ResultAllSettled<T>;
-  protected readonly ctxs: (string | Fn<string>)[];
-  abstract readonly ok: boolean;
+  private constructor();
   /**
    * Check if `Result` is `OK`
    */
@@ -87,7 +81,7 @@ declare abstract class Result<T = unknown, E = unknown> {
   /**
    * Maps `Result<T, E>` to `Result<U, E>`
    */
-  map<U>(fn: (value: T) => U): Result<U, E>;
+  map<U$1>(fn: (value: T) => U$1): Result<U$1, E>;
   /**
    * Maps `Result<T, E>` to `Result<T, F>`
    */
@@ -95,23 +89,23 @@ declare abstract class Result<T = unknown, E = unknown> {
   /**
    * Returns a new `Result` by combining the current `Result` with another `Result`
    */
-  and<R extends Result<unknown, E>>(result: R): Result<InferOkType<R>, E>;
-  and<U>(result: Result<U, E>): Result<U, E>;
+  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 extends Result>(fn: (value: T) => R): Result<InferOkType<R>, InferErrType<R> | E>;
-  andThen<U, F>(fn: (value: T) => Result<U, F>): Result<U, E | F>;
+  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 extends Result<T, unknown>>(result: R): Result<T, InferErrType<R>>;
+  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 extends Result>(fn: (error: E) => R): Result<InferOkType<R> | T, InferErrType<R>>;
-  orElse<U, F>(fn: (error: E) => Result<U, F>): Result<T | U, F>;
+  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
    */
@@ -120,50 +114,41 @@ declare abstract class Result<T = unknown, E = unknown> {
    * 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<U>(defaultValue: U): T | U;
+  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, F = U>(ok: (value: T) => U, err: (error: E) => F): U | F;
+  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;
-  withContext(fn: Fn<string>): this;
-  abstract get value(): T;
-  abstract get error(): E;
-}
-declare class Ok<T = unknown> extends Result<T, never> {
-  readonly ok = true;
-  private readonly _value;
-  constructor(value: T);
-  get value(): T;
-  get error(): never;
-}
-declare class Err<E = unknown> extends Result<never, E> {
-  readonly ok = false;
-  private readonly _error;
-  private stack;
-  constructor(error: E);
-  get value(): never;
-  get error(): E;
-  print(): void;
-  print(preset: PrintPresets): void;
-  print(options: PrintOptions): void;
-  private format;
+  toString(): string;
 }
 declare const ok: typeof Result.ok;
 declare const err: typeof Result.err;
 //#endregion
-//#region src/result/utils.d.ts
-declare function safeTry<T, E>(body: () => Generator<Err<E>, Result<T, E>>): Result<T, E>;
-declare function safeTry<YieldErr extends Err, GeneratorReturnResult extends Result>(body: () => Generator<YieldErr, GeneratorReturnResult>): Result<InferOkType<GeneratorReturnResult>, InferErrType<YieldErr> | InferErrType<GeneratorReturnResult>>;
-declare function safeTry<T, E>(body: () => AsyncGenerator<Err<E>, Result<T, E>>): Promise<Result<T, E>>;
-declare function safeTry<YieldErr extends Err, GeneratorReturnResult extends Result>(body: () => AsyncGenerator<YieldErr, GeneratorReturnResult>): Promise<Result<InferOkType<GeneratorReturnResult>, InferErrType<YieldErr> | InferErrType<GeneratorReturnResult>>>;
+//#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, Ok, Result, err, ok, safeTry };
+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 };