@synopackageland/ui 0.25.21 → 0.25.22

package/dist/modules/vendor/reka-ui/dist/RovingFocus/RovingFocusItem.js

@@ -0,0 +1,110 @@
+import { useForwardExpose as h } from "../shared/useForwardExpose.js";
+import { useId as x } from "../shared/useId.js";
+import { Primitive as w } from "../Primitive/Primitive.js";
+import { useCollection as S } from "../Collection/Collection.js";
+import { getFocusIntent as C, wrapArray as K, focusFirst as R } from "./utils.js";
+import { injectRovingFocusGroupContext as T } from "./RovingFocusGroup.js";
+import { defineComponent as q, computed as d, onMounted as B, onUnmounted as k, watch as f, shallowRef as E, openBlock as A, createBlock as D, unref as i, withCtx as c, createVNode as M, renderSlot as N, nextTick as P } from "vue";
+import { useEventListener as $ } from "../../../@vueuse/core/dist/index.js";
+var j = /* @__PURE__ */ q({
+  __name: "RovingFocusItem",
+  props: {
+    tabStopId: {
+      type: String,
+      required: !1
+    },
+    focusable: {
+      type: Boolean,
+      required: !1,
+      default: !0
+    },
+    active: {
+      type: Boolean,
+      required: !1
+    },
+    allowShiftKey: {
+      type: Boolean,
+      required: !1
+    },
+    asChild: {
+      type: Boolean,
+      required: !1
+    },
+    as: {
+      type: null,
+      required: !1,
+      default: "span"
+    }
+  },
+  setup(r) {
+    const u = r, t = T(), m = x(), l = d(() => u.tabStopId || m), p = d(() => t.currentTabStopId.value === l.value), { getItems: v, CollectionItem: b } = S();
+    B(() => {
+      u.focusable && t.onFocusableItemAdd();
+    }), k(() => {
+      u.focusable && t.onFocusableItemRemove();
+    }), f(() => u.focusable, (e, o) => {
+      e !== o && (e ? t.onFocusableItemAdd() : t.onFocusableItemRemove());
+    });
+    function I(e) {
+      if (e.defaultPrevented) return;
+      if (e.key === "Tab" && e.shiftKey) {
+        t.onItemShiftTab();
+        return;
+      }
+      if (e.target !== e.currentTarget) return;
+      const o = C(e, t.orientation.value, t.dir.value);
+      if (o !== void 0) {
+        if (e.metaKey || e.ctrlKey || e.altKey || !u.allowShiftKey && e.shiftKey) return;
+        e.preventDefault();
+        let a = [...v().map((n) => n.ref).filter((n) => n.dataset.disabled !== "")];
+        if (o === "last") a.reverse();
+        else if (o === "prev" || o === "next") {
+          o === "prev" && a.reverse();
+          const n = a.indexOf(e.currentTarget);
+          a = t.loop.value ? K(a, n + 1) : a.slice(n + 1);
+        }
+        P(() => R(a));
+      }
+    }
+    const { forwardRef: y, currentElement: F } = h(), s = E();
+    f(F, (e) => {
+      s.value = e;
+    }, {
+      immediate: !0,
+      flush: "post"
+    }), $(s, "keydown", I);
+    function g(e) {
+      s.value = e.currentTarget;
+    }
+    return (e, o) => (A(), D(i(b), null, {
+      default: c(() => [M(i(w), {
+        ref: i(y),
+        tabindex: p.value ? 0 : -1,
+        "data-orientation": i(t).orientation.value,
+        "data-active": r.active ? "" : void 0,
+        "data-disabled": r.focusable ? void 0 : "",
+        as: r.as,
+        "as-child": r.asChild,
+        onMousedown: o[0] || (o[0] = (a) => {
+          r.focusable ? i(t).onItemFocus(l.value) : a.preventDefault();
+        }),
+        onFocus: o[1] || (o[1] = (a) => i(t).onItemFocus(l.value)),
+        onFocusin: g
+      }, {
+        default: c(() => [N(e.$slots, "default")]),
+        _: 3
+      }, 8, [
+        "tabindex",
+        "data-orientation",
+        "data-active",
+        "data-disabled",
+        "as",
+        "as-child"
+      ])]),
+      _: 3
+    }));
+  }
+}), V = j;
+export {
+  V as RovingFocusItem_default
+};

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

