@serendie/ui 2.0.0-dev.202507240128 → 2.0.0-dev.202507240155

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

@@ -0,0 +1,131 @@
+import { markToTrack as z, getUntracked as K } from "../../../proxy-compare/dist/index.js";
+function U() {
+  if (typeof globalThis < "u") return globalThis;
+  if (typeof self < "u") return self;
+  if (typeof window < "u") return window;
+  if (typeof global < "u") return global;
+}
+function D(e, l) {
+  const i = U();
+  return i ? (i[e] || (i[e] = l()), i[e]) : l();
+}
+var O = D("__zag__refSet", () => /* @__PURE__ */ new WeakSet()), $ = (e) => typeof e == "object" && e !== null && "$$typeof" in e && "props" in e, q = (e) => typeof e == "object" && e !== null && "__v_isVNode" in e, B = (e) => typeof e == "object" && e !== null && "nodeType" in e && typeof e.nodeName == "string", k = (e) => $(e) || q(e) || B(e), j = (e) => e !== null && typeof e == "object", V = (e) => j(e) && !O.has(e) && (Array.isArray(e) || !(Symbol.iterator in e)) && !k(e) && !(e instanceof WeakMap) && !(e instanceof WeakSet) && !(e instanceof Error) && !(e instanceof Number) && !(e instanceof Date) && !(e instanceof String) && !(e instanceof RegExp) && !(e instanceof ArrayBuffer) && !(e instanceof Promise), S = () => process.env.NODE_ENV !== "production", g = D("__zag__proxyStateMap", () => /* @__PURE__ */ new WeakMap()), G = (e = Object.is, l = (s, p) => new Proxy(s, p), i = /* @__PURE__ */ new WeakMap(), b = (s, p) => {
+  const c = i.get(s);
+  if ((c == null ? void 0 : c[0]) === p)
+    return c[1];
+  const o = Array.isArray(s) ? [] : Object.create(Object.getPrototypeOf(s));
+  return z(o, !0), i.set(s, [p, o]), Reflect.ownKeys(s).forEach((w) => {
+    const d = Reflect.get(s, w);
+    O.has(d) ? (z(d, !1), o[w] = d) : g.has(d) ? o[w] = X(d) : o[w] = d;
+  }), Object.freeze(o);
+}, a = /* @__PURE__ */ new WeakMap(), y = [1, 1], _ = (s) => {
+  if (!j(s))
+    throw new Error("object required");
+  const p = a.get(s);
+  if (p)
+    return p;
+  let c = y[0];
+  const o = /* @__PURE__ */ new Set(), w = (n, t = ++y[0]) => {
+    c !== t && (c = t, o.forEach((r) => r(n, t)));
+  };
+  let d = y[1];
+  const W = (n = ++y[1]) => (d !== n && !o.size && (d = n, u.forEach(([t]) => {
+    const r = t[1](n);
+    r > c && (c = r);
+  })), c), v = (n) => (t, r) => {
+    const f = [...t];
+    f[1] = [n, ...f[1]], w(f, r);
+  }, u = /* @__PURE__ */ new Map(), N = (n, t) => {
+    if (S() && u.has(n))
+      throw new Error("prop listener already exists");
+    if (o.size) {
+      const r = t[3](v(n));
+      u.set(n, [t, r]);
+    } else
+      u.set(n, [t]);
+  }, L = (n) => {
+    var r;
+    const t = u.get(n);
+    t && (u.delete(n), (r = t[1]) == null || r.call(t));
+  }, T = (n) => (o.add(n), o.size === 1 && u.forEach(([r, f], m) => {
+    if (S() && f)
+      throw new Error("remove already exists");
+    const h = r[3](v(m));
+    u.set(m, [r, h]);
+  }), () => {
+    o.delete(n), o.size === 0 && u.forEach(([r, f], m) => {
+      f && (f(), u.set(m, [r]));
+    });
+  }), R = Array.isArray(s) ? [] : Object.create(Object.getPrototypeOf(s)), E = l(R, {
+    deleteProperty(n, t) {
+      const r = Reflect.get(n, t);
+      L(t);
+      const f = Reflect.deleteProperty(n, t);
+      return f && w(["delete", [t], r]), f;
+    },
+    set(n, t, r, f) {
+      var A;
+      const m = Reflect.has(n, t), h = Reflect.get(n, t, f);
+      if (m && (e(h, r) || a.has(r) && e(h, a.get(r))))
+        return !0;
+      L(t), j(r) && (r = K(r) || r);
+      let P = r;
+      if (!((A = Object.getOwnPropertyDescriptor(n, t)) != null && A.set)) {
+        !g.has(r) && V(r) && (P = Q(r));
+        const M = !O.has(P) && g.get(P);
+        M && N(t, M);
+      }
+      return Reflect.set(n, t, P, f), w(["set", [t], r, h]), !0;
+    }
+  });
+  a.set(s, E);
+  const F = [R, W, b, T];
+  return g.set(E, F), Reflect.ownKeys(s).forEach((n) => {
+    const t = Object.getOwnPropertyDescriptor(s, n);
+    t.get || t.set ? Object.defineProperty(R, n, t) : E[n] = s[n];
+  }), E;
+}) => [
+  // public functions
+  _,
+  // shared state
+  g,
+  O,
+  // internal things
+  e,
+  l,
+  V,
+  i,
+  b,
+  a,
+  y
+], [J] = G();
+function Q(e = {}) {
+  return J(e);
+}
+function I(e, l, i) {
+  const b = g.get(e);
+  S() && !b && console.warn("Please use proxy object");
+  let a;
+  const y = [], _ = b[3];
+  let s = !1;
+  const c = _((o) => {
+    y.push(o), a || (a = Promise.resolve().then(() => {
+      a = void 0, s && l(y.splice(0));
+    }));
+  });
+  return s = !0, () => {
+    s = !1, c();
+  };
+}
+function X(e) {
+  const l = g.get(e);
+  S() && !l && console.warn("Please use proxy object");
+  const [i, b, a] = l;
+  return a(i, b());
+}
+export {
+  D as globalRef,
+  Q as proxy,
+  X as snapshot,
+  I as subscribe
+};

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

