@orchidui/dashboard 1.8.1-95 → 1.8.1-96

package/dist/ui/combobox/index.js

@@ -0,0 +1,877 @@
+import { defineComponent as m, createBlock as p, openBlock as u, unref as e, withCtx as r, createVNode as I, mergeProps as v, renderSlot as f, toRefs as J, ref as E, computed as P, reactive as fe, watch as z, nextTick as M, getCurrentInstance as be, onMounted as R, isRef as de, onUnmounted as Q, resolveDynamicComponent as he, createCommentVNode as K, normalizeProps as U, createTextVNode as q, withKeys as ge, withModifiers as ve, toDisplayString as ue, guardReactiveProps as X, createElementBlock as ye, Fragment as _e } from "vue";
+import { a as pe, u as j } from "../../useForwardPropsEmits-0XKBv1pB.js";
+import { u as W, c as Ce } from "../../index-BwPb_idr.js";
+import { b as xe, _ as Be, a as we } from "../../PopperContent-BT3Svcc3.js";
+import { c as Y } from "../../createContext-CZEfaSVa.js";
+import { u as Z } from "../../usePrimitiveElement-BjwUvHih.js";
+import { u as Se } from "../../useDirection-C3C_TLKm.js";
+import { u as $e, _ as Oe, d as Ie, a as ke, e as Ve, b as Ee, c as Pe, f as Fe } from "../../ListboxItem-CjMk-mEX.js";
+import { c as F } from "../../utils-SFgRDk1R.js";
+import { u as $ } from "../../useForwardExpose-DZT6mL_U.js";
+import { P as S } from "../../Primitive-B3twiLO1.js";
+import { r as D } from "../../index-OpE2oGce.js";
+import { u as A } from "../../useId-reAg216X.js";
+import { _ as De } from "../../Teleport-DnUewq5H.js";
+import { a as Te, u as Re } from "../../useBodyScrollLock-CazCRZjZ.js";
+import { _ as je } from "../../DismissableLayer-C7IJliOb.js";
+import { P as Le } from "../../Presence-CxfTrw6l.js";
+import { u as Ge } from "../../useNonce-C1ZOgOp5.js";
+const ze = /* @__PURE__ */ m({
+  __name: "ComboboxAnchor",
+  props: {
+    reference: {},
+    asChild: { type: Boolean },
+    as: {}
+  },
+  setup(l) {
+    const { forwardRef: n } = $();
+    return (t, a) => (u(), p(e(xe), {
+      "as-child": "",
+      reference: t.reference
+    }, {
+      default: r(() => [
+        I(e(S), v({
+          ref: e(n),
+          "as-child": t.asChild,
+          as: t.as
+        }, t.$attrs), {
+          default: r(() => [
+            f(t.$slots, "default")
+          ]),
+          _: 3
+        }, 16, ["as-child", "as"])
+      ]),
+      _: 3
+    }, 8, ["reference"]));
+  }
+}), [O, Me] = Y("ComboboxRoot"), Ke = /* @__PURE__ */ m({
+  __name: "ComboboxRoot",
+  props: {
+    open: { type: Boolean, default: void 0 },
+    defaultOpen: { type: Boolean },
+    resetSearchTermOnBlur: { type: Boolean, default: !0 },
+    resetSearchTermOnSelect: { type: Boolean, default: !0 },
+    ignoreFilter: { type: Boolean },
+    modelValue: {},
+    defaultValue: {},
+    multiple: { type: Boolean },
+    dir: {},
+    disabled: { type: Boolean },
+    highlightOnHover: { type: Boolean },
+    by: {},
+    asChild: { type: Boolean },
+    as: {},
+    name: {},
+    required: { type: Boolean }
+  },
+  emits: ["update:modelValue", "highlight", "update:open"],
+  setup(l, { expose: n, emit: t }) {
+    var le, re, ie;
+    const a = l, o = t, { primitiveElement: s, currentElement: i } = Z(), { multiple: c, disabled: y, ignoreFilter: k, resetSearchTermOnSelect: _, dir: C } = J(a), d = Se(C), b = W(a, "modelValue", o, {
+      defaultValue: a.defaultValue ?? (c.value ? [] : void 0),
+      passive: a.modelValue === void 0,
+      deep: !0
+    }), g = W(a, "open", o, {
+      defaultValue: a.defaultOpen,
+      passive: a.open === void 0
+    });
+    async function V(h) {
+      var x, B;
+      g.value = h, w.search = "", h ? (await M(), (x = s.value) == null || x.highlightSelected(), H.value = !0) : H.value = !1, (B = N.value) == null || B.focus(), setTimeout(() => {
+        !h && a.resetSearchTermOnBlur && ee.trigger();
+      }, 1);
+    }
+    const ee = Ce(), H = E(!1), te = E(!1), N = E(), oe = E(), ae = P(() => {
+      var h;
+      return ((h = s.value) == null ? void 0 : h.highlightedElement) ?? void 0;
+    }), L = E(/* @__PURE__ */ new Map()), se = E(/* @__PURE__ */ new Map()), { contains: me } = $e({ sensitivity: "base" }), w = fe({
+      search: "",
+      filtered: {
+        /** The count of all visible items. */
+        count: 0,
+        /** Map from visible item id to its search score. */
+        items: /* @__PURE__ */ new Map(),
+        /** Set of groups with at least one visible item. */
+        groups: /* @__PURE__ */ new Set()
+      }
+    });
+    function ne() {
+      if (!w.search || a.ignoreFilter || te.value) {
+        w.filtered.count = L.value.size;
+        return;
+      }
+      w.filtered.groups = /* @__PURE__ */ new Set();
+      let h = 0;
+      for (const [x, B] of L.value) {
+        const G = me(B, w.search);
+        w.filtered.items.set(x, G ? 1 : 0), G && h++;
+      }
+      for (const [x, B] of se.value)
+        for (const G of B)
+          if (w.filtered.items.get(G) > 0) {
+            w.filtered.groups.add(x);
+            break;
+          }
+      w.filtered.count = h;
+    }
+    z([() => w.search, () => L.value.size], () => {
+      ne();
+    }, { immediate: !0 }), z(() => g.value, () => {
+      M(() => {
+        g.value && ne();
+      });
+    }, { flush: "post" });
+    const T = be();
+    return R(() => {
+      var h, x, B;
+      T != null && T.exposed && (T.exposed.highlightItem = (h = s.value) == null ? void 0 : h.highlightItem, T.exposed.highlightFirstItem = (x = s.value) == null ? void 0 : x.highlightFirstItem, T.exposed.highlightSelected = (B = s.value) == null ? void 0 : B.highlightSelected);
+    }), n({
+      filtered: P(() => w.filtered),
+      highlightedElement: ae,
+      highlightItem: (le = s.value) == null ? void 0 : le.highlightItem,
+      highlightFirstItem: (re = s.value) == null ? void 0 : re.highlightFirstItem,
+      highlightSelected: (ie = s.value) == null ? void 0 : ie.highlightSelected
+    }), Me({
+      modelValue: b,
+      multiple: c,
+      disabled: y,
+      open: g,
+      onOpenChange: V,
+      contentId: "",
+      isUserInputted: H,
+      isVirtual: te,
+      inputElement: N,
+      highlightedElement: ae,
+      onInputElementChange: (h) => N.value = h,
+      triggerElement: oe,
+      onTriggerElementChange: (h) => oe.value = h,
+      parentElement: i,
+      resetSearchTermOnSelect: _,
+      onResetSearchTerm: ee.on,
+      allItems: L,
+      allGroups: se,
+      filterState: w,
+      ignoreFilter: k
+    }), (h, x) => (u(), p(e(Be), null, {
+      default: r(() => [
+        I(e(Oe), v({
+          ref_key: "primitiveElement",
+          ref: s
+        }, h.$attrs, {
+          modelValue: e(b),
+          "onUpdate:modelValue": x[0] || (x[0] = (B) => de(b) ? b.value = B : null),
+          style: {
+            pointerEvents: e(g) ? "auto" : void 0
+          },
+          as: h.as,
+          "as-child": h.asChild,
+          dir: e(d),
+          multiple: e(c),
+          name: h.name,
+          required: h.required,
+          disabled: e(y),
+          "highlight-on-hover": !0,
+          by: a.by,
+          onHighlight: x[1] || (x[1] = (B) => o("highlight", B))
+        }), {
+          default: r(() => [
+            f(h.$slots, "default", {
+              open: e(g),
+              modelValue: e(b)
+            })
+          ]),
+          _: 3
+        }, 16, ["modelValue", "style", "as", "as-child", "dir", "multiple", "name", "required", "disabled", "by"])
+      ]),
+      _: 3
+    }));
+  }
+}), [_t, Ue] = Y("ComboboxContent"), qe = /* @__PURE__ */ m({
+  __name: "ComboboxContentImpl",
+  props: {
+    position: { default: "inline" },
+    bodyLock: { 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: {},
+    disableOutsidePointerEvents: { type: Boolean }
+  },
+  emits: ["escapeKeyDown", "pointerDownOutside", "focusOutside", "interactOutside"],
+  setup(l, { emit: n }) {
+    const t = l, a = n, { position: o } = J(t), s = O(), { forwardRef: i, currentElement: c } = $();
+    Te(t.bodyLock), Re(s.parentElement);
+    const y = P(() => t.position === "popper" ? t : {}), k = pe(y.value), _ = {
+      // Ensure border-box for floating-ui calculations
+      boxSizing: "border-box",
+      "--reka-combobox-content-transform-origin": "var(--reka-popper-transform-origin)",
+      "--reka-combobox-content-available-width": "var(--reka-popper-available-width)",
+      "--reka-combobox-content-available-height": "var(--reka-popper-available-height)",
+      "--reka-combobox-trigger-width": "var(--reka-popper-anchor-width)",
+      "--reka-combobox-trigger-height": "var(--reka-popper-anchor-height)"
+    };
+    Ue({ position: o });
+    const C = E(!1);
+    return R(() => {
+      s.inputElement.value && (C.value = c.value.contains(s.inputElement.value), C.value && s.inputElement.value.focus());
+    }), Q(() => {
+      var d;
+      C.value && ((d = s.triggerElement.value) == null || d.focus());
+    }), (d, b) => (u(), p(e(Ie), { "as-child": "" }, {
+      default: r(() => [
+        I(e(je), {
+          "as-child": "",
+          "disable-outside-pointer-events": d.disableOutsidePointerEvents,
+          onDismiss: b[0] || (b[0] = (g) => e(s).onOpenChange(!1)),
+          onFocusOutside: b[1] || (b[1] = (g) => {
+            var V;
+            (V = e(s).parentElement.value) != null && V.contains(g.target) && g.preventDefault(), a("focusOutside", g);
+          }),
+          onInteractOutside: b[2] || (b[2] = (g) => a("interactOutside", g)),
+          onEscapeKeyDown: b[3] || (b[3] = (g) => a("escapeKeyDown", g)),
+          onPointerDownOutside: b[4] || (b[4] = (g) => {
+            var V;
+            (V = e(s).parentElement.value) != null && V.contains(g.target) && g.preventDefault(), a("pointerDownOutside", g);
+          })
+        }, {
+          default: r(() => [
+            (u(), p(he(e(o) === "popper" ? e(we) : e(S)), v({ ...d.$attrs, ...e(k) }, {
+              id: e(s).contentId,
+              ref: e(i),
+              "data-state": e(s).open.value ? "open" : "closed",
+              style: {
+                // flex layout so we can place the scroll buttons properly
+                display: "flex",
+                flexDirection: "column",
+                // reset the outline by default as the content MAY get focused
+                outline: "none",
+                ...e(o) === "popper" ? _ : {}
+              }
+            }), {
+              default: r(() => [
+                f(d.$slots, "default")
+              ]),
+              _: 3
+            }, 16, ["id", "data-state", "style"]))
+          ]),
+          _: 3
+        }, 8, ["disable-outside-pointer-events"])
+      ]),
+      _: 3
+    }));
+  }
+}), Ct = /* @__PURE__ */ m({
+  __name: "ComboboxCancel",
+  props: {
+    asChild: { type: Boolean },
+    as: { default: "button" }
+  },
+  setup(l) {
+    const n = l;
+    $();
+    const t = O();
+    function a() {
+      t.filterState.search = "", t.inputElement.value && (t.inputElement.value.value = "", t.inputElement.value.focus());
+    }
+    return (o, s) => (u(), p(e(S), v({
+      type: o.as === "button" ? "button" : void 0
+    }, n, {
+      tabindex: "-1",
+      onClick: a
+    }), {
+      default: r(() => [
+        f(o.$slots, "default")
+      ]),
+      _: 3
+    }, 16, ["type"]));
+  }
+}), Ae = /* @__PURE__ */ m({
+  __name: "ComboboxContent",
+  props: {
+    forceMount: { type: Boolean },
+    position: {},
+    bodyLock: { 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: {},
+    disableOutsidePointerEvents: { type: Boolean }
+  },
+  emits: ["escapeKeyDown", "pointerDownOutside", "focusOutside", "interactOutside"],
+  setup(l, { emit: n }) {
+    const o = j(l, n), { forwardRef: s } = $(), i = O();
+    return i.contentId || (i.contentId = A(void 0, "reka-combobox-content")), (c, y) => (u(), p(e(Le), {
+      present: c.forceMount || e(i).open.value
+    }, {
+      default: r(() => [
+        I(qe, v({ ...e(o), ...c.$attrs }, { ref: e(s) }), {
+          default: r(() => [
+            f(c.$slots, "default")
+          ]),
+          _: 3
+        }, 16)
+      ]),
+      _: 3
+    }, 8, ["present"]));
+  }
+}), He = /* @__PURE__ */ m({
+  __name: "ComboboxEmpty",
+  props: {
+    asChild: { type: Boolean },
+    as: {}
+  },
+  setup(l) {
+    const n = l, t = O(), a = P(
+      () => t.ignoreFilter.value ? t.allItems.value.size === 0 : !!t.filterState.search && t.filterState.filtered.count === 0
+    );
+    return (o, s) => a.value ? (u(), p(e(S), U(v({ key: 0 }, n)), {
+      default: r(() => [
+        f(o.$slots, "default", {}, () => [
+          s[0] || (s[0] = q("No options"))
+        ])
+      ]),
+      _: 3
+    }, 16)) : K("", !0);
+  }
+}), [ce, Ne] = Y("ComboboxGroup"), We = /* @__PURE__ */ m({
+  __name: "ComboboxGroup",
+  props: {
+    asChild: { type: Boolean },
+    as: {}
+  },
+  setup(l) {
+    const n = l, t = A(void 0, "reka-combobox-group"), a = O(), o = P(() => a.ignoreFilter.value ? !0 : a.filterState.search ? a.filterState.filtered.groups.has(t) : !0), s = Ne({
+      id: t,
+      labelId: ""
+    });
+    return R(() => {
+      a.allGroups.value.has(t) || a.allGroups.value.set(t, /* @__PURE__ */ new Set());
+    }), Q(() => {
+      a.allGroups.value.delete(t);
+    }), (i, c) => (u(), p(e(ke), v({
+      id: e(t),
+      "aria-labelledby": e(s).labelId
+    }, n, {
+      hidden: o.value ? void 0 : !0
+    }), {
+      default: r(() => [
+        f(i.$slots, "default")
+      ]),
+      _: 3
+    }, 16, ["id", "aria-labelledby", "hidden"]));
+  }
+}), Je = /* @__PURE__ */ m({
+  __name: "ComboboxInput",
+  props: {
+    displayValue: {},
+    modelValue: {},
+    autoFocus: { type: Boolean },
+    disabled: { type: Boolean },
+    asChild: { type: Boolean },
+    as: { default: "input" }
+  },
+  emits: ["update:modelValue"],
+  setup(l, { emit: n }) {
+    const t = l, a = n, o = O(), s = Ve(), { primitiveElement: i, currentElement: c } = Z(), y = W(t, "modelValue", a, {
+      passive: t.modelValue === void 0
+    });
+    R(() => {
+      c.value && o.onInputElementChange(c.value);
+    });
+    function k(d) {
+      o.open.value || o.onOpenChange(!0);
+    }
+    function _(d) {
+      const b = d.target;
+      o.open.value ? o.filterState.search = b.value : (o.onOpenChange(!0), M(() => {
+        b.value && (o.filterState.search = b.value, s.highlightFirstItem(d));
+      }));
+    }
+    function C() {
+      const d = o.modelValue.value;
+      t.displayValue ? y.value = t.displayValue(d) : !o.multiple.value && d && !Array.isArray(d) && typeof d != "object" ? y.value = d.toString() : y.value = "", M(() => {
+        y.value = y.value;
+      });
+    }
+    return o.onResetSearchTerm(() => {
+      C();
+    }), z(o.modelValue, async () => {
+      !o.isUserInputted.value && o.resetSearchTermOnSelect.value && C();
+    }, { immediate: !0, deep: !0 }), z(
+      () => t.modelValue,
+      () => {
+        t.modelValue !== void 0 && (o.filterState.search = t.modelValue);
+      }
+    ), (d, b) => (u(), p(e(Ee), {
+      ref_key: "primitiveElement",
+      ref: i,
+      modelValue: e(y),
+      "onUpdate:modelValue": b[0] || (b[0] = (g) => de(y) ? y.value = g : null),
+      as: d.as,
+      "as-child": d.asChild,
+      "auto-focus": d.autoFocus,
+      "aria-expanded": e(o).open.value,
+      "aria-controls": e(o).contentId,
+      "aria-autocomplete": "list",
+      role: "combobox",
+      autocomplete: "false",
+      onInput: _,
+      onKeydown: ge(ve(k, ["prevent"]), ["down", "up"])
+    }, {
+      default: r(() => [
+        f(d.$slots, "default")
+      ]),
+      _: 3
+    }, 8, ["modelValue", "as", "as-child", "auto-focus", "aria-expanded", "aria-controls", "onKeydown"]));
+  }
+}), Qe = /* @__PURE__ */ m({
+  __name: "ComboboxItem",
+  props: {
+    textValue: {},
+    value: {},
+    disabled: { type: Boolean },
+    asChild: { type: Boolean },
+    as: {}
+  },
+  emits: ["select"],
+  setup(l, { emit: n }) {
+    const t = l, a = n, o = A(void 0, "reka-combobox-item"), s = O(), i = ce(null), { primitiveElement: c, currentElement: y } = Z();
+    if (t.value === "")
+      throw new Error(
+        "A <ComboboxItem /> must have a value prop that is not an empty string. This is because the Combobox value can be set to an empty string to clear the selection and show the placeholder."
+      );
+    const k = P(() => {
+      if (s.isVirtual.value || s.ignoreFilter.value || !s.filterState.search)
+        return !0;
+      {
+        const _ = s.filterState.filtered.items.get(o);
+        return _ === void 0 ? !0 : _ > 0;
+      }
+    });
+    return R(() => {
+      var C;
+      s.allItems.value.set(o, t.textValue || y.value.textContent || y.value.innerText);
+      const _ = i == null ? void 0 : i.id;
+      _ && (s.allGroups.value.has(_) ? (C = s.allGroups.value.get(_)) == null || C.add(o) : s.allGroups.value.set(_, /* @__PURE__ */ new Set([o])));
+    }), Q(() => {
+      s.allItems.value.delete(o);
+    }), (_, C) => k.value ? (u(), p(e(Pe), v({ key: 0 }, t, {
+      id: e(o),
+      ref_key: "primitiveElement",
+      ref: c,
+      disabled: e(s).disabled.value || _.disabled,
+      onSelect: C[0] || (C[0] = (d) => {
+        a("select", d), !d.defaultPrevented && !e(s).multiple.value && !_.disabled && !e(s).disabled.value && (d.preventDefault(), e(s).onOpenChange(!1), e(s).modelValue.value = t.value);
+      })
+    }), {
+      default: r(() => [
+        f(_.$slots, "default", {}, () => [
+          q(ue(_.value), 1)
+        ])
+      ]),
+      _: 3
+    }, 16, ["id", "disabled"])) : K("", !0);
+  }
+}), Xe = /* @__PURE__ */ m({
+  __name: "ListboxItemIndicator",
+  props: {
+    asChild: { type: Boolean },
+    as: { default: "span" }
+  },
+  setup(l) {
+    const n = l;
+    $();
+    const t = Fe();
+    return (a, o) => e(t).isSelected.value ? (u(), p(e(S), v({
+      key: 0,
+      "aria-hidden": "true"
+    }, n), {
+      default: r(() => [
+        f(a.$slots, "default")
+      ]),
+      _: 3
+    }, 16)) : K("", !0);
+  }
+}), xt = /* @__PURE__ */ m({
+  __name: "ComboboxItemIndicator",
+  props: {
+    asChild: { type: Boolean },
+    as: { default: "span" }
+  },
+  setup(l) {
+    const n = l;
+    return (t, a) => (u(), p(e(Xe), U(X(n)), {
+      default: r(() => [
+        f(t.$slots, "default")
+      ]),
+      _: 3
+    }, 16));
+  }
+}), Ye = /* @__PURE__ */ m({
+  __name: "ComboboxLabel",
+  props: {
+    for: {},
+    asChild: { type: Boolean },
+    as: { default: "div" }
+  },
+  setup(l) {
+    const n = l;
+    $();
+    const t = ce({ id: "", labelId: "" });
+    return t.labelId || (t.labelId = A(void 0, "reka-combobox-group-label")), (a, o) => (u(), p(e(S), v(n, {
+      id: e(t).labelId
+    }), {
+      default: r(() => [
+        f(a.$slots, "default")
+      ]),
+      _: 3
+    }, 16, ["id"]));
+  }
+}), Ze = /* @__PURE__ */ m({
+  __name: "ComboboxPortal",
+  props: {
+    to: {},
+    disabled: { type: Boolean },
+    defer: { type: Boolean },
+    forceMount: { type: Boolean }
+  },
+  setup(l) {
+    const n = l;
+    return (t, a) => (u(), p(e(De), U(X(n)), {
+      default: r(() => [
+        f(t.$slots, "default")
+      ]),
+      _: 3
+    }, 16));
+  }
+}), et = /* @__PURE__ */ m({
+  __name: "ComboboxSeparator",
+  props: {
+    asChild: { type: Boolean },
+    as: {}
+  },
+  setup(l) {
+    const n = l;
+    return $(), (t, a) => (u(), p(e(S), v(n, { "aria-hidden": "true" }), {
+      default: r(() => [
+        f(t.$slots, "default")
+      ]),
+      _: 3
+    }, 16));
+  }
+}), Bt = /* @__PURE__ */ m({
+  __name: "ComboboxTrigger",
+  props: {
+    disabled: { type: Boolean },
+    asChild: { type: Boolean },
+    as: { default: "button" }
+  },
+  setup(l) {
+    const n = l, { forwardRef: t, currentElement: a } = $(), o = O(), s = P(() => n.disabled || o.disabled.value || !1);
+    return R(() => {
+      a.value && o.onTriggerElementChange(a.value);
+    }), (i, c) => (u(), p(e(S), v(n, {
+      ref: e(t),
+      type: i.as === "button" ? "button" : void 0,
+      tabindex: "-1",
+      "aria-label": "Show popup",
+      "aria-haspopup": "listbox",
+      "aria-expanded": e(o).open.value,
+      "aria-controls": e(o).contentId,
+      "data-state": e(o).open.value ? "open" : "closed",
+      disabled: s.value,
+      "data-disabled": s.value ? "" : void 0,
+      "aria-disabled": s.value ?? void 0,
+      onClick: c[0] || (c[0] = (y) => e(o).onOpenChange(!e(o).open.value))
+    }), {
+      default: r(() => [
+        f(i.$slots, "default")
+      ]),
+      _: 3
+    }, 16, ["type", "aria-expanded", "aria-controls", "data-state", "disabled", "data-disabled", "aria-disabled"]));
+  }
+}), tt = /* @__PURE__ */ m({
+  __name: "ComboboxViewport",
+  props: {
+    nonce: {},
+    asChild: { type: Boolean },
+    as: {}
+  },
+  setup(l) {
+    const n = l, { forwardRef: t } = $(), { nonce: a } = J(n), o = Ge(a), s = O();
+    return (i, c) => (u(), ye(_e, null, [
+      I(e(S), v({ ...i.$attrs, ...n }, {
+        ref: e(t),
+        "data-reka-combobox-viewport": "",
+        role: "presentation",
+        style: {
+          // we use position: 'relative' here on the `viewport` so that when we call
+          // `selectedItem.offsetTop` in calculations, the offset is relative to the viewport
+          // (independent of the scrollUpButton).
+          position: "relative",
+          flex: e(s).isVirtual.value ? void 0 : 1,
+          overflow: "auto"
+        }
+      }), {
+        default: r(() => [
+          f(i.$slots, "default")
+        ]),
+        _: 3
+      }, 16, ["style"]),
+      I(e(S), {
+        as: "style",
+        nonce: e(o)
+      }, {
+        default: r(() => c[0] || (c[0] = [
+          q(" /* Hide scrollbars cross-browser and enable momentum scroll for touch devices */ [data-reka-combobox-viewport] { scrollbar-width:none; -ms-overflow-style: none; -webkit-overflow-scrolling: touch; } [data-reka-combobox-viewport]::-webkit-scrollbar { display: none; } ")
+        ])),
+        _: 1
+      }, 8, ["nonce"])
+    ], 64));
+  }
+}), wt = /* @__PURE__ */ m({
+  __name: "Combobox",
+  props: {
+    open: { type: Boolean },
+    defaultOpen: { type: Boolean },
+    resetSearchTermOnBlur: { type: Boolean },
+    resetSearchTermOnSelect: { type: Boolean },
+    ignoreFilter: { type: Boolean },
+    modelValue: {},
+    defaultValue: {},
+    multiple: { type: Boolean },
+    dir: {},
+    disabled: { type: Boolean },
+    highlightOnHover: { type: Boolean },
+    by: { type: [String, Function] },
+    asChild: { type: Boolean },
+    as: { type: [String, Object, Function] },
+    name: {},
+    required: { type: Boolean }
+  },
+  emits: ["update:modelValue", "highlight", "update:open"],
+  setup(l, { emit: n }) {
+    const o = j(l, n);
+    return (s, i) => (u(), p(e(Ke), U(X(e(o))), {
+      default: r(() => [
+        f(s.$slots, "default")
+      ]),
+      _: 3
+    }, 16));
+  }
+}), St = /* @__PURE__ */ m({
+  __name: "ComboboxAnchor",
+  props: {
+    reference: {},
+    asChild: { type: Boolean },
+    as: { type: [String, Object, Function] },
+    class: {}
+  },
+  setup(l) {
+    const n = l, t = D(n, "class"), a = pe(t);
+    return (o, s) => (u(), p(e(ze), v(e(a), {
+      class: e(F)("w-[200px]", n.class)
+    }), {
+      default: r(() => [
+        f(o.$slots, "default")
+      ]),
+      _: 3
+    }, 16, ["class"]));
+  }
+}), $t = /* @__PURE__ */ m({
+  __name: "ComboboxEmpty",
+  props: {
+    asChild: { type: Boolean },
+    as: { type: [String, Object, Function] },
+    class: {}
+  },
+  setup(l) {
+    const n = l, t = D(n, "class");
+    return (a, o) => (u(), p(e(He), v(e(t), {
+      class: e(F)("py-6 text-center text-sm", n.class)
+    }), {
+      default: r(() => [
+        f(a.$slots, "default")
+      ]),
+      _: 3
+    }, 16, ["class"]));
+  }
+}), Ot = /* @__PURE__ */ m({
+  __name: "ComboboxGroup",
+  props: {
+    asChild: { type: Boolean },
+    as: { type: [String, Object, Function] },
+    class: {},
+    heading: {}
+  },
+  setup(l) {
+    const n = l, t = D(n, "class");
+    return (a, o) => (u(), p(e(We), v(e(t), {
+      class: e(F)("overflow-hidden p-1 text-foreground [&_[cmdk-group-heading]]:px-2 [&_[cmdk-group-heading]]:py-1.5 [&_[cmdk-group-heading]]:text-xs [&_[cmdk-group-heading]]:font-medium [&_[cmdk-group-heading]]:text-muted-foreground", n.class)
+    }), {
+      default: r(() => [
+        a.heading ? (u(), p(e(Ye), {
+          key: 0,
+          class: "px-2 py-1.5 text-xs font-medium text-muted-foreground"
+        }, {
+          default: r(() => [
+            q(ue(a.heading), 1)
+          ]),
+          _: 1
+        })) : K("", !0),
+        f(a.$slots, "default")
+      ]),
+      _: 3
+    }, 16, ["class"]));
+  }
+}), It = /* @__PURE__ */ m({
+  __name: "ComboboxInput",
+  props: {
+    displayValue: { type: Function },
+    modelValue: {},
+    autoFocus: { type: Boolean },
+    disabled: { type: Boolean },
+    asChild: { type: Boolean },
+    as: { type: [String, Object, Function] },
+    class: {}
+  },
+  emits: ["update:modelValue"],
+  setup(l, { emit: n }) {
+    const t = l, a = n, o = D(t, "class"), s = j(o, a);
+    return (i, c) => (u(), p(e(Je), v(e(s), {
+      class: e(F)("flex h-9 w-full rounded-md border border-input bg-transparent px-3 py-1 text-sm shadow-sm transition-colors file:border-0 file:bg-transparent file:text-sm file:font-medium placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring disabled:cursor-not-allowed disabled:opacity-50", t.class)
+    }), {
+      default: r(() => [
+        f(i.$slots, "default")
+      ]),
+      _: 3
+    }, 16, ["class"]));
+  }
+}), kt = /* @__PURE__ */ m({
+  __name: "ComboboxItem",
+  props: {
+    textValue: {},
+    value: {},
+    disabled: { type: Boolean },
+    asChild: { type: Boolean },
+    as: { type: [String, Object, Function] },
+    class: {}
+  },
+  emits: ["select"],
+  setup(l, { emit: n }) {
+    const t = l, a = n, o = D(t, "class"), s = j(o, a);
+    return (i, c) => (u(), p(e(Qe), v(e(s), {
+      class: e(F)("relative flex cursor-default gap-2 select-none justify-between items-center rounded-sm px-2 py-1.5 text-sm outline-none data-[highlighted]:bg-accent data-[highlighted]:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50 [&_svg]:size-4 [&_svg]:shrink-0", t.class)
+    }), {
+      default: r(() => [
+        f(i.$slots, "default")
+      ]),
+      _: 3
+    }, 16, ["class"]));
+  }
+}), Vt = /* @__PURE__ */ m({
+  __name: "ComboboxList",
+  props: {
+    forceMount: { type: Boolean },
+    position: { default: "popper" },
+    bodyLock: { type: Boolean },
+    side: {},
+    sideOffset: { default: 4 },
+    align: { default: "center" },
+    alignOffset: {},
+    avoidCollisions: { type: Boolean },
+    collisionBoundary: {},
+    collisionPadding: {},
+    arrowPadding: {},
+    sticky: {},
+    hideWhenDetached: { type: Boolean },
+    positionStrategy: {},
+    updatePositionStrategy: {},
+    disableUpdateOnLayoutShift: { type: Boolean },
+    prioritizePosition: { type: Boolean },
+    reference: {},
+    asChild: { type: Boolean },
+    as: {},
+    disableOutsidePointerEvents: { type: Boolean },
+    class: {}
+  },
+  emits: ["escapeKeyDown", "pointerDownOutside", "focusOutside", "interactOutside"],
+  setup(l, { emit: n }) {
+    const t = l, a = n, o = D(t, "class"), s = j(o, a);
+    return (i, c) => (u(), p(e(Ze), null, {
+      default: r(() => [
+        I(e(Ae), v(e(s), {
+          class: e(F)("z-50 w-[200px] rounded-md border bg-popover text-popover-foreground shadow-md outline-none data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2", t.class)
+        }), {
+          default: r(() => [
+            I(e(tt), null, {
+              default: r(() => [
+                f(i.$slots, "default")
+              ]),
+              _: 3
+            })
+          ]),
+          _: 3
+        }, 16, ["class"])
+      ]),
+      _: 3
+    }));
+  }
+}), Et = /* @__PURE__ */ m({
+  __name: "ComboboxSeparator",
+  props: {
+    asChild: { type: Boolean },
+    as: { type: [String, Object, Function] },
+    class: {}
+  },
+  setup(l) {
+    const n = l, t = D(n, "class");
+    return (a, o) => (u(), p(e(et), v(e(t), {
+      class: e(F)("-mx-1 h-px bg-border", n.class)
+    }), {
+      default: r(() => [
+        f(a.$slots, "default")
+      ]),
+      _: 3
+    }, 16, ["class"]));
+  }
+});
+export {
+  wt as Combobox,
+  St as ComboboxAnchor,
+  Ct as ComboboxCancel,
+  $t as ComboboxEmpty,
+  Ot as ComboboxGroup,
+  It as ComboboxInput,
+  kt as ComboboxItem,
+  xt as ComboboxItemIndicator,
+  Vt as ComboboxList,
+  Et as ComboboxSeparator,
+  Bt as ComboboxTrigger
+};