@serendie/ui 0.1.12 → 0.1.13

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

@@ -0,0 +1,264 @@
+import { createAnatomy as E } from "../../anatomy/dist/index.js";
+import { createScope as m, dataAttr as i, visuallyHiddenStyle as b } from "../../dom-query/dist/index.js";
+import { createMachine as v, guards as I } from "../../core/dist/index.js";
+import { trackPress as y, trackFocusVisible as T } from "../../dom-event/dist/index.js";
+import { trackFormControl as H, setElementChecked as D, dispatchInputCheckedEvent as P } from "../../form-utils/dist/index.js";
+import { compact as x, isEqual as S } from "../../utils/dist/index.js";
+import { createProps as F } from "../../types/dist/index.js";
+var O = E("checkbox").parts("root", "label", "control", "indicator"), u = O.build(), o = m({
+  getRootId: (e) => {
+    var d;
+    return ((d = e.ids) == null ? void 0 : d.root) ?? `checkbox:${e.id}`;
+  },
+  getLabelId: (e) => {
+    var d;
+    return ((d = e.ids) == null ? void 0 : d.label) ?? `checkbox:${e.id}:label`;
+  },
+  getControlId: (e) => {
+    var d;
+    return ((d = e.ids) == null ? void 0 : d.control) ?? `checkbox:${e.id}:control`;
+  },
+  getHiddenInputId: (e) => {
+    var d;
+    return ((d = e.ids) == null ? void 0 : d.hiddenInput) ?? `checkbox:${e.id}:input`;
+  },
+  getRootEl: (e) => o.getById(e, o.getRootId(e)),
+  getHiddenInputEl: (e) => o.getById(e, o.getHiddenInputId(e))
+});
+function A(e, d, t) {
+  const n = e.context.isDisabled, s = !n && e.context.focused, c = e.context.isChecked, a = e.context.isIndeterminate, k = e.context.readOnly, l = {
+    "data-active": i(e.context.active),
+    "data-focus": i(s),
+    "data-readonly": i(k),
+    "data-hover": i(e.context.hovered),
+    "data-disabled": i(n),
+    "data-state": a ? "indeterminate" : e.context.checked ? "checked" : "unchecked",
+    "data-invalid": i(e.context.invalid)
+  };
+  return {
+    checked: c,
+    disabled: n,
+    indeterminate: a,
+    focused: s,
+    checkedState: e.context.checked,
+    setChecked(r) {
+      d({ type: "CHECKED.SET", checked: r, isTrusted: !1 });
+    },
+    toggleChecked() {
+      d({ type: "CHECKED.TOGGLE", checked: c, isTrusted: !1 });
+    },
+    getRootProps() {
+      return t.label({
+        ...u.root.attrs,
+        ...l,
+        dir: e.context.dir,
+        id: o.getRootId(e.context),
+        htmlFor: o.getHiddenInputId(e.context),
+        onPointerMove() {
+          n || d({ type: "CONTEXT.SET", context: { hovered: !0 } });
+        },
+        onPointerLeave() {
+          n || d({ type: "CONTEXT.SET", context: { hovered: !1 } });
+        },
+        onClick(r) {
+          r.target === o.getHiddenInputEl(e.context) && r.stopPropagation();
+        }
+      });
+    },
+    getLabelProps() {
+      return t.element({
+        ...u.label.attrs,
+        ...l,
+        dir: e.context.dir,
+        id: o.getLabelId(e.context)
+      });
+    },
+    getControlProps() {
+      return t.element({
+        ...u.control.attrs,
+        ...l,
+        dir: e.context.dir,
+        id: o.getControlId(e.context),
+        "aria-hidden": !0
+      });
+    },
+    getIndicatorProps() {
+      return t.element({
+        ...u.indicator.attrs,
+        ...l,
+        dir: e.context.dir,
+        hidden: !a && !e.context.checked
+      });
+    },
+    getHiddenInputProps() {
+      return t.input({
+        id: o.getHiddenInputId(e.context),
+        type: "checkbox",
+        required: e.context.required,
+        defaultChecked: c,
+        disabled: n,
+        "aria-labelledby": o.getLabelId(e.context),
+        "aria-invalid": e.context.invalid,
+        name: e.context.name,
+        form: e.context.form,
+        value: e.context.value,
+        style: b,
+        onClick(r) {
+          if (k) {
+            r.preventDefault();
+            return;
+          }
+          const C = r.currentTarget.checked;
+          d({ type: "CHECKED.SET", checked: C, isTrusted: !0 });
+        }
+      });
+    }
+  };
+}
+var { not: p } = I;
+function B(e) {
+  const d = x(e);
+  return v(
+    {
+      id: "checkbox",
+      initial: "ready",
+      context: {
+        checked: !1,
+        value: "on",
+        disabled: !1,
+        ...d,
+        fieldsetDisabled: !1
+      },
+      watch: {
+        disabled: "removeFocusIfNeeded",
+        checked: "syncInputElement"
+      },
+      activities: ["trackFormControlState", "trackPressEvent", "trackFocusVisible"],
+      on: {
+        "CHECKED.TOGGLE": [
+          {
+            guard: p("isTrusted"),
+            actions: ["toggleChecked", "dispatchChangeEvent"]
+          },
+          {
+            actions: ["toggleChecked"]
+          }
+        ],
+        "CHECKED.SET": [
+          {
+            guard: p("isTrusted"),
+            actions: ["setChecked", "dispatchChangeEvent"]
+          },
+          {
+            actions: ["setChecked"]
+          }
+        ],
+        "CONTEXT.SET": {
+          actions: ["setContext"]
+        }
+      },
+      computed: {
+        isIndeterminate: (t) => h(t.checked),
+        isChecked: (t) => g(t.checked),
+        isDisabled: (t) => !!t.disabled || t.fieldsetDisabled
+      },
+      states: {
+        ready: {}
+      }
+    },
+    {
+      guards: {
+        isTrusted: (t, n) => !!n.isTrusted
+      },
+      activities: {
+        trackPressEvent(t) {
+          if (!t.isDisabled)
+            return y({
+              pointerNode: o.getRootEl(t),
+              keyboardNode: o.getHiddenInputEl(t),
+              isValidKey: (n) => n.key === " ",
+              onPress: () => t.active = !1,
+              onPressStart: () => t.active = !0,
+              onPressEnd: () => t.active = !1
+            });
+        },
+        trackFocusVisible(t) {
+          if (!t.isDisabled)
+            return T(o.getHiddenInputEl(t), {
+              onFocus: () => t.focused = !0,
+              onBlur: () => t.focused = !1
+            });
+        },
+        trackFormControlState(t, n, { send: s, initialContext: c }) {
+          return H(o.getHiddenInputEl(t), {
+            onFieldsetDisabledChange(a) {
+              t.fieldsetDisabled = a;
+            },
+            onFormReset() {
+              s({ type: "CHECKED.SET", checked: !!c.checked });
+            }
+          });
+        }
+      },
+      actions: {
+        setContext(t, n) {
+          Object.assign(t, n.context);
+        },
+        syncInputElement(t) {
+          const n = o.getHiddenInputEl(t);
+          n && (D(n, t.isChecked), n.indeterminate = t.isIndeterminate);
+        },
+        removeFocusIfNeeded(t) {
+          t.disabled && t.focused && (t.focused = !1);
+        },
+        setChecked(t, n) {
+          f.checked(t, n.checked);
+        },
+        toggleChecked(t) {
+          const n = h(t.checked) ? !0 : !t.checked;
+          f.checked(t, n);
+        },
+        dispatchChangeEvent(t) {
+          const n = o.getHiddenInputEl(t);
+          P(n, { checked: g(t.checked) });
+        }
+      }
+    }
+  );
+}
+function h(e) {
+  return e === "indeterminate";
+}
+function g(e) {
+  return h(e) ? !1 : !!e;
+}
+var N = {
+  change: (e) => {
+    var d;
+    (d = e.onCheckedChange) == null || d.call(e, { checked: e.checked });
+  }
+}, f = {
+  checked: (e, d) => {
+    S(e.checked, d) || (e.checked = d, N.change(e));
+  }
+};
+F()([
+  "checked",
+  "dir",
+  "disabled",
+  "form",
+  "getRootNode",
+  "id",
+  "ids",
+  "invalid",
+  "name",
+  "onCheckedChange",
+  "readOnly",
+  "required",
+  "value"
+]);
+export {
+  O as anatomy,
+  A as connect,
+  B as machine
+};

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

