@synopackageland/ui 0.25.21 → 0.25.22

package/dist/modules/vendor/reka-ui/dist/Menu/MenuContentImpl.js

@@ -0,0 +1,305 @@
+import { createContext as H } from "../shared/createContext.js";
+import { getActiveElement as h } from "../shared/getActiveElement.js";
+import { useArrowNavigation as k } from "../shared/useArrowNavigation.js";
+import { useBodyScrollLock as J } from "../shared/useBodyScrollLock.js";
+import { useFocusGuards as Q } from "../shared/useFocusGuards.js";
+import { useForwardExpose as Z } from "../shared/useForwardExpose.js";
+import { useTypeahead as _ } from "../shared/useTypeahead.js";
+import { DismissableLayer_default as ee } from "../DismissableLayer/DismissableLayer.js";
+import { FocusScope_default as te } from "../FocusScope/FocusScope.js";
+import { getOpenState as oe, isPointerInGraceArea as ne, isMouseEvent as B, FIRST_LAST_KEYS as ie, LAST_KEYS as re, focusFirst as ae } from "./utils.js";
+import { PopperContent_default as se, PopperContentPropsDefaultValue as ue } from "../Popper/PopperContent.js";
+import { RovingFocusGroup_default as le } from "../RovingFocus/RovingFocusGroup.js";
+import { injectMenuContext as de, injectMenuRootContext as fe } from "./MenuRoot.js";
+import { defineComponent as ce, toRefs as pe, ref as r, watch as E, onUnmounted as me, openBlock as ye, createBlock as ge, unref as i, withCtx as c, createVNode as C, renderSlot as ve, mergeDefaults as we } from "vue";
+const [Me, he] = /* @__PURE__ */ H("MenuContent");
+var Ce = /* @__PURE__ */ ce({
+  __name: "MenuContentImpl",
+  props: /* @__PURE__ */ we({
+    loop: {
+      type: Boolean,
+      required: !1
+    },
+    disableOutsidePointerEvents: {
+      type: Boolean,
+      required: !1
+    },
+    disableOutsideScroll: {
+      type: Boolean,
+      required: !1
+    },
+    trapFocus: {
+      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
+    },
+    asChild: {
+      type: Boolean,
+      required: !1
+    },
+    as: {
+      type: null,
+      required: !1
+    }
+  }, { ...ue }),
+  emits: [
+    "escapeKeyDown",
+    "pointerDownOutside",
+    "focusOutside",
+    "interactOutside",
+    "entryFocus",
+    "openAutoFocus",
+    "closeAutoFocus",
+    "dismiss"
+  ],
+  setup(n, { emit: K }) {
+    const A = n, a = K, F = de(), s = fe(), { trapFocus: M, disableOutsidePointerEvents: b, loop: p } = pe(A);
+    Q(), J(b.value);
+    const q = r(""), P = r(0), R = r(0), m = r(null), S = r("right"), y = r(0), g = r(null), D = r(), { forwardRef: x, currentElement: u } = Z(), { handleTypeaheadSearch: N } = _(), l = r();
+    function G(e) {
+      const t = k(e, l.value || h(), u.value, {
+        loop: p.value,
+        arrowKeyOptions: "vertical",
+        dir: s?.dir.value,
+        focus: !1,
+        attributeName: "[data-reka-collection-item]:not([data-disabled])"
+      });
+      t && (l.value = t, t.scrollIntoView({ block: "nearest" }));
+    }
+    function L() {
+      l.value && l.value.click();
+    }
+    const f = r(), d = r();
+    E(l, (e) => {
+      if (d.value && (e === void 0 || e !== d.value.trigger.value)) {
+        if (e === void 0) return;
+        d.value.onOpenChange(!1), d.value = void 0;
+      }
+    }), E(u, (e) => {
+      F.onContentChange(e);
+    }), me(() => {
+      window.clearTimeout(P.value);
+    });
+    function v(e) {
+      return S.value === m.value?.side && ne(e, m.value?.area);
+    }
+    async function U(e) {
+      a("openAutoFocus", e), !e.defaultPrevented && (e.preventDefault(), u.value?.focus({ preventScroll: !0 }));
+    }
+    function X(e) {
+      if (e.defaultPrevented) return;
+      const t = e.target, o = t.closest("[data-reka-menu-content]") === e.currentTarget, w = ["input", "textarea"].includes(t.tagName.toLowerCase()), W = e.ctrlKey || e.altKey || e.metaKey, Y = e.key.length === 1, O = k(e, h(), u.value, {
+        loop: p.value,
+        arrowKeyOptions: "vertical",
+        dir: s?.dir.value,
+        focus: !0,
+        attributeName: "[data-reka-collection-item]:not([data-disabled])"
+      });
+      if (O) return O?.focus();
+      if (e.code === "Space") return;
+      const I = D.value?.getItems() ?? [];
+      if (o && (e.key === "Tab" && s.modal.value && e.preventDefault(), !W && Y && !w && N(e.key, I)), e.target !== u.value || !ie.includes(e.key)) return;
+      e.preventDefault();
+      const T = [...I.map(($) => $.ref)];
+      re.includes(e.key) && T.reverse(), ae(T);
+    }
+    function j(e) {
+      e?.currentTarget?.contains?.(e.target) || (window.clearTimeout(P.value), q.value = "");
+    }
+    function z(e) {
+      if (!B(e)) return;
+      const t = e.target, o = y.value !== e.clientX;
+      if (e?.currentTarget?.contains(t) && o) {
+        const w = e.clientX > y.value ? "right" : "left";
+        S.value = w, y.value = e.clientX;
+      }
+    }
+    function V(e) {
+      B(e) && f.value && f.value.focus();
+    }
+    return he({
+      onItemEnter: (e) => !!v(e),
+      onItemLeave: (e) => v(e) ? !0 : (["INPUT", "TEXTAREA"].includes(h()?.tagName || "") || u.value?.focus(), g.value = null, !1),
+      onTriggerLeave: (e) => !!v(e),
+      searchRef: q,
+      highlightedElement: l,
+      onKeydownNavigation: G,
+      onKeydownEnter: L,
+      filterElement: f,
+      onFilterElementChange: (e) => {
+        f.value = e;
+      },
+      activeSubmenuContext: d,
+      pointerGraceTimerRef: R,
+      onPointerGraceIntentChange: (e) => {
+        m.value = e;
+      }
+    }), (e, t) => (ye(), ge(i(te), {
+      "as-child": "",
+      trapped: i(M),
+      onMountAutoFocus: U,
+      onUnmountAutoFocus: t[7] || (t[7] = (o) => a("closeAutoFocus", o))
+    }, {
+      default: c(() => [C(i(ee), {
+        "as-child": "",
+        "disable-outside-pointer-events": i(b),
+        onEscapeKeyDown: t[2] || (t[2] = (o) => a("escapeKeyDown", o)),
+        onPointerDownOutside: t[3] || (t[3] = (o) => a("pointerDownOutside", o)),
+        onFocusOutside: t[4] || (t[4] = (o) => a("focusOutside", o)),
+        onInteractOutside: t[5] || (t[5] = (o) => a("interactOutside", o)),
+        onDismiss: t[6] || (t[6] = (o) => a("dismiss"))
+      }, {
+        default: c(() => [C(i(le), {
+          ref_key: "rovingFocusGroupRef",
+          ref: D,
+          "current-tab-stop-id": g.value,
+          "onUpdate:currentTabStopId": t[0] || (t[0] = (o) => g.value = o),
+          "as-child": "",
+          orientation: "vertical",
+          dir: i(s).dir.value,
+          loop: i(p),
+          onEntryFocus: t[1] || (t[1] = (o) => {
+            a("entryFocus", o), i(s).isUsingKeyboardRef.value || o.preventDefault();
+          })
+        }, {
+          default: c(() => [C(i(se), {
+            ref: i(x),
+            role: "menu",
+            as: n.as,
+            "as-child": n.asChild,
+            "aria-orientation": "vertical",
+            "data-reka-menu-content": "",
+            "data-state": i(oe)(i(F).open.value),
+            dir: i(s).dir.value,
+            side: n.side,
+            "side-offset": n.sideOffset,
+            align: n.align,
+            "align-offset": n.alignOffset,
+            "avoid-collisions": n.avoidCollisions,
+            "collision-boundary": n.collisionBoundary,
+            "collision-padding": n.collisionPadding,
+            "arrow-padding": n.arrowPadding,
+            "prioritize-position": n.prioritizePosition,
+            "position-strategy": n.positionStrategy,
+            "update-position-strategy": n.updatePositionStrategy,
+            sticky: n.sticky,
+            "hide-when-detached": n.hideWhenDetached,
+            reference: n.reference,
+            onKeydown: X,
+            onBlur: j,
+            onPointermove: z,
+            onPointerenter: V
+          }, {
+            default: c(() => [ve(e.$slots, "default")]),
+            _: 3
+          }, 8, [
+            "as",
+            "as-child",
+            "data-state",
+            "dir",
+            "side",
+            "side-offset",
+            "align",
+            "align-offset",
+            "avoid-collisions",
+            "collision-boundary",
+            "collision-padding",
+            "arrow-padding",
+            "prioritize-position",
+            "position-strategy",
+            "update-position-strategy",
+            "sticky",
+            "hide-when-detached",
+            "reference"
+          ])]),
+          _: 3
+        }, 8, [
+          "current-tab-stop-id",
+          "dir",
+          "loop"
+        ])]),
+        _: 3
+      }, 8, ["disable-outside-pointer-events"])]),
+      _: 3
+    }, 8, ["trapped"]));
+  }
+}), Re = Ce;
+export {
+  Re as MenuContentImpl_default,
+  Me as injectMenuContentContext
+};

