resultar 0.5.0

package/dist/index-CyqyqPfg.d.ts

@@ -0,0 +1,196 @@
+declare class ResultAsync<T, E> implements PromiseLike<Result<T, E>> {
+    static fromSafePromise<T, E = never>(promise: PromiseLike<T>): ResultAsync<T, E>;
+    static fromPromise<T, E>(promise: PromiseLike<T>, errorFn: (e: unknown) => E): ResultAsync<T, E>;
+    private readonly innerPromise;
+    constructor(res: Promise<Result<T, E>>);
+    then<A, B>(// eslint-disable-line unicorn/no-thenable
+    successCallback?: (res: Result<T, E>) => A | PromiseLike<A>, failureCallback?: (reason: unknown) => B | PromiseLike<B>): PromiseLike<A | B>;
+    mapErr<U>(f: (t: E) => U | Promise<U>): ResultAsync<T, U>;
+    map<X>(f: (t: T) => X | Promise<X>): ResultAsync<X, E>;
+    andThen<R extends Result<unknown, unknown>>(f: (t: T) => R): ResultAsync<R, R | E>;
+    andThen<R extends ResultAsync<unknown, unknown>>(f: (t: T) => R): ResultAsync<R, R | E>;
+    andThen<X, Y>(f: (t: T) => ResultAsync<X, Y>): ResultAsync<X, E | Y>;
+    match<X>(ok: (t: T) => X, _err: (e: E) => X): Promise<X>;
+    /**
+     * Emulates Rust's `?` operator in `safeTry`'s body. See also `safeTry`.
+     */
+    safeUnwrap(): AsyncGenerator<Result<never, E>, T>;
+}
+declare function fromSafePromise<T, E = never>(promise: PromiseLike<T>): ResultAsync<T, E>;
+declare function fromPromise<T, E>(promise: PromiseLike<T>, errorFn: (e: unknown) => E): ResultAsync<T, E>;
+declare function okAsync<T, E = never>(value: T): ResultAsync<T, E>;
+declare function errAsync<T = never, E = unknown>(error: E): ResultAsync<T, E>;
+declare function safeTryAsync<T, E>(body: () => AsyncGenerator<Result<never, E>, Result<T, E>>): ResultAsync<T, E>;
+
+declare class Result<T, E> {
+    private readonly state;
+    /**
+     * Wraps a 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
+     */
+    static fromThrowable<Fn extends (...args: readonly any[]) => unknown, E>(fn: Fn, errorFn?: (e: any) => E): (...args: Parameters<Fn>) => Result<ReturnType<Fn>, E>;
+    static ok<T, E = never>(value: T): Result<T, E>;
+    static err<T = never, E = unknown>(error: E): Result<T, E>;
+    readonly value: T;
+    readonly error: E;
+    private constructor();
+    /**
+     * Used to check if a `Result` is an `OK`
+     *
+     * @returns `true` if the result is an `OK` variant of Result
+     */
+    isOk(): boolean;
+    /**
+     * Used to check if a `Result` is an `Err`
+     *
+     * @returns `true` if the result is an `Err` variant of Result
+     */
+    isErr(): boolean;
+    /**
+     * Maps a `Result<T, E>` to `Result<U, E>`
+     * by applying a function to a contained `Ok` value, leaving an `Err` value
+     * untouched.
+     *
+     * @param f The function to apply an `OK` value
+     * @returns the result of applying `f` or an `Err` untouched
+     */
+    map<X, Y>(f: (t: T) => Exclude<X, Promise<any>>): Result<X, E | Y>;
+    /**
+     * Maps a `Result<T, E>` to `Result<T, F>` by applying a function to a
+     * contained `Err` value, leaving an `Ok` value untouched.
+     *
+     * This function can be used to pass through a successful result while
+     * handling an error.
+     *
+     * @param f a function to apply to the error `Err` value
+     */
+    mapErr<X>(fn: (t: Exclude<E, Promise<any>>) => Exclude<X, Promise<any>>): Result<T, X>;
+    /**
+     * Similar to `map` Except you must return a new `Result`.
+     *
+     * This is useful for when you need to do a subsequent computation using the
+     * inner `T` value, but that computation might fail.
+     * Additionally, `andThen` is really useful as a tool to flatten a
+     * `Result<Result<A, E2>, E1>` into a `Result<A, E2>` (see example below).
+     *
+     * @param f The function to apply to the current value
+     */
+    andThen<X, Y>(f: (t: T) => Exclude<Result<X, Y>, Promise<any>>): Result<X, E | Y>;
+    /**
+     * Takes an `Err` value and maps it to a `Result<T, SomeNewType>`.
+     *
+     * This is useful for error recovery.
+     *
+     *
+     * @param f  A function to apply to an `Err` value, leaving `Ok` values
+     * untouched.
+     */
+    orElse<Y>(f: (t: E) => Result<T, Y>): Result<T, Y>;
+    /**
+     * Similar to `map` Except you must return a new `Result`.
+     *
+     * This is useful for when you need to do a subsequent async computation using
+     * the inner `T` value, but that computation might fail. Must return a ResultAsync
+     *
+     * @param f The function that returns a `ResultAsync` to apply to the current
+     * value
+     */
+    asyncAndThen<X, Y>(f: (t: T) => ResultAsync<X, Y>): ResultAsync<X, E | Y>;
+    /**
+     * Maps a `Result<T, E>` to `ResultAsync<U, E>`
+     * by applying an async function to a contained `Ok` value, leaving an `Err`
+     * value untouched.
+     *
+     * @param f An async function to apply an `OK` value
+     */
+    asyncMap<X>(f: (t: T) => Promise<X>): ResultAsync<X, E>;
+    /**
+     * Unwrap the `Ok` value, or return the default if there is an `Err`
+     *
+     * @param v the default value to return if there is an `Err`
+     */
+    unwrapOr<A>(defaultValue: A): T | A;
+    /**
+     *
+     * Given 2 functions (one for the `Ok` variant and one for the `Err` variant)
+     * execute the function that matches the `Result` variant.
+     *
+     * Match callbacks do not necessitate to return a `Result`, however you can
+     * return a `Result` if you want to.
+     *
+     * `match` is like chaining `map` and `mapErr`, with the distinction that
+     * with `match` both functions must have the same return type.
+     *
+     * @param ok
+     * @param err
+     */
+    match<X>(fnOk: (t: T) => X, fnErr: (e: E) => X): X;
+    /**
+     * **This method is unsafe, and should only be used in a test environments**
+     *
+     * Takes a `Result<T, E>` and returns a `T` when the result is an `Ok`, otherwise it throws a custom object.
+     *
+     * @param config
+     */
+    _unsafeUnwrap(config?: ErrorConfig): T;
+    /**
+     * **This method is unsafe, and should only be used in a test environments**
+     *
+     * takes a `Result<T, E>` and returns a `E` when the result is an `Err`,
+     * otherwise it throws a custom object.
+     *
+     * @param config
+     */
+    _unsafeUnwrapErr(config?: ErrorConfig): E;
+    safeUnwrap(): Generator<Result<never, E>, T>;
+}
+declare const ok: <T, E = never>(value: T) => Result<T, E>;
+declare const err: <T = never, E = unknown>(error: E) => Result<T, E>;
+declare const fromThrowable: <Fn extends (...args: readonly any[]) => unknown, E>(fn: Fn, errorFn?: ((e: any) => E) | undefined) => (...args: Parameters<Fn>) => Result<ReturnType<Fn>, E>;
+/**
+ * Evaluates the given generator to a Result returned or an Err yielded from it,
+ * whichever comes first.
+ *
+ * This function, in combination with `Result.safeUnwrap()`, is intended to emulate
+ * Rust's ? operator.
+ * See `/tests/safeTry.test.ts` for examples.
+ *
+ * @param body - What is evaluated. In body, `yield* result.safeUnwrap()` works as
+ * Rust's `result?` expression.
+ * @returns The first occurence of either an yielded Err or a returned Result.
+ */
+declare function safeTry<T, E>(body: () => Generator<Result<never, E>, Result<T, E>>): Result<T, E>;
+/**
+ * Evaluates the given generator to a Result returned or an Err yielded from it,
+ * whichever comes first.
+ *
+ * This function, in combination with `Result.safeUnwrap()`, is intended to emulate
+ * Rust's ? operator.
+ * See `/tests/safeTry.test.ts` for examples.
+ *
+ * @param body - What is evaluated. In body, `yield* result.safeUnwrap()` and
+ * `yield* resultAsync.safeUnwrap()` work as Rust's `result?` expression.
+ * @returns The first occurence of either an yielded Err or a returned Result.
+ */
+declare function safeTry<T, E>(body: () => AsyncGenerator<Result<never, E>, Result<T, E>>): Promise<Result<T, E>>;
+
+interface ErrorConfig {
+    withStackTrace: boolean;
+}
+interface ResultarError<T, E> {
+    data: {
+        type: string;
+        value: T | undefined;
+    } | {
+        type: string;
+        value: E | undefined;
+    };
+    message: string;
+    stack: string | undefined;
+}
+declare const createResultarError: <T, E>(message: string, result: Result<T, E>, config?: ErrorConfig) => ResultarError<T, E>;
+
+export { type ErrorConfig as E, ResultAsync as R, fromPromise as a, Result as b, ok as c, err as d, errAsync as e, fromSafePromise as f, fromThrowable as g, safeTry as h, createResultarError as i, okAsync as o, safeTryAsync as s };

