@synopackageland/ui 0.25.20 → 0.25.22

package/dist/modules/vendor/reka-ui/dist/Tooltip/TooltipTrigger.js

@@ -0,0 +1,88 @@
+import { useForwardExpose as b } from "../shared/useForwardExpose.js";
+import { useId as P } from "../shared/useId.js";
+import { Primitive as _ } from "../Primitive/Primitive.js";
+import { PopperAnchor_default as y } from "../Popper/PopperAnchor.js";
+import { injectTooltipProviderContext as w } from "./TooltipProvider.js";
+import { injectTooltipRootContext as x } from "./TooltipRoot.js";
+import { defineComponent as k, ref as l, computed as E, watch as B, openBlock as I, createBlock as L, unref as r, withCtx as u, createVNode as q, mergeProps as F, toHandlers as R, renderSlot as j } from "vue";
+var A = /* @__PURE__ */ k({
+  __name: "TooltipTrigger",
+  props: {
+    reference: {
+      type: null,
+      required: !1
+    },
+    asChild: {
+      type: Boolean,
+      required: !1
+    },
+    as: {
+      type: null,
+      required: !1,
+      default: "button"
+    }
+  },
+  setup(o) {
+    const s = o, e = x(), d = w();
+    e.contentId ||= P(void 0, "reka-tooltip-content");
+    const { forwardRef: c, currentElement: a } = b(), n = l(!1), i = l(!1), f = E(() => e.disabled.value ? {} : {
+      click: C,
+      focus: h,
+      pointermove: g,
+      pointerleave: m,
+      pointerdown: v,
+      blur: T
+    });
+    B(a, (t) => {
+      e.onTriggerChange(t);
+    }, { immediate: !0 });
+    function p() {
+      setTimeout(() => {
+        n.value = !1;
+      }, 1);
+    }
+    function v() {
+      e.open && !e.disableClosingTrigger.value && e.onClose(), n.value = !0, document.addEventListener("pointerup", p, { once: !0 });
+    }
+    function g(t) {
+      t.pointerType !== "touch" && !i.value && !d.isPointerInTransitRef.value && (e.onTriggerEnter(), i.value = !0);
+    }
+    function m() {
+      e.onTriggerLeave(), i.value = !1;
+    }
+    function h(t) {
+      n.value || e.ignoreNonKeyboardFocus.value && !t.target.matches?.(":focus-visible") || e.onOpen();
+    }
+    function T() {
+      e.onClose();
+    }
+    function C() {
+      e.disableClosingTrigger.value || e.onClose();
+    }
+    return (t, D) => (I(), L(r(y), {
+      "as-child": "",
+      reference: o.reference ?? r(a)
+    }, {
+      default: u(() => [q(r(_), F({
+        ref: r(c),
+        "aria-describedby": r(e).open.value ? r(e).contentId : void 0,
+        "data-state": r(e).stateAttribute.value,
+        as: o.as,
+        "as-child": s.asChild,
+        "data-grace-area-trigger": ""
+      }, R(f.value)), {
+        default: u(() => [j(t.$slots, "default")]),
+        _: 3
+      }, 16, [
+        "aria-describedby",
+        "data-state",
+        "as",
+        "as-child"
+      ])]),
+      _: 3
+    }, 8, ["reference"]));
+  }
+}), V = A;
+export {
+  V as TooltipTrigger_default
+};

package/dist/modules/vendor/reka-ui/dist/Tooltip/utils.js

@@ -0,0 +1,4 @@
+const o = "tooltip.open";
+export {
+  o as TOOLTIP_OPEN
+};

package/dist/modules/vendor/reka-ui/dist/Tree/TreeItem.js

