resultar 1.1.3 → 1.1.5

package/dist/index.cjs

@@ -35,246 +35,64 @@ __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);
-  }
+// src/error.ts
+var defaultErrorConfig = {
+  withStackTrace: false
 };
-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);
-  }
-  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`
-  */
-  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;
-  }
-  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);
-        }))
-      })
-    };
-  }
-  orElse(f) {
-    return new _ResultAsync(
-      this.innerPromise.then(async (res) => {
-        if (res.isErr()) {
-          return f(res.error);
-        }
-        return okAsync(res.value);
-      })
-    );
-  }
-  async match(ok2, err2) {
-    return this.innerPromise.then((res) => res.match(ok2, err2));
-  }
-  async unwrapOr(t) {
-    return this.innerPromise.then((res) => res.unwrapOr(t));
-  }
-  /**
-   * 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(
-      this.innerPromise.then(async (res) => {
-        try {
-          res.finally(f);
-        } catch {
-        }
-        return res;
-      })
-    );
-  }
-  /**
-   * Emulates Rust's `?` operator in `safeTry`'s body. See also `safeTry`.
-   */
-  async *safeUnwrap() {
-    return yield* await this.innerPromise.then((res) => res.safeUnwrap());
-  }
+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
+  };
 };
-var { okAsync, errAsync, fromPromise, fromSafePromise } = ResultAsync;
-var fromThrowableAsync = ResultAsync.fromThrowable;
-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/utils.ts
-var appendValueToEndOfList = (value) => (list) => [...list, value];
 var combineResultAsyncList = (asyncResultList) => ResultAsync.fromSafePromise(Promise.all(asyncResultList)).andThen(
   combineResultList
 );
-var combineResultList = (resultList) => resultList.reduce(
-  // eslint-disable-line unicorn/no-array-reduce
-  (acc, result) => acc.isOk() ? result.isErr() ? err(result.error) : acc.map(appendValueToEndOfList(result.value)) : acc,
-  ok([])
-);
+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 combineResultAsyncListWithAllErrors = (asyncResultList) => {
   const x = ResultAsync.fromSafePromise(Promise.all(asyncResultList)).andThen(
     combineResultListWithAllErrors
   );
   return x;
 };
-var combineResultListWithAllErrors = (resultList) => resultList.reduce(
-  // eslint-disable-line unicorn/no-array-reduce
-  (acc, result) => result.isErr() ? acc.isErr() ? err([...acc.error, result.error]) : err([result.error]) : acc.isErr() ? acc : ok([...acc.value, result.value]),
-  ok([])
-);
-
-// 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
-  };
+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;
 };
 
 // src/result.ts
 var Ok = class {
-  // eslint-disable-line @typescript-eslint/class-literal-property-style
   constructor(value) {
     this.value = value;
   }
   ok = true;
 };
 var Err = class {
-  // eslint-disable-line @typescript-eslint/class-literal-property-style
   constructor(error) {
     this.error = error;
   }
@@ -298,6 +116,7 @@ var Result = class _Result {
    * @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 {
@@ -437,7 +256,6 @@ var Result = class _Result {
     return defaultValue;
   }
   /**
-   *
    * Given 2 functions (one for the `Ok` variant and one for the `Err` variant)
    * execute the function that matches the `Result` variant.
    *
@@ -456,6 +274,19 @@ var Result = class _Result {
     }
     return fnErr(this.error);
   }
+  /**
+   * Performs a side effect no matter what the `Result` variant is.
+   *
+   * @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`.
    *
@@ -468,9 +299,8 @@ var Result = class _Result {
         fn(this.value);
       } catch {
       }
-      return ok(this.value);
     }
-    return err(this.error);
+    return this;
   }
   /**
    * Performs a side effect for the `Err` variant of `Result`.
@@ -479,14 +309,13 @@ var Result = class _Result {
    * @returns the result of applying `f` or an `Ok` untouched
    */
   tapError(fn) {
-    if (this.state.ok) {
-      return ok(this.value);
-    }
-    try {
-      fn(this.error);
-    } catch {
+    if (!this.state.ok) {
+      try {
+        fn(this.error);
+      } catch {
+      }
     }
-    return err(this.error);
+    return this;
   }
   finally(f) {
     const resultDisposable = new DisposableResult(this, f);
@@ -575,6 +404,228 @@ function safeTry(body) {
   }
   return n.value;
 }
+
+// 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);
+  }
+  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, err2) {
+    return this.innerPromise.then((res) => res.match(ok2, err2));
+  }
+  async unwrapOr(t) {
+    return this.innerPromise.then((res) => res.unwrapOr(t));
+  }
+  /**
+   * 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;
+      })
+    );
+  }
+  /**
+   * Emulates Rust's `?` operator in `safeTry`'s body. See also `safeTry`.
+   */
+  async *safeUnwrap() {
+    return yield* await this.innerPromise.then((res) => res.safeUnwrap());
+  }
+};
+var { okAsync, errAsync, fromPromise, fromSafePromise } = ResultAsync;
+var fromThrowableAsync = ResultAsync.fromThrowable;
+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);
+    })()
+  );
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Result,