resultar 0.9.0 → 1.0.0

package/dist/index.cjs

@@ -36,7 +36,22 @@ __export(src_exports, {
 module.exports = __toCommonJS(src_exports);
 
 // src/result-async.ts
+var DisposableResultAsync = class {
+  innerPromise;
+  constructor(res) {
+    this.innerPromise = res;
+  }
+  then(successCallback, failureCallback) {
+    return this.innerPromise.then(successCallback, failureCallback);
+  }
+};
 var ResultAsync = class _ResultAsync {
+  static okAsync(value) {
+    return new _ResultAsync(Promise.resolve(Result.ok(value)));
+  }
+  static errAsync(error) {
+    return new _ResultAsync(Promise.resolve(Result.err(error)));
+  }
   static fromSafePromise(promise) {
     const newPromise = promise.then((value) => Result.ok(value));
     return new _ResultAsync(newPromise);
@@ -53,6 +68,27 @@ var ResultAsync = class _ResultAsync {
       asyncResultList
     );
   }
+  /**
+  * Wraps a async function with a try catch, creating a new function with the same
+  * arguments but returning `Ok` if successful, `Err` if the function throws
+  *
+  * @param fn function to wrap with ok on success or err on failure
+  * @param errorFn when an error is thrown, this will wrap the error result if provided
+  * @returns a new function that returns a `ResultAsync`
+  */
+  static fromThrowable(fn, errorFn) {
+    return (...args) => new _ResultAsync(
+      (async () => {
+        try {
+          const v = await fn(...args);
+          return Result.ok(v);
+        } catch (error) {
+          const e = errorFn ? errorFn(error) : error;
+          return Result.err(e);
+        }
+      })()
+    );
+  }
   innerPromise;
   constructor(res) {
     this.innerPromise = res;
@@ -121,6 +157,17 @@ var ResultAsync = class _ResultAsync {
       })
     );
   }
+  finally(f) {
+    return new DisposableResultAsync(
+      this.innerPromise.then(async (res) => {
+        try {
+          res.finally(f);
+        } catch {
+        }
+        return res;
+      })
+    );
+  }
   /**
    * Emulates Rust's `?` operator in `safeTry`'s body. See also `safeTry`.
    */
@@ -128,31 +175,8 @@ var ResultAsync = class _ResultAsync {
     return yield* await this.innerPromise.then((res) => res.safeUnwrap());
   }
 };