@@ -0,0 +1,153 @@
+import { getActiveElement as T } from "../shared/getActiveElement.js";
+import { handleAndDispatchCustomEvent as K } from "../shared/handleAndDispatchCustomEvent.js";
+import { Primitive as R } from "../Primitive/Primitive.js";
+import { useCollection as B } from "../Collection/Collection.js";
+import { RovingFocusItem_default as N } from "../RovingFocus/RovingFocusItem.js";
+import { flatten as A } from "./utils.js";
+import { injectTreeRootContext as P } from "./TreeRoot.js";
+import { defineComponent as L, computed as c, openBlock as O, createBlock as G, unref as s, withCtx as I, createVNode as $, mergeProps as j, withModifiers as m, withKeys as y, renderSlot as F } from "vue";
+const M = "tree.select", z = "tree.toggle";
+var H = /* @__PURE__ */ L({
+  inheritAttrs: !1,
+  __name: "TreeItem",
+  props: {
+    value: {
+      type: null,
+      required: !0
+    },
+    level: {
+      type: Number,
+      required: !0
+    },
+    disabled: {
+      type: Boolean,
+      required: !1
+    },
+    asChild: {
+      type: Boolean,
+      required: !1
+    },
+    as: {
+      type: null,
+      required: !1,
+      default: "li"
+    }
+  },
+  emits: ["select", "toggle"],
+  setup(r, { expose: w, emit: k }) {
+    const n = r, h = k, e = P(), { getItems: E } = B(), f = c(() => !!e.getChildren(n.value)), d = c(() => {
+      const t = e.getKey(n.value);
+      return e.expanded.value.includes(t);
+    }), u = c(() => {
+      const t = e.getKey(n.value);
+      return e.selectedKeys.value.includes(t);
+    }), b = c(() => {
+      if (e.bubbleSelect.value && f.value && Array.isArray(e.modelValue.value)) {
+        const t = A(e.getChildren(n.value) || []);
+        return t.some((l) => e.modelValue.value.find((a) => e.getKey(a) === e.getKey(l))) && !t.every((l) => e.modelValue.value.find((a) => e.getKey(a) === e.getKey(l)));
+      } else return e.propagateSelect.value && u.value && f.value && Array.isArray(e.modelValue.value) ? !A(e.getChildren(n.value) || []).every((l) => e.modelValue.value.find((a) => e.getKey(a) === e.getKey(l))) : void 0;
+    }), i = c(() => e.disabled.value || n.disabled);
+    function x(t) {
+      if (!i.value && f.value)
+        if (d.value) {
+          const l = E().map((o) => o.ref), a = T(), p = l.indexOf(a), v = [...l].slice(p).find((o) => Number(o.getAttribute("data-indent")) === n.level + 1);
+          v && v.focus();
+        } else g(t);
+    }
+    function C(t) {
+      if (!i.value)
+        if (d.value) g(t);
+        else {
+          const l = E().map((o) => o.ref), a = T(), p = l.indexOf(a), v = [...l].slice(0, p).reverse().find((o) => Number(o.getAttribute("data-indent")) === n.level - 1);
+          v && v.focus();
+        }
+    }
+    async function V(t) {
+      i.value || (h("select", t), !t?.defaultPrevented && e.onSelect(n.value));
+    }
+    async function q(t) {
+      i.value || (h("toggle", t), !t?.defaultPrevented && e.onToggle(n.value));
+    }
+    async function S(t) {
+      if (!t) return;
+      const l = {
+        originalEvent: t,
+        value: n.value,
+        isExpanded: d.value,
+        isSelected: u.value
+      };
+      K(M, V, l);
+    }
+    async function g(t) {
+      if (!t) return;
+      const l = {
+        originalEvent: t,
+        value: n.value,
+        isExpanded: d.value,
+        isSelected: u.value
+      };
+      K(z, q, l);
+    }
+    return w({
+      isExpanded: d,
+      isSelected: u,
+      isIndeterminate: b,
+      isDisabled: i,
+      handleToggle: () => e.onToggle(n.value),
+      handleSelect: () => e.onSelect(n.value)
+    }), (t, l) => (O(), G(s(N), {
+      "as-child": "",
+      value: r.value,
+      "allow-shift-key": "",
+      focusable: !i.value
+    }, {
+      default: I(() => [$(s(R), j(t.$attrs, {
+        role: "treeitem",
+        as: r.as,
+        "as-child": r.asChild,
+        "aria-selected": u.value,
+        "aria-expanded": f.value ? d.value : void 0,
+        "aria-level": r.level,
+        "aria-disabled": i.value ? !0 : void 0,
+        "data-indent": r.level,
+        "data-selected": u.value ? "" : void 0,
+        "data-expanded": d.value ? "" : void 0,
+        "data-disabled": i.value ? "" : void 0,
+        onKeydown: [
+          y(m(S, ["self", "prevent"]), ["enter", "space"]),
+          l[0] || (l[0] = y(m((a) => s(e).dir.value === "ltr" ? x(a) : C(a), ["self", "prevent"]), ["right"])),
+          l[1] || (l[1] = y(m((a) => s(e).dir.value === "ltr" ? C(a) : x(a), ["self", "prevent"]), ["left"]))
+        ],
+        onClick: l[2] || (l[2] = m((a) => {
+          S(a), g(a);
+        }, ["stop"]))
+      }), {
+        default: I(() => [F(t.$slots, "default", {
+          isExpanded: d.value,
+          isSelected: u.value,
+          isIndeterminate: b.value,
+          isDisabled: i.value,
+          handleSelect: () => s(e).onSelect(r.value),
+          handleToggle: () => s(e).onToggle(r.value)
+        })]),
+        _: 3
+      }, 16, [
+        "as",
+        "as-child",
+        "aria-selected",
+        "aria-expanded",
+        "aria-level",
+        "aria-disabled",
+        "data-indent",
+        "data-selected",
+        "data-expanded",
+        "data-disabled",
+        "onKeydown"
+      ])]),
+      _: 3
+    }, 8, ["value", "focusable"]));
+  }
+}), ee = H;
+export {
+  ee as TreeItem_default
+};