@@ -0,0 +1,243 @@
+import { createAnatomy as E } from "../../anatomy/dist/index.js";
+import { createScope as N, dataAttr as c, raf as O, getComputedStyle as f } from "../../dom-query/dist/index.js";
+import { createMachine as h } from "../../core/dist/index.js";
+import { compact as v } from "../../utils/dist/index.js";
+import { createProps as y } from "../../types/dist/index.js";
+import { ref as I } from "../../store/dist/index.js";
+var L = E("collapsible").parts("root", "trigger", "content"), g = L.build(), l = N({
+  getRootId: (n) => {
+    var r;
+    return ((r = n.ids) == null ? void 0 : r.root) ?? `collapsible:${n.id}`;
+  },
+  getContentId: (n) => {
+    var r;
+    return ((r = n.ids) == null ? void 0 : r.content) ?? `collapsible:${n.id}:content`;
+  },
+  getTriggerId: (n) => {
+    var r;
+    return ((r = n.ids) == null ? void 0 : r.trigger) ?? `collapsible:${n.id}:trigger`;
+  },
+  getRootEl: (n) => l.getById(n, l.getRootId(n)),
+  getContentEl: (n) => l.getById(n, l.getContentId(n)),
+  getTriggerEl: (n) => l.getById(n, l.getTriggerId(n))
+});
+function T(n, r, e) {
+  const o = n.matches("open", "closing"), i = n.matches("open"), t = n.context.height, s = n.context.width, a = !!n.context.disabled, d = !n.context.initial && i;
+  return {
+    disabled: a,
+    visible: o,
+    open: i,
+    setOpen(p) {
+      p !== i && r(p ? "OPEN" : "CLOSE");
+    },
+    getRootProps() {
+      return e.element({
+        ...g.root.attrs,
+        "data-state": i ? "open" : "closed",
+        dir: n.context.dir,
+        id: l.getRootId(n.context)
+      });
+    },
+    getContentProps() {
+      return e.element({
+        ...g.content.attrs,
+        "data-state": d ? void 0 : i ? "open" : "closed",
+        id: l.getContentId(n.context),
+        "data-disabled": c(a),
+        hidden: !o,
+        style: {
+          "--height": t != null ? `${t}px` : void 0,
+          "--width": s != null ? `${s}px` : void 0
+        }
+      });
+    },
+    getTriggerProps() {
+      return e.element({
+        ...g.trigger.attrs,
+        id: l.getTriggerId(n.context),
+        dir: n.context.dir,
+        type: "button",
+        "data-state": i ? "open" : "closed",
+        "data-disabled": c(a),
+        "aria-controls": l.getContentId(n.context),
+        "aria-expanded": o || !1,
+        onClick(p) {
+          p.defaultPrevented || a || r({ type: i ? "CLOSE" : "OPEN", src: "trigger.click" });
+        }
+      });
+    }
+  };
+}
+function P(n) {
+  const r = v(n);
+  return h(
+    {
+      id: "collapsible",
+      initial: r.open ? "open" : "closed",
+      context: {
+        ...r,
+        height: 0,
+        width: 0,
+        initial: !1,
+        stylesRef: null,
+        unmountAnimationName: null
+      },
+      watch: {
+        open: ["setInitial", "computeSize", "toggleVisibility"]
+      },
+      exit: ["clearInitial"],
+      states: {
+        closed: {
+          tags: ["closed"],
+          on: {
+            "CONTROLLED.OPEN": "open",
+            OPEN: [
+              {
+                guard: "isOpenControlled",
+                actions: ["invokeOnOpen"]
+              },
+              {
+                target: "open",
+                actions: ["setInitial", "computeSize", "invokeOnOpen"]
+              }
+            ]
+          }
+        },
+        closing: {
+          tags: ["open"],
+          activities: ["trackAnimationEvents"],
+          on: {
+            "CONTROLLED.CLOSE": "closed",
+            "CONTROLLED.OPEN": "open",
+            OPEN: [
+              {
+                guard: "isOpenControlled",
+                actions: ["invokeOnOpen"]
+              },
+              {
+                target: "open",
+                actions: ["setInitial", "invokeOnOpen"]
+              }
+            ],
+            CLOSE: [
+              {
+                guard: "isOpenControlled",
+                actions: ["invokeOnExitComplete"]
+              },
+              {
+                target: "closed",
+                actions: ["setInitial", "computeSize", "invokeOnExitComplete"]
+              }
+            ],
+            "ANIMATION.END": {
+              target: "closed",
+              actions: ["invokeOnExitComplete"]
+            }
+          }
+        },
+        open: {
+          tags: ["open"],
+          on: {
+            "CONTROLLED.CLOSE": "closing",
+            CLOSE: [
+              {
+                guard: "isOpenControlled",
+                actions: ["invokeOnClose"]
+              },
+              {
+                target: "closing",
+                actions: ["setInitial", "computeSize", "invokeOnClose"]
+              }
+            ]
+          }
+        }
+      }
+    },
+    {
+      guards: {
+        isOpenControlled: (e) => !!e["open.controlled"]
+      },
+      activities: {
+        trackAnimationEvents(e, o, { send: i }) {
+          let t;
+          const s = O(() => {
+            const a = l.getContentEl(e);
+            if (!a) return;
+            const d = f(a).animationName;
+            if (!d || d === "none") {
+              i({ type: "ANIMATION.END" });
+              return;
+            }
+            const m = (u) => {
+              const C = (a.ownerDocument.defaultView || window).getComputedStyle(a).animationName;
+              u.target === a && C === e.unmountAnimationName && i({ type: "ANIMATION.END" });
+            };
+            a.addEventListener("animationend", m), t = () => {
+              a.removeEventListener("animationend", m);
+            };
+          });
+          return () => {
+            s(), t == null || t();
+          };
+        }
+      },
+      actions: {
+        setInitial(e) {
+          e.initial = !0;
+        },
+        clearInitial(e) {
+          e.initial = !1;
+        },
+        computeSize(e, o) {
+          var i;
+          (i = e._rafCleanup) == null || i.call(e), e._rafCleanup = O(() => {
+            const t = l.getContentEl(e);
+            if (!t) return;
+            if (e.stylesRef || (e.stylesRef = I({
+              animationName: t.style.animationName,
+              animationDuration: t.style.animationDuration
+            })), o.type === "CLOSE" || !e.open) {
+              const d = t.ownerDocument.defaultView || window;
+              e.unmountAnimationName = d.getComputedStyle(t).animationName;
+            }
+            const s = t.hidden;
+            t.style.animationName = "none", t.style.animationDuration = "0s", t.hidden = !1;
+            const a = t.getBoundingClientRect();
+            e.height = a.height, e.width = a.width, e.initial && (t.style.animationName = e.stylesRef.animationName, t.style.animationDuration = e.stylesRef.animationDuration), t.hidden = s;
+          });
+        },
+        invokeOnOpen: (e) => {
+          var o;
+          (o = e.onOpenChange) == null || o.call(e, { open: !0 });
+        },
+        invokeOnClose: (e) => {
+          var o;
+          (o = e.onOpenChange) == null || o.call(e, { open: !1 });
+        },
+        invokeOnExitComplete(e) {
+          var o;
+          (o = e.onExitComplete) == null || o.call(e);
+        },
+        toggleVisibility: (e, o, { send: i }) => {
+          i({ type: e.open ? "CONTROLLED.OPEN" : "CONTROLLED.CLOSE" });
+        }
+      }
+    }
+  );
+}
+y()([
+  "dir",
+  "disabled",
+  "getRootNode",
+  "id",
+  "ids",
+  "onExitComplete",
+  "onOpenChange",
+  "open.controlled",
+  "open"
+]);
+export {
+  L as anatomy,
+  T as connect,
+  P as machine
+};

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