@@ -0,0 +1,38 @@
+import { getActiveElement as n } from "../shared/getActiveElement.js";
+const u = "rovingFocusGroup.onEntryFocus", s = {
+  bubbles: !1,
+  cancelable: !0
+}, i = {
+  ArrowLeft: "prev",
+  ArrowUp: "prev",
+  ArrowRight: "next",
+  ArrowDown: "next",
+  PageUp: "first",
+  Home: "first",
+  PageDown: "last",
+  End: "last"
+};
+function c(r, t) {
+  return t !== "rtl" ? r : r === "ArrowLeft" ? "ArrowRight" : r === "ArrowRight" ? "ArrowLeft" : r;
+}
+function w(r, t, e) {
+  const o = c(r.key, e);
+  if (!(t === "vertical" && ["ArrowLeft", "ArrowRight"].includes(o)) && !(t === "horizontal" && ["ArrowUp", "ArrowDown"].includes(o)))
+    return i[o];
+}
+function A(r, t = !1) {
+  const e = n();
+  for (const o of r)
+    if (o === e || (o.focus({ preventScroll: t }), n() !== e)) return;
+}
+function l(r, t) {
+  return r.map((e, o) => r[(t + o) % r.length]);
+}
+export {
+  u as ENTRY_FOCUS,
+  s as EVENT_OPTIONS,
+  i as MAP_KEY_TO_FOCUS_INTENT,
+  A as focusFirst,
+  w as getFocusIntent,
+  l as wrapArray
+};

package/dist/modules/vendor/reka-ui/dist/Select/BubbleSelect.js

@@ -0,0 +1,67 @@
+import { VisuallyHidden_default as p } from "../VisuallyHidden/VisuallyHidden.js";
+import { injectSelectRootContext as i } from "./SelectRoot.js";
+import { defineComponent as d, ref as f, watch as m, openBlock as _, createBlock as v, unref as y, withCtx as b, createElementVNode as q, mergeProps as g, renderSlot as B } from "vue";
+var S = /* @__PURE__ */ d({
+  __name: "BubbleSelect",
+  props: {
+    autocomplete: {
+      type: String,
+      required: !1
+    },
+    autofocus: {
+      type: Boolean,
+      required: !1
+    },
+    disabled: {
+      type: Boolean,
+      required: !1
+    },
+    form: {
+      type: String,
+      required: !1
+    },
+    multiple: {
+      type: Boolean,
+      required: !1
+    },
+    name: {
+      type: String,
+      required: !1
+    },
+    required: {
+      type: Boolean,
+      required: !1
+    },
+    size: {
+      type: Number,
+      required: !1
+    },
+    value: {
+      type: null,
+      required: !1
+    }
+  },
+  setup(n) {
+    const r = n, t = f(), a = i();
+    m(() => r.value, (e, l) => {
+      const s = window.HTMLSelectElement.prototype, o = Object.getOwnPropertyDescriptor(s, "value").set;
+      if (e !== l && o && t.value) {
+        const c = new Event("change", { bubbles: !0 });
+        o.call(t.value, e), t.value.dispatchEvent(c);
+      }
+    });
+    function u(e) {
+      a.onValueChange(e.target.value);
+    }
+    return (e, l) => (_(), v(y(p), { "as-child": "" }, {
+      default: b(() => [q("select", g({
+        ref_key: "selectElement",
+        ref: t
+      }, r, { onInput: u }), [B(e.$slots, "default")], 16)]),
+      _: 3
+    }));
+  }
+}), x = S;
+export {
+  x as BubbleSelect_default
+};

package/dist/modules/vendor/reka-ui/dist/Select/SelectContent.js