package/dist/modules/vendor/reka-ui/dist/Tree/TreeRoot.js

@@ -0,0 +1,216 @@
+import { createContext as Y } from "../shared/createContext.js";
+import { getActiveElement as j } from "../shared/getActiveElement.js";
+import { useDirection as z } from "../shared/useDirection.js";
+import { useSelectionBehavior as L } from "../shared/useSelectionBehavior.js";
+import { useTypeahead as U } from "../shared/useTypeahead.js";
+import { Primitive as W } from "../Primitive/Primitive.js";
+import { MAP_KEY_TO_FOCUS_INTENT as $ } from "../RovingFocus/utils.js";
+import { RovingFocusGroup_default as J } from "../RovingFocus/RovingFocusGroup.js";
+import { flatten as Q } from "./utils.js";
+import { defineComponent as X, toRefs as Z, ref as b, computed as q, openBlock as ee, createBlock as te, unref as u, withCtx as I, createVNode as le, withKeys as re, withModifiers as ae, renderSlot as oe, nextTick as ie } from "vue";
+import { useVModel as T } from "../../../@vueuse/core/dist/index.js";
+import { createEventHook as ne } from "../../../@vueuse/shared/dist/index.js";
+const [xe, ue] = /* @__PURE__ */ Y("TreeRoot");
+var de = /* @__PURE__ */ X({
+  __name: "TreeRoot",
+  props: {
+    modelValue: {
+      type: null,
+      required: !1
+    },
+    defaultValue: {
+      type: null,
+      required: !1
+    },
+    items: {
+      type: Array,
+      required: !1
+    },
+    expanded: {
+      type: Array,
+      required: !1
+    },
+    defaultExpanded: {
+      type: Array,
+      required: !1
+    },
+    getKey: {
+      type: Function,
+      required: !0
+    },
+    getChildren: {
+      type: Function,
+      required: !1,
+      default: (d) => d.children
+    },
+    selectionBehavior: {
+      type: String,
+      required: !1,
+      default: "toggle"
+    },
+    multiple: {
+      type: Boolean,
+      required: !1,
+      skipCheck: !0
+    },
+    dir: {
+      type: String,
+      required: !1
+    },
+    disabled: {
+      type: Boolean,
+      required: !1
+    },
+    propagateSelect: {
+      type: Boolean,
+      required: !1
+    },
+    bubbleSelect: {
+      type: Boolean,
+      required: !1
+    },
+    loop: {
+      type: Boolean,
+      required: !1
+    },
+    asChild: {
+      type: Boolean,
+      required: !1
+    },
+    as: {
+      type: null,
+      required: !1,
+      default: "ul"
+    }
+  },
+  emits: ["update:modelValue", "update:expanded"],
+  setup(d, { emit: k }) {
+    const e = d, v = k, { items: V, multiple: p, disabled: w, propagateSelect: B, dir: R, bubbleSelect: E, loop: g } = Z(e), { handleTypeaheadSearch: F } = U(), h = z(R), y = b(), c = b(!1), K = ne(), r = T(e, "modelValue", v, {
+      defaultValue: e.defaultValue ?? (p.value ? [] : void 0),
+      passive: !0,
+      deep: !0
+    }), n = T(e, "expanded", v, {
+      defaultValue: e.defaultExpanded ?? [],
+      passive: e.expanded === void 0,
+      deep: !0
+    }), { onSelectItem: N, handleMultipleReplace: C } = L(r, e), G = q(() => p.value && Array.isArray(r.value) ? r.value.map((t) => e.getKey(t)) : [e.getKey(r.value ?? {})]);
+    function _(t, l = 1, o) {
+      return t.reduce((a, i, f) => {
+        const S = e.getKey(i), m = e.getChildren(i), D = n.value.includes(S), H = {
+          _id: S,
+          value: i,
+          index: f,
+          level: l,
+          parentItem: o,
+          hasChildren: !!m,
+          bind: {
+            value: i,
+            level: l,
+            "aria-setsize": t.length,
+            "aria-posinset": f + 1
+          }
+        };
+        return a.push(H), m && D && a.push(..._(m, l + 1, i)), a;
+      }, []);
+    }
+    const s = q(() => {
+      const t = e.items;
+      return n.value.map((l) => l), _(t ?? []);
+    }), O = [
+      "input",
+      "textarea",
+      "select"
+    ];
+    function x(t) {
+      const l = t.target;
+      return l ? O.includes(l.tagName.toLowerCase()) || l.isContentEditable : !1;
+    }
+    function M(t) {
+      if (!x(t))
+        if (c.value) K.trigger(t);
+        else {
+          const l = y.value?.getItems() ?? [];
+          F(t.key, l);
+        }
+    }
+    function P(t) {
+      if (c.value || x(t)) return;
+      const l = $[t.key];
+      ie(() => {
+        C(l, j(), y.value?.getItems, s.value.map((o) => o.value));
+      });
+    }
+    function A(t) {
+      if (t.parentItem != null && Array.isArray(r.value) && e.multiple) {
+        const l = s.value.find((o) => t.parentItem != null && e.getKey(o.value) === e.getKey(t.parentItem));
+        l != null && (e.getChildren(l.value)?.every((a) => r.value.find((i) => e.getKey(i) === e.getKey(a))) ? r.value = [...r.value, l.value] : r.value = r.value.filter((a) => e.getKey(a) !== e.getKey(l.value)), A(l));
+      }
+    }
+    return ue({
+      modelValue: r,
+      selectedKeys: G,
+      onSelect: (t) => {
+        const l = (a) => e.getKey(a ?? {}) === e.getKey(t), o = e.multiple && Array.isArray(r.value) ? r.value?.findIndex(l) !== -1 : void 0;
+        if (N(t, l), e.bubbleSelect && e.multiple && Array.isArray(r.value)) {
+          const a = s.value.find((i) => e.getKey(i.value) === e.getKey(t));
+          a != null && A(a);
+        }
+        if (e.propagateSelect && e.multiple && Array.isArray(r.value)) {
+          const a = Q(e.getChildren(t) ?? []);
+          o ? r.value = [...r.value].filter((i) => !a.some((f) => e.getKey(i ?? {}) === e.getKey(f))) : r.value = [...r.value, ...a];
+        }
+      },
+      expanded: n,
+      onToggle(t) {
+        if (!(t ? e.getChildren(t) : void 0)) return;
+        const o = e.getKey(t) ?? t;
+        n.value.includes(o) ? n.value = n.value.filter((a) => a !== o) : n.value = [...n.value, o];
+      },
+      getKey: e.getKey,
+      getChildren: e.getChildren,
+      items: V,
+      expandedItems: s,
+      disabled: w,
+      multiple: p,
+      dir: h,
+      propagateSelect: B,
+      bubbleSelect: E,
+      loop: g,
+      isVirtual: c,
+      virtualKeydownHook: K,
+      handleMultipleReplace: C
+    }), (t, l) => (ee(), te(u(J), {
+      ref_key: "rovingFocusGroupRef",
+      ref: y,
+      "as-child": "",
+      orientation: "vertical",
+      dir: u(h),
+      loop: u(g) && !c.value
+    }, {
+      default: I(() => [le(u(W), {
+        role: "tree",
+        as: d.as,
+        "as-child": d.asChild,
+        "aria-multiselectable": u(p) ? !0 : void 0,
+        onKeydown: [M, re(ae(P, ["shift"]), ["up", "down"])]
+      }, {
+        default: I(() => [oe(t.$slots, "default", {
+          flattenItems: s.value,
+          modelValue: u(r),
+          expanded: u(n)
+        })]),
+        _: 3
+      }, 8, [
+        "as",
+        "as-child",
+        "aria-multiselectable",
+        "onKeydown"
+      ])]),
+      _: 3
+    }, 8, ["dir", "loop"]));
+  }
+}), Ae = de;
+export {
+  Ae as TreeRoot_default,
+  xe as injectTreeRootContext
+};