package/dist/index.cjs

@@ -0,0 +1,337 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Result: () => Result,
+  ResultAsync: () => ResultAsync,
+  err: () => err,
+  errAsync: () => errAsync,
+  fromPromise: () => fromPromise,
+  fromSafePromise: () => fromSafePromise,
+  fromThrowable: () => fromThrowable,
+  ok: () => ok,
+  okAsync: () => okAsync,
+  safeTry: () => safeTry,
+  safeTryAsync: () => safeTryAsync
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/error.ts
+var defaultErrorConfig = {
+  withStackTrace: false
+};
+var createResultarError = (message, result, config = defaultErrorConfig) => {
+  const data = result.isOk() ? { type: "Ok", value: result.value } : { type: "Err", value: result.error };
+  const maybeStack = config.withStackTrace ? new Error().stack : void 0;
+  return {
+    data,
+    message,
+    stack: maybeStack
+  };
+};
+
+// src/result-async.ts
+var ResultAsync = class _ResultAsync {
+  static fromSafePromise(promise) {
+    const newPromise = promise.then((value) => Result.ok(value));
+    return new _ResultAsync(newPromise);
+  }
+  static fromPromise(promise, errorFn) {
+    const newPromise = promise.then((value) => Result.ok(value)).catch((error) => Result.err(errorFn(error)));
+    return new _ResultAsync(newPromise);
+  }
+  innerPromise;
+  constructor(res) {
+    this.innerPromise = res;
+  }
+  then(successCallback, failureCallback) {
+    return this.innerPromise.then(successCallback, failureCallback);
+  }
+  mapErr(f) {
+    return new _ResultAsync(this.innerPromise.then(async (res) => {
+      if (res.isOk()) {
+        return okAsync(res.value);
+      }
+      return errAsync(await f(res.error));
+    }));
+  }
+  map(f) {
+    const x = new _ResultAsync(
+      this.innerPromise.then(async (res) => {
+        if (res.isErr()) {
+          return errAsync(res.error);
+        }
+        return okAsync(await f(res.value));
+      })
+    );
+    return x;
+  }
+  andThen(f) {
+    return new _ResultAsync(
+      this.innerPromise.then(async (res) => {
+        if (res.isErr()) {
+          return errAsync(res.error);
+        }
+        const newValue = f(res.value);
+        return newValue instanceof _ResultAsync ? newValue.innerPromise : newValue;
+      })
+    );
+  }
+  async match(ok2, _err) {
+    return this.innerPromise.then((res) => res.match(ok2, _err));
+  }
+  /**
+   * Emulates Rust's `?` operator in `safeTry`'s body. See also `safeTry`.
+   */
+  async *safeUnwrap() {
+    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 safeTryAsync(body) {
+  return new ResultAsync(
+    (async () => {
+      const n = await body().next();
+      if (n.value.isOk()) {
+        return okAsync(n.value.value);
+      }
+      return errAsync(n.value.error);
+    })()
+  );
+}
+
+// src/result.ts
+var Result = class _Result {
+  constructor(state) {
+    this.state = state;
+    if (state.ok) {
+      this.value = state.value;
+      this.error = void 0;
+    } else {
+      this.error = state.error;
+      this.value = void 0;
+    }
+  }
+  /**
+   * Wraps a 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
+   */
+  static fromThrowable(fn, errorFn) {
+    return (...args) => {
+      try {
+        const result = fn(...args);
+        return ok(result);
+      } catch (error) {
+        if (errorFn) {
+          return err(errorFn(error));
+        }
+        return err(error);
+      }
+    };
+  }
+  static ok(value) {
+    return new _Result({ ok: true, value });
+  }
+  static err(error) {
+    return new _Result({ ok: false, error });
+  }
+  value;
+  error;
+  /**
+   * Used to check if a `Result` is an `OK`
+   *
+   * @returns `true` if the result is an `OK` variant of Result
+   */
+  isOk() {
+    return this.state.ok;
+  }
+  /**
+   * Used to check if a `Result` is an `Err`
+   *
+   * @returns `true` if the result is an `Err` variant of Result
+   */
+  isErr() {
+    return !this.state.ok;
+  }
+  map(f) {
+    if (this.state.ok) {
+      const value = f(this.value);
+      return ok(value);
+    }
+    return err(this.error);
+  }
+  /**
+   * Maps a `Result<T, E>` to `Result<T, F>` by applying a function to a
+   * contained `Err` value, leaving an `Ok` value untouched.
+   *
+   * This function can be used to pass through a successful result while
+   * handling an error.
+   *
+   * @param f a function to apply to the error `Err` value
+   */
+  mapErr(fn) {
+    if (this.state.ok) {
+      return ok(this.value);
+    }
+    return err(fn(this.error));
+  }
+  andThen(f) {
+    if (this.state.ok) {
+      return f(this.value);
+    }
+    return err(this.error);
+  }
+  orElse(f) {
+    if (this.state.ok) {
+      return ok(this.value);
+    }
+    return f(this.error);
+  }
+  asyncAndThen(f) {
+    if (this.state.ok) {
+      return f(this.value);
+    }
+    return errAsync(this.error);
+  }
+  /**
+   * Maps a `Result<T, E>` to `ResultAsync<U, E>`
+   * by applying an async function to a contained `Ok` value, leaving an `Err`
+   * value untouched.
+   *
+   * @param f An async function to apply an `OK` value
+   */
+  asyncMap(f) {
+    if (this.state.ok) {
+      return ResultAsync.fromSafePromise(f(this.value));
+    }
+    return errAsync(this.error);
+  }
+  /**
+   * Unwrap the `Ok` value, or return the default if there is an `Err`
+   *
+   * @param v the default value to return if there is an `Err`
+   */
+  unwrapOr(defaultValue) {
+    if (this.state.ok) {
+      return this.value;
+    }
+    return defaultValue;
+  }
+  /**
+   *
+   * Given 2 functions (one for the `Ok` variant and one for the `Err` variant)
+   * execute the function that matches the `Result` variant.
+   *
+   * Match callbacks do not necessitate to return a `Result`, however you can
+   * return a `Result` if you want to.
+   *
+   * `match` is like chaining `map` and `mapErr`, with the distinction that
+   * with `match` both functions must have the same return type.
+   *
+   * @param ok
+   * @param err
+   */
+  match(fnOk, fnErr) {
+    if (this.state.ok) {
+      return fnOk(this.value);
+    }
+    return fnErr(this.error);
+  }
+  /**
+   * **This method is unsafe, and should only be used in a test environments**
+   *
+   * Takes a `Result<T, E>` and returns a `T` when the result is an `Ok`, otherwise it throws a custom object.
+   *
+   * @param config
+   */
+  _unsafeUnwrap(config) {
+    if (this.state.ok) {
+      return this.value;
+    }
+    throw createResultarError("Called `_unsafeUnwrap` on an Err", this, config);
+  }
+  /**
+   * **This method is unsafe, and should only be used in a test environments**
+   *
+   * takes a `Result<T, E>` and returns a `E` when the result is an `Err`,
+   * otherwise it throws a custom object.
+   *
+   * @param config
+   */
+  _unsafeUnwrapErr(config) {
+    if (this.state.ok) {
+      throw createResultarError("Called `_unsafeUnwrapErr` on an Ok", this, config);
+    }
+    return this.error;
+  }
+  safeUnwrap() {
+    if (this.state.ok) {
+      const { value } = this;
+      return function* () {
+        return value;
+      }();
+    }
+    const { error } = this;
+    return function* () {
+      yield err(error);
+      throw new Error("Do not use this generator out of `safeTry`");
+    }();
+  }
+};
+var ok = (value) => Result.ok(value);
+var err = (error) => Result.err(error);
+var fromThrowable = (fn, errorFn) => Result.fromThrowable(fn, errorFn);
+function safeTry(body) {
+  const n = body().next();
+  if (n instanceof Promise) {
+    return n.then((r) => r.value);
+  }
+  return n.value;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Result,
+  ResultAsync,
+  err,
+  errAsync,
+  fromPromise,
+  fromSafePromise,
+  fromThrowable,
+  ok,
+  okAsync,
+  safeTry,
+  safeTryAsync
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/error.ts","../src/result-async.ts","../src/result.ts"],"sourcesContent":["export * from './result.js'\nexport * from './result-async.js'\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  Result,\n} from './result.js'\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  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<R, R | E>\n  andThen<R extends ResultAsync<unknown, unknown>>(\n    f: (t: T) => R,\n  ): ResultAsync<R, R | E>\n  andThen<X, Y>(f: (t: T) => ResultAsync<X, Y>): ResultAsync<X, E | Y>\n  andThen<X, Y>(f: (t: T) => ResultAsync<X, E>): ResultAsync<X, E | Y> {\n    return new ResultAsync<X, E | Y>(\n      this.innerPromise.then(async res => {\n        if (res.isErr()) {\n          return errAsync(res.error)\n        }\n\n        const newValue = f(res.value)\n        return newValue instanceof ResultAsync ? newValue.innerPromise : newValue\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  /**\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 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","import { ErrorConfig, createResultarError } from './error.js'\nimport { ResultAsync, errAsync } from './result-async.js'\n\ninterface Ok<T> {\n  ok: true\n  value: T\n}\n\ninterface Err<E> {\n  ok: false\n  error: E\n}\n\nexport class Result<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>({ ok: true, value })\n  }\n\n  static err<T=never, E=unknown>(error: E): Result<T, E> {\n    return new Result<T, E>({ ok: false, error })\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, Y>(f: (t: T) => Exclude<X, Promise<any>>): Result<X, E | Y>\n  map<X>(f: (t: T) => Exclude<X, Promise<any>>): 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 as Exclude<E, Promise<any>>)\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: Exclude<E, Promise<any>>) => Exclude<X, Promise<any>>): Result<T, X> {\n    if (this.state.ok) {\n      return ok(this.value as Exclude<T, Promise<any>>)\n    }\n\n    return err(fn(this.error as Exclude<E, Promise<any>>))\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) => Exclude<Result<X, Y>, Promise<any>>): Result<X, E | Y>\n  andThen<X, Y>(f: (t: T) => Exclude<Result<X, Y>, Promise<any>>): Result<X, E | Y> {\n    if (this.state.ok) {\n      return f(this.value)\n    }\n\n    return err(this.error as Exclude<E, Promise<any>>)\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<Y>(f: (t: E) => Result<T, Y>): Result<T, Y>\n  orElse<Y>(f: (t: E) => Result<T, Y>): Result<T, E | Y> {\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   * **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\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"]}

package/dist/index.d.cts

@@ -0,0 +1 @@
+export { b as Result, R as ResultAsync, d as err, e as errAsync, a as fromPromise, f as fromSafePromise, g as fromThrowable, c as ok, o as okAsync, h as safeTry, s as safeTryAsync } from './index-CyqyqPfg.cjs';

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { b as Result, R as ResultAsync, d as err, e as errAsync, a as fromPromise, f as fromSafePromise, g as fromThrowable, c as ok, o as okAsync, h as safeTry, s as safeTryAsync } from './index-CyqyqPfg.js';

package/dist/index.js

@@ -0,0 +1,28 @@
+import {
+  Result,
+  ResultAsync,
+  err,
+  errAsync,
+  fromPromise,
+  fromSafePromise,
+  fromThrowable,
+  ok,
+  okAsync,
+  safeTry,
+  safeTryAsync
+} from "./chunk-DBDW2LXV.js";
+import "./chunk-FBVQYZXO.js";
+export {
+  Result,
+  ResultAsync,
+  err,
+  errAsync,
+  fromPromise,
+  fromSafePromise,
+  fromThrowable,
+  ok,
+  okAsync,
+  safeTry,
+  safeTryAsync
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}