@effect-app/vue-components 3.2.0 → 4.0.0-beta.1

package/dist/vue-components.es36.js

@@ -0,0 +1,320 @@
+import { symbol as d, equals as i } from "./vue-components.es76.js";
+import { format as a } from "./vue-components.es60.js";
+import { identity as E, dual as R } from "./vue-components.es39.js";
+import { symbol as g, array as M, combine as f, string as b, hash as l } from "./vue-components.es77.js";
+import { NodeInspectSymbol as O } from "./vue-components.es78.js";
+import { pipeArguments as S } from "./vue-components.es61.js";
+import { hasProperty as I } from "./vue-components.es38.js";
+import { SingleShotGen as T } from "./vue-components.es79.js";
+const o = "~effect/Effect", _ = "~effect/Exit", Y = {
+  _A: E,
+  _E: E,
+  _R: E
+}, $ = `${o}/identifier`, n = `${o}/args`, h = `${o}/evaluate`, m = `${o}/successCont`, u = `${o}/failureCont`, F = `${o}/ensureCont`, dt = /* @__PURE__ */ Symbol.for("effect/Effect/Yield"), U = {
+  pipe() {
+    return S(this, arguments);
+  },
+  toJSON() {
+    return {
+      ...this
+    };
+  },
+  toString() {
+    return a(this.toJSON(), {
+      ignoreToString: !0,
+      space: 2
+    });
+  },
+  [O]() {
+    return this.toJSON();
+  }
+}, W = {
+  [Symbol.iterator]() {
+    return new T(this);
+  }
+}, z = {
+  ...W,
+  pipe() {
+    return S(this, arguments);
+  }
+}, B = {
+  [o]: Y,
+  ...U,
+  [Symbol.iterator]() {
+    return new T(this);
+  },
+  asEffect() {
+    return this;
+  },
+  toJSON() {
+    return {
+      _id: "Effect",
+      op: this[$],
+      ...n in this ? {
+        args: this[n]
+      } : void 0
+    };
+  }
+}, q = (t) => I(t, _), p = "~effect/Cause", y = "~effect/Cause/Reason", v = (t) => I(t, p);
+class C {
+  [p];
+  reasons;
+  constructor(e) {
+    this[p] = p, this.reasons = e;
+  }
+  pipe() {
+    return S(this, arguments);
+  }
+  toJSON() {
+    return {
+      _id: "Cause",
+      failures: this.reasons.map((e) => e.toJSON())
+    };
+  }
+  toString() {
+    return `Cause(${a(this.reasons)})`;
+  }
+  [O]() {
+    return this.toJSON();
+  }
+  [d](e) {
+    return v(e) && this.reasons.length === e.reasons.length && this.reasons.every((r, s) => i(r, e.reasons[s]));
+  }
+  [g]() {
+    return M(this.reasons);
+  }
+}
+const P = /* @__PURE__ */ new WeakMap();
+class J {
+  [y];
+  annotations;
+  _tag;
+  constructor(e, r, s) {
+    if (this[y] = y, this._tag = e, r !== N && typeof s == "object" && s !== null && r.size > 0) {
+      const c = P.get(s);
+      c && (r = new Map([...c, ...r])), P.set(s, r);
+    }
+    this.annotations = r;
+  }
+  annotate(e, r) {
+    if (e.mapUnsafe.size === 0) return this;
+    const s = new Map(this.annotations);
+    e.mapUnsafe.forEach((D, x) => {
+      r?.overwrite !== !0 && s.has(x) || s.set(x, D);
+    });
+    const c = Object.assign(Object.create(Object.getPrototypeOf(this)), this);
+    return c.annotations = s, c;
+  }
+  pipe() {
+    return S(this, arguments);
+  }
+  toString() {
+    return a(this);
+  }
+  [O]() {
+    return this.toString();
+  }
+}
+const N = /* @__PURE__ */ new Map();
+class G extends J {
+  error;
+  constructor(e, r = N) {
+    super("Fail", r, e), this.error = e;
+  }
+  toString() {
+    return `Fail(${a(this.error)})`;
+  }
+  toJSON() {
+    return {
+      _tag: "Fail",
+      error: this.error
+    };
+  }
+  [d](e) {
+    return Q(e) && i(this.error, e.error) && i(this.annotations, e.annotations);
+  }
+  [g]() {
+    return f(b(this._tag))(f(l(this.error))(l(this.annotations)));
+  }
+}
+const K = (t) => new C([new G(t)]);
+class V extends J {
+  defect;
+  constructor(e, r = N) {
+    super("Die", r, e), this.defect = e;
+  }
+  toString() {
+    return `Die(${a(this.defect)})`;
+  }
+  toJSON() {
+    return {
+      _tag: "Die",
+      defect: this.defect
+    };
+  }
+  [d](e) {
+    return X(e) && i(this.defect, e.defect) && i(this.annotations, e.annotations);
+  }
+  [g]() {
+    return f(b(this._tag))(f(l(this.defect))(l(this.annotations)));
+  }
+}
+const H = (t) => new C([new V(t)]), L = /* @__PURE__ */ R((t) => v(t[0]), (t, e, r) => e.mapUnsafe.size === 0 ? t : new C(t.reasons.map((s) => s.annotate(e, r)))), Q = (t) => t._tag === "Fail", X = (t) => t._tag === "Die", gt = (t) => t._tag === "Interrupt";
+function Z(t) {
+  return st("Effect.evaluate: Not implemented");
+}
+const A = (t) => ({
+  ...B,
+  [$]: t.op,
+  [h]: t[h] ?? Z,
+  [m]: t[m],
+  [u]: t[u],
+  [F]: t[F]
+}), tt = (t) => {
+  const e = A(t);
+  return function() {
+    const r = Object.create(e);
+    return r[n] = t.single === !1 ? arguments : arguments[0], r;
+  };
+}, j = (t) => {
+  const e = {
+    ...A(t),
+    [_]: _,
+    _tag: t.op,
+    get [t.prop]() {
+      return this[n];
+    },
+    toString() {
+      return `${t.op}(${a(this[n])})`;
+    },
+    toJSON() {
+      return {
+        _id: "Exit",
+        _tag: t.op,
+        [t.prop]: this[n]
+      };
+    },
+    [d](r) {
+      return q(r) && r._tag === this._tag && i(this[n], r[n]);
+    },
+    [g]() {
+      return f(b(t.op), l(this[n]));
+    }
+  };
+  return function(r) {
+    const s = Object.create(e);
+    return s[n] = r, s;
+  };
+}, St = /* @__PURE__ */ j({
+  op: "Success",
+  prop: "value",
+  [h](t) {
+    const e = t.getCont(m);
+    return e ? e[m](this[n], t, this) : t.yieldWith(this);
+  }
+}), et = {
+  key: "effect/Cause/StackTrace"
+}, Et = {
+  key: "effect/Cause/InterruptorStackTrace"
+}, w = /* @__PURE__ */ j({
+  op: "Failure",
+  prop: "cause",
+  [h](t) {
+    let e = this[n], r = !1;
+    t.currentStackFrame && (e = L(e, {
+      mapUnsafe: /* @__PURE__ */ new Map([[et.key, t.currentStackFrame]])
+    }), r = !0);
+    let s = t.getCont(u);
+    for (; t.interruptible && t._interruptedCause && s; )
+      s = t.getCont(u);
+    return s ? s[u](e, t, r ? void 0 : this) : t.yieldWith(r ? this : w(e));
+  }
+}), rt = (t) => w(K(t)), st = (t) => w(H(t)), yt = /* @__PURE__ */ tt({
+  op: "WithFiber",
+  [h](t) {
+    return this[n](t);
+  }
+}), nt = /* @__PURE__ */ (function() {
+  class t extends globalThis.Error {
+    asEffect() {
+      return rt(this);
+    }
+  }
+  return Object.assign(t.prototype, z), t;
+})(), ot = /* @__PURE__ */ (function() {
+  const t = /* @__PURE__ */ Symbol.for("effect/Data/Error/plainArgs");
+  return class extends nt {
+    constructor(r) {
+      super(r?.message, r?.cause ? {
+        cause: r.cause
+      } : void 0), r && (Object.assign(this, r), Object.defineProperty(this, t, {
+        value: r,
+        enumerable: !1
+      }));
+    }
+    toJSON() {
+      return {
+        ...this[t],
+        ...this
+      };
+    }
+  };
+})(), it = (t) => {
+  class e extends ot {
+    _tag = t;
+  }
+  return e.prototype.name = t, e;
+}, k = "~effect/Cause/NoSuchElementError";
+class bt extends (/* @__PURE__ */ it("NoSuchElementError")) {
+  [k] = k;
+  constructor(e) {
+    super({
+      message: e
+    });
+  }
+}
+export {
+  C as CauseImpl,
+  y as CauseReasonTypeId,
+  p as CauseTypeId,
+  V as Die,
+  B as EffectProto,
+  o as EffectTypeId,
+  ot as Error,
+  _ as ExitTypeId,
+  G as Fail,
+  Et as InterruptorStackTrace,
+  bt as NoSuchElementError,
+  k as NoSuchElementErrorTypeId,
+  U as PipeInspectableProto,
+  J as ReasonBase,
+  et as StackTraceKey,
+  it as TaggedError,
+  dt as Yield,
+  nt as YieldableError,
+  z as YieldableErrorProto,
+  W as YieldableProto,
+  n as args,
+  L as causeAnnotate,
+  H as causeDie,
+  K as causeFail,
+  N as constEmptyAnnotations,
+  m as contA,
+  F as contAll,
+  u as contE,
+  h as evaluate,
+  st as exitDie,
+  rt as exitFail,
+  w as exitFailCause,
+  St as exitSucceed,
+  $ as identifier,
+  v as isCause,
+  X as isDieReason,
+  q as isExit,
+  Q as isFailReason,
+  gt as isInterruptReason,
+  j as makeExit,
+  tt as makePrimitive,
+  A as makePrimitiveProto,
+  yt as withFiber
+};