@@ -0,0 +1,203 @@
+import { isEqual as c, isObject as a, hasProp as h } from "../../utils/dist/index.js";
+var y = Object.defineProperty, p = (t, e, i) => e in t ? y(t, e, { enumerable: !0, configurable: !0, writable: !0, value: i }) : t[e] = i, I = (t, e, i) => p(t, e + "", i), u = {
+  itemToValue(t) {
+    return typeof t == "string" ? t : a(t) && h(t, "value") ? t.value : "";
+  },
+  itemToString(t) {
+    return typeof t == "string" ? t : a(t) && h(t, "label") ? t.label : u.itemToValue(t);
+  },
+  isItemDisabled(t) {
+    return a(t) && h(t, "disabled") ? !!t.disabled : !1;
+  }
+}, T = class {
+  constructor(t) {
+    this.options = t, I(this, "items"), this.items = [...t.items];
+  }
+  isEqual(t) {
+    return c(this.items, t.items);
+  }
+  /**
+   * Function to update the collection items
+   */
+  setItems(t) {
+    this.items = Array.from(t);
+  }
+  /**
+   * Returns all the values in the collection
+   */
+  getValues(t = this.items) {
+    return Array.from(t).map((e) => this.getItemValue(e)).filter(Boolean);
+  }
+  /**
+   * Get the item based on its value
+   */
+  find(t) {
+    if (t == null) return null;
+    const e = this.items.findIndex((i) => this.getItemValue(i) === t);
+    return e != null ? this.items[e] : null;
+  }
+  /**
+   * Get the items based on its values
+   */
+  findMany(t) {
+    return Array.from(t).map((e) => this.find(e)).filter(Boolean);
+  }
+  /**
+   * Get the item based on its index
+   */
+  at(t) {
+    return this.items[t] ?? null;
+  }
+  sortFn(t, e) {
+    const i = this.indexOf(t), s = this.indexOf(e);
+    return (i ?? 0) - (s ?? 0);
+  }
+  /**
+   * Sort the values based on their index
+   */
+  sort(t) {
+    return [...t].sort(this.sortFn.bind(this));
+  }
+  /**
+   * Convert an item to a value
+   */
+  getItemValue(t) {
+    var e, i;
+    return t == null ? null : ((i = (e = this.options).itemToValue) == null ? void 0 : i.call(e, t)) ?? u.itemToValue(t);
+  }
+  /**
+   * Whether an item is disabled
+   */
+  getItemDisabled(t) {
+    var e, i;
+    return t == null ? !1 : ((i = (e = this.options).isItemDisabled) == null ? void 0 : i.call(e, t)) ?? u.isItemDisabled(t);
+  }
+  /**
+   * Convert an item to a string
+   */
+  stringifyItem(t) {
+    var e, i;
+    return t == null ? null : ((i = (e = this.options).itemToString) == null ? void 0 : i.call(e, t)) ?? u.itemToString(t);
+  }
+  /**
+   * Convert a value to a string
+   */
+  stringify(t) {
+    return t == null ? null : this.stringifyItem(this.find(t));
+  }
+  /**
+   * Convert an array of items to a string
+   */
+  stringifyItems(t, e = ", ") {
+    return Array.from(t).map((i) => this.stringifyItem(i)).filter(Boolean).join(e);
+  }
+  /**
+   * Convert an array of items to a string
+   */
+  stringifyMany(t, e) {
+    return this.stringifyItems(this.findMany(t), e);
+  }
+  /**
+   * Whether the collection has a value
+   */
+  has(t) {
+    return this.indexOf(t) !== -1;
+  }
+  /**
+   * Whether the collection has an item
+   */
+  hasItem(t) {
+    return t == null ? !1 : this.has(this.getItemValue(t));
+  }
+  /**
+   * Returns the number of items in the collection
+   */
+  get size() {
+    return this.items.length;
+  }
+  /**
+   * Returns the first value in the collection
+   */
+  get firstValue() {
+    let t = 0;
+    for (; this.getItemDisabled(this.at(t)); ) t++;
+    return this.getItemValue(this.at(t));
+  }
+  /**
+   * Returns the last value in the collection
+   */
+  get lastValue() {
+    let t = this.size - 1;
+    for (; this.getItemDisabled(this.at(t)); ) t--;
+    return this.getItemValue(this.at(t));
+  }
+  /**
+   * Returns the next value in the collection
+   */
+  getNextValue(t) {
+    let e = this.indexOf(t);
+    if (e === -1) return null;
+    for (e++; e <= this.size && this.getItemDisabled(this.at(e)); ) e++;
+    return this.getItemValue(this.at(e));
+  }
+  /**
+   * Returns the previous value in the collection
+   */
+  getPreviousValue(t) {
+    let e = this.indexOf(t);
+    if (e === -1) return null;
+    for (e--; e >= 0 && this.getItemDisabled(this.at(e)); ) e--;
+    return this.getItemValue(this.at(e));
+  }
+  /**
+   * Get the index of an item based on its key
+   */
+  indexOf(t) {
+    return t == null ? -1 : this.items.findIndex((e) => this.getItemValue(e) === t);
+  }
+  getByText(t, e) {
+    let i = e != null ? x(this.items, this.indexOf(e)) : this.items;
+    return t.length === 1 && (i = i.filter((n) => this.getItemValue(n) !== e)), i.find((n) => V(this.stringifyItem(n), t));
+  }
+  /**
+   * Search for a value based on a query
+   */
+  search(t, e) {
+    const { state: i, currentValue: s, timeout: n = 350 } = e, r = i.keysSoFar + t, m = r.length > 1 && Array.from(r).every((l) => l === r[0]) ? r[0] : r, d = this.getByText(m, s), g = this.getItemValue(d);
+    function f() {
+      clearTimeout(i.timer), i.timer = -1;
+    }
+    function o(l) {
+      i.keysSoFar = l, f(), l !== "" && (i.timer = +setTimeout(() => {
+        o(""), f();
+      }, n));
+    }
+    return o(r), g;
+  }
+  *[Symbol.iterator]() {
+    yield* this.items;
+  }
+  insertBefore(t, e) {
+    const i = this.indexOf(t);
+    i !== -1 && this.items.splice(i, 0, e);
+  }
+  insertAfter(t, e) {
+    const i = this.indexOf(t);
+    i !== -1 && this.items.splice(i + 1, 0, e);
+  }
+  reorder(t, e) {
+    if (t === -1 || e === -1 || t === e) return;
+    const [i] = this.items.splice(t, 1);
+    this.items.splice(e, 0, i);
+  }
+  toJSON() {
+    return {
+      size: this.size,
+      first: this.firstValue,
+      last: this.lastValue
+    };
+  }
+}, V = (t, e) => !!(t != null && t.toLowerCase().startsWith(e.toLowerCase())), x = (t, e) => t.map((i, s) => t[(Math.max(e, 0) + s) % t.length]);
+export {
+  T as Collection
+};