package/dist/modules/vendor/reka-ui/dist/Menu/MenuGroup.js

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

package/dist/modules/vendor/reka-ui/dist/Menu/MenuItem.js

@@ -0,0 +1,61 @@
+import { useForwardExpose as y } from "../shared/useForwardExpose.js";
+import { SELECTION_KEYS as v, ITEM_SELECT as E } from "./utils.js";
+import { injectMenuRootContext as w } from "./MenuRoot.js";
+import { injectMenuContentContext as x } from "./MenuContentImpl.js";
+import { MenuItemImpl_default as k } from "./MenuItemImpl.js";
+import { defineComponent as I, ref as _, openBlock as b, createBlock as M, mergeProps as S, unref as o, nextTick as i, withCtx as T, renderSlot as g } from "vue";
+var P = /* @__PURE__ */ I({
+  __name: "MenuItem",
+  props: {
+    disabled: {
+      type: Boolean,
+      required: !1
+    },
+    textValue: {
+      type: String,
+      required: !1
+    },
+    asChild: {
+      type: Boolean,
+      required: !1
+    },
+    as: {
+      type: null,
+      required: !1
+    }
+  },
+  emits: ["select"],
+  setup(l, { emit: s }) {
+    const u = l, a = s, { forwardRef: f, currentElement: d } = y(), m = w(), c = x(), n = _(!1);
+    async function p() {
+      const r = d.value;
+      if (!u.disabled && r) {
+        const e = new CustomEvent(E, {
+          bubbles: !0,
+          cancelable: !0
+        });
+        a("select", e), await i(), e.defaultPrevented ? n.value = !1 : m.onClose();
+      }
+    }
+    return (r, e) => (b(), M(k, S(u, {
+      ref: o(f),
+      onClick: p,
+      onPointerdown: e[0] || (e[0] = () => {
+        n.value = !0;
+      }),
+      onPointerup: e[1] || (e[1] = async (t) => {
+        await i(), !t.defaultPrevented && (n.value || t.currentTarget?.click());
+      }),
+      onKeydown: e[2] || (e[2] = async (t) => {
+        const C = o(c).searchRef.value !== "";
+        l.disabled || C && t.key === " " || o(v).includes(t.key) && (t.currentTarget?.click(), t.preventDefault());
+      })
+    }), {
+      default: T(() => [g(r.$slots, "default")]),
+      _: 3
+    }, 16));
+  }
+}), L = P;
+export {
+  L as MenuItem_default
+};

