@serendie/ui 0.1.12 → 0.1.13

package/dist/node_modules/@zag-js/core/dist/index.js

@@ -0,0 +1,546 @@
+import { snapshot as M, proxy as V, proxyWithComputed as R, subscribe as O, ref as L } from "../../store/dist/index.js";
+import { klona as q } from "../../../klona/full/index.js";
+var B = Object.defineProperty, H = (t, s, r) => s in t ? B(t, s, { enumerable: !0, configurable: !0, writable: !0, value: r }) : t[s] = r, a = (t, s, r) => H(t, typeof s != "symbol" ? s + "" : s, r);
+function J(t) {
+  for (; t.length > 0; ) t.pop();
+  return t;
+}
+var P = (t, ...s) => (typeof t == "function" ? t(...s) : t) ?? void 0, m = (t) => t, K = () => {
+}, X = (...t) => (...s) => {
+  t.forEach(function(r) {
+    r == null || r(...s);
+  });
+}, $ = /* @__PURE__ */ (() => {
+  let t = 0;
+  return () => (t++, t.toString(36));
+})(), Q = () => process.env.NODE_ENV !== "production", w = (t) => Array.isArray(t), A = (t) => !(t == null || typeof t != "object" || w(t)), U = (t) => typeof t == "number" && !Number.isNaN(t), v = (t) => typeof t == "string", N = (t) => typeof t == "function", Y = (t, s) => Object.prototype.hasOwnProperty.call(t, s);
+function D(t) {
+  if (!Z(t) || t === void 0)
+    return t;
+  const s = Reflect.ownKeys(t).filter((o) => typeof o == "string"), r = {};
+  for (const o of s) {
+    const u = t[o];
+    u !== void 0 && (r[o] = D(u));
+  }
+  return r;
+}
+var Z = (t) => t && typeof t == "object" && t.constructor === Object;
+function T(...t) {
+  const s = t.length === 1 ? t[0] : t[1];
+  (t.length === 2 ? t[0] : !0) && process.env.NODE_ENV !== "production" && console.warn(s);
+}
+function b(...t) {
+  const s = t.length === 1 ? t[0] : t[1];
+  if ((t.length === 2 ? t[0] : !0) && process.env.NODE_ENV !== "production")
+    throw new Error(s);
+}
+function z(t, ...s) {
+  for (const r of s) {
+    const o = D(r);
+    for (const u in o)
+      A(r[u]) ? (t[u] || (t[u] = {}), z(t[u], r[u])) : t[u] = r[u];
+  }
+  return t;
+}
+function F(t) {
+  return q(t);
+}
+function g(t) {
+  return v(t) ? { type: t } : t;
+}
+function x(t) {
+  return t ? w(t) ? t.slice() : [t] : [];
+}
+function W(t) {
+  return A(t) && t.predicate != null;
+}
+var tt = () => !0;
+function _(t, s, r, o) {
+  return (u) => {
+    var p;
+    return v(u) ? !!((p = t[u]) != null && p.call(t, s, r, o)) : N(u) ? u(s, r, o) : u.predicate(t)(s, r, o);
+  };
+}
+function et(...t) {
+  return {
+    predicate: (s) => (r, o, u) => t.map(_(s, r, o, u)).some(Boolean)
+  };
+}
+function it(...t) {
+  return {
+    predicate: (s) => (r, o, u) => t.map(_(s, r, o, u)).every(Boolean)
+  };
+}
+function st(t) {
+  return {
+    predicate: (s) => (r, o, u) => !_(s, r, o, u)(t)
+  };
+}
+function nt(...t) {
+  return (s, r, o) => o.state.matches(...t);
+}
+var vt = { or: et, and: it, not: st, stateIn: nt };
+function k(t, s) {
+  return t = t ?? tt, (r, o, u) => {
+    if (v(t)) {
+      const p = s[t];
+      return N(p) ? p(r, o, u) : p;
+    }
+    return W(t) ? t.predicate(s)(r, o, u) : t == null ? void 0 : t(r, o, u);
+  };
+}
+function j(t, s) {
+  return (r, o, u) => W(t) ? t.predicate(s)(r, o, u) : t;
+}
+function rt(t) {
+  var p, S;
+  const s = t.computed ?? m({}), r = t.context ?? m({}), o = t.initial ? (S = (p = t.states) == null ? void 0 : p[t.initial]) == null ? void 0 : S.tags : [], u = V({
+    value: t.initial ?? "",
+    previousValue: "",
+    event: m({}),
+    previousEvent: m({}),
+    context: R(r, s),
+    done: !1,
+    tags: o ?? [],
+    hasTag(e) {
+      return this.tags.includes(e);
+    },
+    matches(...e) {
+      return e.includes(this.value);
+    },
+    can(e) {
+      return m(this).nextEvents.includes(e);
+    },
+    get nextEvents() {
+      var i, h;
+      const e = ((h = (i = t.states) == null ? void 0 : i[this.value]) == null ? void 0 : h.on) ?? {}, n = (t == null ? void 0 : t.on) ?? {};
+      return Object.keys({ ...e, ...n });
+    },
+    get changed() {
+      return this.event.value === "machine.init" || !this.previousValue ? !1 : this.value !== this.previousValue;
+    }
+  });
+  return m(u);
+}
+function E(t, s) {
+  return (r, o) => {
+    if (U(t)) return t;
+    if (N(t))
+      return t(r, o);
+    if (v(t)) {
+      const u = Number.parseFloat(t);
+      if (!Number.isNaN(u))
+        return u;
+      if (s) {
+        const p = s == null ? void 0 : s[t];
+        return b(
+          p == null,
+          `[@zag-js/core > determine-delay] Cannot determine delay for \`${t}\`. It doesn't exist in \`options.delays\``
+        ), N(p) ? p(r, o) : p;
+      }
+    }
+  };
+}
+function at(t) {
+  return v(t) ? { target: t } : t;
+}
+function ot(t, s) {
+  return (r, o, u) => x(t).map(at).find((p) => k(p.guard, s)(r, o, u) ?? p.target ?? p.actions);
+}
+var G = class {
+  // Let's get started!
+  constructor(t, s) {
+    var r, o, u, p, S;
+    a(
+      this,
+      "status",
+      "Not Started"
+      /* NotStarted */
+    ), a(this, "state"), a(this, "initialState"), a(this, "initialContext"), a(this, "id"), a(
+      this,
+      "type",
+      "machine"
+      /* Machine */
+    ), a(this, "activityEvents", /* @__PURE__ */ new Map()), a(this, "delayedEvents", /* @__PURE__ */ new Map()), a(this, "stateListeners", /* @__PURE__ */ new Set()), a(this, "doneListeners", /* @__PURE__ */ new Set()), a(this, "contextWatchers", /* @__PURE__ */ new Set()), a(this, "removeStateListener", K), a(this, "parent"), a(this, "children", /* @__PURE__ */ new Map()), a(this, "guardMap"), a(this, "actionMap"), a(this, "delayMap"), a(this, "activityMap"), a(this, "sync"), a(this, "options"), a(this, "config"), a(this, "_created", () => {
+      var n;
+      const e = g(
+        "machine.created"
+        /* Created */
+      );
+      this.executeActions((n = this.config) == null ? void 0 : n.created, e);
+    }), a(this, "start", (e) => {
+      if (this.state.value = "", this.state.tags = [], this.status === "Running")
+        return this;
+      this.status = "Running", this.removeStateListener = O(
+        this.state,
+        () => {
+          this.stateListeners.forEach((f) => {
+            f(this.stateSnapshot);
+          });
+        },
+        this.sync
+      ), this.setupContextWatchers(), this.executeActivities(
+        g(
+          "machine.start"
+          /* Start */
+        ),
+        x(this.config.activities),
+        "machine.start"
+        /* Start */
+      ), this.executeActions(this.config.entry, g(
+        "machine.start"
+        /* Start */
+      ));
+      const n = g(
+        "machine.init"
+        /* Init */
+      ), i = A(e) ? e.value : e, h = A(e) ? e.context : void 0;
+      h && this.setContext(h);
+      const c = {
+        target: i ?? this.config.initial
+      }, l = this.getNextStateInfo(c, n);
+      return this.initialState = l, this.performStateChangeEffects(this.state.value, l, n), this;
+    }), a(this, "setupContextWatchers", () => {
+      const { watch: e } = this.config;
+      if (!e) return;
+      let n = M(this.state.context);
+      const i = O(this.state.context, () => {
+        var c;
+        const h = M(this.state.context);
+        for (const [l, f] of Object.entries(e))
+          (((c = this.options.compareFns) == null ? void 0 : c[l]) ?? Object.is)(n[l], h[l]) || this.executeActions(f, this.state.event);
+        n = h;
+      });
+      this.contextWatchers.add(i);
+    }), a(this, "stop", () => {
+      if (this.status !== "Stopped")
+        return this.performExitEffects(this.state.value, g(
+          "machine.stop"
+          /* Stop */
+        )), this.executeActions(this.config.exit, g(
+          "machine.stop"
+          /* Stop */
+        )), this.setState(""), this.setEvent(
+          "machine.stop"
+          /* Stop */
+        ), this.stopStateListeners(), this.stopChildren(), this.stopActivities(), this.stopDelayedEvents(), this.stopContextWatchers(), this.status = "Stopped", this;
+    }), a(this, "stopStateListeners", () => {
+      this.removeStateListener(), this.stateListeners.clear();
+    }), a(this, "stopContextWatchers", () => {
+      this.contextWatchers.forEach((e) => e()), this.contextWatchers.clear();
+    }), a(this, "stopDelayedEvents", () => {
+      this.delayedEvents.forEach((e) => {
+        e.forEach((n) => n());
+      }), this.delayedEvents.clear();
+    }), a(this, "stopActivities", (e) => {
+      var n, i;
+      e ? ((n = this.activityEvents.get(e)) == null || n.forEach((h) => h()), (i = this.activityEvents.get(e)) == null || i.clear(), this.activityEvents.delete(e)) : (this.activityEvents.forEach((h) => {
+        h.forEach((c) => c()), h.clear();
+      }), this.activityEvents.clear());
+    }), a(this, "sendChild", (e, n) => {
+      const i = g(e), h = P(n, this.contextSnapshot), c = this.children.get(h);
+      c || b(`[@zag-js/core] Cannot send '${i.type}' event to unknown child`), c.send(i);
+    }), a(this, "stopChild", (e) => {
+      this.children.has(e) || b(`[@zag-js/core > stop-child] Cannot stop unknown child ${e}`), this.children.get(e).stop(), this.children.delete(e);
+    }), a(this, "removeChild", (e) => {
+      this.children.delete(e);
+    }), a(this, "stopChildren", () => {
+      this.children.forEach((e) => e.stop()), this.children.clear();
+    }), a(this, "setParent", (e) => {
+      this.parent = e;
+    }), a(this, "spawn", (e, n) => {
+      const i = P(e);
+      return n && (i.id = n), i.type = "machine.actor", i.setParent(this), this.children.set(i.id, m(i)), i.onDone(() => {
+        this.removeChild(i.id);
+      }).start(), m(L(i));
+    }), a(this, "stopActivity", (e) => {
+      var i;
+      if (!this.state.value) return;
+      const n = this.activityEvents.get(this.state.value);
+      (i = n == null ? void 0 : n.get(e)) == null || i(), n == null || n.delete(e);
+    }), a(this, "addActivityCleanup", (e, n, i) => {
+      var h;
+      e && (this.activityEvents.has(e) ? (h = this.activityEvents.get(e)) == null || h.set(n, i) : this.activityEvents.set(e, /* @__PURE__ */ new Map([[n, i]])));
+    }), a(this, "setState", (e) => {
+      this.state.previousValue = this.state.value, this.state.value = e;
+      const n = this.getStateNode(e);
+      e == null ? J(this.state.tags) : this.state.tags = x(n == null ? void 0 : n.tags);
+    }), a(this, "setContext", (e) => {
+      e && z(this.state.context, D(e));
+    }), a(this, "setOptions", (e) => {
+      const n = D(e);
+      this.actionMap = { ...this.actionMap, ...n.actions }, this.delayMap = { ...this.delayMap, ...n.delays }, this.activityMap = { ...this.activityMap, ...n.activities }, this.guardMap = { ...this.guardMap, ...n.guards };
+    }), a(this, "getStateNode", (e) => {
+      var n;
+      if (e)
+        return (n = this.config.states) == null ? void 0 : n[e];
+    }), a(this, "getNextStateInfo", (e, n) => {
+      const i = this.determineTransition(e, n), h = !(i != null && i.target), c = (i == null ? void 0 : i.target) ?? this.state.value, l = this.state.value !== c, f = this.getStateNode(c), y = {
+        reenter: !h && !l && !(i != null && i.internal),
+        transition: i,
+        stateNode: f,
+        target: c,
+        changed: l
+      };
+      return this.log("NextState:", `[${n.type}]`, this.state.value, "---->", y.target), y;
+    }), a(this, "getAfterActions", (e, n) => {
+      let i;
+      return {
+        entry: () => {
+          i = globalThis.setTimeout(() => {
+            const h = this.getNextStateInfo(e, this.state.event);
+            this.performStateChangeEffects(this.state.value, h, this.state.event);
+          }, n);
+        },
+        exit: () => {
+          globalThis.clearTimeout(i);
+        }
+      };
+    }), a(this, "getDelayedEventActions", (e) => {
+      const n = this.getStateNode(e), i = this.state.event;
+      if (!n || !n.after) return;
+      const h = [], c = [];
+      if (w(n.after)) {
+        const l = this.determineTransition(n.after, i);
+        if (!l) return;
+        if (!Y(l, "delay"))
+          throw new Error(`[@zag-js/core > after] Delay is required for after transition: ${JSON.stringify(l)}`);
+        const d = E(l.delay, this.delayMap)(this.contextSnapshot, i), y = this.getAfterActions(l, d);
+        return h.push(y.entry), c.push(y.exit), { entries: h, exits: c };
+      }
+      if (A(n.after))
+        for (const l in n.after) {
+          const f = n.after[l], y = E(l, this.delayMap)(this.contextSnapshot, i), C = this.getAfterActions(f, y);
+          h.push(C.entry), c.push(C.exit);
+        }
+      return { entries: h, exits: c };
+    }), a(this, "executeActions", (e, n) => {
+      var h;
+      const i = j(e, this.guardMap)(this.contextSnapshot, n, this.guardMeta);
+      for (const c of x(i)) {
+        const l = v(c) ? (h = this.actionMap) == null ? void 0 : h[c] : c;
+        T(
+          v(c) && !l,
+          `[@zag-js/core > execute-actions] No implementation found for action: \`${c}\``
+        ), l == null || l(this.state.context, n, this.meta);
+      }
+    }), a(this, "executeActivities", (e, n, i) => {
+      var h;
+      for (const c of n) {
+        const l = v(c) ? (h = this.activityMap) == null ? void 0 : h[c] : c;
+        if (!l) {
+          T(`[@zag-js/core > execute-activity] No implementation found for activity: \`${c}\``);
+          continue;
+        }
+        const f = l(this.state.context, e, this.meta);
+        if (f) {
+          const d = v(c) ? c : c.name || $();
+          this.addActivityCleanup(i ?? this.state.value, d, f);
+        }
+      }
+    }), a(this, "createEveryActivities", (e, n) => {
+      if (e)
+        if (w(e)) {
+          const i = x(e).find((f) => {
+            const d = f.delay, C = E(d, this.delayMap)(this.contextSnapshot, this.state.event);
+            return k(f.guard, this.guardMap)(this.contextSnapshot, this.state.event, this.guardMeta) ?? C != null;
+          });
+          if (!i) return;
+          const c = E(i.delay, this.delayMap)(this.contextSnapshot, this.state.event);
+          n(() => {
+            const f = globalThis.setInterval(() => {
+              this.executeActions(i.actions, this.state.event);
+            }, c);
+            return () => {
+              globalThis.clearInterval(f);
+            };
+          });
+        } else
+          for (const i in e) {
+            const h = e == null ? void 0 : e[i], l = E(i, this.delayMap)(this.contextSnapshot, this.state.event);
+            n(() => {
+              const d = globalThis.setInterval(() => {
+                this.executeActions(h, this.state.event);
+              }, l);
+              return () => {
+                globalThis.clearInterval(d);
+              };
+            });
+          }
+    }), a(this, "setEvent", (e) => {
+      this.state.previousEvent = this.state.event, this.state.event = L(g(e));
+    }), a(this, "performExitEffects", (e, n) => {
+      const i = this.state.value;
+      if (i === "") return;
+      const h = e ? this.getStateNode(e) : void 0;
+      this.stopActivities(i);
+      const c = j(h == null ? void 0 : h.exit, this.guardMap)(this.contextSnapshot, n, this.guardMeta), l = x(c), f = this.delayedEvents.get(i);
+      f && l.push(...f), this.executeActions(l, n);
+    }), a(this, "performEntryEffects", (e, n) => {
+      const i = this.getStateNode(e), h = x(i == null ? void 0 : i.activities);
+      this.createEveryActivities(i == null ? void 0 : i.every, (d) => {
+        h.unshift(d);
+      }), h.length > 0 && this.executeActivities(n, h);
+      const c = j(i == null ? void 0 : i.entry, this.guardMap)(
+        this.contextSnapshot,
+        n,
+        this.guardMeta
+      ), l = x(c), f = this.getDelayedEventActions(e);
+      i != null && i.after && f && (this.delayedEvents.set(e, f == null ? void 0 : f.exits), l.push(...f.entries)), this.executeActions(l, n), (i == null ? void 0 : i.type) === "final" && (this.state.done = !0, this.doneListeners.forEach((d) => {
+        d(this.stateSnapshot);
+      }), this.stop());
+    }), a(this, "performTransitionEffects", (e, n) => {
+      const i = this.determineTransition(e, n);
+      this.executeActions(i == null ? void 0 : i.actions, n);
+    }), a(this, "performStateChangeEffects", (e, n, i) => {
+      this.setEvent(i);
+      const h = n.changed || n.reenter;
+      h && this.performExitEffects(e, i), this.performTransitionEffects(n.transition, i), this.setState(n.target), h && this.performEntryEffects(n.target, i);
+    }), a(this, "determineTransition", (e, n) => {
+      const i = ot(e, this.guardMap);
+      return i == null ? void 0 : i(this.contextSnapshot, n, this.guardMeta);
+    }), a(this, "sendParent", (e) => {
+      var i;
+      this.parent || b("[@zag-js/core > send-parent] Cannot send event to an unknown parent");
+      const n = g(e);
+      (i = this.parent) == null || i.send(n);
+    }), a(this, "log", (...e) => {
+      Q() && this.options.debug && console.log(...e);
+    }), a(this, "send", (e) => {
+      const n = g(e);
+      this.transition(this.state.value, n);
+    }), a(this, "transition", (e, n) => {
+      var f, d;
+      const i = v(e) ? this.getStateNode(e) : e == null ? void 0 : e.stateNode, h = g(n);
+      if (!i && !this.config.on) {
+        const y = this.status === "Stopped" ? "[@zag-js/core > transition] Cannot transition a stopped machine" : `[@zag-js/core > transition] State does not have a definition for \`state\`: ${e}, \`event\`: ${h.type}`;
+        T(y);
+        return;
+      }
+      const c = (
+        // @ts-expect-error - Fix this
+        ((f = i == null ? void 0 : i.on) == null ? void 0 : f[h.type]) ?? ((d = this.config.on) == null ? void 0 : d[h.type])
+      ), l = this.getNextStateInfo(c, h);
+      return this.performStateChangeEffects(this.state.value, l, h), l.stateNode;
+    }), a(this, "subscribe", (e) => (this.stateListeners.add(e), this.status === "Running" && e(this.stateSnapshot), () => {
+      this.stateListeners.delete(e);
+    })), a(this, "onDone", (e) => (this.doneListeners.add(e), this)), a(this, "onTransition", (e) => (this.stateListeners.add(e), this.status === "Running" && e(this.stateSnapshot), this)), this.config = F(t), this.options = F(s ?? {}), this.id = this.config.id ?? `machine-${$()}`, this.guardMap = ((r = this.options) == null ? void 0 : r.guards) ?? {}, this.actionMap = ((o = this.options) == null ? void 0 : o.actions) ?? {}, this.delayMap = ((u = this.options) == null ? void 0 : u.delays) ?? {}, this.activityMap = ((p = this.options) == null ? void 0 : p.activities) ?? {}, this.sync = ((S = this.options) == null ? void 0 : S.sync) ?? !1, this.state = rt(this.config), this.initialContext = M(this.state.context);
+  }
+  // immutable state value
+  get stateSnapshot() {
+    return m(M(this.state));
+  }
+  getState() {
+    return this.stateSnapshot;
+  }
+  // immutable context value
+  get contextSnapshot() {
+    return this.stateSnapshot.context;
+  }
+  /**
+   * A reference to the instance methods of the machine.
+   * Useful when spawning child machines and managing the communication between them.
+   */
+  get self() {
+    const t = this;
+    return {
+      id: this.id,
+      send: this.send.bind(this),
+      sendParent: this.sendParent.bind(this),
+      sendChild: this.sendChild.bind(this),
+      stop: this.stop.bind(this),
+      stopChild: this.stopChild.bind(this),
+      spawn: this.spawn.bind(this),
+      stopActivity: this.stopActivity.bind(this),
+      get state() {
+        return t.stateSnapshot;
+      },
+      get initialContext() {
+        return t.initialContext;
+      },
+      get initialState() {
+        var s;
+        return ((s = t.initialState) == null ? void 0 : s.target) ?? "";
+      }
+    };
+  }
+  get meta() {
+    var t;
+    return {
+      state: this.stateSnapshot,
+      guards: this.guardMap,
+      send: this.send.bind(this),
+      self: this.self,
+      initialContext: this.initialContext,
+      initialState: ((t = this.initialState) == null ? void 0 : t.target) ?? "",
+      getState: () => this.stateSnapshot,
+      getAction: (s) => this.actionMap[s],
+      getGuard: (s) => this.guardMap[s]
+    };
+  }
+  get guardMeta() {
+    return {
+      state: this.stateSnapshot
+    };
+  }
+  get [Symbol.toStringTag]() {
+    return "Machine";
+  }
+  getHydrationState() {
+    const t = this.getState();
+    return {
+      value: t.value,
+      tags: t.tags
+    };
+  }
+}, gt = (t, s) => new G(t, s), yt = (t) => t instanceof G || (t == null ? void 0 : t.type) === "machine", ht = (...t) => t.map((s) => {
+  var r;
+  return (r = s == null ? void 0 : s.trim) == null ? void 0 : r.call(s);
+}).filter(Boolean).join(" "), ct = /((?:--)?(?:\w+-?)+)\s*:\s*([^;]*)/g, I = (t) => {
+  const s = {};
+  let r;
+  for (; r = ct.exec(t); )
+    s[r[1]] = r[2];
+  return s;
+}, ut = (t, s) => {
+  if (v(t)) {
+    if (v(s)) return `${t};${s}`;
+    t = I(t);
+  } else v(s) && (s = I(s));
+  return Object.assign({}, t ?? {}, s ?? {});
+};
+function mt(...t) {
+  let s = {};
+  for (let r of t) {
+    for (let o in s) {
+      if (o.startsWith("on") && typeof s[o] == "function" && typeof r[o] == "function") {
+        s[o] = X(r[o], s[o]);
+        continue;
+      }
+      if (o === "className" || o === "class") {
+        s[o] = ht(s[o], r[o]);
+        continue;
+      }
+      if (o === "style") {
+        s[o] = ut(s[o], r[o]);
+        continue;
+      }
+      s[o] = r[o] !== void 0 ? r[o] : s[o];
+    }
+    for (let o in r)
+      s[o] === void 0 && (s[o] = r[o]);
+  }
+  return s;
+}
+export {
+  G as Machine,
+  gt as createMachine,
+  z as deepMerge,
+  vt as guards,
+  yt as isMachine,
+  mt as mergeProps,
+  V as proxy,
+  L as ref,
+  M as snapshot,
+  O as subscribe
+};