@serendie/ui 2.0.0 → 2.1.0

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/@zag-js/types/dist/index.js

@@ -1,12 +1,12 @@
-function e(r) {
+function a(r) {
   return new Proxy({}, {
-    get() {
-      return r;
+    get(n, e) {
+      return e === "style" ? (t) => r({ style: t }).style : r;
     }
   });
 }
-var t = () => (r) => Array.from(new Set(r));
+var o = () => (r) => Array.from(new Set(r));
 export {
-  e as createNormalizer,
-  t as createProps
+  a as createNormalizer,
+  o as createProps
 };