resultar 1.4.5 → 2.0.0-beta.2

package/dist/result-async.cjs

@@ -1,745 +0,0 @@
-"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/result-async.ts
-var result_async_exports = {};
-__export(result_async_exports, {
-  DisposableResultAsync: () => DisposableResultAsync,
-  ResultAsync: () => ResultAsync,
-  errAsync: () => errAsync,
-  fromPromise: () => fromPromise,
-  fromSafePromise: () => fromSafePromise,
-  fromThrowableAsync: () => fromThrowableAsync,
-  okAsync: () => okAsync,
-  safeTryAsync: () => safeTryAsync,
-  tryCatchAsync: () => tryCatchAsync,
-  unitAsync: () => unitAsync
-});
-module.exports = __toCommonJS(result_async_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 {
-    name: "ResultarError",
-    data,
-    message,
-    stack: maybeStack
-  };
-};
-
-// src/utils.ts
-var combineResultList = (resultList) => {
-  let acc = ok([]);
-  for (const result of resultList) {
-    if (result.isErr()) {
-      acc = err(result.error);
-      break;
-    } else {
-      acc.map((list) => list.push(result.value));
-    }
-  }
-  return acc;
-};
-var combineResultAsyncList = (asyncResultList) => ResultAsync.fromSafePromise(Promise.all(asyncResultList)).andThen(
-  combineResultList
-);
-var combineResultListWithAllErrors = (resultList) => {
-  let acc = ok([]);
-  for (const result of resultList) {
-    if (result.isErr() && acc.isErr()) {
-      acc.error.push(result.error);
-    } else if (result.isErr() && acc.isOk()) {
-      acc = err([result.error]);
-    } else if (result.isOk() && acc.isOk()) {
-      acc.value.push(result.value);
-    }
-  }
-  return acc;
-};
-var combineResultAsyncListWithAllErrors = (asyncResultList) => ResultAsync.fromSafePromise(Promise.all(asyncResultList)).andThen(
-  combineResultListWithAllErrors
-);
-
-// src/result.ts
-var Ok = class {
-  constructor(value) {
-    this.value = value;
-  }
-  ok = true;
-};
-var Err = class {
-  constructor(error) {
-    this.error = error;
-  }
-  ok = false;
-};
-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;
-    }
-  }
-  /**
-   * Creates a `Result` by running a function that might throw.
-   * If the function throws, the error will be caught and returned as an `Err`.
-   * If the function succeeds, the value will be wrapped in an `Ok`.
-   *
-   * @param fn - The function to execute, which might throw an error
-   * @param errorFn - Optional function to transform the thrown error before wrapping in `Err`
-   * @returns A `Result` containing either the function's return value or the caught error
-   */
-  static tryCatch(fn, errorFn) {
-    try {
-      return ok(fn());
-    } catch (error) {
-      if (errorFn) {
-        return err(errorFn(error));
-      }
-      return err(error);
-    }
-  }
-  /**
-   * 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
-   */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  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(new Ok(value));
-  }
-  /**
-   * Creates a new `Result` instance representing a successful operation with an undefined value.
-   *
-   * @return {Result<undefined, E>} A new `Result` instance with an undefined value.
-   */
-  static unit() {
-    return new _Result(new Ok(void 0));
-  }
-  static err(error) {
-    return new _Result(new Err(error));
-  }
-  static combine(resultList) {
-    return combineResultList(resultList);
-  }
-  static combineWithAllErrors(resultList) {
-    return combineResultListWithAllErrors(
-      resultList
-    );
-  }
-  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;
-  }
-  /**
-   * 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(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));
-  }
-  /**
-   * 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(f) {
-    if (this.state.ok) {
-      return f(this.value);
-    }
-    return err(this.error);
-  }
-  if(fCondition) {
-    return {
-      true: (fTrue) => ({
-        false: (fFalse) => {
-          if (this.state.ok) {
-            const condition = fCondition(this.value);
-            return condition ? fTrue(this.value) : fFalse(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);
-  }
-  /**
-   * Performs a side effect for the `Ok` or `Err` variant of `Result`.
-   *
-   * @param fn The function to apply an `OK` value
-   * @returns the result of applying `f` or an `Err` untouched
-   */
-  log(fn) {
-    try {
-      fn(this.value, this.error);
-    } catch {
-    }
-    return this;
-  }
-  /**
-   * Performs a side effect for the `Ok` variant of `Result`.
-   *
-   * @param fn The function to apply an `OK` value
-   * @returns the result of applying `f` or an `Err` untouched
-   */
-  tap(fn) {
-    if (this.state.ok) {
-      try {
-        fn(this.value);
-      } catch {
-      }
-    }
-    return this;
-  }
-  /**
-   * Performs a side effect for the `Err` variant of `Result`.
-   *
-   * @param fn The function to apply an `Err` value
-   * @returns the result of applying `f` or an `Ok` untouched
-   */
-  tapError(fn) {
-    if (!this.state.ok) {
-      try {
-        fn(this.error);
-      } catch {
-      }
-    }
-    return this;
-  }
-  finally(f) {
-    const resultDisposable = new DisposableResult(this, f);
-    try {
-      return resultDisposable;
-    } finally {
-      resultDisposable[Symbol.dispose]();
-    }
-  }
-  unwrapOrThrow() {
-    if (this.state.ok) {
-      return this.value;
-    }
-    throw 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;
-  }
-  *[Symbol.iterator]() {
-    if (this.state.ok) {
-      return this.value;
-    }
-    const self = this;
-    yield self;
-    return self;
-  }
-  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 DisposableResult = class {
-  constructor(result, finalizer) {
-    this.result = result;
-    this.finalizer = finalizer;
-  }
-  get value() {
-    return this.result.value;
-  }
-  get error() {
-    return this.result.error;
-  }
-  _unsafeUnwrap(config) {
-    return this.result._unsafeUnwrap(config);
-  }
-  _unsafeUnwrapErr(config) {
-    return this.result._unsafeUnwrapErr(config);
-  }
-  isOk() {
-    return this.result.isOk();
-  }
-  isErr() {
-    return this.result.isErr();
-  }
-  unwrapOr(defaultValue) {
-    return this.result.unwrapOr(defaultValue);
-  }
-  [Symbol.dispose]() {
-    this.finalizer(this.result.value, this.result.error);
-  }
-};
-var ok = Result.ok;
-var err = Result.err;
-var fromThrowable = Result.fromThrowable;
-var unit = Result.unit;
-var tryCatch = Result.tryCatch;
-
-// 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)));
-  }
-  /**
-   * Returns a ResultAsync that is immediately resolved with a Result.ok(undefined) value.
-   *
-   * @return {ResultAsync<undefined, E>} A ResultAsync instance with undefined as the value type and E as the error type.
-   */
-  static unitAsync() {
-    return new _ResultAsync(Promise.resolve(Result.unit()));
-  }
-  static errAsync(error) {
-    return new _ResultAsync(Promise.resolve(Result.err(error)));
-  }
-  /**
-   * Creates a ResultAsync from a Promise, catching any errors that occur during its execution.
-   *
-   * @param fn - The Promise or a function returning a Promise to be wrapped in a ResultAsync.
-   * @param errorFn - Optional function to transform the caught error into a specific error type.
-   *                  If not provided, the original error will be used.
-   * @returns A ResultAsync that will resolve to Ok with the promise's value if successful,
-   *          or Err with either the transformed error (if errorFn is provided) or the original error.
-   *
-   * @example
-   * ```typescript
-   * // Without error transformer
-   * const result = ResultAsync.tryCatch(Promise.resolve(42));
-   *
-   * // With error transformer
-   * const result = ResultAsync.tryCatch(
-   *   fetch('https://api.example.com'),
-   *   (error) => new CustomError('API request failed')
-   * );
-   * ```
-   */
-  static tryCatch(fn, errorFn) {
-    const promiseToProcess = typeof fn === "function" ? fn() : fn;
-    const newPromise = promiseToProcess.then((value) => Result.ok(value)).catch((error) => {
-      if (errorFn) {
-        return Result.err(errorFn(error));
-      }
-      return Result.err(error);
-    });
-    return new _ResultAsync(newPromise);
-  }
-  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);
-  }
-  static combine(asyncResultList) {
-    return combineResultAsyncList(asyncResultList);
-  }
-  static combineWithAllErrors(asyncResultList) {
-    return combineResultAsyncListWithAllErrors(
-      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`
-   */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  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;
-  }
-  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;
-  }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  andThen(f) {
-    return new _ResultAsync(
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-      this.innerPromise.then(async (res) => {
-        if (res.isErr()) {
-          return errAsync(res.error);
-        }
-        const newValue = f(res.value);
-        return newValue instanceof _ResultAsync ? newValue.innerPromise : newValue;
-      })
-    );
-  }
-  if(fCondition) {
-    return {
-      true: (fTrue) => ({
-        false: (fFalse) => new _ResultAsync(this.innerPromise.then(async (res) => {
-          if (res.isOk()) {
-            const condition = fCondition(res.value);
-            return condition ? fTrue(res.value) : fFalse(res.value);
-          }
-          return errAsync(res.error);
-        }))
-      })
-    };
-  }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  orElse(f) {
-    return new _ResultAsync(
-      this.innerPromise.then(async (res) => {
-        if (res.isErr()) {
-          return f(res.error);
-        }
-        return okAsync(res.value);
-      })
-    );
-  }
-  async match(ok2, fnErr) {
-    return this.innerPromise.then((res) => res.match(ok2, fnErr));
-  }
-  async unwrapOr(t) {
-    return this.innerPromise.then((res) => res.unwrapOr(t));
-  }
-  async unwrapOrThrow() {
-    return this.innerPromise.then((res) => res.unwrapOrThrow());
-  }
-  /**
-   * Performs a side effect for the `Ok` variant of `ResultAsync`.
-   * This function can be used for control flow based on result values.
-   * @param f The function to call if the result is `Ok`
-   * @returns `self` if the result is `Err`, otherwise the result of `f`
-   */
-  log(f) {
-    return new _ResultAsync(
-      this.innerPromise.then(async (res) => {
-        if (res.isOk()) {
-          try {
-            await f(res.value);
-          } catch {
-          }
-          return okAsync(res.value);
-        }
-        try {
-          await f(void 0, res.error);
-        } catch {
-        }
-        return errAsync(res.error);
-      })
-    );
-  }
-  /**
-   * Performs a side effect for the `Ok` variant of `ResultAsync`.
-   * This function can be used for control flow based on result values.
-   * @param f The function to call if the result is `Ok`
-   * @returns `self` if the result is `Err`, otherwise the result of `f`
-   */
-  tap(f) {
-    return new _ResultAsync(
-      this.innerPromise.then(async (res) => {
-        if (res.isErr()) {
-          return errAsync(res.error);
-        }
-        try {
-          await f(res.value);
-        } catch {
-        }
-        return okAsync(res.value);
-      })
-    );
-  }
-  /**
-   * Performs a side effect for the `Err` variant of `ResultAsync`.
-   * This function can be used for control flow based on result values.
-   * @param f The function to call if the result is `Err`
-   * @returns `self` if the result is `Ok`, otherwise the result of `f`
-   * @example
-   */
-  tapError(f) {
-    return new _ResultAsync(
-      this.innerPromise.then(async (res) => {
-        if (res.isErr()) {
-          try {
-            await f(res.error);
-          } catch {
-          }
-          return errAsync(res.error);
-        }
-        return okAsync(res.value);
-      })
-    );
-  }
-  finally(f) {
-    return new DisposableResultAsync(
-      // eslint-disable-next-line @typescript-eslint/require-await
-      this.innerPromise.then(async (res) => {
-        try {
-          res.finally(f);
-        } catch {
-        }
-        return res;
-      })
-    );
-  }
-  async *[Symbol.asyncIterator]() {
-    const result = await this.innerPromise;
-    if (result.isErr()) {
-      yield errAsync(result.error);
-    }
-    return result.value;
-  }
-  /**
-   * @deprecated will be removed in 2.0.0.
-   *
-   * You can use `safeTry` without this method.
-   * @example
-   * ```typescript
-   * safeTry(async function* () {
-   *   const okValue = yield* yourResult
-   * })
-   * ```
-   * Emulates Rust's `?` operator in `safeTry`'s body. See also `safeTry`.
-   */
-  async *safeUnwrap() {
-    return yield* await this.innerPromise.then((res) => res.safeUnwrap());
-  }
-};
-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);
-    })()
-  );
-}
-var okAsync = ResultAsync.okAsync;
-var errAsync = ResultAsync.errAsync;
-var fromPromise = ResultAsync.fromPromise;
-var fromSafePromise = ResultAsync.fromSafePromise;
-var unitAsync = ResultAsync.unitAsync;
-var fromThrowableAsync = ResultAsync.fromThrowable;
-var tryCatchAsync = ResultAsync.tryCatch;
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  DisposableResultAsync,
-  ResultAsync,
-  errAsync,
-  fromPromise,
-  fromSafePromise,
-  fromThrowableAsync,
-  okAsync,
-  safeTryAsync,
-  tryCatchAsync,
-  unitAsync
-});
-//# sourceMappingURL=result-async.cjs.map