@serendie/ui 3.2.0-dev.202603311432 → 3.2.0-dev.202604210458

package/dist/node_modules/@zag-js/react/dist/bindable.js

@@ -0,0 +1,52 @@
+import { useState as d, useRef as f, useEffect as x } from "react";
+import { flushSync as y } from "react-dom";
+import { useSafeLayoutEffect as S } from "./use-layout-effect.js";
+import { identity as E } from "../../utils/dist/functions.js";
+import { isFunction as q } from "../../utils/dist/guard.js";
+function g(e) {
+  const i = e().value ?? e().defaultValue, o = e().isEqual ?? Object.is, [s] = d(i), [r, h] = d(s), l = e().value !== void 0, a = f(r);
+  a.current = l ? e().value : r;
+  const m = f(a.current);
+  S(() => {
+    m.current = a.current;
+  }, [r, e().value]);
+  const b = (t) => {
+    var c, v;
+    const n = m.current, u = q(t) ? t(n) : t;
+    e().debug && console.log(`[bindable > ${e().debug}] setValue`, { next: u, prev: n }), l || h(u), o(u, n) || (v = (c = e()).onChange) == null || v.call(c, u, n);
+  };
+  function V() {
+    return l ? e().value : r;
+  }
+  return {
+    initial: s,
+    ref: a,
+    get: V,
+    set(t) {
+      (e().sync ? y : E)(() => b(t));
+    },
+    invoke(t, n) {
+      var u, c;
+      (c = (u = e()).onChange) == null || c.call(u, t, n);
+    },
+    hash(t) {
+      var n, u;
+      return ((u = (n = e()).hash) == null ? void 0 : u.call(n, t)) ?? String(t);
+    }
+  };
+}
+g.cleanup = (e) => {
+  x(() => e, []);
+};
+g.ref = (e) => {
+  const i = f(e);
+  return {
+    get: () => i.current,
+    set: (o) => {
+      i.current = o;
+    }
+  };
+};
+export {
+  g as useBindable
+};

package/dist/node_modules/@zag-js/react/dist/machine.js