@@ -0,0 +1,162 @@
+import { useForwardPropsEmits as S } from "../shared/useForwardPropsEmits.js";
+import { Presence_default as P } from "../Presence/Presence.js";
+import { injectSelectRootContext as h } from "./SelectRoot.js";
+import { SelectContentImpl_default as C } from "./SelectContentImpl.js";
+import { SelectProvider_default as w } from "./SelectProvider.js";
+import { defineComponent as b, ref as n, onMounted as k, computed as N, watch as O, onUnmounted as D, openBlock as i, createBlock as c, unref as a, withCtx as s, createVNode as m, normalizeProps as F, guardReactiveProps as R, renderSlot as y, createElementBlock as T, Teleport as x, createCommentVNode as A } from "vue";
+const E = { key: 1 };
+var M = /* @__PURE__ */ b({
+  inheritAttrs: !1,
+  __name: "SelectContent",
+  props: {
+    forceMount: {
+      type: Boolean,
+      required: !1
+    },
+    position: {
+      type: String,
+      required: !1
+    },
+    bodyLock: {
+      type: Boolean,
+      required: !1
+    },
+    loop: {
+      type: Boolean,
+      required: !1
+    },
+    memoDependencies: {
+      type: Array,
+      required: !1
+    },
+    side: {
+      type: null,
+      required: !1
+    },
+    sideOffset: {
+      type: Number,
+      required: !1
+    },
+    sideFlip: {
+      type: Boolean,
+      required: !1
+    },
+    align: {
+      type: null,
+      required: !1
+    },
+    alignOffset: {
+      type: Number,
+      required: !1
+    },
+    alignFlip: {
+      type: Boolean,
+      required: !1
+    },
+    avoidCollisions: {
+      type: Boolean,
+      required: !1
+    },
+    collisionBoundary: {
+      type: null,
+      required: !1
+    },
+    collisionPadding: {
+      type: [Number, Object],
+      required: !1
+    },
+    arrowPadding: {
+      type: Number,
+      required: !1
+    },
+    hideShiftedArrow: {
+      type: Boolean,
+      required: !1
+    },
+    sticky: {
+      type: String,
+      required: !1
+    },
+    hideWhenDetached: {
+      type: Boolean,
+      required: !1
+    },
+    positionStrategy: {
+      type: String,
+      required: !1
+    },
+    updatePositionStrategy: {
+      type: String,
+      required: !1
+    },
+    disableUpdateOnLayoutShift: {
+      type: Boolean,
+      required: !1
+    },
+    prioritizePosition: {
+      type: Boolean,
+      required: !1
+    },
+    reference: {
+      type: null,
+      required: !1
+    },
+    dir: {
+      type: String,
+      required: !1
+    },
+    asChild: {
+      type: Boolean,
+      required: !1
+    },
+    as: {
+      type: null,
+      required: !1
+    },
+    disableOutsidePointerEvents: {
+      type: Boolean,
+      required: !1
+    }
+  },
+  emits: [
+    "closeAutoFocus",
+    "escapeKeyDown",
+    "pointerDownOutside"
+  ],
+  setup(q, { emit: v }) {
+    const u = q, _ = S(u, v), d = h(), o = n();
+    k(() => {
+      o.value = new DocumentFragment();
+    });
+    const p = n(), e = N(() => u.forceMount || d.open.value), f = n(e.value);
+    let t;
+    function l() {
+      t && (clearTimeout(t), t = void 0);
+    }
+    return O(e, (r, g, B) => {
+      l(), t = setTimeout(() => {
+        f.value = e.value, t = void 0;
+      }), B(l);
+    }), D(l), (r, g) => e.value || f.value || p.value?.present ? (i(), c(a(P), {
+      key: 0,
+      ref_key: "presenceRef",
+      ref: p,
+      present: e.value
+    }, {
+      default: s(() => [m(C, F(R({
+        ...a(_),
+        ...r.$attrs
+      })), {
+        default: s(() => [y(r.$slots, "default")]),
+        _: 3
+      }, 16)]),
+      _: 3
+    }, 8, ["present"])) : o.value ? (i(), T("div", E, [(i(), c(x, { to: o.value }, [m(w, { context: a(d) }, {
+      default: s(() => [y(r.$slots, "default")]),
+      _: 3
+    }, 8, ["context"])], 8, ["to"]))])) : A("v-if", !0);
+  }
+}), K = M;
+export {
+  K as SelectContent_default
+};