package/dist/modules/vendor/reka-ui/dist/Menu/MenuItemImpl.js

@@ -0,0 +1,80 @@
+import { getActiveElement as E } from "../shared/getActiveElement.js";
+import { useForwardExpose as I } from "../shared/useForwardExpose.js";
+import { Primitive as P } from "../Primitive/Primitive.js";
+import { isMouseEvent as s } from "./utils.js";
+import { useCollection as b } from "../Collection/Collection.js";
+import { injectMenuContentContext as x } from "./MenuContentImpl.js";
+import { defineComponent as y, ref as C, computed as M, openBlock as T, createBlock as w, unref as r, withCtx as m, createVNode as B, mergeProps as F, nextTick as o, renderSlot as S } from "vue";
+var q = /* @__PURE__ */ y({
+  inheritAttrs: !1,
+  __name: "MenuItemImpl",
+  props: {
+    disabled: {
+      type: Boolean,
+      required: !1
+    },
+    textValue: {
+      type: String,
+      required: !1
+    },
+    asChild: {
+      type: Boolean,
+      required: !1
+    },
+    as: {
+      type: null,
+      required: !1
+    }
+  },
+  setup(a) {
+    const f = a, t = x(), { forwardRef: v, currentElement: n } = I(), { CollectionItem: c } = b(), u = C(!1), h = M(() => u.value || n.value != null && t.highlightedElement.value === n.value);
+    async function g(e) {
+      if (!(e.defaultPrevented || !s(e))) {
+        if (f.disabled) t.onItemLeave(e);
+        else if (!t.onItemEnter(e)) {
+          const i = e.currentTarget;
+          t.highlightedElement.value = i, ["INPUT", "TEXTAREA"].includes(E()?.tagName || "") || i.focus({ preventScroll: !0 });
+        }
+      }
+    }
+    async function p(e) {
+      if (await o(), e.defaultPrevented || !s(e) || t.highlightedElement.value !== n.value) return;
+      !t.onItemLeave(e) && t.highlightedElement.value === n.value && (t.highlightedElement.value = void 0);
+    }
+    return (e, l) => (T(), w(r(c), { value: { textValue: a.textValue } }, {
+      default: m(() => [B(r(P), F({
+        ref: r(v),
+        role: "menuitem",
+        tabindex: "-1"
+      }, e.$attrs, {
+        as: a.as,
+        "as-child": a.asChild,
+        "aria-disabled": a.disabled || void 0,
+        "data-disabled": a.disabled ? "" : void 0,
+        "data-highlighted": h.value ? "" : void 0,
+        onPointermove: g,
+        onPointerleave: p,
+        onFocus: l[0] || (l[0] = async (i) => {
+          const d = i.currentTarget;
+          await o(), !(i.defaultPrevented || a.disabled) && (u.value = !0, r(t).highlightedElement.value = d);
+        }),
+        onBlur: l[1] || (l[1] = async (i) => {
+          await o(), !i.defaultPrevented && (u.value = !1);
+        })
+      }), {
+        default: m(() => [S(e.$slots, "default")]),
+        _: 3
+      }, 16, [
+        "as",
+        "as-child",
+        "aria-disabled",
+        "data-disabled",
+        "data-highlighted"
+      ])]),
+      _: 3
+    }, 8, ["value"]));
+  }
+}), j = q;
+export {
+  j as MenuItemImpl_default
+};