@@ -0,0 +1,208 @@
+import { useMemo as Y, useRef as d } from "react";
+import { flushSync as Q } from "react-dom";
+import { useBindable as D } from "./bindable.js";
+import { useRefs as Z } from "./refs.js";
+import { useTrack as P } from "./track.js";
+import { useSafeLayoutEffect as h } from "./use-layout-effect.js";
+import { createScope as tt } from "../../core/dist/scope.js";
+import { compact as rt } from "../../utils/dist/object.js";
+import { ensure as et, warn as G } from "../../utils/dist/warning.js";
+import { MachineStatus as E, INIT_STATE as w } from "../../core/dist/types.js";
+import { getExitEnterStates as nt, resolveStateValue as H, findTransition as ot, hasTag as st, matchesState as ut } from "../../core/dist/state.js";
+import { isFunction as q, isString as ct } from "../../utils/dist/guard.js";
+import { toArray as ft } from "../../utils/dist/array.js";
+function yt(e, a = {}) {
+  var O, V, B, F;
+  const l = Y(() => {
+    const { id: r, ids: t, getRootNode: n } = a;
+    return tt({ id: r, ids: t, getRootNode: n });
+  }, [a]), R = (...r) => {
+    e.debug && console.log(...r);
+  }, W = ((O = e.props) == null ? void 0 : O.call(e, { props: rt(a), scope: l })) ?? a, S = it(W), X = (V = e.context) == null ? void 0 : V.call(e, {
+    prop: S,
+    bindable: D,
+    scope: l,
+    flush: K,
+    getContext() {
+      return M;
+    },
+    getComputed() {
+      return j;
+    },
+    getRefs() {
+      return b;
+    },
+    getEvent() {
+      return T();
+    }
+  }), v = U(X), M = {
+    get(r) {
+      var t;
+      return (t = v.current) == null ? void 0 : t[r].ref.current;
+    },
+    set(r, t) {
+      var n;
+      (n = v.current) == null || n[r].set(t);
+    },
+    initial(r) {
+      var t;
+      return (t = v.current) == null ? void 0 : t[r].initial;
+    },
+    hash(r) {
+      var n, u;
+      const t = (n = v.current) == null ? void 0 : n[r].get();
+      return (u = v.current) == null ? void 0 : u[r].hash(t);
+    }
+  }, m = d(/* @__PURE__ */ new Map()), N = d(null), z = d(null), y = d({ type: "" }), T = () => ({
+    ...y.current,
+    current() {
+      return y.current;
+    },
+    previous() {
+      return z.current;
+    }
+  }), C = () => ({
+    ...i,
+    matches(...r) {
+      return r.some((t) => ut(i.ref.current, t));
+    },
+    hasTag(r) {
+      return st(e, i.ref.current, r);
+    }
+  }), b = Z(((B = e.refs) == null ? void 0 : B.call(e, { prop: S, context: M })) ?? {}), p = () => ({
+    state: C(),
+    context: M,
+    event: T(),
+    prop: S,
+    send: L,
+    action: g,
+    guard: k,
+    track: P,
+    refs: b,
+    computed: j,
+    flush: K,
+    scope: l,
+    choose: A
+  }), g = (r) => {
+    const t = q(r) ? r(p()) : r;
+    if (!t) return;
+    const n = t.map((u) => {
+      var f, s;
+      const o = (s = (f = e.implementations) == null ? void 0 : f.actions) == null ? void 0 : s[u];
+      return o || G(`[zag-js] No implementation found for action "${JSON.stringify(u)}"`), o;
+    });
+    for (const u of n)
+      u == null || u(p());
+  }, k = (r) => {
+    var t, n;
+    return q(r) ? r(p()) : (n = (t = e.implementations) == null ? void 0 : t.guards) == null ? void 0 : n[r](p());
+  }, $ = (r) => {
+    const t = q(r) ? r(p()) : r;
+    if (!t) return;
+    const n = t.map((o) => {
+      var s, c;
+      const f = (c = (s = e.implementations) == null ? void 0 : s.effects) == null ? void 0 : c[o];
+      return f || G(`[zag-js] No implementation found for effect "${JSON.stringify(o)}"`), f;
+    }), u = [];
+    for (const o of n) {
+      const f = o == null ? void 0 : o(p());
+      f && u.push(f);
+    }
+    return () => u.forEach((o) => o == null ? void 0 : o());
+  }, A = (r) => ft(r).find((t) => {
+    let n = !t.guard;
+    return ct(t.guard) ? n = !!k(t.guard) : q(t.guard) && (n = t.guard(p())), n;
+  }), j = (r) => {
+    et(e.computed, () => "[zag-js] No computed object found on machine");
+    const t = e.computed[r];
+    return t({
+      context: M,
+      event: T(),
+      prop: S,
+      refs: b,
+      scope: l,
+      computed: j
+    });
+  }, i = D(() => ({
+    defaultValue: H(e, e.initialState({ prop: S })),
+    onChange(r, t) {
+      var o, f;
+      const { exiting: n, entering: u } = nt(e, t, r, (o = N.current) == null ? void 0 : o.reenter);
+      if (n.forEach((s) => {
+        const c = m.current.get(s.path);
+        c == null || c(), m.current.delete(s.path);
+      }), n.forEach((s) => {
+        var c;
+        g((c = s.state) == null ? void 0 : c.exit);
+      }), g((f = N.current) == null ? void 0 : f.actions), u.forEach((s) => {
+        var _;
+        const c = $((_ = s.state) == null ? void 0 : _.effects);
+        c && m.current.set(s.path, c);
+      }), t === w) {
+        g(e.entry);
+        const s = $(e.effects);
+        s && m.current.set(w, s);
+      }
+      u.forEach((s) => {
+        var c;
+        g((c = s.state) == null ? void 0 : c.entry);
+      });
+    }
+  })), I = d(void 0), x = d(E.NotStarted);
+  h(() => {
+    queueMicrotask(() => {
+      const t = x.current === E.Started;
+      x.current = E.Started, R(t ? "rehydrating..." : "initializing...");
+      const n = I.current ?? i.initial;
+      i.invoke(n, t ? i.get() : w);
+    });
+    const r = m.current;
+    return () => {
+      const t = J();
+      R("unmounting..."), I.current = t, x.current = E.Stopped, r.forEach((n) => n == null ? void 0 : n()), m.current = /* @__PURE__ */ new Map(), N.current = null, queueMicrotask(() => {
+        g(e.exit), x.current = E.Stopped;
+      });
+    };
+  }, []);
+  const J = () => "ref" in i ? i.ref.current : i.get(), L = (r) => {
+    queueMicrotask(() => {
+      if (x.current !== E.Started) return;
+      z.current = y.current, y.current = r;
+      let t = J();
+      const { transitions: n, source: u } = ot(e, t, r.type), o = A(n);
+      if (!o) return;
+      N.current = o;
+      const f = H(e, o.target ?? t, u);
+      R("transition", r.type, o.target || t, `(${o.actions})`), f !== t ? Q(() => i.set(f)) : o.reenter ? i.invoke(t, t) : g(o.actions ?? []);
+    });
+  };
+  return (F = e.watch) == null || F.call(e, p()), {
+    state: C(),
+    send: L,
+    context: M,
+    prop: S,
+    scope: l,
+    refs: b,
+    computed: j,
+    event: T(),
+    getStatus: () => x.current
+  };
+}
+function U(e) {
+  const a = d(e);
+  return a.current = e, a;
+}
+function it(e) {
+  const a = U(e);
+  return function(R) {
+    return a.current[R];
+  };
+}
+function K(e) {
+  queueMicrotask(() => {
+    Q(() => e());
+  });
+}
+export {
+  yt as useMachine
+};

