resultar 2.0.0 → 3.0.0-alpha.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (11) hide show
  1. package/README.md +437 -606
  2. package/dist/index.d.ts +622 -3
  3. package/dist/index.js +1007 -10
  4. package/dist/index.js.map +1 -1
  5. package/package.json +30 -60
  6. package/dist/no-discard.d.ts +0 -18
  7. package/dist/no-discard.js +0 -124
  8. package/dist/no-discard.js.map +0 -1
  9. package/dist/result-async-CdlVdXgX.js +0 -698
  10. package/dist/result-async-CdlVdXgX.js.map +0 -1
  11. package/dist/result-async-CxGBicja.d.ts +0 -439
package/dist/result-async-CdlVdXgX.js.map DELETED
@@ -1 +0,0 @@
1
- {"version":3,"file":"result-async-CdlVdXgX.js","names":[],"sources":["../src/error.ts","../src/utils.ts","../src/tagged-match.ts","../src/result.ts","../src/result-async.ts"],"sourcesContent":["import type { Result } from './result.js'\n\nexport interface ErrorConfig {\n withStackTrace: boolean\n}\n\nconst defaultErrorConfig: ErrorConfig = { withStackTrace: false }\n\ninterface ResultarError<T, E> extends Error {\n data: { type: string; value: T | undefined } | { type: string; value: E | undefined }\n}\n\nexport const createResultarError = <T, E>(\n message: string,\n result: Result<T, E>,\n config: ErrorConfig = defaultErrorConfig,\n): ResultarError<T, E> => {\n const data = result.isOk()\n ? { type: 'Ok', value: result.value }\n : { type: 'Err', value: result.error }\n\n const maybeStack = config.withStackTrace ? new Error().stack : undefined // eslint-disable-line unicorn/error-message\n\n const error = { name: 'ResultarError', data, message }\n\n return maybeStack === undefined ? error : Object.assign(error, { stack: maybeStack })\n}\n","import type { Result } from './result.js'\n\nimport { ResultAsync } from './result-async.js'\nimport { err, ok } from './result.js'\n\n// Given a list of Results, this extracts all the different `T` types from that list\nexport type ExtractOkTypes<T extends readonly Result<unknown, unknown>[]> = {\n [idx in keyof T]: T[idx] extends Result<infer U, unknown> ? U : never\n}\n\n// Given a list of ResultAsyncs, this extracts all the different `T` types from that list\nexport type ExtractOkAsyncTypes<T extends readonly ResultAsync<unknown, unknown>[]> = {\n [idx in keyof T]: T[idx] extends ResultAsync<infer U, unknown> ? U : never\n}\n\n// Given a list of Results, this extracts all the different `E` types from that list\nexport type ExtractErrTypes<T extends readonly Result<unknown, unknown>[]> = {\n [idx in keyof T]: T[idx] extends Result<unknown, infer E> ? E : never\n}\n\n// Given a list of ResultAsyncs, this extracts all the different `E` types from that list\nexport type ExtractErrAsyncTypes<T extends readonly ResultAsync<unknown, unknown>[]> = {\n [idx in keyof T]: T[idx] extends ResultAsync<unknown, infer E> ? E : never\n}\n\nexport type InferOkTypes<R> = R extends Result<infer T, unknown> ? T : never\nexport type InferErrTypes<R> = R extends Result<unknown, infer E> ? E : never\n\nexport type InferAsyncOkTypes<R> = R extends ResultAsync<infer T, unknown> ? T : never\nexport type InferAsyncErrTypes<R> = R extends ResultAsync<unknown, infer E> ? E : never\n\n/**\n * Short circuits on the FIRST Err value that we find\n */\nexport const combineResultList = <T, E>(\n resultList: readonly Result<T, E>[],\n): Result<readonly T[], E> => {\n const values: T[] = []\n\n for (const result of resultList) {\n if (result.isErr()) {\n return err(result.error)\n }\n\n values.push(result.value)\n }\n\n return ok(values)\n}\n\n/* This is the typesafe version of Promise.all\n *\n * Takes a list of ResultAsync<T, E> and success if all inner results are Ok values\n * or fails if one (or more) of the inner results are Err values\n */\nexport const combineResultAsyncList = <T, E>(\n asyncResultList: readonly ResultAsync<T, E>[],\n): ResultAsync<readonly T[], E> =>\n ResultAsync.fromSafePromise(Promise.all(asyncResultList)).andThen(\n combineResultList,\n ) as ResultAsync<T[], E>\n\n/**\n * Give a list of all the errors we find\n */\nexport const combineResultListWithAllErrors = <T, E>(\n resultList: readonly Result<T, E>[],\n): Result<readonly T[], E[]> => {\n let acc = ok([]) as Result<T[], E[]>\n\n for (const result of resultList) {\n if (result.isErr() && acc.isErr()) {\n acc.error.push(result.error)\n } else if (result.isErr() && acc.isOk()) {\n acc = err([result.error])\n } else if (result.isOk() && acc.isOk()) {\n acc.value.push(result.value)\n }\n // do nothing when result.isOk() && acc.isErr()\n }\n return acc\n}\n\nexport const combineResultAsyncListWithAllErrors = <T, E>(\n asyncResultList: readonly ResultAsync<T, E>[],\n): ResultAsync<readonly T[], E[]> =>\n ResultAsync.fromSafePromise(Promise.all(asyncResultList)).andThen(\n combineResultListWithAllErrors,\n ) as ResultAsync<T[], E[]>\n","export type TaggedValue = { readonly _tag: string }\n\nexport type TaggedHandlerCall<R> =\n | { readonly matched: false }\n | { readonly matched: true; readonly value: R }\n\nexport const isTaggedValue = (value: unknown): value is TaggedValue =>\n typeof value === 'object' && value !== null && '_tag' in value\n\nexport const hasTag = <Tag extends string>(\n value: unknown,\n tag: Tag,\n): value is { readonly _tag: Tag } => isTaggedValue(value) && value._tag === tag\n\nexport const callTaggedHandler = <R>(value: unknown, handlers: object): TaggedHandlerCall<R> => {\n if (!isTaggedValue(value)) {\n return { matched: false }\n }\n\n const handler = (handlers as Record<string, unknown>)[value._tag]\n\n if (handler === undefined) {\n return { matched: false }\n }\n\n return { matched: true, value: (handler as (error: unknown) => R)(value) }\n}\n\nexport const callErrorHandler = <E, R>(\n error: E,\n handlers: { readonly Error?: (error: E) => R },\n): TaggedHandlerCall<R> => {\n if (handlers.Error === undefined) {\n return { matched: false }\n }\n\n return { matched: true, value: handlers.Error(error) }\n}\n","import { type ErrorConfig, createResultarError } from './error.js'\nimport { ResultAsync, errAsync } from './result-async.js'\nimport {\n type ExtractErrTypes,\n type ExtractOkTypes,\n type InferErrTypes,\n type InferOkTypes,\n combineResultList,\n combineResultListWithAllErrors,\n} from './utils.js'\nimport { callErrorHandler, callTaggedHandler, hasTag } from './tagged-match.js'\n\ntype TaggedValue = { readonly _tag: string }\ntype TaggedErrorValue = Error & TaggedValue\ntype TagsOf<E> = Extract<E, TaggedValue>['_tag']\ntype ErrorTagsOf<E> = Extract<E, TaggedErrorValue>['_tag']\ntype ErrorForTag<E, Tag extends string> = Extract<E, { readonly _tag: Tag }>\ntype ExcludeTag<E, Tag extends string> = Exclude<E, { readonly _tag: Tag }>\ntype UntaggedError<E> = Exclude<Extract<E, Error>, TaggedErrorValue>\ntype CatchTagHandlerResult<Handlers> = {\n readonly [Key in keyof Handlers]: Handlers[Key] extends (...args: infer _Args) => infer R\n ? R\n : never\n}[keyof Handlers]\ntype MatchTagHandlerResult<Handlers> = {\n readonly [Key in keyof Handlers]: Handlers[Key] extends (...args: infer _Args) => infer R\n ? R\n : never\n}[keyof Handlers]\ntype CatchTagHandlers<E, Handlers> = {\n readonly [Tag in keyof Handlers]: Tag extends TagsOf<E>\n ? (error: ErrorForTag<E, Tag & string>) => Result<unknown, unknown>\n : never\n}\ntype MatchTagHandlers<E, Handlers> = {\n readonly [Tag in ErrorTagsOf<E>]: (error: ErrorForTag<E, Tag>) => unknown\n} & ([UntaggedError<E>] extends [never]\n ? { readonly Error?: (error: Error) => unknown }\n : { readonly Error: (error: UntaggedError<E>) => unknown }) & {\n readonly [Tag in keyof Handlers]: Tag extends ErrorTagsOf<E> | 'Error' ? Handlers[Tag] : never\n }\ntype PartialMatchTagHandlers<E, Handlers> = {\n readonly [Tag in keyof Handlers]: Tag extends ErrorTagsOf<E>\n ? (error: ErrorForTag<E, Tag & string>) => unknown\n : Tag extends 'Error'\n ? (error: Extract<E, Error>) => unknown\n : never\n}\ntype PipeFn<Input, Output> = (input: Input) => Output\ntype ResultFinalizer<T, E> = (value: T | undefined, error: E | undefined) => void\n\n/**\n * A Result interface that is used to define the methods that are available on a\n * `Result` object.\n *\n * The immutability of the `Result` object is maintained by the interface.\n */\ninterface Resultable<T, E> {\n get value(): T\n get error(): E\n\n /**\n * Used to check if a `Result` is an `OK`\n *\n * @returns `true` if the result is an `OK` variant of Result\n */\n isOk(): boolean\n\n /**\n * Used to check if a `Result` is an `Err`\n *\n * @returns `true` if the result is an `Err` variant of Result\n */\n isErr(): boolean\n /**\n * Unwrap the `Ok` value, or return the default if there is an `Err`\n *\n * @param v the default value to return if there is an `Err`\n */\n\n unwrapOr<A>(defaultValue: A): T | A\n\n // safeUnwrap(): Generator<Result<never, E>, T>\n\n /**\n * **This method is unsafe, and should only be used in a test environments**\n *\n * Takes a `Result<T, E>` and returns a `T` when the result is an `Ok`, otherwise it throws a custom object.\n *\n * @param config\n */\n _unsafeUnwrap(config?: ErrorConfig): T\n\n /**\n * **This method is unsafe, and should only be used in a test environments**\n *\n * takes a `Result<T, E>` and returns a `E` when the result is an `Err`,\n * otherwise it throws a custom object.\n *\n * @param config\n */\n _unsafeUnwrapErr(config?: ErrorConfig): E\n}\n\nexport interface ResultOperations<T, E> {\n isOk(): this is OkResult<T, E>\n isErr(): this is ErrResult<T, E>\n unwrapOr<A>(defaultValue: A): T | A\n _unsafeUnwrap(config?: ErrorConfig): T\n _unsafeUnwrapErr(config?: ErrorConfig): E\n map<X>(f: (t: T) => X): Result<X, E>\n filterOrElse<U extends T, F>(\n predicate: (value: T) => value is U,\n onFalse: (value: T) => F,\n ): Result<U, E | F>\n filterOrElse<F>(predicate: (value: T) => boolean, onFalse: (value: T) => F): Result<T, E | F>\n mapErr<X>(fn: (t: E) => X): Result<T, X>\n andThen<X, Y>(f: (t: T) => Result<X, Y>): Result<X, E | Y>\n if(fCondition: (t: T) => boolean): {\n true: <X1, Y1>(\n fTrue: (t: T) => Result<X1, Y1>,\n ) => { false: <X2, Y2>(fFalse: (t: T) => Result<X2, Y2>) => Result<X1 | X2, Y1 | Y2 | E> }\n }\n orElse<R extends Result<unknown, unknown>>(\n f: (e: E) => R,\n ): Result<InferOkTypes<R> | T, InferErrTypes<R>>\n catchTag<const Tag extends TagsOf<E>, R extends Result<unknown, unknown>>(\n tag: Tag,\n f: (error: ErrorForTag<E, Tag>) => R,\n ): Result<T | InferOkTypes<R>, ExcludeTag<E, Tag> | InferErrTypes<R>>\n catchTags<const Handlers extends object>(\n handlers: Handlers & CatchTagHandlers<E, Handlers>,\n ): Result<\n T | InferOkTypes<CatchTagHandlerResult<Handlers>>,\n ExcludeTag<E, keyof Handlers & string> | InferErrTypes<CatchTagHandlerResult<Handlers>>\n >\n asyncAndThen<X, Y>(f: (t: T) => ResultAsync<X, Y>): ResultAsync<X, E | Y>\n asyncMap<X>(f: (t: T) => Promise<X>): ResultAsync<X, E>\n match<A, B = A>(fnOk: (t: T) => A, fnErr: (e: E) => B): A | B\n matchTags<A, const Handlers extends object>(\n fnOk: (t: T) => A,\n handlers: Handlers & MatchTagHandlers<E, Handlers>,\n ): A | MatchTagHandlerResult<Handlers>\n matchTagsPartial<A, B, const Handlers extends object>(\n fnOk: (t: T) => A,\n handlers: Handlers & PartialMatchTagHandlers<E, Handlers>,\n fallback: (error: E) => B,\n ): A | MatchTagHandlerResult<Handlers> | B\n pipe<A>(ab: PipeFn<Result<T, E>, A>): A\n pipe<A, B>(ab: PipeFn<Result<T, E>, A>, bc: PipeFn<A, B>): B\n pipe<A, B, C>(ab: PipeFn<Result<T, E>, A>, bc: PipeFn<A, B>, cd: PipeFn<B, C>): C\n log(fn: (t?: T, e?: E) => void): this\n tap(fn: (t: T) => void): this\n tapError(fn: (e: E) => void): this\n toDisposable(f: ResultFinalizer<T, E>): DisposableResult<T, E>\n unwrapOrThrow(): T\n [Symbol.iterator](): Generator<Result<never, E>, T>\n safeUnwrap(): Generator<Result<never, E>, T>\n}\n\nexport interface OkResult<T, E> extends ResultOperations<T, E> {\n readonly value: T\n}\n\nexport interface ErrResult<T, E> extends ResultOperations<T, E> {\n readonly error: E\n}\n\nexport type Result<T, E> = OkResult<T, E> | ErrResult<T, E>\nexport type StrictResult<T, E extends Error = Error> = Result<T, E>\n\ninterface ResultStatic {\n [Symbol.hasInstance](value: unknown): boolean\n tryCatch<T, E>(\n this: void,\n fn: () => Exclude<T, Promise<unknown>>,\n errorFn?: (e: unknown) => E,\n ): Result<T, E>\n fromThrowable<Fn extends (...args: readonly any[]) => unknown, E>(\n this: void,\n fn: Fn,\n errorFn?: (e: any) => E,\n ): (...args: Parameters<Fn>) => Result<ReturnType<Fn>, E>\n ok<T, E = never>(this: void, value: T): OkResult<T, E>\n ok<E = never>(this: void, value: void): OkResult<void, E>\n unit<E = never>(this: void): Result<undefined, E>\n err<T = never, E extends string = string>(this: void, err: E): ErrResult<T, E>\n err<T = never, E = unknown>(this: void, err: E): ErrResult<T, E>\n err<T = never>(this: void, err: void): ErrResult<T, void>\n combine<T extends readonly [Result<unknown, unknown>, ...Result<unknown, unknown>[]]>(\n this: void,\n resultList: T,\n ): CombineResults<T>\n combine<T extends readonly Result<unknown, unknown>[]>(\n this: void,\n resultList: T,\n ): CombineResults<T>\n combineWithAllErrors<\n T extends readonly [Result<unknown, unknown>, ...Result<unknown, unknown>[]],\n >(\n this: void,\n resultList: T,\n ): CombineResultsWithAllErrorsArray<T>\n combineWithAllErrors<T extends readonly Result<unknown, unknown>[]>(\n this: void,\n resultList: T,\n ): CombineResultsWithAllErrorsArray<T>\n}\n\n/**\n * Runtime namespace for Result constructors and static helpers.\n */\n/* eslint-disable @typescript-eslint/no-extraneous-class, unicorn/no-static-only-class */\nclass ResultNamespace {\n static [Symbol.hasInstance](value: unknown): boolean {\n return value instanceof Ok || value instanceof Err\n }\n\n /**\n * Creates a `Result` by running a function that might throw.\n * If the function throws, the error will be caught and returned as an `Err`.\n * If the function succeeds, the value will be wrapped in an `Ok`.\n *\n * @param fn - The function to execute, which might throw an error\n * @param errorFn - Optional function to transform the thrown error before wrapping in `Err`\n * @returns A `Result` containing either the function's return value or the caught error\n */\n static tryCatch<T, E>(\n this: void,\n fn: () => Exclude<T, Promise<unknown>>,\n errorFn?: (e: unknown) => E,\n ): Result<T, E> {\n try {\n return ok(fn())\n } catch (error) {\n if (errorFn) {\n return err(errorFn(error))\n }\n return err(error as E)\n }\n }\n\n /**\n * Wraps a function with a try catch, creating a new function with the same\n * arguments but returning `Ok` if successful, `Err` if the function throws\n *\n * @param fn function to wrap with ok on success or err on failure\n * @param errorFn when an error is thrown, this will wrap the error result if provided\n */\n static fromThrowable<Fn extends (...args: readonly any[]) => unknown, E>(\n this: void,\n fn: Fn,\n errorFn?: (e: any) => E,\n ): (...args: Parameters<Fn>) => Result<ReturnType<Fn>, E> {\n return (...args) => {\n try {\n const result = fn(...args)\n return ok(result as ReturnType<Fn>)\n } catch (error) {\n if (errorFn) {\n return err(errorFn(error))\n }\n\n return err(error as E)\n }\n }\n }\n\n /**\n * Creates a new `Result` instance representing a successful operation.\n *\n * @param {T} value - The value to be wrapped in the `Result` instance.\n * @return {Result<T, E>} A new `Result` instance with the provided value.\n */\n\n static ok<T, E = never>(this: void, value: T): OkResult<T, E>\n static ok<E = never>(this: void, value: void): OkResult<void, E>\n static ok<T, E = never>(this: void, value: T): OkResult<T, E> {\n return ok<T, E>(value)\n }\n\n /**\n * Creates a new `Result` instance representing a successful operation with an undefined value.\n *\n * @return {Result<undefined, E>} A new `Result` instance with an undefined value.\n */\n static unit<E = never>(this: void): Result<undefined, E> {\n return unit<E>()\n }\n\n static err<T = never, E extends string = string>(this: void, err: E): ErrResult<T, E>\n static err<T = never, E = unknown>(this: void, err: E): ErrResult<T, E>\n static err<T = never>(this: void, err: void): ErrResult<T, void>\n static err<T = never, E = unknown>(this: void, error: E): ErrResult<T, E> {\n return err<T, E>(error)\n }\n\n static combine<T extends readonly [Result<unknown, unknown>, ...Result<unknown, unknown>[]]>(\n this: void,\n resultList: T,\n ): CombineResults<T>\n static combine<T extends readonly Result<unknown, unknown>[]>(\n this: void,\n resultList: T,\n ): CombineResults<T>\n static combine<T extends readonly [Result<unknown, unknown>, ...Result<unknown, unknown>[]]>(\n this: void,\n resultList: T,\n ): CombineResults<T> {\n return combineResultList(resultList) as CombineResults<T>\n }\n\n static combineWithAllErrors<\n T extends readonly [Result<unknown, unknown>, ...Result<unknown, unknown>[]],\n >(this: void, resultList: T): CombineResultsWithAllErrorsArray<T>\n static combineWithAllErrors<T extends readonly Result<unknown, unknown>[]>(\n this: void,\n resultList: T,\n ): CombineResultsWithAllErrorsArray<T>\n static combineWithAllErrors<T extends readonly Result<unknown, unknown>[]>(\n this: void,\n resultList: T,\n ): CombineResultsWithAllErrorsArray<T> {\n return combineResultListWithAllErrors(resultList) as CombineResultsWithAllErrorsArray<T>\n }\n}\n\nexport const Result: ResultStatic = ResultNamespace\n\nclass Ok<T, E> {\n readonly value: T\n\n constructor(value: T) {\n this.value = value\n }\n\n isOk(): this is OkResult<T, E> {\n void this\n return true\n }\n\n isErr(): this is ErrResult<T, E> {\n void this\n return false\n }\n\n map<X>(f: (t: T) => X): Result<X, E> {\n return ok<X, E>(f(this.value))\n }\n\n filterOrElse<U extends T, F>(\n predicate: (value: T) => value is U,\n onFalse: (value: T) => F,\n ): Result<U, E | F>\n filterOrElse<F>(predicate: (value: T) => boolean, onFalse: (value: T) => F): Result<T, E | F>\n filterOrElse<F>(predicate: (value: T) => boolean, onFalse: (value: T) => F): Result<T, E | F> {\n if (predicate(this.value)) {\n return ok<T, E | F>(this.value)\n }\n\n return err<T, E | F>(onFalse(this.value))\n }\n\n mapErr<X>(_fn: (t: E) => X): Result<T, X> {\n return ok<T, X>(this.value)\n }\n\n andThen<X, Y>(f: (t: T) => Result<X, Y>): Result<X, E | Y> {\n return f(this.value)\n }\n\n if(fCondition: (t: T) => boolean): {\n true: <X1, Y1>(\n fTrue: (t: T) => Result<X1, Y1>,\n ) => { false: <X2, Y2>(fFalse: (t: T) => Result<X2, Y2>) => Result<X1 | X2, Y1 | Y2 | E> }\n } {\n return {\n true: <X1, Y1>(fTrue: (t: T) => Result<X1, Y1>) => ({\n false: <X2, Y2>(fFalse: (t: T) => Result<X2, Y2>): Result<X1 | X2, Y1 | Y2 | E> =>\n fCondition(this.value) ? fTrue(this.value) : fFalse(this.value),\n }),\n }\n }\n\n orElse<R extends Result<unknown, unknown>>(\n f: (e: E) => R,\n ): Result<InferOkTypes<R> | T, InferErrTypes<R>>\n orElse<U, A>(f: (e: E) => Result<U, A>): Result<U | T, A>\n orElse<U, A>(_f: (e: E) => Result<U, A>): Result<U | T, A> {\n return ok<U | T, A>(this.value as Exclude<T, Promise<any>>)\n }\n\n catchTag<const Tag extends TagsOf<E>, R extends Result<unknown, unknown>>(\n _tag: Tag,\n _f: (error: ErrorForTag<E, Tag>) => R,\n ): Result<T | InferOkTypes<R>, ExcludeTag<E, Tag> | InferErrTypes<R>> {\n return ok(this.value)\n }\n\n catchTags<const Handlers extends object>(\n _handlers: Handlers & CatchTagHandlers<E, Handlers>,\n ): Result<\n T | InferOkTypes<CatchTagHandlerResult<Handlers>>,\n ExcludeTag<E, keyof Handlers & string> | InferErrTypes<CatchTagHandlerResult<Handlers>>\n > {\n return ok(this.value)\n }\n\n asyncAndThen<X, Y>(f: (t: T) => ResultAsync<X, Y>): ResultAsync<X, E | Y>\n asyncAndThen<X, Y>(f: (t: T) => ResultAsync<X, E>): ResultAsync<X, E | Y> {\n return f(this.value)\n }\n\n asyncMap<X>(f: (t: T) => Promise<X>): ResultAsync<X, E> {\n return ResultAsync.fromSafePromise(f(this.value))\n }\n\n unwrapOr<A>(_defaultValue: A): T | A {\n return this.value\n }\n\n match<A, B = A>(fnOk: (t: T) => A, _fnErr: (e: E) => B): A | B {\n return fnOk(this.value)\n }\n\n matchTags<A, const Handlers extends object>(\n fnOk: (t: T) => A,\n _handlers: Handlers & MatchTagHandlers<E, Handlers>,\n ): A | MatchTagHandlerResult<Handlers> {\n return fnOk(this.value)\n }\n\n matchTagsPartial<A, B, const Handlers extends object>(\n fnOk: (t: T) => A,\n _handlers: Handlers & PartialMatchTagHandlers<E, Handlers>,\n _fallback: (error: E) => B,\n ): A | MatchTagHandlerResult<Handlers> | B {\n return fnOk(this.value)\n }\n\n pipe<A>(ab: PipeFn<this, A>): A\n pipe<A, B>(ab: PipeFn<this, A>, bc: PipeFn<A, B>): B\n pipe<A, B, C>(ab: PipeFn<this, A>, bc: PipeFn<A, B>, cd: PipeFn<B, C>): C\n pipe(...fns: readonly PipeFn<never, unknown>[]): unknown {\n const first = fns[0]\n\n if (!first) {\n return this\n }\n\n let input = first(this as never)\n\n for (const fn of fns.slice(1)) {\n input = (fn as PipeFn<unknown, unknown>)(input)\n }\n\n return input\n }\n\n log(fn: (t?: T, e?: E) => void): this {\n try {\n fn(this.value, undefined)\n } catch {\n /* empty */\n }\n\n return this\n }\n\n tap(fn: (t: T) => void): this {\n try {\n fn(this.value)\n } catch {\n /* empty */\n }\n\n return this\n }\n\n tapError(_fn: (e: E) => void): this {\n return this\n }\n\n toDisposable(f: ResultFinalizer<T, E>): DisposableResult<T, E> {\n return new DisposableResult(this, f)\n }\n\n unwrapOrThrow(): T {\n return this.value\n }\n\n _unsafeUnwrap(_config?: ErrorConfig): T {\n return this.value\n }\n\n _unsafeUnwrapErr(config?: ErrorConfig): E {\n throw createResultarError('Called `_unsafeUnwrapErr` on an Ok', this, config)\n }\n\n /* eslint-disable-next-line require-yield */\n *[Symbol.iterator](): Generator<Result<never, E>, T> {\n return this.value\n }\n\n safeUnwrap(): Generator<Result<never, E>, T> {\n const { value } = this\n /* eslint-disable-next-line require-yield */\n return (function* () {\n return value\n })()\n }\n}\n\nclass Err<T, E> {\n readonly error: E\n\n constructor(error: E) {\n this.error = error\n }\n\n isOk(): this is OkResult<T, E> {\n void this\n return false\n }\n\n isErr(): this is ErrResult<T, E> {\n void this\n return true\n }\n\n map<X>(_f: (t: T) => X): Result<X, E> {\n return err<X, E>(this.error)\n }\n\n filterOrElse<U extends T, F>(\n predicate: (value: T) => value is U,\n onFalse: (value: T) => F,\n ): Result<U, E | F>\n filterOrElse<F>(predicate: (value: T) => boolean, onFalse: (value: T) => F): Result<T, E | F>\n filterOrElse<F>(_predicate: (value: T) => boolean, _onFalse: (value: T) => F): Result<T, E | F> {\n return err<T, E | F>(this.error)\n }\n\n mapErr<X>(fn: (t: E) => X): Result<T, X> {\n return err<T, X>(fn(this.error))\n }\n\n andThen<X, Y>(_f: (t: T) => Result<X, Y>): Result<X, E | Y> {\n return err<X, E | Y>(this.error)\n }\n\n if(_fCondition: (t: T) => boolean): {\n true: <X1, Y1>(\n fTrue: (t: T) => Result<X1, Y1>,\n ) => { false: <X2, Y2>(fFalse: (t: T) => Result<X2, Y2>) => Result<X1 | X2, Y1 | Y2 | E> }\n } {\n return {\n true: <X1, Y1>(_fTrue: (t: T) => Result<X1, Y1>) => ({\n false: <X2, Y2>(_fFalse: (t: T) => Result<X2, Y2>): Result<X1 | X2, Y1 | Y2 | E> =>\n err<X1 | X2, Y1 | Y2 | E>(this.error),\n }),\n }\n }\n\n orElse<R extends Result<unknown, unknown>>(\n f: (e: E) => R,\n ): Result<InferOkTypes<R> | T, InferErrTypes<R>>\n orElse<U, A>(f: (e: E) => Result<U, A>): Result<U | T, A>\n orElse<U, A>(f: (e: E) => Result<U, A>): Result<U | T, A> {\n return f(this.error)\n }\n\n catchTag<const Tag extends TagsOf<E>, R extends Result<unknown, unknown>>(\n tag: Tag,\n f: (error: ErrorForTag<E, Tag>) => R,\n ): Result<T | InferOkTypes<R>, ExcludeTag<E, Tag> | InferErrTypes<R>> {\n if (hasTag(this.error, tag)) {\n return f(this.error as ErrorForTag<E, Tag>) as Result<\n T | InferOkTypes<R>,\n ExcludeTag<E, Tag> | InferErrTypes<R>\n >\n }\n\n return err(this.error as ExcludeTag<E, Tag>)\n }\n\n catchTags<const Handlers extends object>(\n handlers: Handlers & CatchTagHandlers<E, Handlers>,\n ): Result<\n T | InferOkTypes<CatchTagHandlerResult<Handlers>>,\n ExcludeTag<E, keyof Handlers & string> | InferErrTypes<CatchTagHandlerResult<Handlers>>\n > {\n const error = this.error\n const handled = callTaggedHandler<CatchTagHandlerResult<Handlers>>(error, handlers)\n\n if (handled.matched) {\n return handled.value as Result<\n T | InferOkTypes<CatchTagHandlerResult<Handlers>>,\n ExcludeTag<E, keyof Handlers & string> | InferErrTypes<CatchTagHandlerResult<Handlers>>\n >\n }\n\n return err(error as ExcludeTag<E, keyof Handlers & string>)\n }\n\n asyncAndThen<X, Y>(_f: (t: T) => ResultAsync<X, Y>): ResultAsync<X, E | Y>\n asyncAndThen<X, Y>(_f: (t: T) => ResultAsync<X, E>): ResultAsync<X, E | Y> {\n return errAsync(this.error)\n }\n\n asyncMap<X>(_f: (t: T) => Promise<X>): ResultAsync<X, E> {\n return errAsync(this.error)\n }\n\n unwrapOr<A>(defaultValue: A): T | A {\n void this\n return defaultValue\n }\n\n match<A, B = A>(_fnOk: (t: T) => A, fnErr: (e: E) => B): A | B {\n return fnErr(this.error)\n }\n\n matchTags<A, const Handlers extends object>(\n _fnOk: (t: T) => A,\n handlers: Handlers & MatchTagHandlers<E, Handlers>,\n ): A | MatchTagHandlerResult<Handlers> {\n const error = this.error\n const tagged = callTaggedHandler<MatchTagHandlerResult<Handlers>>(error, handlers)\n\n if (tagged.matched) {\n return tagged.value\n }\n\n const errorHandler = callErrorHandler(\n error,\n handlers as { readonly Error?: (error: E) => MatchTagHandlerResult<Handlers> },\n )\n\n if (errorHandler.matched) {\n return errorHandler.value\n }\n\n // eslint-disable-next-line @typescript-eslint/only-throw-error\n throw error\n }\n\n matchTagsPartial<A, B, const Handlers extends object>(\n _fnOk: (t: T) => A,\n handlers: Handlers & PartialMatchTagHandlers<E, Handlers>,\n fallback: (error: E) => B,\n ): A | MatchTagHandlerResult<Handlers> | B {\n const error = this.error\n const tagged = callTaggedHandler<MatchTagHandlerResult<Handlers>>(error, handlers)\n\n if (tagged.matched) {\n return tagged.value\n }\n\n const errorHandler = callErrorHandler(\n error,\n handlers as { readonly Error?: (error: E) => MatchTagHandlerResult<Handlers> },\n )\n\n if (errorHandler.matched) {\n return errorHandler.value\n }\n\n return fallback(error)\n }\n\n pipe<A>(ab: PipeFn<this, A>): A\n pipe<A, B>(ab: PipeFn<this, A>, bc: PipeFn<A, B>): B\n pipe<A, B, C>(ab: PipeFn<this, A>, bc: PipeFn<A, B>, cd: PipeFn<B, C>): C\n pipe(...fns: readonly PipeFn<never, unknown>[]): unknown {\n const first = fns[0]\n\n if (!first) {\n return this\n }\n\n let input = first(this as never)\n\n for (const fn of fns.slice(1)) {\n input = (fn as PipeFn<unknown, unknown>)(input)\n }\n\n return input\n }\n\n log(fn: (t?: T, e?: E) => void): this {\n try {\n fn(undefined, this.error)\n } catch {\n /* empty */\n }\n\n return this\n }\n\n tap(_fn: (t: T) => void): this {\n return this\n }\n\n tapError(fn: (e: E) => void): this {\n try {\n fn(this.error)\n } catch {\n /* empty */\n }\n\n return this\n }\n\n toDisposable(f: ResultFinalizer<T, E>): DisposableResult<T, E> {\n return new DisposableResult(this, f)\n }\n\n unwrapOrThrow(): T {\n // eslint-disable-next-line @typescript-eslint/only-throw-error\n throw this.error\n }\n\n _unsafeUnwrap(config?: ErrorConfig): T {\n throw createResultarError('Called `_unsafeUnwrap` on an Err', this, config)\n }\n\n _unsafeUnwrapErr(_config?: ErrorConfig): E {\n return this.error\n }\n\n *[Symbol.iterator](): Generator<Result<never, E>, T> {\n yield this as never\n return this as never\n }\n\n safeUnwrap(): Generator<Result<never, E>, T> {\n const { error } = this\n return (function* () {\n yield err(error)\n\n throw new Error('Do not use this generator out of `safeTry`')\n })()\n }\n}\n\n/**\n * A `Disposable` is an object that has a `dispose` method that can be used to\n * clean up resources.\n */\nexport class DisposableResult<T, E> implements Resultable<T, E>, Disposable {\n private disposed = false\n private readonly finalizer: (value: unknown, error: unknown) => void\n readonly result: Result<T, E>\n\n constructor(result: Result<T, E>, finalizer: ResultFinalizer<T, E>) {\n this.result = result\n this.finalizer = finalizer as (value: unknown, error: unknown) => void\n }\n\n get value(): T {\n return this.result.isOk() ? this.result.value : (undefined as T)\n }\n\n get error(): E {\n return this.result.isErr() ? this.result.error : (undefined as E)\n }\n\n _unsafeUnwrap(config?: ErrorConfig): T {\n return this.result._unsafeUnwrap(config)\n }\n\n _unsafeUnwrapErr(config?: ErrorConfig): E {\n return this.result._unsafeUnwrapErr(config)\n }\n\n isOk(): boolean {\n return this.result.isOk()\n }\n\n isErr(): boolean {\n return this.result.isErr()\n }\n\n unwrapOr<A>(defaultValue: A): T | A {\n return this.result.unwrapOr(defaultValue)\n }\n\n [Symbol.dispose](): void {\n if (this.disposed) {\n return\n }\n\n this.disposed = true\n try {\n this.finalizer(\n this.result.isOk() ? this.result.value : undefined,\n this.result.isErr() ? this.result.error : undefined,\n )\n } catch {\n /* empty */\n }\n }\n}\n\n/**\n * Evaluates the given generator to a Result returned or an Err yielded from it,\n * whichever comes first.\n *\n * This function, in combination with `Result.safeUnwrap()`, is intended to emulate\n * Rust's ? operator.\n * See `/tests/safeTry.test.ts` for examples.\n *\n * @param body - What is evaluated. In body, `yield* result.safeUnwrap()` works as\n * Rust's `result?` expression.\n * @returns The first occurence of either an yielded Err or a returned Result.\n */\nexport function safeTry<T, E>(body: () => Generator<Result<never, E>, Result<T, E>>): Result<T, E>\nexport function safeTry<\n YieldErr extends Result<never, unknown>,\n GeneratorReturnResult extends Result<unknown, unknown>,\n>(\n body: () => Generator<YieldErr, GeneratorReturnResult>,\n): Result<\n InferOkTypes<GeneratorReturnResult>,\n InferErrTypes<YieldErr> | InferErrTypes<GeneratorReturnResult>\n>\n\n/**\n * Evaluates the given generator to a Result returned or an Err yielded from it,\n * whichever comes first.\n *\n * This function, in combination with `Result.safeUnwrap()`, is intended to emulate\n * Rust's ? operator.\n * See `/tests/safeTry.test.ts` for examples.\n *\n * @param body - What is evaluated. In body, `yield* result.safeUnwrap()`,\n * `yield* result`, and `yield* resultAsync` work as Rust's `result?` expression.\n * @returns The first occurence of either an yielded Err or a returned Result.\n */\nexport function safeTry<T, E>(\n body: () => AsyncGenerator<Result<never, E>, Result<T, E>>,\n): ResultAsync<T, E>\nexport function safeTry<\n YieldErr extends Result<never, unknown>,\n GeneratorReturnResult extends Result<unknown, unknown>,\n>(\n body: () => AsyncGenerator<YieldErr, GeneratorReturnResult>,\n): ResultAsync<\n InferOkTypes<GeneratorReturnResult>,\n InferErrTypes<YieldErr> | InferErrTypes<GeneratorReturnResult>\n>\nexport function safeTry<T, E>(\n body:\n | (() => Generator<Result<never, E>, Result<T, E>>)\n | (() => AsyncGenerator<Result<never, E>, Result<T, E>>),\n): Result<T, E> | ResultAsync<T, E> {\n const n = body().next()\n if (n instanceof Promise) {\n return new ResultAsync(n.then((r) => r.value))\n }\n\n return n.value\n}\n\nexport function ok<T, E = never>(value: T): OkResult<T, E>\nexport function ok<E = never>(value: void): OkResult<void, E>\nexport function ok<T, E = never>(value: T): OkResult<T, E> {\n return new Ok<T, E>(value)\n}\n\nexport function err<T = never, E extends string = string>(err: E): ErrResult<T, E>\nexport function err<T = never, E = unknown>(err: E): ErrResult<T, E>\nexport function err<T = never>(err: void): ErrResult<T, void>\nexport function err<T = never, E = unknown>(error: E): ErrResult<T, E> {\n return new Err<T, E>(error)\n}\n\nexport const fromThrowable: typeof Result.fromThrowable = Result.fromThrowable\nexport function unit<E = never>(): OkResult<undefined, E> {\n return ok<undefined, E>(undefined)\n}\n\nexport const tryCatch: typeof Result.tryCatch = Result.tryCatch\n\n// #region Combine - Types\n\n// This is a helper type to prevent infinite recursion in typing rules.\n//\n// Use this with your `depth` variable in your types.\ntype Prev = [\n never,\n 0,\n 1,\n 2,\n 3,\n 4,\n 5,\n 6,\n 7,\n 8,\n 9,\n 10,\n 11,\n 12,\n 13,\n 14,\n 15,\n 16,\n 17,\n 18,\n 19,\n 20,\n 21,\n 22,\n 23,\n 24,\n 25,\n 26,\n 27,\n 28,\n 29,\n 30,\n 31,\n 32,\n 33,\n 34,\n 35,\n 36,\n 37,\n 38,\n 39,\n 40,\n 41,\n 42,\n 43,\n 44,\n 45,\n 46,\n 47,\n 48,\n 49,\n ...0[],\n]\n\n// Collects the results array into separate tuple array.\n//\n// T - The array of the results\n// Collected - The collected tuples.\n// Depth - The maximum depth.\ntype CollectResults<T, Collected extends unknown[] = [], Depth extends number = 50> = [\n Depth,\n] extends [never]\n ? []\n : T extends [infer H, ...infer Rest]\n ? // And test whether the head of the list is a result\n H extends Result<infer L, infer R>\n ? // Continue collecting...\n CollectResults<\n // the rest of the elements\n Rest,\n // The collected\n [...Collected, [L, R]],\n // and one less of the current depth\n Prev[Depth]\n >\n : never // Impossible\n : Collected\n\n// Transposes an array\n//\n// A - The array source\n// Transposed - The collected transposed array\n// Depth - The maximum depth.\nexport type Transpose<\n A,\n Transposed extends unknown[][] = [],\n Depth extends number = 10,\n> = A extends [infer T, ...infer Rest]\n ? T extends [infer L, infer R]\n ? Transposed extends [infer PL, infer PR]\n ? PL extends unknown[]\n ? PR extends unknown[]\n ? Transpose<Rest, [[...PL, L], [...PR, R]], Prev[Depth]>\n : never\n : never\n : Transpose<Rest, [[L], [R]], Prev[Depth]>\n : Transposed\n : Transposed\n\n// Combines the both sides of the array of the results into a tuple of the\n// union of the ok types and the union of the err types.\n//\n// T - The array of the results\n// Depth - The maximum depth.\nexport type Combine<T, Depth extends number = 5> =\n Transpose<CollectResults<T>, [], Depth> extends [infer L, infer R]\n ? [UnknownMembersToNever<L>, UnknownMembersToNever<R>]\n : Transpose<CollectResults<T>, [], Depth> extends []\n ? [[], []]\n : never\n\n// Deduplicates the result, as the result type is a union of Err and Ok types.\nexport type Dedup<T> = T extends Result<infer RL, infer RR> ? Result<RL, RR> : T\n\n// Given a union, this gives the array of the union members.\nexport type MemberListOf<T> = (\n (T extends unknown ? (t: T) => T : never) extends infer U\n ? (U extends unknown ? (u: U) => unknown : never) extends (v: infer V) => unknown\n ? V\n : never\n : never\n) extends (_: unknown) => infer W\n ? [...MemberListOf<Exclude<T, W>>, W]\n : []\n\n// Converts an empty array to never.\n//\n// The second type parameter here will affect how to behave to `never[]`s.\n// If a precise type is required, pass `1` here so that it will resolve\n// a literal array such as `[ never, never ]`. Otherwise, set `0` or the default\n// type value will cause this to resolve the arrays containing only `never`\n// items as `never` only.\nexport type EmptyArrayToNever<T, NeverArrayToNever extends number = 0> = T extends []\n ? never\n : NeverArrayToNever extends 1\n ? T extends [never, ...infer Rest]\n ? [EmptyArrayToNever<Rest>] extends [never]\n ? never\n : T\n : T\n : T\n\n// Converts the `unknown` items of an array to `never`s.\ntype UnknownMembersToNever<T> = T extends [infer H, ...infer R]\n ? [[unknown] extends [H] ? never : H, ...UnknownMembersToNever<R>]\n : T\n\n// Gets the member type of the array or never.\nexport type MembersToUnion<T> = T extends unknown[] ? T[number] : never\n\n// Checks if the given type is a literal array.\nexport type IsLiteralArray<T> = T extends { length: infer L }\n ? L extends number\n ? number extends L\n ? 0\n : 1\n : 0\n : 0\n\n// Traverses an array of results and returns a single result containing\n// the oks and errs union-ed/combined.\ntype Traverse<T, Depth extends number = 5> =\n Combine<T, Depth> extends [infer Oks, infer Errs]\n ? Result<EmptyArrayToNever<Oks, 1>, MembersToUnion<Errs>>\n : never\n\n// Traverses an array of results and returns a single result containing\n// the oks combined and the array of errors combined.\ntype TraverseWithAllErrors<T, Depth extends number = 5> =\n Traverse<T, Depth> extends Result<infer Oks, infer Errs> ? Result<Oks, Errs[]> : never\n\n// Combines the array of results into one result.\nexport type CombineResults<T extends readonly Result<unknown, unknown>[]> =\n IsLiteralArray<T> extends 1 ? Traverse<T> : Result<ExtractOkTypes<T>, ExtractErrTypes<T>[number]>\n\n// Combines the array of results into one result with all errors.\nexport type CombineResultsWithAllErrorsArray<T extends readonly Result<unknown, unknown>[]> =\n IsLiteralArray<T> extends 1\n ? TraverseWithAllErrors<T>\n : Result<ExtractOkTypes<T>, ExtractErrTypes<T>[number][]>\n\n// #endregion\n","import type {\n Combine,\n Dedup,\n EmptyArrayToNever,\n IsLiteralArray,\n MemberListOf,\n MembersToUnion,\n} from './result.js'\nimport type {\n ExtractErrAsyncTypes,\n ExtractOkAsyncTypes,\n InferAsyncErrTypes,\n InferAsyncOkTypes,\n InferErrTypes,\n InferOkTypes,\n} from './utils.js'\n\nimport { Result, err } from './result.js'\nimport { callErrorHandler, callTaggedHandler, hasTag } from './tagged-match.js'\nimport { combineResultAsyncList, combineResultAsyncListWithAllErrors } from './utils.js'\n\ntype TaggedValue = { readonly _tag: string }\ntype TaggedErrorValue = Error & TaggedValue\ntype TagsOf<E> = Extract<E, TaggedValue>['_tag']\ntype ErrorTagsOf<E> = Extract<E, TaggedErrorValue>['_tag']\ntype ErrorForTag<E, Tag extends string> = Extract<E, { readonly _tag: Tag }>\ntype ExcludeTag<E, Tag extends string> = Exclude<E, { readonly _tag: Tag }>\ntype UntaggedError<E> = Exclude<Extract<E, Error>, TaggedErrorValue>\ntype CatchTagHandlerResult<Handlers> = {\n readonly [Key in keyof Handlers]: Handlers[Key] extends (...args: infer _Args) => infer R\n ? R\n : never\n}[keyof Handlers]\ntype MatchTagHandlerResult<Handlers> = {\n readonly [Key in keyof Handlers]: Handlers[Key] extends (...args: infer _Args) => infer R\n ? R\n : never\n}[keyof Handlers]\ntype CatchTagHandlers<E, Handlers> = {\n readonly [Tag in keyof Handlers]: Tag extends TagsOf<E>\n ? (\n error: ErrorForTag<E, Tag & string>,\n ) => Result<unknown, unknown> | ResultAsync<unknown, unknown>\n : never\n}\ntype MatchTagHandlers<E, Handlers> = {\n readonly [Tag in ErrorTagsOf<E>]: (error: ErrorForTag<E, Tag>) => unknown\n} & ([UntaggedError<E>] extends [never]\n ? { readonly Error?: (error: Error) => unknown }\n : { readonly Error: (error: UntaggedError<E>) => unknown }) & {\n readonly [Tag in keyof Handlers]: Tag extends ErrorTagsOf<E> | 'Error' ? Handlers[Tag] : never\n }\ntype PartialMatchTagHandlers<E, Handlers> = {\n readonly [Tag in keyof Handlers]: Tag extends ErrorTagsOf<E>\n ? (error: ErrorForTag<E, Tag & string>) => unknown\n : Tag extends 'Error'\n ? (error: Extract<E, Error>) => unknown\n : never\n}\ntype PipeFn<Input, Output> = (input: Input) => Output\ntype ResultAsyncFinalizer<T, E> = (\n value: T | undefined,\n error: E | undefined,\n) => void | Promise<void>\n\ntype HandlerOk<R> = InferOkTypes<R> | InferAsyncOkTypes<R>\ntype HandlerErr<R> = InferErrTypes<R> | InferAsyncErrTypes<R>\n\nexport class DisposableResultAsync<T, E> implements PromiseLike<Result<T, E>>, AsyncDisposable {\n private readonly innerPromise: Promise<Result<T, E>>\n private readonly finalizer: (value: unknown, error: unknown) => void | Promise<void>\n private disposed = false\n\n constructor(res: Promise<Result<T, E>>, finalizer: ResultAsyncFinalizer<T, E>) {\n this.innerPromise = res\n this.finalizer = finalizer as (value: unknown, error: unknown) => void | Promise<void>\n }\n\n then<A, B>(\n successCallback?: (res: Result<T, E>) => A | PromiseLike<A>,\n failureCallback?: (reason: unknown) => B | PromiseLike<B>,\n ): PromiseLike<A | B> {\n return this.innerPromise.then(successCallback, failureCallback)\n }\n\n async [Symbol.asyncDispose](): Promise<void> {\n if (this.disposed) {\n return\n }\n\n this.disposed = true\n const result = await this.innerPromise\n\n try {\n await this.finalizer(\n result.isOk() ? result.value : undefined,\n result.isErr() ? result.error : undefined,\n )\n } catch {\n /* empty */\n }\n }\n}\n\n/**\n * Represents an asynchronous Result type that wraps a Promise of a Result<T, E>.\n * This class provides a way to handle asynchronous operations that may succeed with a value of type T\n * or fail with an error of type E.\n *\n * @template T - The type of the success value\n * @template E - The type of the error value\n *\n * @implements {PromiseLike<Result<T, E>>}\n *\n * @example\n * ```typescript\n * // Create a successful async result\n * const okAsync = ResultAsync.okAsync(42);\n *\n * // Create a failed async result\n * const errAsync = ResultAsync.errAsync(new Error(\"Something went wrong\"));\n *\n * // Transform a Promise into a ResultAsync\n * const resultFromPromise = ResultAsync.fromPromise(\n * fetch(\"https://api.example.com/data\"),\n * (error) => new Error(`API call failed: ${error}`)\n * );\n * ```\n *\n * @remarks\n * ResultAsync implements the PromiseLike interface, allowing it to be used with async/await syntax.\n * It provides various utility methods for transforming and combining results, similar to the Result type,\n * but operating in an asynchronous context.\n *\n * The class includes methods for:\n * - Creating ResultAsync instances (okAsync, errAsync, fromPromise)\n * - Transforming values (map, mapErr)\n * - Chaining operations (andThen, orElse)\n * - Error handling (tapError)\n * - Conditional branching (if)\n * - Combining multiple ResultAsync instances (combine, combineWithAllErrors)\n */\nexport class ResultAsync<T, E> implements PromiseLike<Result<T, E>> {\n /**\n * Returns a ResultAsync instance that is immediately resolved with a Result.ok(value).\n *\n * @param {T} value - The value to be wrapped in a Result.ok.\n * @return {ResultAsync<T, E>} A ResultAsync instance with the given value and error type E.\n */\n static okAsync<T, E = never>(this: void, value: T): ResultAsync<T, E>\n static okAsync<E = never>(this: void, value: void): ResultAsync<void, E>\n static okAsync<T, E = never>(this: void, value: T): ResultAsync<T, E> {\n return new ResultAsync<T, E>(Promise.resolve(Result.ok(value)))\n }\n\n /**\n * Returns a ResultAsync that is immediately resolved with a Result.ok(undefined) value.\n *\n * @return {ResultAsync<undefined, E>} A ResultAsync instance with undefined as the value type and E as the error type.\n */\n static unitAsync<E = never>(this: void): ResultAsync<undefined, E> {\n return new ResultAsync<undefined, E>(Promise.resolve(Result.unit()))\n }\n\n /**\n * Returns a ResultAsync instance that is immediately resolved with a Result.err(error).\n *\n * @param {E} error - The error to be wrapped in a Result.err.\n * @return {ResultAsync<T, E>} A ResultAsync instance with the given error and value type T.\n */\n static errAsync<T = never, E = unknown>(this: void, err: E): ResultAsync<T, E>\n static errAsync<T = never>(this: void, err: void): ResultAsync<T, void>\n static errAsync<T = never, E = unknown>(this: void, error: E): ResultAsync<T, E> {\n return new ResultAsync<T, E>(Promise.resolve(Result.err(error)))\n }\n\n /**\n * Creates a ResultAsync from a Promise, catching any errors that occur during its execution.\n *\n * @param fn - The Promise or a function returning a Promise to be wrapped in a ResultAsync.\n * @param errorFn - Optional function to transform the caught error into a specific error type.\n * If not provided, the original error will be used.\n * @returns A ResultAsync that will resolve to Ok with the promise's value if successful,\n * or Err with either the transformed error (if errorFn is provided) or the original error.\n *\n * @example\n * ```typescript\n * // Without error transformer\n * const result = ResultAsync.tryCatch(Promise.resolve(42));\n *\n * // With error transformer\n * const result = ResultAsync.tryCatch(\n * fetch('https://api.example.com'),\n * (error) => new CustomError('API request failed')\n * );\n * ```\n */\n static tryCatch<T>(this: void, fn: Promise<T> | (() => Promise<T>)): ResultAsync<T, unknown>\n static tryCatch<T, E>(\n this: void,\n fn: Promise<T> | (() => Promise<T>),\n errorFn: (e: unknown) => E,\n ): ResultAsync<T, E>\n static tryCatch<T, E>(\n this: void,\n fn: Promise<T> | (() => Promise<T>),\n errorFn?: (e: unknown) => E,\n ): ResultAsync<T, unknown> {\n const promiseToProcess = typeof fn === 'function' ? Promise.try(fn) : fn\n const newPromise = promiseToProcess\n .then((value: T) => Result.ok(value))\n .catch((error: unknown) => {\n if (errorFn) {\n return Result.err(errorFn(error))\n }\n return Result.err(error)\n })\n return new ResultAsync<T, unknown>(newPromise)\n }\n\n /**\n * Returns a ResultAsync instance that is resolved with a Result.ok(value) or Result.err(error)\n * based on the provided promise.\n *\n * @param {Promise<T>} promise - The promise to be wrapped in a ResultAsync.\n * @return {ResultAsync<T, E>} A ResultAsync instance with the given promise and error type E.\n */\n static fromSafePromise<T, E = never>(this: void, promise: PromiseLike<T>): ResultAsync<T, E>\n static fromSafePromise<T, E = never>(this: void, promise: Promise<T>): ResultAsync<T, E> {\n const newPromise = promise.then((value: T) => Result.ok(value))\n\n return new ResultAsync<T, E>(newPromise)\n }\n\n /**\n * Returns a ResultAsync instance that is resolved with a Result.ok(value) or Result.err(error)\n * based on the provided promise.\n *\n * @param {Promise<T>} promise - The promise to be wrapped in a ResultAsync.\n * @param {(e: unknown) => E} errorFn - A function that transforms the error from the promise into the error type E.\n * @return {ResultAsync<T, E>} A ResultAsync instance with the given promise and error type E.\n */\n static fromPromise<T, E>(\n this: void,\n promise: PromiseLike<T>,\n errorFn: (e: unknown) => E,\n ): ResultAsync<T, E>\n static fromPromise<T, E>(\n this: void,\n promise: Promise<T>,\n errorFn: (e: unknown) => E,\n ): ResultAsync<T, E> {\n const newPromise = promise\n .then((value: T) => Result.ok(value))\n .catch((error: unknown) => Result.err(errorFn(error)))\n\n return new ResultAsync<T, E>(newPromise)\n }\n\n static combine<\n T extends readonly [ResultAsync<unknown, unknown>, ...ResultAsync<unknown, unknown>[]],\n >(this: void, asyncResultList: T): CombineResultAsyncs<T>\n static combine<T extends readonly ResultAsync<unknown, unknown>[]>(\n this: void,\n asyncResultList: T,\n ): CombineResultAsyncs<T>\n static combine<T extends readonly ResultAsync<unknown, unknown>[]>(\n this: void,\n asyncResultList: T,\n ): CombineResultAsyncs<T> {\n return combineResultAsyncList(asyncResultList) as CombineResultAsyncs<T>\n }\n\n static combineWithAllErrors<\n T extends readonly [ResultAsync<unknown, unknown>, ...ResultAsync<unknown, unknown>[]],\n >(this: void, asyncResultList: T): CombineResultsWithAllErrorsArrayAsync<T>\n static combineWithAllErrors<T extends readonly ResultAsync<unknown, unknown>[]>(\n this: void,\n asyncResultList: T,\n ): CombineResultsWithAllErrorsArrayAsync<T>\n static combineWithAllErrors<T extends readonly ResultAsync<unknown, unknown>[]>(\n this: void,\n asyncResultList: T,\n ): CombineResultsWithAllErrorsArrayAsync<T> {\n return combineResultAsyncListWithAllErrors(\n asyncResultList,\n ) as CombineResultsWithAllErrorsArrayAsync<T>\n }\n\n /**\n * Wraps a async function with a try catch, creating a new function with the same\n * arguments but returning `Ok` if successful, `Err` if the function throws\n *\n * @param fn function to wrap with ok on success or err on failure\n * @param errorFn when an error is thrown, this will wrap the error result if provided\n * @returns a new function that returns a `ResultAsync`\n */\n static fromThrowable<A extends readonly unknown[], T, E>(\n this: void,\n fn: (...args: A) => Promise<T>,\n errorFn?: (err: unknown) => E,\n ): (...args: A) => ResultAsync<T, E> {\n return (...args) =>\n new ResultAsync<T, E>(\n (async () => {\n try {\n const v = await fn(...args)\n return Result.ok(v)\n } catch (error) {\n const e = errorFn ? errorFn(error) : error\n return Result.err(e as E)\n }\n })(),\n )\n }\n\n private readonly innerPromise: Promise<Result<T, E>>\n\n constructor(res: Promise<Result<T, E>>) {\n this.innerPromise = res\n }\n\n then<A, B>(\n successCallback?: (res: Result<T, E>) => A | PromiseLike<A>,\n failureCallback?: (reason: unknown) => B | PromiseLike<B>,\n ): PromiseLike<A | B> {\n return this.innerPromise.then(successCallback, failureCallback)\n }\n\n mapErr<U>(f: (t: E) => U | Promise<U>): ResultAsync<T, U> {\n return new ResultAsync<T, U>(\n this.innerPromise.then(async (res) => {\n if (res.isOk()) {\n return Result.ok<T, U>(res.value)\n }\n\n return Result.err<T, U>(await f(res.error))\n }),\n )\n }\n\n map<X>(f: (t: T) => X | Promise<X>): ResultAsync<X, E> {\n return new ResultAsync<X, E>(\n this.innerPromise.then(async (res: Result<T, E>) => {\n if (res.isErr()) {\n return Result.err<X, E>(res.error)\n }\n\n return Result.ok<X, E>(await f(res.value))\n }),\n )\n }\n\n filterOrElse<U extends T, F>(\n predicate: (value: T) => value is U,\n onFalse: (value: T) => F | Promise<F>,\n ): ResultAsync<U, E | F>\n filterOrElse<F>(\n predicate: (value: T) => boolean | Promise<boolean>,\n onFalse: (value: T) => F | Promise<F>,\n ): ResultAsync<T, E | F>\n filterOrElse<F>(\n predicate: (value: T) => boolean | Promise<boolean>,\n onFalse: (value: T) => F | Promise<F>,\n ): ResultAsync<T, E | F> {\n return new ResultAsync<T, E | F>(\n this.innerPromise.then(async (res) => {\n if (res.isErr()) {\n return Result.err(res.error)\n }\n\n if (await predicate(res.value)) {\n return Result.ok(res.value)\n }\n\n return Result.err(await onFalse(res.value))\n }),\n )\n }\n\n andThen<R extends Result<unknown, unknown>>(\n f: (t: T) => R,\n ): ResultAsync<InferOkTypes<R>, InferErrTypes<R> | E>\n andThen<R extends ResultAsync<unknown, unknown>>(\n f: (t: T) => R,\n ): ResultAsync<InferAsyncOkTypes<R>, InferAsyncErrTypes<R> | E>\n andThen<U, F>(f: (t: T) => Result<U, F> | ResultAsync<U, F>): ResultAsync<U, E | F>\n andThen<U, F>(f: (t: T) => Result<U, F> | ResultAsync<U, F>): ResultAsync<U, E | F> {\n return new ResultAsync<U, E | F>(\n this.innerPromise.then((res) => {\n if (res.isErr()) {\n return Result.err<U, E | F>(res.error)\n }\n\n const next = f(res.value)\n return next instanceof ResultAsync ? next.innerPromise : next\n }),\n )\n }\n\n if(fCondition: (t: T) => boolean): {\n true: <X1, Y1>(\n fTrue: (t: T) => ResultAsync<X1, Y1>,\n ) => {\n false: <X2, Y2>(fFalse: (t: T) => ResultAsync<X2, Y2>) => ResultAsync<X1 | X2, Y1 | Y2 | E>\n }\n } {\n return {\n true: <X1, Y1>(fTrue: (t: T) => ResultAsync<X1, Y1>) => ({\n false: <X2, Y2>(fFalse: (t: T) => ResultAsync<X2, Y2>): ResultAsync<X1 | X2, Y1 | Y2 | E> =>\n new ResultAsync(\n this.innerPromise.then(async (res) => {\n if (res.isOk()) {\n const condition = fCondition(res.value)\n return condition ? fTrue(res.value) : fFalse(res.value)\n }\n\n return errAsync(res.error)\n }),\n ),\n }),\n }\n }\n\n orElse<R extends Result<unknown, unknown>>(\n f: (e: E) => R,\n ): ResultAsync<InferOkTypes<R> | T, InferErrTypes<R>>\n orElse<R extends ResultAsync<unknown, unknown>>(\n f: (e: E) => R,\n ): ResultAsync<InferAsyncOkTypes<R> | T, InferAsyncErrTypes<R>>\n orElse<U, A>(f: (e: E) => Result<U, A> | ResultAsync<U, A>): ResultAsync<U | T, A>\n orElse<U, A>(f: (e: E) => Result<U, A> | ResultAsync<U, A>): ResultAsync<U | T, A> {\n return new ResultAsync<U | T, A>(\n this.innerPromise.then((res) => {\n if (res.isErr()) {\n const next = f(res.error)\n return next instanceof ResultAsync ? next.innerPromise : next\n }\n\n return Result.ok<U | T, A>(res.value)\n }),\n )\n }\n\n catchTag<const Tag extends TagsOf<E>, R extends Result<unknown, unknown>>(\n tag: Tag,\n f: (error: ErrorForTag<E, Tag>) => R,\n ): ResultAsync<T | InferOkTypes<R>, ExcludeTag<E, Tag> | InferErrTypes<R>>\n catchTag<const Tag extends TagsOf<E>, R extends ResultAsync<unknown, unknown>>(\n tag: Tag,\n f: (error: ErrorForTag<E, Tag>) => R,\n ): ResultAsync<T | InferAsyncOkTypes<R>, ExcludeTag<E, Tag> | InferAsyncErrTypes<R>>\n catchTag<U, F, const Tag extends TagsOf<E>>(\n tag: Tag,\n f: (error: ErrorForTag<E, Tag>) => Result<U, F> | ResultAsync<U, F>,\n ): ResultAsync<T | U, ExcludeTag<E, Tag> | F>\n catchTag<U, F, const Tag extends TagsOf<E>>(\n tag: Tag,\n f: (error: ErrorForTag<E, Tag>) => Result<U, F> | ResultAsync<U, F>,\n ): ResultAsync<T | U, ExcludeTag<E, Tag> | F> {\n return new ResultAsync(\n this.innerPromise.then((res) => {\n if (res.isOk()) {\n return Result.ok(res.value)\n }\n\n if (hasTag(res.error, tag)) {\n const next = f(res.error as ErrorForTag<E, Tag>)\n return next instanceof ResultAsync ? next.innerPromise : next\n }\n\n return Result.err(res.error as ExcludeTag<E, Tag>)\n }),\n )\n }\n\n catchTags<const Handlers extends object>(\n handlers: Handlers & CatchTagHandlers<E, Handlers>,\n ): ResultAsync<\n T | HandlerOk<CatchTagHandlerResult<Handlers>>,\n ExcludeTag<E, keyof Handlers & string> | HandlerErr<CatchTagHandlerResult<Handlers>>\n > {\n return new ResultAsync<\n T | HandlerOk<CatchTagHandlerResult<Handlers>>,\n ExcludeTag<E, keyof Handlers & string> | HandlerErr<CatchTagHandlerResult<Handlers>>\n >(\n this.innerPromise.then((res) => {\n if (res.isOk()) {\n return Result.ok(res.value)\n }\n\n const error = res.error\n const handled = callTaggedHandler<CatchTagHandlerResult<Handlers>>(error, handlers)\n\n if (handled.matched) {\n const next = handled.value as Result<unknown, unknown> | ResultAsync<unknown, unknown>\n return next instanceof ResultAsync ? next.innerPromise : next\n }\n\n return Result.err(error as ExcludeTag<E, keyof Handlers & string>)\n }) as Promise<\n Result<\n T | HandlerOk<CatchTagHandlerResult<Handlers>>,\n ExcludeTag<E, keyof Handlers & string> | HandlerErr<CatchTagHandlerResult<Handlers>>\n >\n >,\n )\n }\n\n async match<A, B = A>(ok: (t: T) => A, fnErr: (e: E) => B): Promise<A | B> {\n return this.innerPromise.then((res) => res.match(ok, fnErr))\n }\n\n async matchTags<A, const Handlers extends object>(\n ok: (t: T) => A,\n handlers: Handlers & MatchTagHandlers<E, Handlers>,\n ): Promise<A | MatchTagHandlerResult<Handlers>> {\n return this.innerPromise.then((res) => {\n if (res.isOk()) {\n return ok(res.value)\n }\n\n const error = res.error\n const tagged = callTaggedHandler<MatchTagHandlerResult<Handlers>>(error, handlers)\n\n if (tagged.matched) {\n return tagged.value\n }\n\n const errorHandler = callErrorHandler(\n error,\n handlers as { readonly Error?: (error: E) => MatchTagHandlerResult<Handlers> },\n )\n\n if (errorHandler.matched) {\n return errorHandler.value\n }\n\n // eslint-disable-next-line @typescript-eslint/only-throw-error\n throw error\n })\n }\n\n async matchTagsPartial<A, B, const Handlers extends object>(\n ok: (t: T) => A,\n handlers: Handlers & PartialMatchTagHandlers<E, Handlers>,\n fallback: (error: E) => B,\n ): Promise<A | MatchTagHandlerResult<Handlers> | B> {\n return this.innerPromise.then((res) => {\n if (res.isOk()) {\n return ok(res.value)\n }\n\n const error = res.error\n const tagged = callTaggedHandler<MatchTagHandlerResult<Handlers>>(error, handlers)\n\n if (tagged.matched) {\n return tagged.value\n }\n\n const errorHandler = callErrorHandler(\n error,\n handlers as { readonly Error?: (error: E) => MatchTagHandlerResult<Handlers> },\n )\n\n if (errorHandler.matched) {\n return errorHandler.value\n }\n\n return fallback(error)\n })\n }\n\n async unwrapOr<A>(t: A): Promise<T | A> {\n return this.innerPromise.then((res) => res.unwrapOr(t))\n }\n\n async unwrapOrThrow(): Promise<T> {\n return this.innerPromise.then((res) => res.unwrapOrThrow())\n }\n\n pipe<A>(ab: PipeFn<this, A>): A\n pipe<A, B>(ab: PipeFn<this, A>, bc: PipeFn<A, B>): B\n pipe<A, B, C>(ab: PipeFn<this, A>, bc: PipeFn<A, B>, cd: PipeFn<B, C>): C\n pipe(...fns: readonly PipeFn<never, unknown>[]): unknown {\n const first = fns[0]\n\n if (!first) {\n return this\n }\n\n let input = first(this as never)\n\n for (const fn of fns.slice(1)) {\n input = (fn as PipeFn<unknown, unknown>)(input)\n }\n\n return input\n }\n\n /**\n * Runs a side effect for either variant and preserves the original async result.\n *\n * For `Ok`, the callback receives `(value, undefined)`.\n * For `Err`, the callback receives `(undefined, error)`.\n * Callback errors and rejected callback promises are intentionally ignored.\n *\n * Use `map`, `mapErr`, `andThen`, or `orElse` when the callback should\n * transform the result.\n */\n log(f: (t?: T, e?: E) => void | Promise<void>): ResultAsync<T, E> {\n return new ResultAsync(\n this.innerPromise.then(async (res) => {\n if (res.isOk()) {\n try {\n await f(res.value)\n } catch {\n /* empty */\n }\n\n return okAsync(res.value)\n }\n\n try {\n await f(undefined, res.error)\n } catch {\n /* empty */\n }\n\n return errAsync(res.error)\n }),\n )\n }\n\n /**\n * Runs a side effect only for the `Ok` variant and preserves the original async result.\n *\n * Callback errors and rejected callback promises are intentionally ignored.\n * Use `map` or `andThen` when the callback should transform the value.\n */\n tap(f: (t: T) => void | Promise<void>): ResultAsync<T, E> {\n return new ResultAsync(\n this.innerPromise.then(async (res) => {\n if (res.isErr()) {\n return errAsync(res.error)\n }\n\n try {\n await f(res.value)\n } catch {\n /* empty */\n }\n\n return okAsync(res.value)\n }),\n )\n }\n\n /**\n * Runs a side effect only for the `Err` variant and preserves the original async result.\n *\n * Callback errors and rejected callback promises are intentionally ignored.\n * Use `mapErr` or `orElse` when the callback should transform the error.\n */\n tapError(f: (e: E) => void | Promise<void>): ResultAsync<T, E> {\n return new ResultAsync(\n this.innerPromise.then(async (res) => {\n if (res.isErr()) {\n try {\n await f(res.error)\n } catch {\n /* empty */\n }\n\n return errAsync(res.error)\n }\n\n return okAsync(res.value)\n }),\n )\n }\n\n toAsyncDisposable(f: ResultAsyncFinalizer<T, E>): DisposableResultAsync<T, E> {\n return new DisposableResultAsync(this.innerPromise, f)\n }\n\n async *[Symbol.asyncIterator](): AsyncGenerator<Result<never, E>, T> {\n const result = await this.innerPromise\n\n if (result.isOk()) {\n return result.value\n }\n\n yield err(result.error)\n\n return undefined as T\n }\n}\n\nexport type StrictResultAsync<T, E extends Error = Error> = ResultAsync<T, E>\n\nexport const okAsync: typeof ResultAsync.okAsync = ResultAsync.okAsync\nexport const errAsync: typeof ResultAsync.errAsync = ResultAsync.errAsync\nexport const fromPromise: typeof ResultAsync.fromPromise = ResultAsync.fromPromise\nexport const fromSafePromise: typeof ResultAsync.fromSafePromise = ResultAsync.fromSafePromise\nexport const unitAsync: typeof ResultAsync.unitAsync = ResultAsync.unitAsync\nexport const fromThrowableAsync: typeof ResultAsync.fromThrowable = ResultAsync.fromThrowable\nexport const tryCatchAsync: typeof ResultAsync.tryCatch = ResultAsync.tryCatch\n\n// Combines the array of async results into one result.\nexport type CombineResultAsyncs<T extends readonly ResultAsync<unknown, unknown>[]> =\n IsLiteralArray<T> extends 1\n ? TraverseAsync<UnwrapAsync<T>>\n : ResultAsync<ExtractOkAsyncTypes<T>, ExtractErrAsyncTypes<T>[number]>\n\n// Combines the array of async results into one result with all errors.\nexport type CombineResultsWithAllErrorsArrayAsync<\n T extends readonly ResultAsync<unknown, unknown>[],\n> =\n IsLiteralArray<T> extends 1\n ? TraverseWithAllErrorsAsync<UnwrapAsync<T>>\n : ResultAsync<ExtractOkAsyncTypes<T>, ExtractErrAsyncTypes<T>[number][]>\n\n// Unwraps the inner `Result` from a `ResultAsync` for all elements.\ntype UnwrapAsync<T> =\n IsLiteralArray<T> extends 1\n ? Writable<T> extends [infer H, ...infer Rest]\n ? H extends PromiseLike<infer HI>\n ? HI extends Result<unknown, unknown>\n ? [Dedup<HI>, ...UnwrapAsync<Rest>]\n : never\n : never\n : []\n : // If we got something too general such as ResultAsync<X, Y>[] then we\n // simply need to map it to ResultAsync<X[], Y[]>. Yet `ResultAsync`\n // itself is a union therefore it would be enough to cast it to Ok.\n T extends (infer A)[]\n ? A extends PromiseLike<infer HI>\n ? HI extends Result<infer L, infer R>\n ? Result<L, R>[]\n : never\n : never\n : never\n\n// Traverse through the tuples of the async results and create one\n// `ResultAsync` where the collected tuples are merged.\ntype TraverseAsync<T, Depth extends number = 5> =\n IsLiteralArray<T> extends 1\n ? Combine<T, Depth> extends [infer Oks, infer Errs]\n ? ResultAsync<EmptyArrayToNever<Oks>, MembersToUnion<Errs>>\n : never\n : // The following check is important if we somehow reach to the point of\n // checking something similar to ResultAsync<X, Y>[]. In this case we don't\n // know the length of the elements, therefore we need to traverse the X and Y\n // in a way that the result should contain X[] and Y[].\n T extends (infer I)[]\n ? // The MemberListOf<I> here is to include all possible types. Therefore\n // if we face (ResultAsync<X, Y> | ResultAsync<A, B>)[] this type should\n // handle the case.\n Combine<MemberListOf<I>, Depth> extends [infer Oks, infer Errs]\n ? // The following `extends unknown[]` checks are just to satisfy the TS.\n // we already expect them to be an array.\n Oks extends unknown[]\n ? Errs extends unknown[]\n ? ResultAsync<EmptyArrayToNever<Oks[number][]>, MembersToUnion<Errs[number][]>>\n : ResultAsync<EmptyArrayToNever<Oks[number][]>, Errs>\n : // The rest of the conditions are to satisfy the TS and support\n // the edge cases which are not really expected to happen.\n Errs extends unknown[]\n ? ResultAsync<Oks, MembersToUnion<Errs[number][]>>\n : ResultAsync<Oks, Errs>\n : never\n : never\n\n// This type is similar to the `TraverseAsync` while the errors are also\n// collected in a list. For the checks/conditions made here, see that type\n// for the documentation.\ntype TraverseWithAllErrorsAsync<T, Depth extends number = 5> =\n TraverseAsync<T, Depth> extends ResultAsync<infer Oks, infer Errs>\n ? ResultAsync<Oks, Errs[]>\n : never\n\n// Converts a reaodnly array into a writable array\ntype Writable<T> = T extends readonly unknown[] ? [...T] : T\n"],"mappings":"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"}