@pvorona/failable 0.7.0 → 0.9.0

package/dist/index.js

@@ -1,41 +1,56 @@
-import { isFunction as h, isObject as u, hasOwnPropertyValue as S, hasOwnKey as g } from "@pvorona/assert";
-import { notImplemented as a } from "@pvorona/not-implemented";
-const F = /* @__PURE__ */ Symbol("Failable"), A = /* @__PURE__ */ Symbol("Success"), O = /* @__PURE__ */ Symbol("Failure"), o = Object.freeze({
+import { isFunction as b, isObject as c, hasOwnPropertyValue as j, hasOwnKey as I } from "@pvorona/assert";
+import { notImplemented as o } from "@pvorona/not-implemented";
+const P = /* @__PURE__ */ Symbol("Failable"), L = /* @__PURE__ */ Symbol("Success"), _ = /* @__PURE__ */ Symbol("Failure"), n = Object.freeze({
   Success: "success",
   Failure: "failure"
-}), p = Object.freeze({
+}), x = Object.freeze({
   mode: "normalized-errors"
 });
-function T(r) {
-  return u(r) && Object.keys(r).length === 2 && S(r, "status", o.Success) && g(r, "data");
+function D(r) {
+  return c(r) && Object.keys(r).length === 2 && j(r, "status", n.Success) && I(r, "data");
 }
-function N(r) {
-  return u(r) && Object.keys(r).length === 2 && S(r, "status", o.Failure) && g(r, "error");
+function V(r) {
+  return c(r) && Object.keys(r).length === 2 && j(r, "status", n.Failure) && I(r, "error");
 }
-function w(r) {
-  return N(r) || T(r);
+function y(r) {
+  return V(r) || D(r);
 }
-const m = {
-  [F]: !0,
+const G = {
+  [P]: !0,
   isSuccess: !1,
   isFailure: !1,
   data: null,
   error: null,
-  or: a,
-  orElse: a,
-  getOr: a,
-  getOrElse: a,
-  getOrThrow: a,
-  match: a,
+  or: o,
+  orElse: o,
+  getOr: o,
+  getOrElse: o,
+  getOrThrow: o,
+  match: o,
+  map: o,
+  flatMap: o,
   [Symbol.iterator]: function() {
-    return R(this);
+    return Q(this);
   },
   [Symbol.asyncIterator]: function() {
-    return I(this);
+    return W(this);
   }
-}, U = (() => {
-  const r = Object.create(m);
-  return r[A] = !0, r.status = o.Success, r.isSuccess = !0, r.or = function() {
+};
+function O(r, e) {
+  return r(e);
+}
+function K(r, e) {
+  if (e === void 0)
+    return m(r);
+  const t = C(e);
+  return t === null ? m(r) : r instanceof Error && A(e) ? r : t(r);
+}
+function M(r, e) {
+  throw K(r, e);
+}
+const H = (() => {
+  const r = Object.create(G);
+  return r[L] = !0, r.status = n.Success, r.isSuccess = !0, r.or = function() {
     return this;
   }, r.orElse = function() {
     return this;
@@ -43,248 +58,264 @@ const m = {
     return this.data;
   }, r.getOrElse = function() {
     return this.data;
-  }, r.getOrThrow = function() {
+  }, r.getOrThrow = function(t) {
     return this.data;
   }, r.match = function(t) {
     return t(this.data);
+  }, r.map = function(t) {
+    return s(t(this.data));
+  }, r.flatMap = function(t) {
+    return t(this.data);
   }, Object.freeze(r);
-})(), C = (() => {
-  const r = Object.create(m);
-  return r[O] = !0, r.status = o.Failure, r.isFailure = !0, r.or = function(t) {
-    return f(t);
+})(), q = (() => {
+  const r = Object.create(G);
+  return r[_] = !0, r.status = n.Failure, r.isFailure = !0, r.or = function(t) {
+    return s(t);
   }, r.orElse = function(t) {
-    return f(t());
+    return s(O(t, this.error));
   }, r.getOr = function(t) {
     return t;
   }, r.getOrElse = function(t) {
-    return t();
-  }, r.getOrThrow = function() {
-    throw this.error === void 0 ? new Error("getOrThrow() called on Failure<void> with no error value") : this.error;
-  }, r.match = function(t, n) {
-    return n(this.error);
+    return O(t, this.error);
+  }, r.getOrThrow = function(t) {
+    M(this.error, t);
+  }, r.match = function(t, u) {
+    return u(this.error);
+  }, r.map = function() {
+    return this;
+  }, r.flatMap = function() {
+    return this;
   }, Object.freeze(r);
 })();
-function E(r, e) {
-  return u(r) ? r[e] === !0 : !1;
+function g(r, e) {
+  return c(r) ? r[e] === !0 : !1;
 }
-function c(r) {
-  return E(r, F);
+function a(r) {
+  return g(r, P);
 }
-function cr(r) {
-  return E(r, A);
+function hr(r) {
+  return g(r, L);
 }
-function sr(r) {
-  return E(r, O);
+function dr(r) {
+  return g(r, _);
 }
-function f(r) {
-  const e = Object.create(U);
+function s(r) {
+  const e = Object.create(H);
   return e.data = r, Object.freeze(e);
 }
-function d(r) {
-  const e = Object.create(C);
+function l(r) {
+  const e = Object.create(q);
   return e.error = r, Object.freeze(e);
 }
-function ar(r) {
-  if (r.status === o.Failure) throw r.error;
+function Sr(r, e) {
+  r.status === n.Failure && M(r.error, e);
 }
-function fr(r) {
-  return r.status === o.Failure ? { status: o.Failure, error: r.error } : { status: o.Success, data: r.data };
+function mr(r) {
+  return r.status === n.Failure ? { status: n.Failure, error: r.error } : { status: n.Success, data: r.data };
 }
-const M = "`failable(() => ...)` only accepts synchronous callbacks. This callback returned a Promise. Pass the promise directly instead: `await failable(promise)`.", j = /* @__PURE__ */ Symbol("FailablePromiseCallbackGuard"), z = /* @__PURE__ */ Symbol("RunGet");
-class s {
-  [z] = !0;
+const J = "`failable(() => ...)` only accepts synchronous callbacks. This callback returned a Promise. Pass the promise directly instead: `await failable(promise)`.", T = /* @__PURE__ */ Symbol(
+  "FailablePromiseCallbackGuard"
+), Y = /* @__PURE__ */ Symbol("RunGet");
+class f {
+  [Y] = !0;
   source;
   constructor(e) {
     this.source = e;
   }
   static create(e) {
-    return new s(e);
+    return new f(e);
   }
 }
-const l = "`run()` generators must use `yield*` only with hydrated sync `Failable` values or with `get(...)`. Use `yield* helper()` for sync hydrated `Failable` helpers and `yield* get(...)` for promised sources.", B = "`run()` generators must return a `Failable` or finish without returning a value.";
-function* R(r) {
-  return yield s.create(r);
+const h = "`run()` generators must use `yield*` only with hydrated `Failable` values. Use `yield* helper()` for sync helpers and `yield* await promisedHelper()` for promised sources.", v = "`run()` generators must return a `Failable` or finish without returning a value.";
+function* Q(r) {
+  return yield f.create(r);
 }
-async function* I(r) {
-  return yield s.create(r);
+async function* W(r) {
+  return yield f.create(r);
 }
-function L(r) {
-  return !u(r) && !h(r) ? !1 : h(r.then);
+function k(r) {
+  return !c(r) && !b(r) ? !1 : b(r.then);
+}
+const X = Object.freeze({});
+function E(r) {
+  return a(r) ? r : l(r);
+}
+function F(r) {
+  for (const e of r)
+    if (k(e)) return !0;
+  return !1;
+}
+async function N(r) {
+  return (await Promise.all(
+    r.map((t) => Promise.resolve(t))
+  )).map((t) => E(t));
+}
+function p(r) {
+  for (const t of r)
+    if (t.status === n.Failure)
+      return t;
+  const e = r.map(
+    (t) => t.data
+  );
+  return s(e);
 }
-function x(r) {
-  return L(r) ? I(r) : R(r);
+function yr(...r) {
+  return F(r) ? N(r).then(
+    (e) => p(e)
+  ) : p(
+    r.map((e) => E(e))
+  );
 }
-const D = Object.freeze({
-  get: x
-});
-function P(r) {
-  if (!(r instanceof s))
-    throw new Error(l);
+function gr(...r) {
+  return F(r) ? N(r).then(
+    (e) => e
+  ) : r.map((e) => E(e));
+}
+function Fr(...r) {
+  return r.length === 0 ? Promise.reject(
+    new Error("`race()` requires at least one `Failable` source.")
+  ) : F(r) ? Promise.race(r.map((e) => Promise.resolve(e))).then(
+    (e) => E(e)
+  ) : E(r[0]);
+}
+function U(r) {
+  if (!(r instanceof f))
+    throw new Error(h);
   const e = r.source;
-  if (!c(e))
-    throw new Error(l);
+  if (!a(e))
+    throw new Error(h);
   return e;
 }
-async function V(r) {
-  if (!(r instanceof s))
-    throw new Error(l);
+async function z(r) {
+  if (!(r instanceof f))
+    throw new Error(h);
   const e = await r.source;
-  if (!c(e))
-    throw new Error(l);
+  if (!a(e))
+    throw new Error(h);
   return e;
 }
-async function _(r) {
-  if (!(r instanceof s))
-    throw new Error(l);
-  let e;
-  try {
-    e = await r.source;
-  } catch (t) {
-    return { kind: "rejection", rejection: t };
-  }
-  if (!c(e))
-    throw new Error(l);
-  return { kind: "source", source: e };
-}
-function K(r, e) {
+function Z(r, e) {
   let t = r.return(e);
   for (; !t.done; ) {
-    const n = P(t.value);
-    if (n.status === o.Failure) {
+    const u = U(t.value);
+    if (u.status === n.Failure) {
       t = r.return(e);
       continue;
     }
-    t = r.next(n.data);
+    t = r.next(u.data);
   }
+  return d(t.value);
 }
-async function H(r, e) {
+async function $(r, e) {
   let t = await r.return(e);
   for (; !t.done; ) {
-    const n = await V(t.value);
-    if (n.status === o.Failure) {
+    const u = await z(t.value);
+    if (u.status === n.Failure) {
       t = await r.return(e);
       continue;
     }
-    t = await r.next(n.data);
+    t = await r.next(u.data);
   }
+  return d(t.value);
 }
-async function J(r) {
-  let e = await r.return(void 0);
-  for (; !e.done; ) {
-    const t = await _(e.value);
-    if (t.kind === "rejection") {
-      e = await r.return(void 0);
-      continue;
-    }
-    const n = t.source;
-    if (n.status === o.Failure) {
-      e = await r.return(void 0);
-      continue;
-    }
-    e = await r.next(n.data);
-  }
-}
-function k(r) {
-  if (c(r))
+function d(r) {
+  if (a(r))
     return r;
   if (r === void 0)
-    return f();
-  throw new Error(B);
+    return s();
+  throw new Error(v);
 }
-function W(r) {
+function rr(r) {
   return Symbol.asyncIterator in r;
 }
-function Y(r) {
+function er(r) {
   let e = r.next();
   for (; !e.done; ) {
-    const t = P(e.value);
-    if (t.status === o.Failure)
-      return K(r, t), t;
+    const t = U(e.value);
+    if (t.status === n.Failure)
+      return Z(r, t);
     e = r.next(t.data);
   }
-  return k(e.value);
+  return d(e.value);
 }
-async function q(r) {
+async function tr(r) {
   let e = await r.next();
   for (; !e.done; ) {
-    const t = await _(e.value);
-    if (t.kind === "rejection")
-      throw await J(r), t.rejection;
-    const n = t.source;
-    if (n.status === o.Failure)
-      return await H(r, n), n;
-    e = await r.next(n.data);
+    const t = await z(e.value);
+    if (t.status === n.Failure)
+      return $(r, t);
+    e = await r.next(t.data);
   }
-  return k(e.value);
+  return d(e.value);
 }
-function lr(r) {
-  const e = r(D);
-  return W(e) ? q(e) : Y(e);
+function wr(r) {
+  const e = r(X);
+  return rr(e) ? tr(e) : er(e);
 }
-function dr(r, e) {
-  return c(r) ? i(r, e) : w(r) ? i(b(r), e) : h(r) ? $(r, e) : v(r, e);
+function Ar(r, e) {
+  return a(r) ? i(r, e) : y(r) ? i(w(r), e) : b(r) ? or(r, e) : sr(r, e);
 }
-function b(r) {
-  return r.status === o.Success ? f(r.data) : d(r.error);
+function w(r) {
+  return r.status === n.Success ? s(r.data) : l(r.error);
 }
-function Q() {
+function nr() {
   const r = new Error(
-    M
+    J
   );
-  return Object.defineProperty(r, j, {
+  return Object.defineProperty(r, T, {
     value: !0,
     enumerable: !1,
     configurable: !1,
     writable: !1
   }), r;
 }
-function X(r) {
+function ur(r) {
   return r instanceof Error ? Object.getOwnPropertyDescriptor(
     r,
-    j
+    T
   )?.value === !0 : !1;
 }
-function Z(r) {
+function ir(r) {
   Promise.resolve(r).catch(() => {
   });
 }
-function $(r, e) {
+function or(r, e) {
   try {
     const t = r();
-    return L(t) ? (Z(t), i(
-      d(Q()),
+    return k(t) ? (ir(t), i(
+      l(nr()),
       e
-    )) : c(t) ? i(t, e) : w(t) ? i(b(t), e) : f(t);
+    )) : a(t) ? i(t, e) : y(t) ? i(w(t), e) : s(t);
   } catch (t) {
-    return i(d(t), e);
+    return i(l(t), e);
   }
 }
-function v(r, e) {
+function sr(r, e) {
   return Promise.resolve(r).then(
-    (t) => c(t) ? i(t, e) : w(t) ? i(b(t), e) : f(t),
-    (t) => i(d(t), e)
+    (t) => a(t) ? i(t, e) : y(t) ? i(w(t), e) : s(t),
+    (t) => i(l(t), e)
   );
 }
 function i(r, e) {
-  if (r.status === o.Success || X(r.error)) return r;
-  const t = rr(e);
-  return t === null || r.error instanceof Error && e !== void 0 && G(e) ? r : d(t(r.error));
+  if (r.status === n.Success || ur(r.error)) return r;
+  const t = C(e);
+  return t === null || r.error instanceof Error && e !== void 0 && A(e) ? r : l(t(r.error));
 }
-function rr(r) {
-  return r === void 0 ? null : G(r) ? or : er(r) ? r.normalizeError : null;
+function C(r) {
+  return r === void 0 ? null : A(r) ? m : cr(r) ? r.normalizeError : null;
 }
-function G(r) {
-  return !u(r) || Object.keys(r).length !== 1 ? !1 : Object.getOwnPropertyDescriptor(r, "mode")?.value === p.mode;
+function A(r) {
+  return !c(r) || Object.keys(r).length !== 1 ? !1 : Object.getOwnPropertyDescriptor(r, "mode")?.value === x.mode;
 }
-function er(r) {
-  return u(r) ? h(r.normalizeError) : !1;
+function cr(r) {
+  return c(r) ? b(r.normalizeError) : !1;
 }
-function tr(r) {
-  if (!u(r) || Array.isArray(r)) return !1;
+function ar(r) {
+  if (!c(r) || Array.isArray(r)) return !1;
   const e = Object.getPrototypeOf(r);
   return e === Object.prototype || e === null;
 }
-function y(r) {
+function R(r) {
   try {
     const e = JSON.stringify(r);
     if (typeof e == "string") return e;
@@ -293,30 +324,51 @@ function y(r) {
   }
   return null;
 }
-function nr(r) {
-  if (Object.getPrototypeOf(r) === null) {
-    const n = y(r);
-    return n !== null ? n : Object.prototype.toString.call(r);
+const S = "Unstringifiable error value";
+function B(r) {
+  try {
+    return String(r);
+  } catch {
+    return null;
   }
-  const e = String(r);
-  if (e !== "[object Object]") return e;
-  const t = y(r);
-  return t === null ? e : t;
 }
-function or(r) {
-  return r instanceof Error ? r : Array.isArray(r) ? new AggregateError(r, "Multiple errors", { cause: r }) : tr(r) ? new Error(nr(r), { cause: r }) : new Error(String(r), { cause: r });
+function lr(r) {
+  try {
+    return Object.prototype.toString.call(r);
+  } catch {
+    return null;
+  }
+}
+function fr(r) {
+  if (Object.getPrototypeOf(r) === null) {
+    const u = R(r);
+    return u !== null ? u : lr(r) ?? S;
+  }
+  const e = B(r);
+  if (e !== null && e !== "[object Object]") return e;
+  const t = R(r);
+  return t !== null ? t : e ?? S;
+}
+function m(r) {
+  return r instanceof Error ? r : Array.isArray(r) ? new AggregateError(r, "Multiple errors", { cause: r }) : ar(r) ? new Error(fr(r), { cause: r }) : new Error(
+    B(r) ?? S,
+    { cause: r }
+  );
 }
 export {
-  o as FailableStatus,
-  p as NormalizedErrors,
-  dr as failable,
-  d as failure,
-  c as isFailable,
-  w as isFailableLike,
-  sr as isFailure,
-  cr as isSuccess,
-  lr as run,
-  f as success,
-  ar as throwIfError,
-  fr as toFailableLike
+  n as FailableStatus,
+  x as NormalizedErrors,
+  yr as all,
+  gr as allSettled,
+  Ar as failable,
+  l as failure,
+  a as isFailable,
+  y as isFailableLike,
+  dr as isFailure,
+  hr as isSuccess,
+  Fr as race,
+  wr as run,
+  s as success,
+  Sr as throwIfFailure,
+  mr as toFailableLike
 };