package/dist/node_modules/@zag-js/react/dist/normalize-props.js

@@ -0,0 +1,5 @@
+import { createNormalizer as o } from "../../types/dist/prop-types.js";
+var a = o((r) => r);
+export {
+  a as normalizeProps
+};

package/dist/node_modules/@zag-js/react/dist/refs.js

@@ -0,0 +1,15 @@
+import { useRef as u } from "react";
+function o(t) {
+  const r = u(t);
+  return {
+    get(e) {
+      return r.current[e];
+    },
+    set(e, n) {
+      r.current[e] = n;
+    }
+  };
+}
+export {
+  o as useRefs
+};

package/dist/node_modules/@zag-js/react/dist/track.js

@@ -0,0 +1,13 @@
+import { useRef as n, useEffect as u } from "react";
+var a = (c, o) => {
+  const e = n(!1), t = n(!1);
+  u(() => {
+    if (e.current && t.current) return o();
+    t.current = !0;
+  }, [...(c ?? []).map((r) => typeof r == "function" ? r() : r)]), u(() => (e.current = !0, () => {
+    e.current = !1;
+  }), []);
+};
+export {
+  a as useTrack
+};

package/dist/node_modules/@zag-js/react/dist/use-layout-effect.js

@@ -0,0 +1,5 @@
+import { useLayoutEffect as e, useEffect as f } from "react";
+var o = typeof globalThis.document < "u" ? e : f;
+export {
+  o as useSafeLayoutEffect
+};

package/dist/node_modules/@zag-js/rect-utils/dist/polygon.js

@@ -0,0 +1,23 @@
+import { createRect as m, getRectCorners as h } from "./rect.js";
+function a(e, s) {
+  const i = m(e), { top: n, right: o, left: t, bottom: c } = h(i), [r] = s.split("-");
+  return {
+    top: [t, n, o, c],
+    right: [n, o, c, t],
+    bottom: [n, t, c, o],
+    left: [o, n, t, c]
+  }[r];
+}
+function b(e, s) {
+  const { x: i, y: n } = s;
+  let o = !1;
+  for (let t = 0, c = e.length - 1; t < e.length; c = t++) {
+    const r = e[t].x, f = e[t].y, x = e[c].x, l = e[c].y;
+    f > n != l > n && i < (x - r) * (n - f) / (l - f) + r && (o = !o);
+  }
+  return o;
+}
+export {
+  a as getElementPolygon,
+  b as isPointInPolygon
+};

package/dist/node_modules/@zag-js/rect-utils/dist/rect.js

@@ -0,0 +1,26 @@
+var c = (t, n) => ({ x: t, y: n });
+function a(t) {
+  const { x: n, y: e, width: m, height: o } = t, i = n + m / 2, r = e + o / 2;
+  return {
+    x: n,
+    y: e,
+    width: m,
+    height: o,
+    minX: n,
+    minY: e,
+    maxX: n + m,
+    maxY: e + o,
+    midX: i,
+    midY: r,
+    center: c(i, r)
+  };
+}
+function s(t) {
+  const n = c(t.minX, t.minY), e = c(t.maxX, t.minY), m = c(t.maxX, t.maxY), o = c(t.minX, t.maxY);
+  return { top: n, right: e, bottom: m, left: o };
+}
+export {
+  c as createPoint,
+  a as createRect,
+  s as getRectCorners
+};

package/dist/node_modules/@zag-js/remove-scroll/dist/index.js