package/dist/modules/vendor/reka-ui/dist/Menu/MenuItemIndicator.js

@@ -0,0 +1,46 @@
+import { createContext as n } from "../shared/createContext.js";
+import { Presence_default as u } from "../Presence/Presence.js";
+import { Primitive as l } from "../Primitive/Primitive.js";
+import { isIndeterminate as d, getCheckedState as i } from "./utils.js";
+import { defineComponent as m, ref as c, openBlock as s, createBlock as f, unref as e, withCtx as o, createVNode as p, renderSlot as I } from "vue";
+const [C, y] = /* @__PURE__ */ n(["MenuCheckboxItem", "MenuRadioItem"], "MenuItemIndicatorContext");
+var _ = /* @__PURE__ */ m({
+  __name: "MenuItemIndicator",
+  props: {
+    forceMount: {
+      type: Boolean,
+      required: !1
+    },
+    asChild: {
+      type: Boolean,
+      required: !1
+    },
+    as: {
+      type: null,
+      required: !1,
+      default: "span"
+    }
+  },
+  setup(t) {
+    const a = C({ modelValue: c(!1) });
+    return (r, M) => (s(), f(e(u), { present: t.forceMount || e(d)(e(a).modelValue.value) || e(a).modelValue.value === !0 }, {
+      default: o(() => [p(e(l), {
+        as: t.as,
+        "as-child": t.asChild,
+        "data-state": e(i)(e(a).modelValue.value)
+      }, {
+        default: o(() => [I(r.$slots, "default")]),
+        _: 3
+      }, 8, [
+        "as",
+        "as-child",
+        "data-state"
+      ])]),
+      _: 3
+    }, 8, ["present"]));
+  }
+}), B = _;
+export {
+  B as MenuItemIndicator_default,
+  y as provideMenuItemIndicatorContext
+};

package/dist/modules/vendor/reka-ui/dist/Menu/MenuPortal.js