package/dist/modules/vendor/reka-ui/dist/Tree/utils.js

@@ -0,0 +1,6 @@
+function u(e) {
+  return e.reduce((r, n) => (r.push(n), n.children && r.push(...u(n.children)), r), []);
+}
+export {
+  u as flatten
+};

package/dist/modules/vendor/reka-ui/dist/VisuallyHidden/VisuallyHidden.js

@@ -0,0 +1,57 @@
+import { Primitive as d } from "../Primitive/Primitive.js";
+import { defineComponent as i, openBlock as t, createBlock as l, unref as r, withCtx as n, renderSlot as u } from "vue";
+var o = /* @__PURE__ */ i({
+  __name: "VisuallyHidden",
+  props: {
+    feature: {
+      type: String,
+      required: !1,
+      default: "focusable"
+    },
+    asChild: {
+      type: Boolean,
+      required: !1
+    },
+    as: {
+      type: null,
+      required: !1,
+      default: "span"
+    }
+  },
+  setup(e) {
+    return (a, f) => (t(), l(r(d), {
+      as: e.as,
+      "as-child": e.asChild,
+      "aria-hidden": e.feature === "fully-hidden" ? "true" : void 0,
+      "data-hidden": e.feature === "fully-hidden" ? "" : void 0,
+      tabindex: e.feature === "fully-hidden" ? "-1" : void 0,
+      style: {
+        position: "absolute",
+        border: 0,
+        width: "1px",
+        height: "1px",
+        padding: 0,
+        margin: "-1px",
+        overflow: "hidden",
+        clip: "rect(0, 0, 0, 0)",
+        clipPath: "inset(50%)",
+        whiteSpace: "nowrap",
+        wordWrap: "normal",
+        top: "-1px",
+        left: "-1px"
+      }
+    }, {
+      default: n(() => [u(a.$slots, "default")]),
+      _: 3
+    }, 8, [
+      "as",
+      "as-child",
+      "aria-hidden",
+      "data-hidden",
+      "tabindex"
+    ]));
+  }
+}), h = o;
+export {
+  h as VisuallyHidden_default
+};