@@ -0,0 +1,459 @@
+import { createAnatomy as M } from "../../anatomy/dist/index.js";
+import { addDomEvent as u, getOverflowAncestors as D, isComposingEvent as E, dataAttr as I, isLeftClick as V } from "../../dom-query/dist/index.js";
+import { trackFocusVisible as T, isFocusVisible as S } from "../../focus-visible/dist/index.js";
+import { getPlacement as k, getPlacementStyles as F } from "../../popper/dist/index.js";
+import { subscribe as A, proxy as G } from "../../store/dist/index.js";
+import { createMachine as K, createGuards as L } from "../../core/dist/index.js";
+import { createProps as $ } from "../../types/dist/index.js";
+var q = M("tooltip").parts("trigger", "arrow", "arrowTip", "positioner", "content"), d = q.build(), b = (e) => {
+  var t;
+  return ((t = e.ids) == null ? void 0 : t.trigger) ?? `tooltip:${e.id}:trigger`;
+}, x = (e) => {
+  var t;
+  return ((t = e.ids) == null ? void 0 : t.content) ?? `tooltip:${e.id}:content`;
+}, B = (e) => {
+  var t;
+  return ((t = e.ids) == null ? void 0 : t.arrow) ?? `tooltip:${e.id}:arrow`;
+}, w = (e) => {
+  var t;
+  return ((t = e.ids) == null ? void 0 : t.positioner) ?? `tooltip:${e.id}:popper`;
+}, v = (e) => e.getById(b(e)), m = (e) => e.getById(w(e)), l = G({ id: null });
+function X(e, t) {
+  const { state: o, context: s, send: r, scope: a, prop: n, event: O } = e, f = n("id"), P = !!n("aria-label"), p = o.matches("open", "closing"), h = b(a), y = x(a), c = n("disabled"), g = F({
+    ...n("positioning"),
+    placement: s.get("currentPlacement")
+  });
+  return {
+    open: p,
+    setOpen(i) {
+      o.matches("open", "closing") !== i && r({ type: i ? "open" : "close" });
+    },
+    reposition(i = {}) {
+      r({ type: "positioning.set", options: i });
+    },
+    getTriggerProps() {
+      return t.button({
+        ...d.trigger.attrs,
+        id: h,
+        dir: n("dir"),
+        "data-expanded": I(p),
+        "data-state": p ? "open" : "closed",
+        "aria-describedby": p ? y : void 0,
+        onClick(i) {
+          i.defaultPrevented || c || n("closeOnClick") && r({ type: "close", src: "trigger.click" });
+        },
+        onFocus(i) {
+          queueMicrotask(() => {
+            i.defaultPrevented || c || O.src !== "trigger.pointerdown" && S() && r({ type: "open", src: "trigger.focus" });
+          });
+        },
+        onBlur(i) {
+          i.defaultPrevented || c || f === l.id && r({ type: "close", src: "trigger.blur" });
+        },
+        onPointerDown(i) {
+          i.defaultPrevented || c || V(i) && n("closeOnPointerDown") && f === l.id && r({ type: "close", src: "trigger.pointerdown" });
+        },
+        onPointerMove(i) {
+          i.defaultPrevented || c || i.pointerType !== "touch" && r({ type: "pointer.move" });
+        },
+        onPointerLeave() {
+          c || r({ type: "pointer.leave" });
+        },
+        onPointerCancel() {
+          c || r({ type: "pointer.leave" });
+        }
+      });
+    },
+    getArrowProps() {
+      return t.element({
+        id: B(a),
+        ...d.arrow.attrs,
+        dir: n("dir"),
+        style: g.arrow
+      });
+    },
+    getArrowTipProps() {
+      return t.element({
+        ...d.arrowTip.attrs,
+        dir: n("dir"),
+        style: g.arrowTip
+      });
+    },
+    getPositionerProps() {
+      return t.element({
+        id: w(a),
+        ...d.positioner.attrs,
+        dir: n("dir"),
+        style: g.floating
+      });
+    },
+    getContentProps() {
+      return t.element({
+        ...d.content.attrs,
+        dir: n("dir"),
+        hidden: !p,
+        "data-state": p ? "open" : "closed",
+        role: P ? void 0 : "tooltip",
+        id: P ? void 0 : y,
+        "data-placement": s.get("currentPlacement"),
+        onPointerEnter() {
+          r({ type: "content.pointer.move" });
+        },
+        onPointerLeave() {
+          r({ type: "content.pointer.leave" });
+        },
+        style: {
+          pointerEvents: n("interactive") ? "auto" : "none"
+        }
+      });
+    }
+  };
+}
+var { and: N, not: C } = L(), Y = K({
+  initialState: ({ prop: e }) => e("open") || e("defaultOpen") ? "open" : "closed",
+  props({ props: e }) {
+    return {
+      id: "x",
+      openDelay: 1e3,
+      closeDelay: 500,
+      closeOnPointerDown: !0,
+      closeOnEscape: !0,
+      interactive: !1,
+      closeOnScroll: !0,
+      closeOnClick: !0,
+      disabled: !1,
+      ...e,
+      positioning: {
+        placement: "bottom",
+        ...e.positioning
+      }
+    };
+  },
+  effects: ["trackFocusVisible", "trackStore"],
+  context: ({ bindable: e }) => ({
+    currentPlacement: e(() => ({ defaultValue: void 0 })),
+    hasPointerMoveOpened: e(() => ({ defaultValue: !1 }))
+  }),
+  watch({ track: e, action: t, prop: o }) {
+    e([() => o("disabled")], () => {
+      t(["closeIfDisabled"]);
+    }), e([() => o("open")], () => {
+      t(["toggleVisibility"]);
+    });
+  },
+  states: {
+    closed: {
+      entry: ["clearGlobalId"],
+      on: {
+        "controlled.open": {
+          target: "open"
+        },
+        open: [
+          {
+            guard: "isOpenControlled",
+            actions: ["invokeOnOpen"]
+          },
+          {
+            target: "open",
+            actions: ["invokeOnOpen"]
+          }
+        ],
+        "pointer.leave": {
+          actions: ["clearPointerMoveOpened"]
+        },
+        "pointer.move": [
+          {
+            guard: N("noVisibleTooltip", C("hasPointerMoveOpened")),
+            target: "opening"
+          },
+          {
+            guard: C("hasPointerMoveOpened"),
+            target: "open",
+            actions: ["setPointerMoveOpened", "invokeOnOpen"]
+          }
+        ]
+      }
+    },
+    opening: {
+      effects: ["trackScroll", "trackPointerlockChange", "waitForOpenDelay"],
+      on: {
+        "after.openDelay": [
+          {
+            guard: "isOpenControlled",
+            actions: ["setPointerMoveOpened", "invokeOnOpen"]
+          },
+          {
+            target: "open",
+            actions: ["setPointerMoveOpened", "invokeOnOpen"]
+          }
+        ],
+        "controlled.open": {
+          target: "open"
+        },
+        "controlled.close": {
+          target: "closed"
+        },
+        open: [
+          {
+            guard: "isOpenControlled",
+            actions: ["invokeOnOpen"]
+          },
+          {
+            target: "open",
+            actions: ["invokeOnOpen"]
+          }
+        ],
+        "pointer.leave": [
+          {
+            guard: "isOpenControlled",
+            // We trigger toggleVisibility manually since the `ctx.open` has not changed yet (at this point)
+            actions: ["clearPointerMoveOpened", "invokeOnClose", "toggleVisibility"]
+          },
+          {
+            target: "closed",
+            actions: ["clearPointerMoveOpened", "invokeOnClose"]
+          }
+        ],
+        close: [
+          {
+            guard: "isOpenControlled",
+            // We trigger toggleVisibility manually since the `ctx.open` has not changed yet (at this point)
+            actions: ["invokeOnClose", "toggleVisibility"]
+          },
+          {
+            target: "closed",
+            actions: ["invokeOnClose"]
+          }
+        ]
+      }
+    },
+    open: {
+      effects: ["trackEscapeKey", "trackScroll", "trackPointerlockChange", "trackPositioning"],
+      entry: ["setGlobalId"],
+      on: {
+        "controlled.close": {
+          target: "closed"
+        },
+        close: [
+          {
+            guard: "isOpenControlled",
+            actions: ["invokeOnClose"]
+          },
+          {
+            target: "closed",
+            actions: ["invokeOnClose"]
+          }
+        ],
+        "pointer.leave": [
+          {
+            guard: "isVisible",
+            target: "closing",
+            actions: ["clearPointerMoveOpened"]
+          },
+          // == group ==
+          {
+            guard: "isOpenControlled",
+            actions: ["clearPointerMoveOpened", "invokeOnClose"]
+          },
+          {
+            target: "closed",
+            actions: ["clearPointerMoveOpened", "invokeOnClose"]
+          }
+        ],
+        "content.pointer.leave": {
+          guard: "isInteractive",
+          target: "closing"
+        },
+        "positioning.set": {
+          actions: ["reposition"]
+        }
+      }
+    },
+    closing: {
+      effects: ["trackPositioning", "waitForCloseDelay"],
+      on: {
+        "after.closeDelay": [
+          {
+            guard: "isOpenControlled",
+            actions: ["invokeOnClose"]
+          },
+          {
+            target: "closed",
+            actions: ["invokeOnClose"]
+          }
+        ],
+        "controlled.close": {
+          target: "closed"
+        },
+        "controlled.open": {
+          target: "open"
+        },
+        close: [
+          {
+            guard: "isOpenControlled",
+            actions: ["invokeOnClose"]
+          },
+          {
+            target: "closed",
+            actions: ["invokeOnClose"]
+          }
+        ],
+        "pointer.move": [
+          {
+            guard: "isOpenControlled",
+            // We trigger toggleVisibility manually since the `ctx.open` has not changed yet (at this point)
+            actions: ["setPointerMoveOpened", "invokeOnOpen", "toggleVisibility"]
+          },
+          {
+            target: "open",
+            actions: ["setPointerMoveOpened", "invokeOnOpen"]
+          }
+        ],
+        "content.pointer.move": {
+          guard: "isInteractive",
+          target: "open"
+        },
+        "positioning.set": {
+          actions: ["reposition"]
+        }
+      }
+    }
+  },
+  implementations: {
+    guards: {
+      noVisibleTooltip: () => l.id === null,
+      isVisible: ({ prop: e }) => e("id") === l.id,
+      isInteractive: ({ prop: e }) => !!e("interactive"),
+      hasPointerMoveOpened: ({ context: e }) => e.get("hasPointerMoveOpened"),
+      isOpenControlled: ({ prop: e }) => e("open") !== void 0
+    },
+    actions: {
+      setGlobalId: ({ prop: e }) => {
+        l.id = e("id");
+      },
+      clearGlobalId: ({ prop: e }) => {
+        e("id") === l.id && (l.id = null);
+      },
+      invokeOnOpen: ({ prop: e }) => {
+        var t;
+        (t = e("onOpenChange")) == null || t({ open: !0 });
+      },
+      invokeOnClose: ({ prop: e }) => {
+        var t;
+        (t = e("onOpenChange")) == null || t({ open: !1 });
+      },
+      closeIfDisabled: ({ prop: e, send: t }) => {
+        e("disabled") && t({ type: "close", src: "disabled.change" });
+      },
+      reposition: ({ context: e, event: t, prop: o, scope: s }) => {
+        if (t.type !== "positioning.set") return;
+        const r = () => m(s);
+        return k(v(s), r, {
+          ...o("positioning"),
+          ...t.options,
+          defer: !0,
+          listeners: !1,
+          onComplete(a) {
+            e.set("currentPlacement", a.placement);
+          }
+        });
+      },
+      toggleVisibility: ({ prop: e, event: t, send: o }) => {
+        queueMicrotask(() => {
+          o({
+            type: e("open") ? "controlled.open" : "controlled.close",
+            previousEvent: t
+          });
+        });
+      },
+      setPointerMoveOpened: ({ context: e }) => {
+        e.set("hasPointerMoveOpened", !0);
+      },
+      clearPointerMoveOpened: ({ context: e }) => {
+        e.set("hasPointerMoveOpened", !1);
+      }
+    },
+    effects: {
+      trackFocusVisible: ({ scope: e }) => {
+        var t;
+        return T({ root: (t = e.getRootNode) == null ? void 0 : t.call(e) });
+      },
+      trackPositioning: ({ context: e, prop: t, scope: o }) => {
+        e.get("currentPlacement") || e.set("currentPlacement", t("positioning").placement);
+        const s = () => m(o);
+        return k(v(o), s, {
+          ...t("positioning"),
+          defer: !0,
+          onComplete(r) {
+            e.set("currentPlacement", r.placement);
+          }
+        });
+      },
+      trackPointerlockChange: ({ send: e, scope: t }) => {
+        const o = t.getDoc();
+        return u(o, "pointerlockchange", () => e({ type: "close", src: "pointerlock:change" }), !1);
+      },
+      trackScroll: ({ send: e, prop: t, scope: o }) => {
+        if (!t("closeOnScroll")) return;
+        const s = v(o);
+        if (!s) return;
+        const a = D(s).map((n) => u(n, "scroll", () => {
+          e({ type: "close", src: "scroll" });
+        }, {
+          passive: !0,
+          capture: !0
+        }));
+        return () => {
+          a.forEach((n) => n == null ? void 0 : n());
+        };
+      },
+      trackStore: ({ prop: e, send: t }) => {
+        let o;
+        return queueMicrotask(() => {
+          o = A(l, () => {
+            l.id !== e("id") && t({ type: "close", src: "id.change" });
+          });
+        }), () => o == null ? void 0 : o();
+      },
+      trackEscapeKey: ({ send: e, prop: t }) => t("closeOnEscape") ? u(document, "keydown", (s) => {
+        E(s) || s.key === "Escape" && (s.stopPropagation(), e({ type: "close", src: "keydown.escape" }));
+      }, !0) : void 0,
+      waitForOpenDelay: ({ send: e, prop: t }) => {
+        const o = setTimeout(() => {
+          e({ type: "after.openDelay" });
+        }, t("openDelay"));
+        return () => clearTimeout(o);
+      },
+      waitForCloseDelay: ({ send: e, prop: t }) => {
+        const o = setTimeout(() => {
+          e({ type: "after.closeDelay" });
+        }, t("closeDelay"));
+        return () => clearTimeout(o);
+      }
+    }
+  }
+});
+$()([
+  "aria-label",
+  "closeDelay",
+  "closeOnEscape",
+  "closeOnPointerDown",
+  "closeOnScroll",
+  "closeOnClick",
+  "dir",
+  "disabled",
+  "getRootNode",
+  "id",
+  "ids",
+  "interactive",
+  "onOpenChange",
+  "defaultOpen",
+  "open",
+  "openDelay",
+  "positioning"
+]);
+export {
+  q as anatomy,
+  X as connect,
+  Y as machine
+};

package/dist/node_modules/proxy-compare/dist/index.js

@@ -0,0 +1,7 @@
+const c = Symbol(), r = Object.getPrototypeOf, e = /* @__PURE__ */ new WeakMap(), n = (t) => t && (e.has(t) ? e.get(t) : r(t) === Object.prototype || r(t) === Array.prototype), s = (t) => n(t) && t[c] || null, a = (t, o = !0) => {
+  e.set(t, o);
+};
+export {
+  s as getUntracked,
+  a as markToTrack
+};