@@ -0,0 +1,33 @@
+import { Teleport_default as o } from "../Teleport/Teleport.js";
+import { defineComponent as a, openBlock as l, createBlock as u, unref as n, normalizeProps as p, guardReactiveProps as d, withCtx as f, renderSlot as s } from "vue";
+var _ = /* @__PURE__ */ a({
+  __name: "MenuPortal",
+  props: {
+    to: {
+      type: null,
+      required: !1
+    },
+    disabled: {
+      type: Boolean,
+      required: !1
+    },
+    defer: {
+      type: Boolean,
+      required: !1
+    },
+    forceMount: {
+      type: Boolean,
+      required: !1
+    }
+  },
+  setup(e) {
+    const r = e;
+    return (t, i) => (l(), u(n(o), p(d(r)), {
+      default: f(() => [s(t.$slots, "default")]),
+      _: 3
+    }, 16));
+  }
+}), v = _;
+export {
+  v as MenuPortal_default
+};

package/dist/modules/vendor/reka-ui/dist/Menu/MenuRadioGroup.js

@@ -0,0 +1,42 @@
+import { createContext as p } from "../shared/createContext.js";
+import { useForwardProps as i } from "../shared/useForwardProps.js";
+import { MenuGroup_default as s } from "./MenuGroup.js";
+import { defineComponent as m, openBlock as f, createBlock as c, normalizeProps as _, guardReactiveProps as v, unref as t, withCtx as M, renderSlot as V } from "vue";
+import { useVModel as C } from "../../../@vueuse/core/dist/index.js";
+import { reactiveOmit as G } from "../../../@vueuse/shared/dist/index.js";
+const [k, R] = /* @__PURE__ */ p("MenuRadioGroup");
+var x = /* @__PURE__ */ m({
+  __name: "MenuRadioGroup",
+  props: {
+    modelValue: {
+      type: null,
+      required: !1,
+      default: ""
+    },
+    asChild: {
+      type: Boolean,
+      required: !1
+    },
+    as: {
+      type: null,
+      required: !1
+    }
+  },
+  emits: ["update:modelValue"],
+  setup(u, { emit: a }) {
+    const r = u, l = a, d = G(r, ["modelValue"]), n = i(d), e = C(r, "modelValue", l);
+    return R({
+      modelValue: e,
+      onValueChange: (o) => {
+        e.value = o;
+      }
+    }), (o, g) => (f(), c(s, _(v(t(n))), {
+      default: M(() => [V(o.$slots, "default", { modelValue: t(e) })]),
+      _: 3
+    }, 16));
+  }
+}), j = x;
+export {
+  j as MenuRadioGroup_default,
+  k as injectMenuRadioGroupContext
+};

package/dist/modules/vendor/reka-ui/dist/Menu/MenuRadioItem.js

@@ -0,0 +1,49 @@
+import { useForwardProps as c } from "../shared/useForwardProps.js";
+import { getCheckedState as f } from "./utils.js";
+import { MenuItem_default as v } from "./MenuItem.js";
+import { provideMenuItemIndicatorContext as _ } from "./MenuItemIndicator.js";
+import { injectMenuRadioGroupContext as C } from "./MenuRadioGroup.js";
+import { defineComponent as y, toRefs as g, computed as h, openBlock as k, createBlock as x, mergeProps as I, unref as t, withCtx as M, renderSlot as q } from "vue";
+import { reactiveOmit as R } from "../../../@vueuse/shared/dist/index.js";
+var B = /* @__PURE__ */ y({
+  __name: "MenuRadioItem",
+  props: {
+    value: {
+      type: null,
+      required: !0
+    },
+    disabled: {
+      type: Boolean,
+      required: !1
+    },
+    textValue: {
+      type: String,
+      required: !1
+    },
+    asChild: {
+      type: Boolean,
+      required: !1
+    },
+    as: {
+      type: null,
+      required: !1
+    }
+  },
+  emits: ["select"],
+  setup(l, { emit: n }) {
+    const o = l, d = n, i = R(o, ["value"]), s = c(i), { value: r } = g(o), a = C(), e = h(() => a.modelValue.value === r?.value);
+    return _({ modelValue: e }), (m, u) => (k(), x(v, I({ role: "menuitemradio" }, t(s), {
+      "aria-checked": e.value,
+      "data-state": t(f)(e.value),
+      onSelect: u[0] || (u[0] = async (p) => {
+        d("select", p), t(a).onValueChange(t(r));
+      })
+    }), {
+      default: M(() => [q(m.$slots, "default", { checked: e.value })]),
+      _: 3
+    }, 16, ["aria-checked", "data-state"]));
+  }
+}), F = B;
+export {
+  F as MenuRadioItem_default
+};