@orchidui/dashboard 1.8.1-93 → 1.8.1-96

package/dist/MenuSubTrigger-CUrxnPwO.js

@@ -0,0 +1,845 @@
+import { ref as _, onMounted as Ce, defineComponent as P, toRefs as H, createBlock as h, openBlock as b, unref as e, withCtx as y, renderSlot as w, mergeDefaults as he, watch as be, onUnmounted as ae, createVNode as k, mergeProps as B, nextTick as F, withModifiers as X, normalizeProps as T, guardReactiveProps as x, computed as we, watchEffect as Pe } from "vue";
+import { g as _e, e as ne, u as U } from "./index-BwPb_idr.js";
+import { g as se, i as Be, a as E, F as Me, L as Oe, f as Ie, S as Se, I as $e, b as Y, c as q, d as ke, e as De } from "./utils-DxQ_ywGa.js";
+import { u as z } from "./useForwardPropsEmits-0XKBv1pB.js";
+import { u as K } from "./useForwardExpose-DZT6mL_U.js";
+import { a as Fe, u as Te } from "./useBodyScrollLock-CazCRZjZ.js";
+import { P as J } from "./Presence-CxfTrw6l.js";
+import { P as V } from "./Primitive-B3twiLO1.js";
+import { _ as Re } from "./Teleport-DnUewq5H.js";
+import { c as R } from "./createContext-CZEfaSVa.js";
+import { u as ie } from "./useId-reAg216X.js";
+import { _ as re, a as Ee, P as Ke, b as Ve } from "./PopperContent-BT3Svcc3.js";
+import { u as Ae } from "./Collection-COudIl-A.js";
+import { u as Le } from "./useDirection-C3C_TLKm.js";
+import { u as Ge } from "./useFocusGuards-CyjC9cG9.js";
+import { u as xe } from "./useTypeahead-oSidjyFF.js";
+import { _ as Ue } from "./FocusScope--pJ6bboI.js";
+import { _ as ze } from "./DismissableLayer-C7IJliOb.js";
+import { _ as je } from "./RovingFocusGroup-0OHdFQl0.js";
+import { u as Ne } from "./useArrowNavigation-BRMPveaB.js";
+import { g as We } from "./getActiveElement-B-HWdUIb.js";
+function Xe() {
+  const r = _(!1);
+  return Ce(() => {
+    ne("keydown", () => {
+      r.value = !0;
+    }, { capture: !0, passive: !0 }), ne(["pointerdown", "pointermove"], () => {
+      r.value = !1;
+    }, { capture: !0, passive: !0 });
+  }), r;
+}
+const Ye = _e(Xe), [D, le] = R(["MenuRoot", "MenuSub"], "MenuContext"), [A, He] = R("MenuRoot"), Ot = /* @__PURE__ */ P({
+  __name: "MenuRoot",
+  props: {
+    open: { type: Boolean, default: !1 },
+    dir: {},
+    modal: { type: Boolean, default: !0 }
+  },
+  emits: ["update:open"],
+  setup(r, { emit: i }) {
+    const o = r, c = i, { modal: s, dir: n } = H(o), p = Le(n), l = U(o, "open", c), a = _(), C = Ye();
+    return le({
+      open: l,
+      onOpenChange: (m) => {
+        l.value = m;
+      },
+      content: a,
+      onContentChange: (m) => {
+        a.value = m;
+      }
+    }), He({
+      onClose: () => {
+        l.value = !1;
+      },
+      isUsingKeyboardRef: C,
+      dir: p,
+      modal: s
+    }), (m, d) => (b(), h(e(re), null, {
+      default: y(() => [
+        w(m.$slots, "default")
+      ]),
+      _: 3
+    }));
+  }
+}), [Q, qe] = R("MenuContent"), Z = /* @__PURE__ */ P({
+  __name: "MenuContentImpl",
+  props: /* @__PURE__ */ he({
+    loop: { type: Boolean },
+    disableOutsidePointerEvents: { type: Boolean },
+    disableOutsideScroll: { type: Boolean },
+    trapFocus: { type: Boolean },
+    side: {},
+    sideOffset: {},
+    align: {},
+    alignOffset: {},
+    avoidCollisions: { type: Boolean },
+    collisionBoundary: {},
+    collisionPadding: {},
+    arrowPadding: {},
+    sticky: {},
+    hideWhenDetached: { type: Boolean },
+    positionStrategy: {},
+    updatePositionStrategy: {},
+    disableUpdateOnLayoutShift: { type: Boolean },
+    prioritizePosition: { type: Boolean },
+    reference: {},
+    asChild: { type: Boolean },
+    as: {}
+  }, {
+    ...Ke
+  }),
+  emits: ["escapeKeyDown", "pointerDownOutside", "focusOutside", "interactOutside", "entryFocus", "openAutoFocus", "closeAutoFocus", "dismiss"],
+  setup(r, { emit: i }) {
+    const o = r, c = i, s = D(), n = A(), { trapFocus: p, disableOutsidePointerEvents: l, loop: a } = H(o);
+    Ge(), Fe(l.value);
+    const C = _(""), m = _(0), d = _(0), u = _(null), g = _("right"), M = _(0), O = _(null), I = _(), { forwardRef: j, currentElement: S } = K(), { handleTypeaheadSearch: L } = xe();
+    be(S, (t) => {
+      s.onContentChange(t);
+    }), ae(() => {
+      window.clearTimeout(m.value);
+    });
+    function N(t) {
+      var v, $;
+      return g.value === ((v = u.value) == null ? void 0 : v.side) && Be(t, ($ = u.value) == null ? void 0 : $.area);
+    }
+    async function fe(t) {
+      var f;
+      c("openAutoFocus", t), !t.defaultPrevented && (t.preventDefault(), (f = S.value) == null || f.focus({
+        preventScroll: !0
+      }));
+    }
+    function me(t) {
+      var oe;
+      if (t.defaultPrevented)
+        return;
+      const v = t.target.closest("[data-reka-menu-content]") === t.currentTarget, $ = t.ctrlKey || t.altKey || t.metaKey, W = t.key.length === 1, G = Ne(
+        t,
+        We(),
+        S.value,
+        {
+          loop: a.value,
+          arrowKeyOptions: "vertical",
+          dir: n == null ? void 0 : n.dir.value,
+          focus: !0,
+          attributeName: "[data-reka-collection-item]:not([data-disabled])"
+        }
+      );
+      if (G)
+        return G == null ? void 0 : G.focus();
+      if (t.code === "Space")
+        return;
+      const ee = ((oe = I.value) == null ? void 0 : oe.getItems()) ?? [];
+      if (v && (t.key === "Tab" && t.preventDefault(), !$ && W && L(t.key, ee)), t.target !== S.value || !Me.includes(t.key))
+        return;
+      t.preventDefault();
+      const te = [...ee.map((ve) => ve.ref)];
+      Oe.includes(t.key) && te.reverse(), Ie(te);
+    }
+    function ye(t) {
+      var f, v;
+      (v = (f = t == null ? void 0 : t.currentTarget) == null ? void 0 : f.contains) != null && v.call(f, t.target) || (window.clearTimeout(m.value), C.value = "");
+    }
+    function ge(t) {
+      var $;
+      if (!E(t))
+        return;
+      const f = t.target, v = M.value !== t.clientX;
+      if (($ = t == null ? void 0 : t.currentTarget) != null && $.contains(f) && v) {
+        const W = t.clientX > M.value ? "right" : "left";
+        g.value = W, M.value = t.clientX;
+      }
+    }
+    return qe({
+      onItemEnter: (t) => !!N(t),
+      onItemLeave: (t) => {
+        var f;
+        N(t) || ((f = S.value) == null || f.focus(), O.value = null);
+      },
+      onTriggerLeave: (t) => !!N(t),
+      searchRef: C,
+      pointerGraceTimerRef: d,
+      onPointerGraceIntentChange: (t) => {
+        u.value = t;
+      }
+    }), (t, f) => (b(), h(e(Ue), {
+      "as-child": "",
+      trapped: e(p),
+      onMountAutoFocus: fe,
+      onUnmountAutoFocus: f[7] || (f[7] = (v) => c("closeAutoFocus", v))
+    }, {
+      default: y(() => [
+        k(e(ze), {
+          "as-child": "",
+          "disable-outside-pointer-events": e(l),
+          onEscapeKeyDown: f[2] || (f[2] = (v) => c("escapeKeyDown", v)),
+          onPointerDownOutside: f[3] || (f[3] = (v) => c("pointerDownOutside", v)),
+          onFocusOutside: f[4] || (f[4] = (v) => c("focusOutside", v)),
+          onInteractOutside: f[5] || (f[5] = (v) => c("interactOutside", v)),
+          onDismiss: f[6] || (f[6] = (v) => c("dismiss"))
+        }, {
+          default: y(() => [
+            k(e(je), {
+              ref_key: "rovingFocusGroupRef",
+              ref: I,
+              "current-tab-stop-id": O.value,
+              "onUpdate:currentTabStopId": f[0] || (f[0] = (v) => O.value = v),
+              "as-child": "",
+              orientation: "vertical",
+              dir: e(n).dir.value,
+              loop: e(a),
+              onEntryFocus: f[1] || (f[1] = (v) => {
+                c("entryFocus", v), e(n).isUsingKeyboardRef.value || v.preventDefault();
+              })
+            }, {
+              default: y(() => [
+                k(e(Ee), {
+                  ref: e(j),
+                  role: "menu",
+                  as: t.as,
+                  "as-child": t.asChild,
+                  "aria-orientation": "vertical",
+                  "data-reka-menu-content": "",
+                  "data-state": e(se)(e(s).open.value),
+                  dir: e(n).dir.value,
+                  side: t.side,
+                  "side-offset": t.sideOffset,
+                  align: t.align,
+                  "align-offset": t.alignOffset,
+                  "avoid-collisions": t.avoidCollisions,
+                  "collision-boundary": t.collisionBoundary,
+                  "collision-padding": t.collisionPadding,
+                  "arrow-padding": t.arrowPadding,
+                  "prioritize-position": t.prioritizePosition,
+                  "position-strategy": t.positionStrategy,
+                  "update-position-strategy": t.updatePositionStrategy,
+                  sticky: t.sticky,
+                  "hide-when-detached": t.hideWhenDetached,
+                  reference: t.reference,
+                  onKeydown: me,
+                  onBlur: ye,
+                  onPointermove: ge
+                }, {
+                  default: y(() => [
+                    w(t.$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"]));
+  }
+}), ue = /* @__PURE__ */ P({
+  inheritAttrs: !1,
+  __name: "MenuItemImpl",
+  props: {
+    disabled: { type: Boolean },
+    textValue: {},
+    asChild: { type: Boolean },
+    as: {}
+  },
+  setup(r) {
+    const i = r, o = Q(), { forwardRef: c } = K(), { CollectionItem: s } = Ae(), n = _(!1);
+    async function p(a) {
+      if (!a.defaultPrevented && E(a)) {
+        if (i.disabled)
+          o.onItemLeave(a);
+        else if (!o.onItemEnter(a)) {
+          const m = a.currentTarget;
+          m == null || m.focus({ preventScroll: !0 });
+        }
+      }
+    }
+    async function l(a) {
+      await F(), !a.defaultPrevented && E(a) && o.onItemLeave(a);
+    }
+    return (a, C) => (b(), h(e(s), {
+      value: { textValue: a.textValue }
+    }, {
+      default: y(() => [
+        k(e(V), B({
+          ref: e(c),
+          role: "menuitem",
+          tabindex: "-1"
+        }, a.$attrs, {
+          as: a.as,
+          "as-child": a.asChild,
+          "aria-disabled": a.disabled || void 0,
+          "data-disabled": a.disabled ? "" : void 0,
+          "data-highlighted": n.value ? "" : void 0,
+          onPointermove: p,
+          onPointerleave: l,
+          onFocus: C[0] || (C[0] = async (m) => {
+            await F(), !(m.defaultPrevented || a.disabled) && (n.value = !0);
+          }),
+          onBlur: C[1] || (C[1] = async (m) => {
+            await F(), !m.defaultPrevented && (n.value = !1);
+          })
+        }), {
+          default: y(() => [
+            w(a.$slots, "default")
+          ]),
+          _: 3
+        }, 16, ["as", "as-child", "aria-disabled", "data-disabled", "data-highlighted"])
+      ]),
+      _: 3
+    }, 8, ["value"]));
+  }
+}), de = /* @__PURE__ */ P({
+  __name: "MenuItem",
+  props: {
+    disabled: { type: Boolean },
+    textValue: {},
+    asChild: { type: Boolean },
+    as: {}
+  },
+  emits: ["select"],
+  setup(r, { emit: i }) {
+    const o = r, c = i, { forwardRef: s, currentElement: n } = K(), p = A(), l = Q(), a = _(!1);
+    async function C() {
+      const m = n.value;
+      if (!o.disabled && m) {
+        const d = new CustomEvent($e, {
+          bubbles: !0,
+          cancelable: !0
+        });
+        c("select", d), await F(), d.defaultPrevented ? a.value = !1 : p.onClose();
+      }
+    }
+    return (m, d) => (b(), h(ue, B(o, {
+      ref: e(s),
+      onClick: C,
+      onPointerdown: d[0] || (d[0] = () => {
+        a.value = !0;
+      }),
+      onPointerup: d[1] || (d[1] = async (u) => {
+        var g;
+        await F(), !u.defaultPrevented && (a.value || (g = u.currentTarget) == null || g.click());
+      }),
+      onKeydown: d[2] || (d[2] = async (u) => {
+        const g = e(l).searchRef.value !== "";
+        m.disabled || g && u.key === " " || e(Se).includes(u.key) && (u.currentTarget.click(), u.preventDefault());
+      })
+    }), {
+      default: y(() => [
+        w(m.$slots, "default")
+      ]),
+      _: 3
+    }, 16));
+  }
+}), [Je, ce] = R(
+  ["MenuCheckboxItem", "MenuRadioItem"],
+  "MenuItemIndicatorContext"
+), It = /* @__PURE__ */ P({
+  __name: "MenuItemIndicator",
+  props: {
+    forceMount: { type: Boolean },
+    asChild: { type: Boolean },
+    as: { default: "span" }
+  },
+  setup(r) {
+    const i = Je({
+      modelValue: _(!1)
+    });
+    return (o, c) => (b(), h(e(J), {
+      present: o.forceMount || e(Y)(e(i).modelValue.value) || e(i).modelValue.value === !0
+    }, {
+      default: y(() => [
+        k(e(V), {
+          as: o.as,
+          "as-child": o.asChild,
+          "data-state": e(q)(e(i).modelValue.value)
+        }, {
+          default: y(() => [
+            w(o.$slots, "default")
+          ]),
+          _: 3
+        }, 8, ["as", "as-child", "data-state"])
+      ]),
+      _: 3
+    }, 8, ["present"]));
+  }
+}), St = /* @__PURE__ */ P({
+  __name: "MenuCheckboxItem",
+  props: {
+    modelValue: { type: [Boolean, String], default: !1 },
+    disabled: { type: Boolean },
+    textValue: {},
+    asChild: { type: Boolean },
+    as: {}
+  },
+  emits: ["select", "update:modelValue"],
+  setup(r, { emit: i }) {
+    const o = r, c = i, s = U(o, "modelValue", c);
+    return ce({ modelValue: s }), (n, p) => (b(), h(de, B({ role: "menuitemcheckbox" }, o, {
+      "aria-checked": e(Y)(e(s)) ? "mixed" : e(s),
+      "data-state": e(q)(e(s)),
+      onSelect: p[0] || (p[0] = async (l) => {
+        c("select", l), e(Y)(e(s)) ? s.value = !0 : s.value = !e(s);
+      })
+    }), {
+      default: y(() => [
+        w(n.$slots, "default", { modelValue: e(s) })
+      ]),
+      _: 3
+    }, 16, ["aria-checked", "data-state"]));
+  }
+}), Qe = /* @__PURE__ */ P({
+  __name: "MenuRootContentModal",
+  props: {
+    loop: { type: Boolean },
+    side: {},
+    sideOffset: {},
+    align: {},
+    alignOffset: {},
+    avoidCollisions: { type: Boolean },
+    collisionBoundary: {},
+    collisionPadding: {},
+    arrowPadding: {},
+    sticky: {},
+    hideWhenDetached: { type: Boolean },
+    positionStrategy: {},
+    updatePositionStrategy: {},
+    disableUpdateOnLayoutShift: { type: Boolean },
+    prioritizePosition: { type: Boolean },
+    reference: {},
+    asChild: { type: Boolean },
+    as: {}
+  },
+  emits: ["escapeKeyDown", "pointerDownOutside", "focusOutside", "interactOutside", "entryFocus", "openAutoFocus", "closeAutoFocus"],
+  setup(r, { emit: i }) {
+    const o = r, c = i, s = z(o, c), n = D(), { forwardRef: p, currentElement: l } = K();
+    return Te(l), (a, C) => (b(), h(Z, B(e(s), {
+      ref: e(p),
+      "trap-focus": e(n).open.value,
+      "disable-outside-pointer-events": e(n).open.value,
+      "disable-outside-scroll": !0,
+      onDismiss: C[0] || (C[0] = (m) => e(n).onOpenChange(!1)),
+      onFocusOutside: C[1] || (C[1] = X((m) => c("focusOutside", m), ["prevent"]))
+    }), {
+      default: y(() => [
+        w(a.$slots, "default")
+      ]),
+      _: 3
+    }, 16, ["trap-focus", "disable-outside-pointer-events"]));
+  }
+}), Ze = /* @__PURE__ */ P({
+  __name: "MenuRootContentNonModal",
+  props: {
+    loop: { type: Boolean },
+    side: {},
+    sideOffset: {},
+    align: {},
+    alignOffset: {},
+    avoidCollisions: { type: Boolean },
+    collisionBoundary: {},
+    collisionPadding: {},
+    arrowPadding: {},
+    sticky: {},
+    hideWhenDetached: { type: Boolean },
+    positionStrategy: {},
+    updatePositionStrategy: {},
+    disableUpdateOnLayoutShift: { type: Boolean },
+    prioritizePosition: { type: Boolean },
+    reference: {},
+    asChild: { type: Boolean },
+    as: {}
+  },
+  emits: ["escapeKeyDown", "pointerDownOutside", "focusOutside", "interactOutside", "entryFocus", "openAutoFocus", "closeAutoFocus"],
+  setup(r, { emit: i }) {
+    const s = z(r, i), n = D();
+    return (p, l) => (b(), h(Z, B(e(s), {
+      "trap-focus": !1,
+      "disable-outside-pointer-events": !1,
+      "disable-outside-scroll": !1,
+      onDismiss: l[0] || (l[0] = (a) => e(n).onOpenChange(!1))
+    }), {
+      default: y(() => [
+        w(p.$slots, "default")
+      ]),
+      _: 3
+    }, 16));
+  }
+}), $t = /* @__PURE__ */ P({
+  __name: "MenuContent",
+  props: {
+    forceMount: { type: Boolean },
+    loop: { type: Boolean },
+    side: {},
+    sideOffset: {},
+    align: {},
+    alignOffset: {},
+    avoidCollisions: { type: Boolean },
+    collisionBoundary: {},
+    collisionPadding: {},
+    arrowPadding: {},
+    sticky: {},
+    hideWhenDetached: { type: Boolean },
+    positionStrategy: {},
+    updatePositionStrategy: {},
+    disableUpdateOnLayoutShift: { type: Boolean },
+    prioritizePosition: { type: Boolean },
+    reference: {},
+    asChild: { type: Boolean },
+    as: {}
+  },
+  emits: ["escapeKeyDown", "pointerDownOutside", "focusOutside", "interactOutside", "entryFocus", "openAutoFocus", "closeAutoFocus"],
+  setup(r, { emit: i }) {
+    const s = z(r, i), n = D(), p = A();
+    return (l, a) => (b(), h(e(J), {
+      present: l.forceMount || e(n).open.value
+    }, {
+      default: y(() => [
+        e(p).modal.value ? (b(), h(Qe, T(B({ key: 0 }, { ...l.$attrs, ...e(s) })), {
+          default: y(() => [
+            w(l.$slots, "default")
+          ]),
+          _: 3
+        }, 16)) : (b(), h(Ze, T(B({ key: 1 }, { ...l.$attrs, ...e(s) })), {
+          default: y(() => [
+            w(l.$slots, "default")
+          ]),
+          _: 3
+        }, 16))
+      ]),
+      _: 3
+    }, 8, ["present"]));
+  }
+}), et = /* @__PURE__ */ P({
+  __name: "MenuGroup",
+  props: {
+    asChild: { type: Boolean },
+    as: {}
+  },
+  setup(r) {
+    const i = r;
+    return (o, c) => (b(), h(e(V), B({ role: "group" }, i), {
+      default: y(() => [
+        w(o.$slots, "default")
+      ]),
+      _: 3
+    }, 16));
+  }
+}), kt = /* @__PURE__ */ P({
+  __name: "MenuLabel",
+  props: {
+    asChild: { type: Boolean },
+    as: { default: "div" }
+  },
+  setup(r) {
+    const i = r;
+    return (o, c) => (b(), h(e(V), T(x(i)), {
+      default: y(() => [
+        w(o.$slots, "default")
+      ]),
+      _: 3
+    }, 16));
+  }
+}), Dt = /* @__PURE__ */ P({
+  __name: "MenuPortal",
+  props: {
+    to: {},
+    disabled: { type: Boolean },
+    defer: { type: Boolean },
+    forceMount: { type: Boolean }
+  },
+  setup(r) {
+    const i = r;
+    return (o, c) => (b(), h(e(Re), T(x(i)), {
+      default: y(() => [
+        w(o.$slots, "default")
+      ]),
+      _: 3
+    }, 16));
+  }
+}), [tt, ot] = R("MenuRadioGroup"), Ft = /* @__PURE__ */ P({
+  __name: "MenuRadioGroup",
+  props: {
+    modelValue: { default: "" },
+    asChild: { type: Boolean },
+    as: {}
+  },
+  emits: ["update:modelValue"],
+  setup(r, { emit: i }) {
+    const o = r, s = U(o, "modelValue", i);
+    return ot({
+      modelValue: s,
+      onValueChange: (n) => {
+        s.value = n;
+      }
+    }), (n, p) => (b(), h(et, T(x(o)), {
+      default: y(() => [
+        w(n.$slots, "default", { modelValue: e(s) })
+      ]),
+      _: 3
+    }, 16));
+  }
+}), Tt = /* @__PURE__ */ P({
+  __name: "MenuRadioItem",
+  props: {
+    value: {},
+    disabled: { type: Boolean },
+    textValue: {},
+    asChild: { type: Boolean },
+    as: {}
+  },
+  emits: ["select"],
+  setup(r, { emit: i }) {
+    const o = r, c = i, { value: s } = H(o), n = tt(), p = we(
+      () => n.modelValue.value === (s == null ? void 0 : s.value)
+    );
+    return ce({ modelValue: p }), (l, a) => (b(), h(de, B({ role: "menuitemradio" }, o, {
+      "aria-checked": p.value,
+      "data-state": e(q)(p.value),
+      onSelect: a[0] || (a[0] = async (C) => {
+        c("select", C), e(n).onValueChange(e(s));
+      })
+    }), {
+      default: y(() => [
+        w(l.$slots, "default")
+      ]),
+      _: 3
+    }, 16, ["aria-checked", "data-state"]));
+  }
+}), Rt = /* @__PURE__ */ P({
+  __name: "MenuSeparator",
+  props: {
+    asChild: { type: Boolean },
+    as: {}
+  },
+  setup(r) {
+    const i = r;
+    return (o, c) => (b(), h(e(V), B(i, {
+      role: "separator",
+      "aria-orientation": "horizontal"
+    }), {
+      default: y(() => [
+        w(o.$slots, "default")
+      ]),
+      _: 3
+    }, 16));
+  }
+}), [pe, nt] = R("MenuSub"), Et = /* @__PURE__ */ P({
+  __name: "MenuSub",
+  props: {
+    open: { type: Boolean, default: void 0 }
+  },
+  emits: ["update:open"],
+  setup(r, { emit: i }) {
+    const o = r, s = U(o, "open", i, {
+      defaultValue: !1,
+      passive: o.open === void 0
+    }), n = D(), p = _(), l = _();
+    return Pe((a) => {
+      (n == null ? void 0 : n.open.value) === !1 && (s.value = !1), a(() => s.value = !1);
+    }), le({
+      open: s,
+      onOpenChange: (a) => {
+        s.value = a;
+      },
+      content: l,
+      onContentChange: (a) => {
+        l.value = a;
+      }
+    }), nt({
+      triggerId: "",
+      contentId: "",
+      trigger: p,
+      onTriggerChange: (a) => {
+        p.value = a;
+      }
+    }), (a, C) => (b(), h(e(re), null, {
+      default: y(() => [
+        w(a.$slots, "default")
+      ]),
+      _: 3
+    }));
+  }
+}), Kt = /* @__PURE__ */ P({
+  __name: "MenuSubContent",
+  props: {
+    forceMount: { type: Boolean },
+    loop: { type: Boolean },
+    sideOffset: {},
+    alignOffset: {},
+    avoidCollisions: { type: Boolean },
+    collisionBoundary: {},
+    collisionPadding: {},
+    arrowPadding: {},
+    sticky: {},
+    hideWhenDetached: { type: Boolean },
+    positionStrategy: {},
+    updatePositionStrategy: {},
+    disableUpdateOnLayoutShift: { type: Boolean },
+    prioritizePosition: { type: Boolean, default: !0 },
+    reference: {},
+    asChild: { type: Boolean },
+    as: {}
+  },
+  emits: ["escapeKeyDown", "pointerDownOutside", "focusOutside", "interactOutside", "entryFocus", "openAutoFocus", "closeAutoFocus"],
+  setup(r, { emit: i }) {
+    const s = z(r, i), n = D(), p = A(), l = pe(), { forwardRef: a, currentElement: C } = K();
+    return l.contentId || (l.contentId = ie(void 0, "reka-menu-sub-content")), (m, d) => (b(), h(e(J), {
+      present: m.forceMount || e(n).open.value
+    }, {
+      default: y(() => [
+        k(Z, B(e(s), {
+          id: e(l).contentId,
+          ref: e(a),
+          "aria-labelledby": e(l).triggerId,
+          align: "start",
+          side: e(p).dir.value === "rtl" ? "left" : "right",
+          "disable-outside-pointer-events": !1,
+          "disable-outside-scroll": !1,
+          "trap-focus": !1,
+          onOpenAutoFocus: d[0] || (d[0] = X((u) => {
+            var g;
+            e(p).isUsingKeyboardRef.value && ((g = e(C)) == null || g.focus());
+          }, ["prevent"])),
+          onCloseAutoFocus: d[1] || (d[1] = X(() => {
+          }, ["prevent"])),
+          onFocusOutside: d[2] || (d[2] = (u) => {
+            u.defaultPrevented || u.target !== e(l).trigger.value && e(n).onOpenChange(!1);
+          }),
+          onEscapeKeyDown: d[3] || (d[3] = (u) => {
+            e(p).onClose(), u.preventDefault();
+          }),
+          onKeydown: d[4] || (d[4] = (u) => {
+            var O, I;
+            const g = (O = u.currentTarget) == null ? void 0 : O.contains(u.target), M = e(ke)[e(p).dir.value].includes(u.key);
+            g && M && (e(n).onOpenChange(!1), (I = e(l).trigger.value) == null || I.focus(), u.preventDefault());
+          })
+        }), {
+          default: y(() => [
+            w(m.$slots, "default")
+          ]),
+          _: 3
+        }, 16, ["id", "aria-labelledby", "side"])
+      ]),
+      _: 3
+    }, 8, ["present"]));
+  }
+}), at = /* @__PURE__ */ P({
+  __name: "MenuAnchor",
+  props: {
+    reference: {},
+    asChild: { type: Boolean },
+    as: {}
+  },
+  setup(r) {
+    const i = r;
+    return (o, c) => (b(), h(e(Ve), T(x(i)), {
+      default: y(() => [
+        w(o.$slots, "default")
+      ]),
+      _: 3
+    }, 16));
+  }
+}), Vt = /* @__PURE__ */ P({
+  __name: "MenuSubTrigger",
+  props: {
+    disabled: { type: Boolean },
+    textValue: {},
+    asChild: { type: Boolean },
+    as: {}
+  },
+  setup(r) {
+    const i = r, o = D(), c = A(), s = pe(), n = Q(), p = _(null);
+    s.triggerId || (s.triggerId = ie(void 0, "reka-menu-sub-trigger"));
+    function l() {
+      p.value && window.clearTimeout(p.value), p.value = null;
+    }
+    ae(() => {
+      l();
+    });
+    function a(d) {
+      !E(d) || n.onItemEnter(d) || !i.disabled && !o.open.value && !p.value && (n.onPointerGraceIntentChange(null), p.value = window.setTimeout(() => {
+        o.onOpenChange(!0), l();
+      }, 100));
+    }
+    async function C(d) {
+      var g, M;
+      if (!E(d))
+        return;
+      l();
+      const u = (g = o.content.value) == null ? void 0 : g.getBoundingClientRect();
+      if (u != null && u.width) {
+        const O = (M = o.content.value) == null ? void 0 : M.dataset.side, I = O === "right", j = I ? -5 : 5, S = u[I ? "left" : "right"], L = u[I ? "right" : "left"];
+        n.onPointerGraceIntentChange({
+          area: [
+            // Apply a bleed on clientX to ensure that our exit point is
+            // consistently within polygon bounds
+            { x: d.clientX + j, y: d.clientY },
+            { x: S, y: u.top },
+            { x: L, y: u.top },
+            { x: L, y: u.bottom },
+            { x: S, y: u.bottom }
+          ],
+          side: O
+        }), window.clearTimeout(n.pointerGraceTimerRef.value), n.pointerGraceTimerRef.value = window.setTimeout(
+          () => n.onPointerGraceIntentChange(null),
+          300
+        );
+      } else {
+        if (n.onTriggerLeave(d))
+          return;
+        n.onPointerGraceIntentChange(null);
+      }
+    }
+    async function m(d) {
+      var g;
+      const u = n.searchRef.value !== "";
+      i.disabled || u && d.key === " " || De[c.dir.value].includes(d.key) && (o.onOpenChange(!0), await F(), (g = o.content.value) == null || g.focus(), d.preventDefault());
+    }
+    return (d, u) => (b(), h(at, { "as-child": "" }, {
+      default: y(() => [
+        k(ue, B(i, {
+          id: e(s).triggerId,
+          ref: (g) => {
+            var M;
+            (M = e(s)) == null || M.onTriggerChange(g == null ? void 0 : g.$el);
+          },
+          "aria-haspopup": "menu",
+          "aria-expanded": e(o).open.value,
+          "aria-controls": e(s).contentId,
+          "data-state": e(se)(e(o).open.value),
+          onClick: u[0] || (u[0] = async (g) => {
+            i.disabled || g.defaultPrevented || (g.currentTarget.focus(), e(o).open.value || e(o).onOpenChange(!0));
+          }),
+          onPointermove: a,
+          onPointerleave: C,
+          onKeydown: m
+        }), {
+          default: y(() => [
+            w(d.$slots, "default")
+          ]),
+          _: 3
+        }, 16, ["id", "aria-expanded", "aria-controls", "data-state"])
+      ]),
+      _: 3
+    }));
+  }
+});
+export {
+  St as _,
+  Ot as a,
+  $t as b,
+  et as c,
+  de as d,
+  It as e,
+  kt as f,
+  Dt as g,
+  Ft as h,
+  Tt as i,
+  Rt as j,
+  Et as k,
+  Kt as l,
+  Vt as m,
+  at as n
+};