package/dist/modules/vendor/reka-ui/dist/Select/SelectContentImpl.js

@@ -0,0 +1,288 @@
+import { injectModalScope as T } from "../../../../lib/localModal.js";
+import { defineComponent as N, ref as a, watch as U, watchEffect as j, computed as $, openBlock as h, createBlock as x, unref as l, withCtx as c, createVNode as k, withModifiers as g, resolveDynamicComponent as H, mergeProps as z, renderSlot as G } from "vue";
+import { createContext as W } from "../shared/createContext.js";
+import { useBodyScrollLock as X } from "../shared/useBodyScrollLock.js";
+import { useFocusGuards as Y } from "../shared/useFocusGuards.js";
+import { useForwardProps as J } from "../shared/useForwardProps.js";
+import { useHideOthers as Q } from "../shared/useHideOthers.js";
+import { useTypeahead as Z, wrapArray as _ } from "../shared/useTypeahead.js";
+import { DismissableLayer_default as ee } from "../DismissableLayer/DismissableLayer.js";
+import { FocusScope_default as te } from "../FocusScope/FocusScope.js";
+import { focusFirst as F } from "../Menu/utils.js";
+import { useCollection as oe } from "../Collection/Collection.js";
+import { valueComparator as E } from "./utils.js";
+import { injectSelectRootContext as re } from "./SelectRoot.js";
+import { SelectItemAlignedPosition_default as ie } from "./SelectItemAlignedPosition.js";
+import { SelectPopperPosition_default as ne } from "./SelectPopperPosition.js";
+import { unrefElement as le } from "../../../@vueuse/core/dist/index.js";
+import { reactiveOmit as se } from "../../../@vueuse/shared/dist/index.js";
+const ke = {
+  onViewportChange: () => {
+  },
+  itemTextRefCallback: () => {
+  },
+  itemRefCallback: () => {
+  }
+}, [Fe, ae] = /* @__PURE__ */ W("SelectContent");
+var ue = /* @__PURE__ */ N({
+  __name: "SelectContentImpl",
+  props: {
+    position: {
+      type: String,
+      required: !1,
+      default: "item-aligned"
+    },
+    bodyLock: {
+      type: Boolean,
+      required: !1,
+      default: !0
+    },
+    loop: {
+      type: Boolean,
+      required: !1
+    },
+    memoDependencies: {
+      type: Array,
+      required: !1
+    },
+    side: {
+      type: null,
+      required: !1
+    },
+    sideOffset: {
+      type: Number,
+      required: !1
+    },
+    sideFlip: {
+      type: Boolean,
+      required: !1
+    },
+    align: {
+      type: null,
+      required: !1,
+      default: "start"
+    },
+    alignOffset: {
+      type: Number,
+      required: !1
+    },
+    alignFlip: {
+      type: Boolean,
+      required: !1
+    },
+    avoidCollisions: {
+      type: Boolean,
+      required: !1
+    },
+    collisionBoundary: {
+      type: null,
+      required: !1
+    },
+    collisionPadding: {
+      type: [Number, Object],
+      required: !1
+    },
+    arrowPadding: {
+      type: Number,
+      required: !1
+    },
+    hideShiftedArrow: {
+      type: Boolean,
+      required: !1
+    },
+    sticky: {
+      type: String,
+      required: !1
+    },
+    hideWhenDetached: {
+      type: Boolean,
+      required: !1
+    },
+    positionStrategy: {
+      type: String,
+      required: !1
+    },
+    updatePositionStrategy: {
+      type: String,
+      required: !1
+    },
+    disableUpdateOnLayoutShift: {
+      type: Boolean,
+      required: !1
+    },
+    prioritizePosition: {
+      type: Boolean,
+      required: !1
+    },
+    reference: {
+      type: null,
+      required: !1
+    },
+    dir: {
+      type: String,
+      required: !1
+    },
+    asChild: {
+      type: Boolean,
+      required: !1
+    },
+    as: {
+      type: null,
+      required: !1
+    },
+    disableOutsidePointerEvents: {
+      type: Boolean,
+      required: !1,
+      default: !0
+    }
+  },
+  emits: [
+    "closeAutoFocus",
+    "escapeKeyDown",
+    "pointerDownOutside"
+  ],
+  setup(m, { emit: A }) {
+    const u = m, y = A, n = re(), p = T();
+    Y(), X(u.bodyLock);
+    const { CollectionSlot: B, getItems: C } = oe(), s = a();
+    Q(s);
+    const { search: w, handleTypeaheadSearch: O } = Z(), q = a(), d = a(), b = a(), v = a(!1), S = a(!1), D = a(!1);
+    function P() {
+      d.value && s.value && F([d.value, s.value]);
+    }
+    U(v, () => {
+      (!p || p.canFocus()) && P();
+    });
+    const { onOpenChange: L, triggerPointerDownPosRef: f } = n;
+    j((e) => {
+      if (!s.value) return;
+      let t = {
+        x: 0,
+        y: 0
+      };
+      const o = (i) => {
+        t = {
+          x: Math.abs(Math.round(i.pageX) - (f.value?.x ?? 0)),
+          y: Math.abs(Math.round(i.pageY) - (f.value?.y ?? 0))
+        };
+      }, r = (i) => {
+        i.pointerType !== "touch" && (t.x <= 10 && t.y <= 10 ? i.preventDefault() : s.value?.contains(i.target) || L(!1), document.removeEventListener("pointermove", o), f.value = null);
+      };
+      f.value !== null && (document.addEventListener("pointermove", o), document.addEventListener("pointerup", r, {
+        capture: !0,
+        once: !0
+      })), e(() => {
+        document.removeEventListener("pointermove", o), document.removeEventListener("pointerup", r, { capture: !0 });
+      });
+    });
+    function K(e) {
+      const t = e.ctrlKey || e.altKey || e.metaKey;
+      if (e.key === "Tab" && e.preventDefault(), e.code === "Space") {
+        if (w.value === "") return;
+        e.preventDefault();
+      }
+      if (!t && e.key.length === 1 && O(e.key, C()), [
+        "ArrowUp",
+        "ArrowDown",
+        "Home",
+        "End"
+      ].includes(e.key)) {
+        let r = [...C().map((i) => i.ref)];
+        if (["ArrowUp", "End"].includes(e.key) && (r = r.slice().reverse()), ["ArrowUp", "ArrowDown"].includes(e.key)) {
+          const i = e.target, I = r.indexOf(i);
+          r = u.loop ? _(r, I + 1) : r.slice(I + 1);
+        }
+        setTimeout(() => F(r)), e.preventDefault();
+      }
+    }
+    const M = se(u, "loop"), R = $(() => u.position === "popper" ? M : {}), V = J(R.value);
+    return ae({
+      content: s,
+      viewport: q,
+      onViewportChange: (e) => {
+        q.value = e;
+      },
+      itemRefCallback: (e, t, o) => {
+        const r = !S.value && !o, i = E(n.modelValue.value, t, n.by);
+        if (n.multiple.value) {
+          if (D.value) return;
+          (i || r) && (d.value = e, i && (D.value = !0));
+        } else (i || r) && (d.value = e);
+        r && (S.value = !0);
+      },
+      selectedItem: d,
+      selectedItemText: b,
+      onItemLeave: () => {
+        s.value?.focus();
+      },
+      itemTextRefCallback: (e, t, o) => {
+        const r = !S.value && !o;
+        (E(n.modelValue.value, t, n.by) || r) && (b.value = e);
+      },
+      focusSelectedItem: P,
+      position: u.position,
+      isPositioned: v,
+      searchRef: w
+    }), (e, t) => (h(), x(l(B), null, {
+      default: c(() => [k(l(te), {
+        "as-child": "",
+        onMountAutoFocus: t[6] || (t[6] = g(() => {
+        }, ["prevent"])),
+        onUnmountAutoFocus: t[7] || (t[7] = (o) => {
+          y("closeAutoFocus", o), !o.defaultPrevented && (p ? p.restoreFocus(l(n).triggerElement.value) : l(n).triggerElement.value?.focus({ preventScroll: !0 }), o.preventDefault());
+        })
+      }, {
+        default: c(() => [k(l(ee), {
+          "as-child": "",
+          "disable-outside-pointer-events": m.disableOutsidePointerEvents,
+          onFocusOutside: t[2] || (t[2] = g(() => {
+          }, ["prevent"])),
+          onDismiss: t[3] || (t[3] = (o) => l(n).onOpenChange(!1)),
+          onEscapeKeyDown: t[4] || (t[4] = (o) => y("escapeKeyDown", o)),
+          onPointerDownOutside: t[5] || (t[5] = (o) => y("pointerDownOutside", o))
+        }, {
+          default: c(() => [(h(), x(H(m.position === "popper" ? ne : ie), z({
+            ...e.$attrs,
+            ...l(V)
+          }, {
+            id: l(n).contentId,
+            ref: (o) => {
+              if (!o) return;
+              const r = l(le)(o);
+              r?.hasAttribute("data-reka-popper-content-wrapper") ? s.value = r.firstElementChild : s.value = r;
+            },
+            role: "listbox",
+            "data-state": l(n).open.value ? "open" : "closed",
+            dir: l(n).dir.value,
+            style: {
+              display: "flex",
+              flexDirection: "column",
+              outline: "none"
+            },
+            onContextmenu: t[0] || (t[0] = g(() => {
+            }, ["prevent"])),
+            onPlaced: t[1] || (t[1] = (o) => v.value = !0),
+            onKeydown: K
+          }), {
+            default: c(() => [G(e.$slots, "default")]),
+            _: 3
+          }, 16, [
+            "id",
+            "data-state",
+            "dir",
+            "onKeydown"
+          ]))]),
+          _: 3
+        }, 8, ["disable-outside-pointer-events"])]),
+        _: 3
+      })]),
+      _: 3
+    }));
+  }
+}), Ee = ue;
+export {
+  ke as SelectContentDefaultContextValue,
+  Ee as SelectContentImpl_default,
+  Fe as injectSelectContentContext,
+  ae as provideSelectContentContext
+};

package/dist/modules/vendor/reka-ui/dist/Select/SelectGroup.js

@@ -0,0 +1,29 @@
+import { createContext as p } from "../shared/createContext.js";
+import { useId as u } from "../shared/useId.js";
+import { Primitive as a } from "../Primitive/Primitive.js";
+import { defineComponent as i, openBlock as n, createBlock as c, unref as r, mergeProps as s, withCtx as d, renderSlot as _ } from "vue";
+const [y, f] = /* @__PURE__ */ p("SelectGroup");
+var m = /* @__PURE__ */ i({
+  __name: "SelectGroup",
+  props: {
+    asChild: {
+      type: Boolean,
+      required: !1
+    },
+    as: {
+      type: null,
+      required: !1
+    }
+  },
+  setup(t) {
+    const o = t, e = u(void 0, "reka-select-group");
+    return f({ id: e }), (l, v) => (n(), c(r(a), s({ role: "group" }, o, { "aria-labelledby": r(e) }), {
+      default: d(() => [_(l.$slots, "default")]),
+      _: 3
+    }, 16, ["aria-labelledby"]));
+  }
+}), b = m;
+export {
+  b as SelectGroup_default,
+  y as injectSelectGroupContext
+};