@manyducks.co/dolla 2.0.0-alpha.51 → 2.0.0-alpha.52

package/dist/logger-CSRDjb4e.js

@@ -0,0 +1,623 @@
+import { c as T, t as N, i as B } from "./typeChecking-EAVNeFyB.js";
+var v = /* @__PURE__ */ ((e) => (e[e.Computed = 1] = "Computed", e[e.Effect = 2] = "Effect", e[e.Tracking = 4] = "Tracking", e[e.Notified = 8] = "Notified", e[e.Recursed = 16] = "Recursed", e[e.Dirty = 32] = "Dirty", e[e.PendingComputed = 64] = "PendingComputed", e[e.PendingEffect = 128] = "PendingEffect", e[e.Propagated = 224] = "Propagated", e))(v || {});
+function L({
+  updateComputed: e,
+  notifyEffect: t
+}) {
+  let i, r;
+  return {
+    /**
+     * Links a given dependency and subscriber if they are not already linked.
+     * 
+     * @param dep - The dependency to be linked.
+     * @param sub - The subscriber that depends on this dependency.
+     * @returns The newly created link object if the two are not already linked; otherwise `undefined`.
+     */
+    link(n, s) {
+      const f = s.depsTail;
+      if (f !== void 0 && f.dep === n)
+        return;
+      const c = f !== void 0 ? f.nextDep : s.deps;
+      if (c !== void 0 && c.dep === n) {
+        s.depsTail = c;
+        return;
+      }
+      const o = n.subsTail;
+      if (!(o !== void 0 && o.sub === s && E(o, s)))
+        return u(n, s, c, f);
+    },
+    /**
+     * Traverses and marks subscribers starting from the provided link.
+     * 
+     * It sets flags (e.g., Dirty, PendingComputed, PendingEffect) on each subscriber
+     * to indicate which ones require re-computation or effect processing. 
+     * This function should be called after a signal's value changes.
+     * 
+     * @param link - The starting link from which propagation begins.
+     */
+    propagate(n) {
+      let s = 32, f = n, c = 0;
+      e: do {
+        const o = n.sub, l = o.flags;
+        if (!(l & 244) && (o.flags = l | s | 8, !0) || l & 16 && !(l & 4) && (o.flags = l & -17 | s | 8, !0) || !(l & 224) && E(n, o) && (o.flags = l | 16 | s | 8, o.subs !== void 0)) {
+          const g = o.subs;
+          if (g !== void 0) {
+            g.nextSub !== void 0 ? (g.prevSub = f, n = f = g, s = 64, ++c) : (n = g, s = l & 2 ? 128 : 64);
+            continue;
+          }
+          l & 2 && (r !== void 0 ? r.depsTail.nextDep = o.deps : i = o, r = o);
+        } else l & (4 | s) ? !(l & s) && l & 224 && E(n, o) && (o.flags = l | s) : (o.flags = l | s | 8, (l & 10) === 2 && (r !== void 0 ? r.depsTail.nextDep = o.deps : i = o, r = o));
+        if ((n = f.nextSub) !== void 0) {
+          f = n, s = c ? 64 : 32;
+          continue;
+        }
+        for (; c; ) {
+          --c;
+          const q = f.dep.subs;
+          if (f = q.prevSub, q.prevSub = void 0, (n = f.nextSub) !== void 0) {
+            f = n, s = c ? 64 : 32;
+            continue e;
+          }
+        }
+        break;
+      } while (!0);
+    },
+    /**
+     * Prepares the given subscriber to track new dependencies.
+     * 
+     * It resets the subscriber's internal pointers (e.g., depsTail) and
+     * sets its flags to indicate it is now tracking dependency links.
+     * 
+     * @param sub - The subscriber to start tracking.
+     */
+    startTracking(n) {
+      n.depsTail = void 0, n.flags = n.flags & -249 | 4;
+    },
+    /**
+     * Concludes tracking of dependencies for the specified subscriber.
+     * 
+     * It clears or unlinks any tracked dependency information, then
+     * updates the subscriber's flags to indicate tracking is complete.
+     * 
+     * @param sub - The subscriber whose tracking is ending.
+     */
+    endTracking(n) {
+      const s = n.depsTail;
+      if (s !== void 0) {
+        const f = s.nextDep;
+        f !== void 0 && (P(f), s.nextDep = void 0);
+      } else n.deps !== void 0 && (P(n.deps), n.deps = void 0);
+      n.flags &= -5;
+    },
+    /**
+     * Updates the dirty flag for the given subscriber based on its dependencies.
+     * 
+     * If the subscriber has any pending computeds, this function sets the Dirty flag
+     * and returns `true`. Otherwise, it clears the PendingComputed flag and returns `false`.
+     * 
+     * @param sub - The subscriber to update.
+     * @param flags - The current flag set for this subscriber.
+     * @returns `true` if the subscriber is marked as Dirty; otherwise `false`.
+     */
+    updateDirtyFlag(n, s) {
+      return a(n.deps) ? (n.flags = s | 32, !0) : (n.flags = s & -65, !1);
+    },
+    /**
+     * Updates the computed subscriber if necessary before its value is accessed.
+     * 
+     * If the subscriber is marked Dirty or PendingComputed, this function runs
+     * the provided updateComputed logic and triggers a shallowPropagate for any
+     * downstream subscribers if an actual update occurs.
+     * 
+     * @param computed - The computed subscriber to update.
+     * @param flags - The current flag set for this subscriber.
+     */
+    processComputedUpdate(n, s) {
+      if ((s & 32 || (a(n.deps) || (n.flags = s & -65, !1))) && e(n)) {
+        const f = n.subs;
+        f !== void 0 && p(f);
+      }
+    },
+    /**
+     * Ensures all pending internal effects for the given subscriber are processed.
+     * 
+     * This should be called after an effect decides not to re-run itself but may still
+     * have dependencies flagged with PendingEffect. If the subscriber is flagged with
+     * PendingEffect, this function clears that flag and invokes `notifyEffect` on any
+     * related dependencies marked as Effect and Propagated, processing pending effects.
+     * 
+     * @param sub - The subscriber which may have pending effects.
+     * @param flags - The current flags on the subscriber to check.
+     */
+    processPendingInnerEffects(n, s) {
+      if (s & 128) {
+        n.flags = s & -129;
+        let f = n.deps;
+        do {
+          const c = f.dep;
+          "flags" in c && c.flags & 2 && c.flags & 224 && t(c), f = f.nextDep;
+        } while (f !== void 0);
+      }
+    },
+    /**
+     * Processes queued effect notifications after a batch operation finishes.
+     * 
+     * Iterates through all queued effects, calling notifyEffect on each.
+     * If an effect remains partially handled, its flags are updated, and future
+     * notifications may be triggered until fully handled.
+     */
+    processEffectNotifications() {
+      for (; i !== void 0; ) {
+        const n = i, s = n.depsTail, f = s.nextDep;
+        f !== void 0 ? (s.nextDep = void 0, i = f.sub) : (i = void 0, r = void 0), t(n) || (n.flags &= -9);
+      }
+    }
+  };
+  function u(n, s, f, c) {
+    const o = {
+      dep: n,
+      sub: s,
+      nextDep: f,
+      prevSub: void 0,
+      nextSub: void 0
+    };
+    if (c === void 0 ? s.deps = o : c.nextDep = o, n.subs === void 0)
+      n.subs = o;
+    else {
+      const l = n.subsTail;
+      o.prevSub = l, l.nextSub = o;
+    }
+    return s.depsTail = o, n.subsTail = o, o;
+  }
+  function a(n) {
+    let s = 0, f;
+    e: do {
+      f = !1;
+      const c = n.dep;
+      if ("flags" in c) {
+        const o = c.flags;
+        if ((o & 33) === 33) {
+          if (e(c)) {
+            const l = c.subs;
+            l.nextSub !== void 0 && p(l), f = !0;
+          }
+        } else if ((o & 65) === 65) {
+          const l = c.subs;
+          l.nextSub !== void 0 && (l.prevSub = n), n = c.deps, ++s;
+          continue;
+        }
+      }
+      if (!f && n.nextDep !== void 0) {
+        n = n.nextDep;
+        continue;
+      }
+      if (s) {
+        let o = n.sub;
+        do {
+          --s;
+          const l = o.subs;
+          if (f) {
+            if (e(o)) {
+              (n = l.prevSub) !== void 0 ? (l.prevSub = void 0, p(o.subs), o = n.sub) : o = l.sub;
+              continue;
+            }
+          } else
+            o.flags &= -65;
+          if ((n = l.prevSub) !== void 0) {
+            if (l.prevSub = void 0, n.nextDep !== void 0) {
+              n = n.nextDep;
+              continue e;
+            }
+            o = n.sub;
+          } else {
+            if ((n = l.nextDep) !== void 0)
+              continue e;
+            o = l.sub;
+          }
+          f = !1;
+        } while (s);
+      }
+      return f;
+    } while (!0);
+  }
+  function p(n) {
+    do {
+      const s = n.sub, f = s.flags;
+      (f & 96) === 64 && (s.flags = f | 32 | 8, (f & 10) === 2 && (r !== void 0 ? r.depsTail.nextDep = s.deps : i = s, r = s)), n = n.nextSub;
+    } while (n !== void 0);
+  }
+  function E(n, s) {
+    const f = s.depsTail;
+    if (f !== void 0) {
+      let c = s.deps;
+      do {
+        if (c === n)
+          return !0;
+        if (c === f)
+          break;
+        c = c.nextDep;
+      } while (c !== void 0);
+    }
+    return !1;
+  }
+  function P(n) {
+    do {
+      const s = n.dep, f = n.nextDep, c = n.nextSub, o = n.prevSub;
+      if (c !== void 0 ? c.prevSub = o : s.subsTail = o, o !== void 0 ? o.nextSub = c : s.subs = c, s.subs === void 0 && "deps" in s) {
+        const l = s.flags;
+        l & 32 || (s.flags = l | 32);
+        const g = s.deps;
+        if (g !== void 0) {
+          n = g, s.depsTail.nextDep = f, s.deps = void 0, s.depsTail = void 0;
+          continue;
+        }
+      }
+      n = f;
+    } while (n !== void 0);
+  }
+}
+var {
+  link: ce,
+  propagate: le,
+  updateDirtyFlag: X,
+  startTracking: _,
+  endTracking: A,
+  processEffectNotifications: ae,
+  processComputedUpdate: de,
+  processPendingInnerEffects: I
+} = L({
+  updateComputed(e) {
+    _(e);
+    try {
+      const t = e.currentValue, i = e.getter(t);
+      return t !== i ? (e.currentValue = i, !0) : !1;
+    } finally {
+      A(e);
+    }
+  },
+  notifyEffect(e) {
+    return "isScope" in e ? K(e) : J(e);
+  }
+});
+function H(e) {
+  _(e);
+  try {
+    e.fn();
+  } finally {
+    A(e);
+  }
+}
+function J(e) {
+  const t = e.flags;
+  return t & 32 || t & 64 && X(e, t) ? H(e) : I(e, e.flags), !0;
+}
+function K(e) {
+  return e.flags & 128 ? (I(e, e.flags), !0) : !1;
+}
+const {
+  link: O,
+  propagate: Q,
+  updateDirtyFlag: Y,
+  startTracking: b,
+  endTracking: C,
+  processEffectNotifications: Z,
+  processComputedUpdate: F,
+  processPendingInnerEffects: ee
+} = L({
+  updateComputed(e) {
+    const t = d;
+    d = e, b(e);
+    try {
+      const i = e.current, r = e.getter(i);
+      return e.equals(i, r) ? !1 : (e.current = r, !0);
+    } finally {
+      d = t, C(e);
+    }
+  },
+  notifyEffect(e) {
+    const t = e.flags;
+    return t & v.Dirty || t & v.PendingComputed && Y(e, t) ? V(e) : ee(e, e.flags), !0;
+  }
+});
+let d;
+const h = [];
+let S = !1;
+function te() {
+  S || (S = !0, queueMicrotask(() => {
+    S = !1;
+    for (let e = 0; e < h.length; e++) {
+      const t = h[e], i = d;
+      d = t, b(t);
+      try {
+        t.cleanup && (z(), t.cleanup(), R()), t.cleanup = t.fn() ?? void 0;
+      } finally {
+        d = i, C(t);
+      }
+    }
+    h.length = 0;
+  }));
+}
+function V(e) {
+  h.push(e), te();
+}
+function ne() {
+  b(this), C(this), queueMicrotask(() => {
+    h.splice(h.indexOf(this), 1), this.cleanup && this.cleanup();
+  });
+}
+const k = [];
+function z() {
+  k.push(d), d = void 0;
+}
+function R() {
+  d = k.pop();
+}
+const j = Symbol("SIGNAL"), U = Symbol("SOURCE");
+function pe(e) {
+  let t;
+  return z(), t = D(e), R(), t;
+}
+function D(e) {
+  return T(e) ? e() : e;
+}
+function ge(e) {
+  const t = {
+    fn: e,
+    subs: void 0,
+    subsTail: void 0,
+    deps: void 0,
+    depsTail: void 0,
+    flags: v.Effect
+  };
+  return d !== void 0 && O(t, d), V(t), ne.bind(t);
+}
+function ve(e, t) {
+  return T(e) ? re(e, t) : $(e === void 0 ? void 0 : e, t);
+}
+function $(e, t) {
+  const i = {
+    current: e,
+    subs: void 0,
+    subsTail: void 0
+  }, r = (t == null ? void 0 : t.equals) ?? Object.is, u = function() {
+    if (arguments.length > 0) {
+      let a = arguments[0];
+      if (typeof a == "function" && (a = a(i.current)), !r(i.current, a)) {
+        i.current = a;
+        const p = i.subs;
+        p !== void 0 && (Q(p), Z());
+      }
+    } else
+      return d !== void 0 && O(i, d), i.current;
+  };
+  return u._type = U, u;
+}
+function re(e, t) {
+  if (T(e) && e._type === j)
+    return e._type === U ? () => e() : e;
+  const i = {
+    current: void 0,
+    equals: (t == null ? void 0 : t.equals) ?? Object.is,
+    subs: void 0,
+    subsTail: void 0,
+    deps: void 0,
+    depsTail: void 0,
+    flags: v.Computed | v.Dirty,
+    getter: (u) => {
+      const a = e(u);
+      return D(a);
+    }
+  }, r = function() {
+    if (arguments.length > 0)
+      throw new Error("Signals cannot be set as their values are derived from the sources they depend on.");
+    d !== void 0 && O(i, d);
+    const u = i.flags;
+    return u & (v.Dirty | v.PendingComputed) && F(i, u), i.current;
+  };
+  return r._type = j, r;
+}
+const se = () => {
+};
+let w = 1;
+function he() {
+  return w = w % Number.MAX_SAFE_INTEGER + 1, w.toString(36) + Date.now().toString(36);
+}
+function ye(e, t) {
+  return Object.is(e, t);
+}
+function xe(e, t) {
+  if (Object.is(e, t)) return !0;
+  const i = N(e);
+  if (i !== N(t))
+    return !1;
+  switch (i) {
+    case "object":
+      let r = 0;
+      for (const u in e) {
+        if (e[u] !== t[u]) return !1;
+        r++;
+      }
+      return Object.keys(t).length === r;
+    case "array":
+      if (e.length !== t.length) return !1;
+      for (let u = 0; u < e.length; u++)
+        if (e[u] !== t[u]) return !1;
+      return !0;
+    case "map":
+      if (e.size !== t.size) return !1;
+      for (const u of e.keys())
+        if (e[u] !== t[u]) return !1;
+      return !0;
+    case "set":
+      if (T(e.symmetricDifference))
+        return e.symmetricDifference(t).size === 0;
+      for (const u of e.keys())
+        if (e[u] !== t.get(u)) return !1;
+      return !0;
+  }
+  return !1;
+}
+function m(e, t) {
+  if (e === t) return !0;
+  if (e && t && typeof e == "object" && typeof t == "object") {
+    if (e.constructor !== t.constructor) return !1;
+    var i, r, u;
+    if (Array.isArray(e)) {
+      if (i = e.length, i != t.length) return !1;
+      for (r = i; r-- !== 0; ) if (!m(e[r], t[r])) return !1;
+      return !0;
+    }
+    if (e instanceof Map && t instanceof Map) {
+      if (e.size !== t.size) return !1;
+      for (r of e.entries()) if (!t.has(r[0])) return !1;
+      for (r of e.entries()) if (!m(r[1], t.get(r[0]))) return !1;
+      return !0;
+    }
+    if (e instanceof Set && t instanceof Set) {
+      if (e.size !== t.size) return !1;
+      for (r of e.entries()) if (!t.has(r[0])) return !1;
+      return !0;
+    }
+    if (ArrayBuffer.isView(e) && ArrayBuffer.isView(t)) {
+      if (i = e.length, i != t.length) return !1;
+      for (r = i; r-- !== 0; ) if (e[r] !== t[r]) return !1;
+      return !0;
+    }
+    if (e.constructor === RegExp) return e.source === t.source && e.flags === t.flags;
+    if (e.valueOf !== Object.prototype.valueOf) return e.valueOf() === t.valueOf();
+    if (e.toString !== Object.prototype.toString) return e.toString() === t.toString();
+    if (u = Object.keys(e), i = u.length, i !== Object.keys(t).length) return !1;
+    for (r = i; r-- !== 0; ) if (!Object.prototype.hasOwnProperty.call(t, u[r])) return !1;
+    for (r = i; r-- !== 0; ) {
+      var a = u[r];
+      if (!m(e[a], t[a])) return !1;
+    }
+    return !0;
+  }
+  return e !== e && t !== t;
+}
+function De(e, t) {
+  const i = {};
+  for (const r in t)
+    e.includes(r) || (i[r] = t[r]);
+  return i;
+}
+function ie(e) {
+  let t = 0;
+  for (let i = 0; i < e.length; i++)
+    t = (t + e.charCodeAt(i) * 10) % 360;
+  return `oklch(0.68 0.15 ${t}deg)`;
+}
+function M(e) {
+  if (e instanceof RegExp)
+    return (r) => e.test(r);
+  const t = {
+    positive: [],
+    negative: []
+  }, i = e.split(",").map((r) => r.trim()).filter((r) => r !== "");
+  for (let r of i) {
+    let u = "positive";
+    r.startsWith("-") && (u = "negative", r = r.slice(1)), r === "*" ? t[u].push(function() {
+      return !0;
+    }) : r.endsWith("*") ? t[u].push(function(a) {
+      return a.startsWith(r.slice(0, r.length - 1));
+    }) : t[u].push(function(a) {
+      return a === r;
+    });
+  }
+  return function(r) {
+    const { positive: u, negative: a } = t;
+    return !(a.some((p) => p(r)) || u.length > 0 && !u.some((p) => p(r)));
+  };
+}
+let G = "production";
+function fe() {
+  return G;
+}
+function Te(e) {
+  G = e;
+}
+let y = {
+  info: "development",
+  log: "development",
+  warn: "development",
+  error: !0
+}, W = M("*,-Dolla.*"), x = [];
+function Ee(e) {
+  return x.push(e), function() {
+    x.splice(x.indexOf(e), 1);
+  };
+}
+function Se(e, t) {
+  const i = (t == null ? void 0 : t.console) ?? oe(), r = (u) => {
+    if (y[u] === !1 || B(y[u]) && y[u] !== fe() || !W(D(e)))
+      return se;
+    {
+      let a = `%c${e}`;
+      return t != null && t.uid ? a += ` %c[uid: %c${t.uid}%c]` : a += "%c%c%c", i[u].bind(
+        i,
+        a,
+        `color:${ie(a)};font-weight:bold`,
+        "color:#777",
+        "color:#aaa",
+        "color:#777"
+      );
+    }
+  };
+  return {
+    get info() {
+      return r("info");
+    },
+    get log() {
+      return r("log");
+    },
+    get warn() {
+      return r("warn");
+    },
+    get error() {
+      return r("error");
+    },
+    crash(u) {
+      const a = {
+        error: u,
+        loggerName: D(e),
+        uid: t == null ? void 0 : t.uid
+      };
+      for (const p of x)
+        p(a);
+    }
+  };
+}
+function we(e) {
+  W = M(e);
+}
+function me(e) {
+  for (const t in e) {
+    const i = e[t];
+    i && (y[t] = i);
+  }
+}
+function oe() {
+  if (typeof window < "u" && window.console)
+    return window.console;
+  if (typeof global < "u" && global.console)
+    return global.console;
+}
+export {
+  ve as $,
+  ye as a,
+  fe as b,
+  Te as c,
+  m as d,
+  ge as e,
+  Se as f,
+  D as g,
+  we as h,
+  me as i,
+  De as j,
+  he as k,
+  Ee as o,
+  pe as p,
+  xe as s
+};
+//# sourceMappingURL=logger-CSRDjb4e.js.map