package/dist/modules/vendor/reka-ui/dist/VisuallyHidden/VisuallyHiddenInput.js

@@ -0,0 +1,65 @@
+import { VisuallyHiddenInputBubble_default as n } from "./VisuallyHiddenInputBubble.js";
+import { defineComponent as y, computed as i, openBlock as l, createElementBlock as o, Fragment as d, createCommentVNode as c, createBlock as m, mergeProps as v, renderList as q } from "vue";
+var b = /* @__PURE__ */ y({
+  inheritAttrs: !1,
+  __name: "VisuallyHiddenInput",
+  props: {
+    name: {
+      type: String,
+      required: !0
+    },
+    value: {
+      type: null,
+      required: !0
+    },
+    checked: {
+      type: Boolean,
+      required: !1,
+      default: void 0
+    },
+    required: {
+      type: Boolean,
+      required: !1
+    },
+    disabled: {
+      type: Boolean,
+      required: !1
+    },
+    feature: {
+      type: String,
+      required: !1,
+      default: "fully-hidden"
+    }
+  },
+  setup(t) {
+    const e = t, s = i(() => typeof e.value == "object" && Array.isArray(e.value) && e.value.length === 0 && e.required), f = i(() => typeof e.value == "string" || typeof e.value == "number" || typeof e.value == "boolean" || e.value === null || e.value === void 0 ? [{
+      name: e.name,
+      value: e.value
+    }] : typeof e.value == "object" && Array.isArray(e.value) ? e.value.flatMap((a, r) => typeof a == "object" ? Object.entries(a).map(([u, p]) => ({
+      name: `${e.name}[${r}][${u}]`,
+      value: p
+    })) : {
+      name: `${e.name}[${r}]`,
+      value: a
+    }) : e.value !== null && typeof e.value == "object" && !Array.isArray(e.value) ? Object.entries(e.value).map(([a, r]) => ({
+      name: `${e.name}[${a}]`,
+      value: r
+    })) : []);
+    return (a, r) => (l(), o(d, null, [c(" We render single input if it's required "), s.value ? (l(), m(n, v({ key: t.name }, {
+      ...e,
+      ...a.$attrs
+    }, {
+      name: t.name,
+      value: t.value
+    }), null, 16, ["name", "value"])) : (l(!0), o(d, { key: 1 }, q(f.value, (u) => (l(), m(n, v({ key: u.name }, { ref_for: !0 }, {
+      ...e,
+      ...a.$attrs
+    }, {
+      name: u.name,
+      value: u.value
+    }), null, 16, ["name", "value"]))), 128))], 2112));
+  }
+}), g = b;
+export {
+  g as VisuallyHiddenInput_default
+};