-function fromSafePromise(promise) {
-  return ResultAsync.fromSafePromise(promise);
-}
-function fromPromise(promise, errorFn) {
-  return ResultAsync.fromPromise(promise, errorFn);
-}
-function okAsync(value) {
-  return new ResultAsync(Promise.resolve(Result.ok(value)));
-}
-function errAsync(error) {
-  return new ResultAsync(Promise.resolve(Result.err(error)));
-}
-function fromThrowableAsync(fn, errorFn) {
-  return (...args) => new ResultAsync(
-    (async () => {
-      try {
-        const v = await fn(...args);
-        return Result.ok(v);
-      } catch (error) {
-        const e = errorFn ? errorFn(error) : error;
-        return Result.err(e);
-      }
-    })()
-  );
-}
+var { okAsync, errAsync, fromPromise, fromSafePromise } = ResultAsync;
+var fromThrowableAsync = ResultAsync.fromThrowable;
 function safeTryAsync(body) {
   return new ResultAsync(
     (async () => {
@@ -474,9 +498,7 @@ var DisposableResult = class {
     this.finalizer(this.result.value, this.result.error);
   }
 };
-var ok = (value) => Result.ok(value);
-var err = (error) => Result.err(error);
-var fromThrowable = (fn, errorFn) => Result.fromThrowable(fn, errorFn);
+var { ok, err, fromThrowable } = Result;
 function safeTry(body) {
   const n = body().next();
   if (n instanceof Promise) {

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts","../src/result-async.ts","../src/utils.ts","../src/error.ts","../src/result.ts"],"sourcesContent":["export {\n  Result, ok, err, fromThrowable, safeTry,\n} from './result.js'\nexport {\n  ResultAsync, okAsync, errAsync, fromPromise, fromSafePromise, safeTryAsync, fromThrowableAsync,\n} from './result-async.js'\n","/* eslint-disable @typescript-eslint/ban-types */\n\nimport {\n  Result,\n} from './result.js'\nimport {\n  Combine,\n  Dedup,\n  EmptyArrayToNever,\n  ExtractErrAsyncTypes,\n  ExtractOkAsyncTypes,\n  InferAsyncErrTypes, InferAsyncOkTypes, InferErrTypes, InferOkTypes,\n  IsLiteralArray,\n  MemberListOf,\n  MembersToUnion,\n  combineResultAsyncList,\n  combineResultAsyncListWithAllErrors,\n} from './utils.js'\n\n// Combines the array of async results into one result.\nexport type CombineResultAsyncs<\n  T extends ReadonlyArray<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 ReadonlyArray<ResultAsync<unknown, unknown>>,\n> = IsLiteralArray<T> extends 1\n  ? TraverseWithAllErrorsAsync<UnwrapAsync<T>>\n  : ResultAsync<ExtractOkAsyncTypes<T>, Array<ExtractErrAsyncTypes<T>[number]>>\n\n// Unwraps the inner `Result` from a `ResultAsync` for all elements.\ntype UnwrapAsync<T> = 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 Array<infer A>\n    ? A extends PromiseLike<infer HI>\n      ? HI extends Result<infer L, infer R>\n        ? Array<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> = 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 Array<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<Array<Oks[number]>>, MembersToUnion<Array<Errs[number]>>>\n          : ResultAsync<EmptyArrayToNever<Array<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<Array<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 order. For the checks/conditions made here, see that type\n// for the documentation.\ntype TraverseWithAllErrorsAsync<T, Depth extends number = 5> = IsLiteralArray<T> extends 1\n  ? Combine<T, Depth> extends [infer Oks, infer Errs]\n    ? ResultAsync<EmptyArrayToNever<Oks>, EmptyArrayToNever<Errs>>\n    : never\n  : Writable<T> extends Array<infer I>\n    ? Combine<MemberListOf<I>, Depth> extends [infer Oks, infer Errs]\n      ? Oks extends unknown[]\n        ? Errs extends unknown[]\n          ? ResultAsync<EmptyArrayToNever<Array<Oks[number]>>, EmptyArrayToNever<Array<Errs[number]>>>\n          : ResultAsync<EmptyArrayToNever<Array<Oks[number]>>, Errs>\n        : Errs extends unknown[]\n          ? ResultAsync<Oks, EmptyArrayToNever<Array<Errs[number]>>>\n          : ResultAsync<Oks, Errs>\n      : never\n    : never\n\n// Converts a reaodnly array into a writable array\ntype Writable<T> = T extends readonly unknown[] ? [...T] : T\n\nexport class ResultAsync<T, E> implements PromiseLike<Result<T, E>> {\n  static fromSafePromise<T, E = never>(promise: PromiseLike<T>): ResultAsync<T, E>\n  static fromSafePromise<T, E = never>(promise: Promise<T>): ResultAsync<T, E> {\n    const newPromise = promise\n      .then((value: T) => Result.ok(value))\n\n    return new ResultAsync<T, E>(newPromise)\n  }\n\n  static fromPromise<T, E>(promise: PromiseLike<T>, errorFn: (e: unknown) => E): ResultAsync<T, E>\n  static fromPromise<T, E>(promise: Promise<T>, errorFn: (e: unknown) => E): ResultAsync<T, E> {\n    const newPromise = promise\n      .then((value: T) => Result.ok(value))\n      .catch(error => Result.err(errorFn(error)))\n\n    return new ResultAsync<T, E>(newPromise)\n  }\n\n  static combine<\n    T extends readonly [ResultAsync<unknown, unknown>, ...Array<ResultAsync<unknown, unknown>>],\n  >(asyncResultList: T): CombineResultAsyncs<T>\n  static combine<T extends ReadonlyArray<ResultAsync<unknown, unknown>>>(\n    asyncResultList: T,\n  ): CombineResultAsyncs<T>\n  static combine<T extends ReadonlyArray<ResultAsync<unknown, unknown>>>(\n    asyncResultList: T,\n  ): CombineResultAsyncs<T> {\n    return (combineResultAsyncList(asyncResultList) as unknown) as CombineResultAsyncs<T>\n  }\n\n  static combineWithAllErrors<\n    T extends readonly [ResultAsync<unknown, unknown>, ...Array<ResultAsync<unknown, unknown>>],\n  >(asyncResultList: T): CombineResultsWithAllErrorsArrayAsync<T>\n  static combineWithAllErrors<T extends ReadonlyArray<ResultAsync<unknown, unknown>>>(\n    asyncResultList: T,\n  ): CombineResultsWithAllErrorsArrayAsync<T>\n  static combineWithAllErrors<T extends ReadonlyArray<ResultAsync<unknown, unknown>>>(\n    asyncResultList: T,\n  ): CombineResultsWithAllErrorsArrayAsync<T> {\n    return combineResultAsyncListWithAllErrors(\n      asyncResultList,\n    ) as CombineResultsWithAllErrorsArrayAsync<T>\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>( // eslint-disable-line unicorn/no-thenable\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>(this.innerPromise.then(async res => {\n      if (res.isOk()) {\n        return okAsync(res.value)\n      }\n\n      return errAsync(await f(res.error))\n    }))\n  }\n\n  map<X>(f: (t: T) => X | Promise<X>): ResultAsync<X, E> {\n    const x = new ResultAsync(\n      this.innerPromise.then(async (res: Result<T, E>) => {\n        if (res.isErr()) {\n          return errAsync(res.error)\n        }\n\n        return okAsync(await f(res.value))\n      }),\n    )\n\n    return x\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(f: any): any {\n    return new ResultAsync(\n      // eslint-disable-next-line @typescript-eslint/no-unsafe-argument\n      this.innerPromise.then(async res => {\n        if (res.isErr()) {\n          return errAsync(res.error)\n        }\n\n        const newValue = f(res.value) // eslint-disable-line @typescript-eslint/no-unsafe-assignment\n        return newValue instanceof ResultAsync ? newValue.innerPromise : newValue // eslint-disable-line @typescript-eslint/no-unsafe-return\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(f: any): any {\n    return new ResultAsync(\n      this.innerPromise.then(async (res: Result<T, E>) => { // eslint-disable-line @typescript-eslint/no-unsafe-argument\n        if (res.isErr()) {\n          return f(res.error) // eslint-disable-line @typescript-eslint/no-unsafe-return\n        }\n\n        return okAsync(res.value)\n      }),\n    )\n  }\n\n  async match<X>(ok: (t: T) => X, _err: (e: E) => X): Promise<X> {\n    return this.innerPromise.then(res => res.match(ok, _err))\n  }\n\n  async unwrapOr<A>(t: A): Promise<T | A> {\n    return this.innerPromise.then(res => res.unwrapOr(t))\n  }\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          // Dont do anything. Its just a tap\n        }\n\n        return okAsync(res.value)\n      }),\n    )\n  }\n\n  /**\n   * Emulates Rust's `?` operator in `safeTry`'s body. See also `safeTry`.\n   */\n  async * safeUnwrap(): AsyncGenerator<Result<never, E>, T> {\n    return yield * await this.innerPromise.then(res => res.safeUnwrap())\n  }\n}\n\nexport function fromSafePromise<T, E = never>(promise: PromiseLike<T>): ResultAsync<T, E>\nexport function fromSafePromise<T, E = never>(promise:\n| PromiseLike<T>\n| Promise<T>): ResultAsync<T, E> {\n  return ResultAsync.fromSafePromise(promise)\n}\n\nexport function fromPromise<T, E>(promise: PromiseLike<T>, errorFn: (e: unknown) => E): ResultAsync<T, E>\nexport function fromPromise<T, E>(promise:\n| PromiseLike<T>\n| Promise<T>, errorFn: (e: unknown) => E): ResultAsync<T, E> {\n  return ResultAsync.fromPromise(promise, errorFn)\n}\n\nexport function okAsync<T, E = never>(value: T): ResultAsync<T, E> {\n  return new ResultAsync<T, E>(Promise.resolve(Result.ok(value)))\n}\n\nexport function errAsync<T = never, E = unknown>(error: E): ResultAsync<T, E> {\n  return new ResultAsync<T, E>(Promise.resolve(Result.err(error)))\n}\n\nexport function fromThrowableAsync<A extends readonly any[], T, E>(\n  fn: (...args: A) => Promise<T>,\n  errorFn?: (err: unknown) => E,\n): (...args: A) => ResultAsync<T, E> {\n  return (...args) => 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\nexport function safeTryAsync<T, E>(\n  body: () => AsyncGenerator<Result<never, E>, Result<T, E>>,\n): ResultAsync<T, E> {\n  return new ResultAsync<T, E>(\n    (async () => {\n      const n = await body().next()\n      if (n.value.isOk()) {\n        return okAsync(n.value.value)\n      }\n\n      return errAsync(n.value.error)\n    })(),\n  )\n}\n\n","/* eslint-disable @typescript-eslint/ban-types */\nimport { ResultAsync } from './result-async.js'\nimport { Result, ok, err } from './result.js'\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>\n  ? Result<RL, RR>\n  : 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// Given a list of Results, this extracts all the different `T` types from that list\nexport type ExtractOkTypes<T extends ReadonlyArray<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 ReadonlyArray<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 ReadonlyArray<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 ReadonlyArray<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// 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// 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// #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.\n    type 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      ...Array<0>,\n    ]\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// 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// 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// 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> = Transpose<CollectResults<T>, [], Depth> extends [\n  infer L,\n  infer R,\n]\n  ? [UnknownMembersToNever<L>, UnknownMembersToNever<R>]\n  : Transpose<CollectResults<T>, [], Depth> extends []\n    ? [[], []]\n    : never\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> = 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> = Combine<T, Depth> extends [\n  infer Oks,\n  infer Errs,\n]\n  ? Result<EmptyArrayToNever<Oks>, EmptyArrayToNever<Errs>>\n  : never\n\nconst appendValueToEndOfList = <T>(value: T) => (list: T[]): T[] => [...list, value]\n\nexport type CombineResults<\n  T extends ReadonlyArray<Result<unknown, unknown>>,\n> = IsLiteralArray<T> extends 1\n  ? Traverse<T>\n  : Result<ExtractOkTypes<T>, ExtractErrTypes<T>[number]>\n\n// Combines the array of results into one result with all errors.\nexport type CombineResultsWithAllErrorsArray<\n  T extends ReadonlyArray<Result<unknown, unknown>>,\n> = IsLiteralArray<T> extends 1\n  ? TraverseWithAllErrors<T>\n  : Result<ExtractOkTypes<T>, Array<ExtractErrTypes<T>[number]>>\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: ReadonlyArray<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 * Short circuits on the FIRST Err value that we find\n */\nexport const combineResultList = <T, E>(\n  resultList: ReadonlyArray<Result<T, E>>,\n): Result<readonly T[], E> =>\n  resultList.reduce<Result<T[], E>>( // eslint-disable-line unicorn/no-array-reduce\n    (acc, result) =>\n      acc.isOk()\n        ? (result.isErr()\n          ? err(result.error)\n          : acc.map(appendValueToEndOfList(result.value)))\n        : acc,\n    ok([]),\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 combineResultAsyncListWithAllErrors = <T, E>(\n  asyncResultList: ReadonlyArray<ResultAsync<T, E>>,\n): ResultAsync<readonly T[], E[]> => {\n  const x = ResultAsync.fromSafePromise(Promise.all(asyncResultList)).andThen(\n    combineResultListWithAllErrors,\n  )\n  return x as ResultAsync<T[], E[]>\n}\n\n/**\n * Give a list of all the errors we find\n */\nexport const combineResultListWithAllErrors = <T, E>(\n  resultList: ReadonlyArray<Result<T, E>>,\n): Result<readonly T[], E[]> =>\n  resultList.reduce<Result<T[], E[]>>( // eslint-disable-line unicorn/no-array-reduce\n    (acc, result) =>\n      result.isErr()\n        ? (acc.isErr()\n          ? err([...acc.error, result.error])\n          : err([result.error]))\n        : (acc.isErr()\n          ? acc\n          : ok([...acc.value, result.value])),\n    ok([]),\n  )\n\n","import { Result } from './result.js'\n\nexport interface ErrorConfig {\n  withStackTrace: boolean\n}\n\nconst defaultErrorConfig: ErrorConfig = {\n  withStackTrace: false,\n}\n\ninterface ResultarError<T, E> {\n  data:\n  | {\n    type: string\n    value: T | undefined\n  }\n  | {\n    type: string\n    value: E | undefined\n  }\n  message: string\n  stack: string | 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  return {\n    data,\n    message,\n    stack: maybeStack,\n  }\n}\n","import {\n  CombineResults, CombineResultsWithAllErrorsArray, InferErrTypes, InferOkTypes, combineResultList, combineResultListWithAllErrors,\n} from './utils.js'\nimport { ErrorConfig, createResultarError } from './error.js'\nimport { ResultAsync, errAsync } from './result-async.js'\n\nclass Ok<T> {\n  readonly ok = true // eslint-disable-line @typescript-eslint/class-literal-property-style\n  constructor(public readonly value: T) {}\n}\n\nclass Err<E> {\n  readonly ok = false // eslint-disable-line @typescript-eslint/class-literal-property-style\n  constructor(public readonly error: E) {}\n}\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\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}\n\n/**\n * A `Result` is a type that represents either success (`Ok`) or failure (`Err`).\n * It is often used to replace exceptions or `null` returns.\n * `Result` is often used to handle errors in a functional way.\n * The `Result` type is often used to handle errors in a functional way.\n */\nexport class Result<T, E> implements Resultable<T, E> {\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    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  static ok<T, E=never>(value: T): Result<T, E> {\n    return new Result<T, E>(new Ok(value))\n  }\n\n  static err<T=never, E=unknown>(error: E): Result<T, E> {\n    return new Result<T, E>(new Err(error))\n  }\n\n  static combine<\n    T extends readonly [Result<unknown, unknown>, ...Array<Result<unknown, unknown>>],\n  >(resultList: T): CombineResults<T>\n  static combine<T extends ReadonlyArray<Result<unknown, unknown>>>(\n    resultList: T,\n  ): CombineResults<T>\n  static combine<\n    T extends readonly [Result<unknown, unknown>, ...Array<Result<unknown, unknown>>],\n  >(resultList: T): CombineResults<T> {\n    return combineResultList(resultList) as CombineResults<T>\n  }\n\n  static combineWithAllErrors<\n    T extends readonly [Result<unknown, unknown>, ...Array<Result<unknown, unknown>>],\n  >(resultList: T): CombineResultsWithAllErrorsArray<T>\n  static combineWithAllErrors<T extends ReadonlyArray<Result<unknown, unknown>>>(\n    resultList: T,\n  ): CombineResultsWithAllErrorsArray<T>\n  static combineWithAllErrors<T extends ReadonlyArray<Result<unknown, unknown>>>(\n    resultList: T,\n  ): CombineResultsWithAllErrorsArray<T> {\n    return combineResultListWithAllErrors(resultList) as CombineResultsWithAllErrorsArray<T>\n  }\n\n  readonly value: T\n  readonly error: E\n\n  private constructor(private readonly state: Ok<T> | Err<E>) {\n    if (state.ok) {\n      this.value = state.value\n      this.error = undefined as E\n    } else {\n      this.error = state.error\n      this.value = undefined as T\n    }\n  }\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    return this.state.ok\n  }\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    return !this.state.ok\n  }\n\n  /**\n   * Maps a `Result<T, E>` to `Result<U, E>`\n   * by applying a function to a contained `Ok` value, leaving an `Err` value\n   * untouched.\n   *\n   * @param f The function to apply an `OK` value\n   * @returns the result of applying `f` or an `Err` untouched\n   */\n  map<X>(f: (t: T) => X): Result<X, E> {\n    if (this.state.ok) {\n      const value = f(this.value)\n      return ok(value)\n    }\n\n    return err(this.error)\n  }\n\n  /**\n   * Maps a `Result<T, E>` to `Result<T, F>` by applying a function to a\n   * contained `Err` value, leaving an `Ok` value untouched.\n   *\n   * This function can be used to pass through a successful result while\n   * handling an error.\n   *\n   * @param f a function to apply to the error `Err` value\n   */\n  mapErr<X>(fn: (t: E) => X): Result<T, X> {\n    if (this.state.ok) {\n      return ok(this.value)\n    }\n\n    return err(fn(this.error))\n  }\n\n  /**\n   * Similar to `map` Except you must return a new `Result`.\n   *\n   * This is useful for when you need to do a subsequent computation using the\n   * inner `T` value, but that computation might fail.\n   * Additionally, `andThen` is really useful as a tool to flatten a\n   * `Result<Result<A, E2>, E1>` into a `Result<A, E2>` (see example below).\n   *\n   * @param f The function to apply to the current value\n   */\n  andThen<X, Y>(f: (t: T) => Result<X, Y>): Result<X, E | Y> {\n    if (this.state.ok) {\n      return f(this.value)\n    }\n\n    return err(this.error)\n  }\n\n  /**\n   * Takes an `Err` value and maps it to a `Result<T, SomeNewType>`.\n   *\n   * This is useful for error recovery.\n   *\n   *\n   * @param f  A function to apply to an `Err` value, leaving `Ok` values\n   * untouched.\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    if (this.state.ok) {\n      return ok(this.value as Exclude<T, Promise<any>>)\n    }\n\n    return f(this.error)\n  }\n\n  /**\n   * Similar to `map` Except you must return a new `Result`.\n   *\n   * This is useful for when you need to do a subsequent async computation using\n   * the inner `T` value, but that computation might fail. Must return a ResultAsync\n   *\n   * @param f The function that returns a `ResultAsync` to apply to the current\n   * value\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    if (this.state.ok) {\n      return f(this.value)\n    }\n\n    return errAsync(this.error)\n  }\n\n  /**\n   * Maps a `Result<T, E>` to `ResultAsync<U, E>`\n   * by applying an async function to a contained `Ok` value, leaving an `Err`\n   * value untouched.\n   *\n   * @param f An async function to apply an `OK` value\n   */\n  asyncMap<X>(f: (t: T) => Promise<X>): ResultAsync<X, E> {\n    if (this.state.ok) {\n      return ResultAsync.fromSafePromise(f(this.value))\n    }\n\n    return errAsync(this.error)\n  }\n\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  unwrapOr<A>(defaultValue: A): T | A {\n    if (this.state.ok) {\n      return this.value\n    }\n\n    return defaultValue\n  }\n\n  /**\n   *\n   * Given 2 functions (one for the `Ok` variant and one for the `Err` variant)\n   * execute the function that matches the `Result` variant.\n   *\n   * Match callbacks do not necessitate to return a `Result`, however you can\n   * return a `Result` if you want to.\n   *\n   * `match` is like chaining `map` and `mapErr`, with the distinction that\n   * with `match` both functions must have the same return type.\n   *\n   * @param ok\n   * @param err\n   */\n  match<X>(fnOk: (t: T) => X, fnErr: (e: E) => X): X {\n    if (this.state.ok) {\n      return fnOk(this.value)\n    }\n\n    return fnErr(this.error)\n  }\n\n  /**\n   * Performs a side effect for the `Ok` variant of `Result`.\n   *\n   * @param f The function to apply an `OK` value\n   * @returns the result of applying `f` or an `Err` untouched\n   */\n  tap(f: (t: T) => void): Result<T, E> {\n    if (this.state.ok) {\n      try {\n        f(this.value)\n      } catch {\n        // Dont do anything. Its just a tap\n      }\n\n      return ok(this.value)\n    }\n\n    return err(this.error)\n  }\n\n  /**\n   * This method is used to clean up and release any resources that the `Result`\n   * @param f The function that will be called to clean up the resources\n   */\n  finally<X=T, Y=E>(f: (value: X, error: Y) => void): DisposableResult<X, Y>\n  finally(f: (value: T, error: E) => void): DisposableResult<T, E> {\n    const resultDisposable = new DisposableResult(this, f)\n    try {\n      return resultDisposable\n    } finally {\n      resultDisposable[Symbol.dispose]() // eslint-disable-line no-use-extend-native/no-use-extend-native\n    }\n  }\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    if (this.state.ok) {\n      return this.value\n    }\n\n    throw createResultarError('Called `_unsafeUnwrap` on an Err', this, config) // eslint-disable-line @typescript-eslint/no-throw-literal\n  }\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    if (this.state.ok) {\n      throw createResultarError('Called `_unsafeUnwrapErr` on an Ok', this, config) // eslint-disable-line @typescript-eslint/no-throw-literal\n    }\n\n    return this.error\n  }\n\n  safeUnwrap(): Generator<Result<never, E>, T> {\n    if (this.state.ok) {\n      const { value } = this\n      /* eslint-disable-next-line require-yield */\n      return (function * () {\n        return value\n      })()\n    }\n\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  constructor(readonly result: Resultable<T, E>,\n    private readonly finalizer: (value: T, error: E) => void) {}\n\n  get value(): T {\n    return this.result.value\n  }\n\n  get error(): E {\n    return this.result.error\n  }\n\n  _unsafeUnwrap(config?: ErrorConfig | undefined): T {\n    return this.result._unsafeUnwrap(config)\n  }\n\n  _unsafeUnwrapErr(config?: ErrorConfig | undefined): 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    this.finalizer(this.result.value, this.result.error)\n  }\n}\n\nexport const ok = <T, E = never>(value: T): Result<T, E> => Result.ok(value)\nexport const err = <T = never, E = unknown>(error: E): Result<T, E> => Result.err(error)\nexport const fromThrowable = <Fn extends (...args: readonly any[]) => unknown, E>(\n  fn: Fn,\n  errorFn?: (e: any) => E,\n): (...args: Parameters<Fn>) => Result<ReturnType<Fn>, E> => Result.fromThrowable(fn, errorFn)\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>\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()` and\n * `yield* resultAsync.safeUnwrap()` work as Rust's `result?` expression.\n * @returns The first occurence of either an yielded Err or a returned Result.\n */\n// NOTE:\n// Since body is potentially throwable because `await` can be used in it,\n// Promise<Result<T, E>>, not ResultAsync<T, E>, is used as the return type.\nexport function safeTry<T, E>(\n  body: () => AsyncGenerator<Result<never, E>, Result<T, E>>,\n): Promise<Result<T, E>>\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> | Promise<Result<T, E>> {\n  const n = body().next()\n  if (n instanceof Promise) {\n    return n.then(r => r.value)\n  }\n\n  return n.value\n}\n\n"],"mappings":"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","names":["ok"]}
+{"version":3,"sources":["../src/index.ts","../src/result-async.ts","../src/utils.ts","../src/error.ts","../src/result.ts"],"sourcesContent":["export {\n  Result, ok, err, fromThrowable, safeTry,\n} from './result.js'\nexport {\n  ResultAsync, okAsync, errAsync, fromPromise, fromSafePromise, safeTryAsync, fromThrowableAsync,\n} from './result-async.js'\n","/* eslint-disable @typescript-eslint/ban-types */\n\nimport {\n  Result,\n} from './result.js'\nimport {\n  Combine,\n  Dedup,\n  EmptyArrayToNever,\n  ExtractErrAsyncTypes,\n  ExtractOkAsyncTypes,\n  InferAsyncErrTypes, InferAsyncOkTypes, InferErrTypes, InferOkTypes,\n  IsLiteralArray,\n  MemberListOf,\n  MembersToUnion,\n  combineResultAsyncList,\n  combineResultAsyncListWithAllErrors,\n} from './utils.js'\n\n// Combines the array of async results into one result.\nexport type CombineResultAsyncs<\n  T extends ReadonlyArray<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 ReadonlyArray<ResultAsync<unknown, unknown>>,\n> = IsLiteralArray<T> extends 1\n  ? TraverseWithAllErrorsAsync<UnwrapAsync<T>>\n  : ResultAsync<ExtractOkAsyncTypes<T>, Array<ExtractErrAsyncTypes<T>[number]>>\n\n// Unwraps the inner `Result` from a `ResultAsync` for all elements.\ntype UnwrapAsync<T> = 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 Array<infer A>\n    ? A extends PromiseLike<infer HI>\n      ? HI extends Result<infer L, infer R>\n        ? Array<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> = 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 Array<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<Array<Oks[number]>>, MembersToUnion<Array<Errs[number]>>>\n          : ResultAsync<EmptyArrayToNever<Array<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<Array<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 order. For the checks/conditions made here, see that type\n// for the documentation.\ntype TraverseWithAllErrorsAsync<T, Depth extends number = 5> = IsLiteralArray<T> extends 1\n  ? Combine<T, Depth> extends [infer Oks, infer Errs]\n    ? ResultAsync<EmptyArrayToNever<Oks>, EmptyArrayToNever<Errs>>\n    : never\n  : Writable<T> extends Array<infer I>\n    ? Combine<MemberListOf<I>, Depth> extends [infer Oks, infer Errs]\n      ? Oks extends unknown[]\n        ? Errs extends unknown[]\n          ? ResultAsync<EmptyArrayToNever<Array<Oks[number]>>, EmptyArrayToNever<Array<Errs[number]>>>\n          : ResultAsync<EmptyArrayToNever<Array<Oks[number]>>, Errs>\n        : Errs extends unknown[]\n          ? ResultAsync<Oks, EmptyArrayToNever<Array<Errs[number]>>>\n          : ResultAsync<Oks, Errs>\n      : never\n    : never\n\n// Converts a reaodnly array into a writable array\ntype Writable<T> = T extends readonly unknown[] ? [...T] : T\n\nexport class DisposableResultAsync<T, E> implements PromiseLike<Result<T, E>> {\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>( // eslint-disable-line unicorn/no-thenable\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\nexport class ResultAsync<T, E> implements PromiseLike<Result<T, E>> {\n  static okAsync<T, E = never>(value: T): ResultAsync<T, E> {\n    return new ResultAsync<T, E>(Promise.resolve(Result.ok(value)))\n  }\n\n  static errAsync<T = never, E = unknown>(error: E): ResultAsync<T, E> {\n    return new ResultAsync<T, E>(Promise.resolve(Result.err(error)))\n  }\n\n  static fromSafePromise<T, E = never>(promise: PromiseLike<T>): ResultAsync<T, E>\n  static fromSafePromise<T, E = never>(promise: Promise<T>): ResultAsync<T, E> {\n    const newPromise = promise\n      .then((value: T) => Result.ok(value))\n\n    return new ResultAsync<T, E>(newPromise)\n  }\n\n  static fromPromise<T, E>(promise: PromiseLike<T>, errorFn: (e: unknown) => E): ResultAsync<T, E>\n  static fromPromise<T, E>(promise: Promise<T>, errorFn: (e: unknown) => E): ResultAsync<T, E> {\n    const newPromise = promise\n      .then((value: T) => Result.ok(value))\n      .catch(error => Result.err(errorFn(error)))\n\n    return new ResultAsync<T, E>(newPromise)\n  }\n\n  static combine<\n    T extends readonly [ResultAsync<unknown, unknown>, ...Array<ResultAsync<unknown, unknown>>],\n  >(asyncResultList: T): CombineResultAsyncs<T>\n  static combine<T extends ReadonlyArray<ResultAsync<unknown, unknown>>>(\n    asyncResultList: T,\n  ): CombineResultAsyncs<T>\n  static combine<T extends ReadonlyArray<ResultAsync<unknown, unknown>>>(\n    asyncResultList: T,\n  ): CombineResultAsyncs<T> {\n    return (combineResultAsyncList(asyncResultList) as unknown) as CombineResultAsyncs<T>\n  }\n\n  static combineWithAllErrors<\n    T extends readonly [ResultAsync<unknown, unknown>, ...Array<ResultAsync<unknown, unknown>>],\n  >(asyncResultList: T): CombineResultsWithAllErrorsArrayAsync<T>\n  static combineWithAllErrors<T extends ReadonlyArray<ResultAsync<unknown, unknown>>>(\n    asyncResultList: T,\n  ): CombineResultsWithAllErrorsArrayAsync<T>\n  static combineWithAllErrors<T extends ReadonlyArray<ResultAsync<unknown, unknown>>>(\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 any[], T, E>(\n    fn: (...args: A) => Promise<T>,\n    errorFn?: (err: unknown) => E,\n  ): (...args: A) => ResultAsync<T, E> {\n    return (...args) => 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>( // eslint-disable-line unicorn/no-thenable\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>(this.innerPromise.then(async res => {\n      if (res.isOk()) {\n        return okAsync(res.value)\n      }\n\n      return errAsync(await f(res.error))\n    }))\n  }\n\n  map<X>(f: (t: T) => X | Promise<X>): ResultAsync<X, E> {\n    const x = new ResultAsync(\n      this.innerPromise.then(async (res: Result<T, E>) => {\n        if (res.isErr()) {\n          return errAsync(res.error)\n        }\n\n        return okAsync(await f(res.value))\n      }),\n    )\n\n    return x\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(f: any): any {\n    return new ResultAsync(\n      // eslint-disable-next-line @typescript-eslint/no-unsafe-argument\n      this.innerPromise.then(async res => {\n        if (res.isErr()) {\n          return errAsync(res.error)\n        }\n\n        const newValue = f(res.value) // eslint-disable-line @typescript-eslint/no-unsafe-assignment\n        return newValue instanceof ResultAsync ? newValue.innerPromise : newValue // eslint-disable-line @typescript-eslint/no-unsafe-return\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(f: any): any {\n    return new ResultAsync(\n      this.innerPromise.then(async (res: Result<T, E>) => { // eslint-disable-line @typescript-eslint/no-unsafe-argument\n        if (res.isErr()) {\n          return f(res.error) // eslint-disable-line @typescript-eslint/no-unsafe-return\n        }\n\n        return okAsync(res.value)\n      }),\n    )\n  }\n\n  async match<X>(ok: (t: T) => X, _err: (e: E) => X): Promise<X> {\n    return this.innerPromise.then(res => res.match(ok, _err))\n  }\n\n  async unwrapOr<A>(t: A): Promise<T | A> {\n    return this.innerPromise.then(res => res.unwrapOr(t))\n  }\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          // Dont do anything. Its just a tap\n        }\n\n        return okAsync(res.value)\n      }),\n    )\n  }\n\n  finally(f: (value: T, error: E) => void): DisposableResultAsync<T, E> {\n    return new DisposableResultAsync(\n      this.innerPromise.then(async res => {\n        try {\n          res.finally(f)\n        } catch {\n          // Dont do anything. Its just a finally\n        }\n\n        return res\n      }),\n    )\n  }\n\n  /**\n   * Emulates Rust's `?` operator in `safeTry`'s body. See also `safeTry`.\n   */\n  async * safeUnwrap(): AsyncGenerator<Result<never, E>, T> {\n    return yield * await this.innerPromise.then(res => res.safeUnwrap())\n  }\n}\n\nexport const { okAsync, errAsync, fromPromise, fromSafePromise } = ResultAsync\nexport const fromThrowableAsync = ResultAsync.fromThrowable\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 `ResultAsync`.\n */\nexport function safeTryAsync<T, E>(\n  body: () => AsyncGenerator<Result<never, E>, Result<T, E>>,\n): ResultAsync<T, E> {\n  return new ResultAsync<T, E>(\n    (async () => {\n      const n = await body().next()\n      if (n.value.isOk()) {\n        return okAsync(n.value.value)\n      }\n\n      return errAsync(n.value.error)\n    })(),\n  )\n}\n\n","/* eslint-disable @typescript-eslint/ban-types */\nimport { ResultAsync } from './result-async.js'\nimport { Result, ok, err } from './result.js'\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>\n  ? Result<RL, RR>\n  : 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// Given a list of Results, this extracts all the different `T` types from that list\nexport type ExtractOkTypes<T extends ReadonlyArray<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 ReadonlyArray<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 ReadonlyArray<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 ReadonlyArray<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// 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// 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// #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.\n    type 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      ...Array<0>,\n    ]\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// 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// 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// 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> = Transpose<CollectResults<T>, [], Depth> extends [\n  infer L,\n  infer R,\n]\n  ? [UnknownMembersToNever<L>, UnknownMembersToNever<R>]\n  : Transpose<CollectResults<T>, [], Depth> extends []\n    ? [[], []]\n    : never\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> = 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> = Combine<T, Depth> extends [\n  infer Oks,\n  infer Errs,\n]\n  ? Result<EmptyArrayToNever<Oks>, EmptyArrayToNever<Errs>>\n  : never\n\nconst appendValueToEndOfList = <T>(value: T) => (list: T[]): T[] => [...list, value]\n\nexport type CombineResults<\n  T extends ReadonlyArray<Result<unknown, unknown>>,\n> = IsLiteralArray<T> extends 1\n  ? Traverse<T>\n  : Result<ExtractOkTypes<T>, ExtractErrTypes<T>[number]>\n\n// Combines the array of results into one result with all errors.\nexport type CombineResultsWithAllErrorsArray<\n  T extends ReadonlyArray<Result<unknown, unknown>>,\n> = IsLiteralArray<T> extends 1\n  ? TraverseWithAllErrors<T>\n  : Result<ExtractOkTypes<T>, Array<ExtractErrTypes<T>[number]>>\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: ReadonlyArray<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 * Short circuits on the FIRST Err value that we find\n */\nexport const combineResultList = <T, E>(\n  resultList: ReadonlyArray<Result<T, E>>,\n): Result<readonly T[], E> =>\n  resultList.reduce<Result<T[], E>>( // eslint-disable-line unicorn/no-array-reduce\n    (acc, result) =>\n      acc.isOk()\n        ? (result.isErr()\n          ? err(result.error)\n          : acc.map(appendValueToEndOfList(result.value)))\n        : acc,\n    ok([]),\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 combineResultAsyncListWithAllErrors = <T, E>(\n  asyncResultList: ReadonlyArray<ResultAsync<T, E>>,\n): ResultAsync<readonly T[], E[]> => {\n  const x = ResultAsync.fromSafePromise(Promise.all(asyncResultList)).andThen(\n    combineResultListWithAllErrors,\n  )\n  return x as ResultAsync<T[], E[]>\n}\n\n/**\n * Give a list of all the errors we find\n */\nexport const combineResultListWithAllErrors = <T, E>(\n  resultList: ReadonlyArray<Result<T, E>>,\n): Result<readonly T[], E[]> =>\n  resultList.reduce<Result<T[], E[]>>( // eslint-disable-line unicorn/no-array-reduce\n    (acc, result) =>\n      result.isErr()\n        ? (acc.isErr()\n          ? err([...acc.error, result.error])\n          : err([result.error]))\n        : (acc.isErr()\n          ? acc\n          : ok([...acc.value, result.value])),\n    ok([]),\n  )\n\n","import { Result } from './result.js'\n\nexport interface ErrorConfig {\n  withStackTrace: boolean\n}\n\nconst defaultErrorConfig: ErrorConfig = {\n  withStackTrace: false,\n}\n\ninterface ResultarError<T, E> {\n  data:\n  | {\n    type: string\n    value: T | undefined\n  }\n  | {\n    type: string\n    value: E | undefined\n  }\n  message: string\n  stack: string | 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  return {\n    data,\n    message,\n    stack: maybeStack,\n  }\n}\n","import {\n  CombineResults, CombineResultsWithAllErrorsArray, InferErrTypes, InferOkTypes, combineResultList, combineResultListWithAllErrors,\n} from './utils.js'\nimport { ErrorConfig, createResultarError } from './error.js'\nimport { ResultAsync, errAsync } from './result-async.js'\n\nclass Ok<T> {\n  readonly ok = true // eslint-disable-line @typescript-eslint/class-literal-property-style\n  constructor(public readonly value: T) {}\n}\n\nclass Err<E> {\n  readonly ok = false // eslint-disable-line @typescript-eslint/class-literal-property-style\n  constructor(public readonly error: E) {}\n}\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\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}\n\n/**\n * A `Result` is a type that represents either success (`Ok`) or failure (`Err`).\n * It is often used to replace exceptions or `null` returns.\n * `Result` is often used to handle errors in a functional way.\n * The `Result` type is often used to handle errors in a functional way.\n */\nexport class Result<T, E> implements Resultable<T, E> {\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    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  static ok<T, E=never>(value: T): Result<T, E> {\n    return new Result<T, E>(new Ok(value))\n  }\n\n  static err<T=never, E=unknown>(error: E): Result<T, E> {\n    return new Result<T, E>(new Err(error))\n  }\n\n  static combine<\n    T extends readonly [Result<unknown, unknown>, ...Array<Result<unknown, unknown>>],\n  >(resultList: T): CombineResults<T>\n  static combine<T extends ReadonlyArray<Result<unknown, unknown>>>(\n    resultList: T,\n  ): CombineResults<T>\n  static combine<\n    T extends readonly [Result<unknown, unknown>, ...Array<Result<unknown, unknown>>],\n  >(resultList: T): CombineResults<T> {\n    return combineResultList(resultList) as CombineResults<T>\n  }\n\n  static combineWithAllErrors<\n    T extends readonly [Result<unknown, unknown>, ...Array<Result<unknown, unknown>>],\n  >(resultList: T): CombineResultsWithAllErrorsArray<T>\n  static combineWithAllErrors<T extends ReadonlyArray<Result<unknown, unknown>>>(\n    resultList: T,\n  ): CombineResultsWithAllErrorsArray<T>\n  static combineWithAllErrors<T extends ReadonlyArray<Result<unknown, unknown>>>(\n    resultList: T,\n  ): CombineResultsWithAllErrorsArray<T> {\n    return combineResultListWithAllErrors(resultList) as CombineResultsWithAllErrorsArray<T>\n  }\n\n  readonly value: T\n  readonly error: E\n\n  private constructor(private readonly state: Ok<T> | Err<E>) {\n    if (state.ok) {\n      this.value = state.value\n      this.error = undefined as E\n    } else {\n      this.error = state.error\n      this.value = undefined as T\n    }\n  }\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    return this.state.ok\n  }\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    return !this.state.ok\n  }\n\n  /**\n   * Maps a `Result<T, E>` to `Result<U, E>`\n   * by applying a function to a contained `Ok` value, leaving an `Err` value\n   * untouched.\n   *\n   * @param f The function to apply an `OK` value\n   * @returns the result of applying `f` or an `Err` untouched\n   */\n  map<X>(f: (t: T) => X): Result<X, E> {\n    if (this.state.ok) {\n      const value = f(this.value)\n      return ok(value)\n    }\n\n    return err(this.error)\n  }\n\n  /**\n   * Maps a `Result<T, E>` to `Result<T, F>` by applying a function to a\n   * contained `Err` value, leaving an `Ok` value untouched.\n   *\n   * This function can be used to pass through a successful result while\n   * handling an error.\n   *\n   * @param f a function to apply to the error `Err` value\n   */\n  mapErr<X>(fn: (t: E) => X): Result<T, X> {\n    if (this.state.ok) {\n      return ok(this.value)\n    }\n\n    return err(fn(this.error))\n  }\n\n  /**\n   * Similar to `map` Except you must return a new `Result`.\n   *\n   * This is useful for when you need to do a subsequent computation using the\n   * inner `T` value, but that computation might fail.\n   * Additionally, `andThen` is really useful as a tool to flatten a\n   * `Result<Result<A, E2>, E1>` into a `Result<A, E2>` (see example below).\n   *\n   * @param f The function to apply to the current value\n   */\n  andThen<X, Y>(f: (t: T) => Result<X, Y>): Result<X, E | Y> {\n    if (this.state.ok) {\n      return f(this.value)\n    }\n\n    return err(this.error)\n  }\n\n  /**\n   * Takes an `Err` value and maps it to a `Result<T, SomeNewType>`.\n   *\n   * This is useful for error recovery.\n   *\n   *\n   * @param f  A function to apply to an `Err` value, leaving `Ok` values\n   * untouched.\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    if (this.state.ok) {\n      return ok(this.value as Exclude<T, Promise<any>>)\n    }\n\n    return f(this.error)\n  }\n\n  /**\n   * Similar to `map` Except you must return a new `Result`.\n   *\n   * This is useful for when you need to do a subsequent async computation using\n   * the inner `T` value, but that computation might fail. Must return a ResultAsync\n   *\n   * @param f The function that returns a `ResultAsync` to apply to the current\n   * value\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    if (this.state.ok) {\n      return f(this.value)\n    }\n\n    return errAsync(this.error)\n  }\n\n  /**\n   * Maps a `Result<T, E>` to `ResultAsync<U, E>`\n   * by applying an async function to a contained `Ok` value, leaving an `Err`\n   * value untouched.\n   *\n   * @param f An async function to apply an `OK` value\n   */\n  asyncMap<X>(f: (t: T) => Promise<X>): ResultAsync<X, E> {\n    if (this.state.ok) {\n      return ResultAsync.fromSafePromise(f(this.value))\n    }\n\n    return errAsync(this.error)\n  }\n\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  unwrapOr<A>(defaultValue: A): T | A {\n    if (this.state.ok) {\n      return this.value\n    }\n\n    return defaultValue\n  }\n\n  /**\n   *\n   * Given 2 functions (one for the `Ok` variant and one for the `Err` variant)\n   * execute the function that matches the `Result` variant.\n   *\n   * Match callbacks do not necessitate to return a `Result`, however you can\n   * return a `Result` if you want to.\n   *\n   * `match` is like chaining `map` and `mapErr`, with the distinction that\n   * with `match` both functions must have the same return type.\n   *\n   * @param ok\n   * @param err\n   */\n  match<X>(fnOk: (t: T) => X, fnErr: (e: E) => X): X {\n    if (this.state.ok) {\n      return fnOk(this.value)\n    }\n\n    return fnErr(this.error)\n  }\n\n  /**\n   * Performs a side effect for the `Ok` variant of `Result`.\n   *\n   * @param f The function to apply an `OK` value\n   * @returns the result of applying `f` or an `Err` untouched\n   */\n  tap(f: (t: T) => void): Result<T, E> {\n    if (this.state.ok) {\n      try {\n        f(this.value)\n      } catch {\n        // Dont do anything. Its just a tap\n      }\n\n      return ok(this.value)\n    }\n\n    return err(this.error)\n  }\n\n  /**\n   * This method is used to clean up and release any resources that the `Result`\n   * @param f The function that will be called to clean up the resources\n   */\n  finally<X=T, Y=E>(f: (value: X, error: Y) => void): DisposableResult<X, Y>\n  finally(f: (value: T, error: E) => void): DisposableResult<T, E> {\n    const resultDisposable = new DisposableResult(this, f)\n    try {\n      return resultDisposable\n    } finally {\n      resultDisposable[Symbol.dispose]() // eslint-disable-line no-use-extend-native/no-use-extend-native\n    }\n  }\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    if (this.state.ok) {\n      return this.value\n    }\n\n    throw createResultarError('Called `_unsafeUnwrap` on an Err', this, config) // eslint-disable-line @typescript-eslint/no-throw-literal\n  }\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    if (this.state.ok) {\n      throw createResultarError('Called `_unsafeUnwrapErr` on an Ok', this, config) // eslint-disable-line @typescript-eslint/no-throw-literal\n    }\n\n    return this.error\n  }\n\n  safeUnwrap(): Generator<Result<never, E>, T> {\n    if (this.state.ok) {\n      const { value } = this\n      /* eslint-disable-next-line require-yield */\n      return (function * () {\n        return value\n      })()\n    }\n\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  constructor(readonly result: Resultable<T, E>,\n    private readonly finalizer: (value: T, error: E) => void) {}\n\n  get value(): T {\n    return this.result.value\n  }\n\n  get error(): E {\n    return this.result.error\n  }\n\n  _unsafeUnwrap(config?: ErrorConfig | undefined): T {\n    return this.result._unsafeUnwrap(config)\n  }\n\n  _unsafeUnwrapErr(config?: ErrorConfig | undefined): 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    this.finalizer(this.result.value, this.result.error)\n  }\n}\n\nexport const { ok, err, fromThrowable } = Result\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>\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()` and\n * `yield* resultAsync.safeUnwrap()` work as Rust's `result?` expression.\n * @returns The first occurence of either an yielded Err or a returned Result.\n */\n// NOTE:\n// Since body is potentially throwable because `await` can be used in it,\n// Promise<Result<T, E>>, not ResultAsync<T, E>, is used as the return type.\nexport function safeTry<T, E>(\n  body: () => AsyncGenerator<Result<never, E>, Result<T, E>>,\n): Promise<Result<T, E>>\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> | Promise<Result<T, E>> {\n  const n = body().next()\n  if (n instanceof Promise) {\n    return n.then(r => r.value)\n  }\n\n  return n.value\n}\n\n"],"mappings":"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","names":["ok"]}

package/dist/index.d.cts

@@ -1 +1 @@
-export { x as Result, R as ResultAsync, A as err, e as errAsync, b as fromPromise, f as fromSafePromise, B as fromThrowable, c as fromThrowableAsync, z as ok, o as okAsync, F as safeTry, s as safeTryAsync } from './index-9lE2iSGp.cjs';
+export { y as Result, R as ResultAsync, B as err, e as errAsync, f as fromPromise, b as fromSafePromise, F as fromThrowable, c as fromThrowableAsync, A as ok, o as okAsync, G as safeTry, s as safeTryAsync } from './index-NFyjn3tp.cjs';

package/dist/index.d.ts

@@ -1 +1 @@
-export { x as Result, R as ResultAsync, A as err, e as errAsync, b as fromPromise, f as fromSafePromise, B as fromThrowable, c as fromThrowableAsync, z as ok, o as okAsync, F as safeTry, s as safeTryAsync } from './index-9lE2iSGp.js';
+export { y as Result, R as ResultAsync, B as err, e as errAsync, f as fromPromise, b as fromSafePromise, F as fromThrowable, c as fromThrowableAsync, A as ok, o as okAsync, G as safeTry, s as safeTryAsync } from './index-NFyjn3tp.js';

package/dist/index.js

@@ -11,7 +11,7 @@ import {
   okAsync,
   safeTry,
   safeTryAsync
-} from "./chunk-MBKNXNSW.js";
+} from "./chunk-DGYSVV77.js";
 import "./chunk-FBVQYZXO.js";
 export {
   Result,

package/dist/result-async.cjs

@@ -20,6 +20,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/result-async.ts
 var result_async_exports = {};
 __export(result_async_exports, {
+  DisposableResultAsync: () => DisposableResultAsync,
   ResultAsync: () => ResultAsync,
   errAsync: () => errAsync,
   fromPromise: () => fromPromise,
@@ -339,11 +340,25 @@ var DisposableResult = class {
     this.finalizer(this.result.value, this.result.error);
   }
 };
-var ok = (value) => Result2.ok(value);
-var err = (error) => Result2.err(error);
+var { ok, err, fromThrowable } = Result2;
 
 // src/result-async.ts
+var DisposableResultAsync = class {
+  innerPromise;
+  constructor(res) {
+    this.innerPromise = res;
+  }
+  then(successCallback, failureCallback) {
+    return this.innerPromise.then(successCallback, failureCallback);
+  }
+};
 var ResultAsync = class _ResultAsync {
+  static okAsync(value) {
+    return new _ResultAsync(Promise.resolve(Result2.ok(value)));
+  }
+  static errAsync(error) {
+    return new _ResultAsync(Promise.resolve(Result2.err(error)));
+  }
   static fromSafePromise(promise) {
     const newPromise = promise.then((value) => Result2.ok(value));
     return new _ResultAsync(newPromise);
@@ -360,6 +375,27 @@ var ResultAsync = class _ResultAsync {
       asyncResultList
     );
   }
+  /**
+  * Wraps a async function with a try catch, creating a new function with the same
+  * arguments but returning `Ok` if successful, `Err` if the function throws
+  *
+  * @param fn function to wrap with ok on success or err on failure
+  * @param errorFn when an error is thrown, this will wrap the error result if provided
+  * @returns a new function that returns a `ResultAsync`
+  */
+  static fromThrowable(fn, errorFn) {
+    return (...args) => new _ResultAsync(
+      (async () => {
+        try {
+          const v = await fn(...args);
+          return Result2.ok(v);
+        } catch (error) {
+          const e = errorFn ? errorFn(error) : error;
+          return Result2.err(e);
+        }
+      })()
+    );
+  }
   innerPromise;
   constructor(res) {
     this.innerPromise = res;
@@ -428,6 +464,17 @@ var ResultAsync = class _ResultAsync {
       })
     );
   }
+  finally(f) {
+    return new DisposableResultAsync(
+      this.innerPromise.then(async (res) => {
+        try {
+          res.finally(f);
+        } catch {
+        }
+        return res;
+      })
+    );
+  }
   /**
    * Emulates Rust's `?` operator in `safeTry`'s body. See also `safeTry`.
    */
@@ -435,31 +482,8 @@ var ResultAsync = class _ResultAsync {
     return yield* await this.innerPromise.then((res) => res.safeUnwrap());
   }
 };
-function fromSafePromise(promise) {
-  return ResultAsync.fromSafePromise(promise);
-}
-function fromPromise(promise, errorFn) {
-  return ResultAsync.fromPromise(promise, errorFn);
-}
-function okAsync(value) {
-  return new ResultAsync(Promise.resolve(Result2.ok(value)));
-}
-function errAsync(error) {
-  return new ResultAsync(Promise.resolve(Result2.err(error)));
-}
-function fromThrowableAsync(fn, errorFn) {
-  return (...args) => new ResultAsync(
-    (async () => {
-      try {
-        const v = await fn(...args);
-        return Result2.ok(v);
-      } catch (error) {
-        const e = errorFn ? errorFn(error) : error;
-        return Result2.err(e);
-      }
-    })()
-  );
-}
+var { okAsync, errAsync, fromPromise, fromSafePromise } = ResultAsync;
+var fromThrowableAsync = ResultAsync.fromThrowable;
 function safeTryAsync(body) {
   return new ResultAsync(
     (async () => {
@@ -473,6 +497,7 @@ function safeTryAsync(body) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  DisposableResultAsync,
   ResultAsync,
   errAsync,
   fromPromise,