@@ -1,34 +1,43 @@
-import { setStyleProperty as x, setStyle as p, isIos as L } from "../../dom-query/dist/index.js";
+import { isIos as A } from "../../dom-query/dist/platform.js";
+import { getComputedStyle as P } from "../../dom-query/dist/computed-style.js";
+import { setStyleProperty as W, setStyle as h } from "../../dom-query/dist/set.js";
 var i = "data-scroll-lock";
-function m(r) {
-  const n = r.getBoundingClientRect().left;
-  return Math.round(n) + r.scrollLeft ? "paddingLeft" : "paddingRight";
-}
 function $(r) {
-  const n = r ?? document, c = n.defaultView ?? window, { documentElement: s, body: e } = n;
-  if (e.hasAttribute(i)) return;
-  const l = c.innerWidth - s.clientWidth;
-  e.setAttribute(i, "");
-  const h = () => x(s, "--scrollbar-width", `${l}px`), f = m(s), u = () => p(e, {
-    overflow: "hidden",
-    [f]: `${l}px`
-  }), y = () => {
-    const { scrollX: t, scrollY: a, visualViewport: o } = c, g = (o == null ? void 0 : o.offsetLeft) ?? 0, S = (o == null ? void 0 : o.offsetTop) ?? 0, d = p(e, {
+  const e = r.getBoundingClientRect().left;
+  return Math.round(e) + r.scrollLeft ? "paddingLeft" : "paddingRight";
+}
+function b(r) {
+  const e = P(r), t = e == null ? void 0 : e.scrollbarGutter;
+  return t === "stable" || (t == null ? void 0 : t.startsWith("stable ")) === !0;
+}
+function k(r) {
+  const e = r ?? document, t = e.defaultView ?? window, { documentElement: l, body: n } = e;
+  if (n.hasAttribute(i)) return;
+  const f = b(l) || b(n), c = t.innerWidth - l.clientWidth;
+  n.setAttribute(i, "");
+  const y = () => W(l, "--scrollbar-width", `${c}px`), a = $(l), S = () => {
+    const o = {
+      overflow: "hidden"
+    };
+    return !f && c > 0 && (o[a] = `${c}px`), h(n, o);
+  }, g = () => {
+    const { scrollX: o, scrollY: p, visualViewport: s } = t, x = (s == null ? void 0 : s.offsetLeft) ?? 0, L = (s == null ? void 0 : s.offsetTop) ?? 0, u = {
       position: "fixed",
       overflow: "hidden",
-      top: `${-(a - Math.floor(S))}px`,
-      left: `${-(t - Math.floor(g))}px`,
-      right: "0",
-      [f]: `${l}px`
-    });
+      top: `${-(p - Math.floor(L))}px`,
+      left: `${-(o - Math.floor(x))}px`,
+      right: "0"
+    };
+    !f && c > 0 && (u[a] = `${c}px`);
+    const d = h(n, u);
     return () => {
-      d == null || d(), c.scrollTo({ left: t, top: a, behavior: "instant" });
+      d == null || d(), t.scrollTo({ left: o, top: p, behavior: "instant" });
     };
-  }, b = [h(), L() ? y() : u()];
+  }, m = [y(), A() ? g() : S()];
   return () => {
-    b.forEach((t) => t == null ? void 0 : t()), e.removeAttribute(i);
+    m.forEach((o) => o == null ? void 0 : o()), n.removeAttribute(i);
   };
 }
 export {
-  $ as preventBodyScroll
+  k as preventBodyScroll
 };

package/dist/node_modules/@zag-js/select/dist/select.anatomy.js

@@ -0,0 +1,22 @@
+import { createAnatomy as t } from "../../anatomy/dist/create-anatomy.js";
+var e = t("select").parts(
+  "label",
+  "positioner",
+  "trigger",
+  "indicator",
+  "clearTrigger",
+  "item",
+  "itemText",
+  "itemIndicator",
+  "itemGroup",
+  "itemGroupLabel",
+  "list",
+  "content",
+  "root",
+  "control",
+  "valueText"
+), o = e.build();
+export {
+  e as anatomy,
+  o as parts
+};

package/dist/node_modules/@zag-js/select/dist/select.collection.js

@@ -0,0 +1,6 @@
+import { ListCollection as e } from "../../collection/dist/list-collection.js";
+var r = (t) => new e(t);
+r.empty = () => new e({ items: [] });
+export {
+  r as collection
+};