package/dist/modules/vendor/reka-ui/dist/VisuallyHidden/VisuallyHiddenInputBubble.js

@@ -0,0 +1,55 @@
+import { usePrimitiveElement as c } from "../Primitive/usePrimitiveElement.js";
+import { VisuallyHidden_default as f } from "./VisuallyHidden.js";
+import { defineComponent as v, computed as m, watch as y, openBlock as b, createBlock as _, mergeProps as E } from "vue";
+var h = /* @__PURE__ */ v({
+  inheritAttrs: !1,
+  __name: "VisuallyHiddenInputBubble",
+  props: {
+    name: {
+      type: String,
+      required: !0
+    },
+    value: {
+      type: null,
+      required: !0
+    },
+    checked: {
+      type: Boolean,
+      required: !1,
+      default: void 0
+    },
+    required: {
+      type: Boolean,
+      required: !1
+    },
+    disabled: {
+      type: Boolean,
+      required: !1
+    },
+    feature: {
+      type: String,
+      required: !1,
+      default: "fully-hidden"
+    }
+  },
+  setup(i) {
+    const t = i, { primitiveElement: a, currentElement: n } = c(), o = m(() => t.checked ?? t.value);
+    return y(o, (e, u) => {
+      if (!n.value) return;
+      const r = n.value, p = window.HTMLInputElement.prototype, l = Object.getOwnPropertyDescriptor(p, "value").set;
+      if (l && e !== u) {
+        const s = new Event("input", { bubbles: !0 }), d = new Event("change", { bubbles: !0 });
+        l.call(r, e), r.dispatchEvent(s), r.dispatchEvent(d);
+      }
+    }), (e, u) => (b(), _(f, E({
+      ref_key: "primitiveElement",
+      ref: a
+    }, {
+      ...t,
+      ...e.$attrs
+    }, { as: "input" }), null, 16));
+  }
+}), k = h;
+export {
+  k as VisuallyHiddenInputBubble_default
+};