@commercetools/nimbus 0.0.0-canary-20260114153122 → 0.0.0-canary-20260116085607

package/dist/chunks/combobox-B_Qx3gRo.es.js

@@ -0,0 +1,1539 @@
+import { jsx as g, jsxs as he, Fragment as He } from "react/jsx-runtime";
+import { useReducer as St, useRef as O, useEffect as H, createContext as Qe, useMemo as J, useContext as Ee, useState as U, useCallback as L, isValidElement as wt, cloneElement as $t } from "react";
+import { d as Kt } from "./Header-2KETI4X9.es.js";
+import { $ as Xe, a as It, b as Bt, c as Mt, d as At } from "./ListBox-DkaySjTS.es.js";
+import { g as Tt, c as Ft } from "./CollectionBuilder-BnYe2z4W.es.js";
+import { createSlotRecipeContext as Ot } from "@chakra-ui/react";
+import { Close as Vt, KeyboardArrowDown as Pt, Check as Lt } from "@commercetools/nimbus-icons";
+import { e as ue } from "./extract-style-props-BUbbGs7l.es.js";
+import { P as Rt } from "./popover-MW_SlCEP.es.js";
+import { I as Ue } from "./icon-button-CXRvSNxO.es.js";
+import { L as Et } from "./loading-spinner-DF6c3rBM.es.js";
+import { $ as Me, a as Dt } from "./Input-Cmg08oRP.es.js";
+import { $ as De, T as Pe } from "./tag-group-DrXuPS-n.es.js";
+import { useSlotRecipe as Nt } from "@chakra-ui/react/styled-system";
+import { b as zt } from "./RSPContexts-DLgb84PF.es.js";
+import { $ as Le } from "./Button-BjcDZ5eb.es.js";
+import { $ as kt, e as Ye } from "./utils-B6pV5ewr.es.js";
+import { a as Wt } from "./Group-BQc9LuMT.es.js";
+import { $ as Gt } from "./Label-DIseLESi.es.js";
+import { i as qt } from "./Dialog-BZs_dKan.es.js";
+import { $ as jt } from "./Text-DOcU1ycg.es.js";
+import { defineMessages as Ht, useIntl as Ut } from "react-intl";
+import { $ as Jt } from "./useListData-CX8_NxJv.es.js";
+import { a as Je } from "./mergeProps-Dsl8k3Ig.es.js";
+import { a as Qt } from "./useListState-6ejgSjM7.es.js";
+function Xt(e, t) {
+  let r;
+  switch (e.state) {
+    case "idle":
+    case "error":
+      switch (t.type) {
+        case "loading":
+        case "loadingMore":
+        case "sorting":
+        case "filtering":
+          var s, o;
+          return {
+            ...e,
+            filterText: (s = t.filterText) !== null && s !== void 0 ? s : e.filterText,
+            state: t.type,
+            // Reset items to an empty list if loading, but not when sorting.
+            items: t.type === "loading" ? [] : e.items,
+            sortDescriptor: (o = t.sortDescriptor) !== null && o !== void 0 ? o : e.sortDescriptor,
+            abortController: t.abortController
+          };
+        case "update":
+          var n;
+          return {
+            ...e,
+            ...(n = t.updater) === null || n === void 0 ? void 0 : n.call(t, e)
+          };
+        case "success":
+        case "error":
+          return e;
+        default:
+          throw new Error(`Invalid action "${t.type}" in state "${e.state}"`);
+      }
+    case "loading":
+    case "sorting":
+    case "filtering":
+      switch (t.type) {
+        case "success":
+          if (t.abortController !== e.abortController) return e;
+          var c;
+          r = (c = t.selectedKeys) !== null && c !== void 0 ? c : e.selectedKeys;
+          var l, u, b;
+          return {
+            ...e,
+            filterText: (l = t.filterText) !== null && l !== void 0 ? l : e.filterText,
+            state: "idle",
+            items: [
+              ...(u = t.items) !== null && u !== void 0 ? u : []
+            ],
+            selectedKeys: r === "all" ? "all" : new Set(r),
+            sortDescriptor: (b = t.sortDescriptor) !== null && b !== void 0 ? b : e.sortDescriptor,
+            abortController: void 0,
+            cursor: t.cursor
+          };
+        case "error":
+          return t.abortController !== e.abortController ? e : {
+            ...e,
+            state: "error",
+            error: t.error,
+            abortController: void 0
+          };
+        case "loading":
+        case "loadingMore":
+        case "sorting":
+        case "filtering":
+          var x;
+          (x = e.abortController) === null || x === void 0 || x.abort();
+          var d;
+          return {
+            ...e,
+            filterText: (d = t.filterText) !== null && d !== void 0 ? d : e.filterText,
+            state: t.type,
+            // Reset items to an empty list if loading, but not when sorting.
+            items: t.type === "loading" ? [] : e.items,
+            abortController: t.abortController
+          };
+        case "update":
+          var w;
+          return {
+            ...e,
+            ...(w = t.updater) === null || w === void 0 ? void 0 : w.call(t, e)
+          };
+        default:
+          throw new Error(`Invalid action "${t.type}" in state "${e.state}"`);
+      }
+    case "loadingMore":
+      switch (t.type) {
+        case "success":
+          var p;
+          r = e.selectedKeys === "all" || t.selectedKeys === "all" ? "all" : /* @__PURE__ */ new Set([
+            ...e.selectedKeys,
+            ...(p = t.selectedKeys) !== null && p !== void 0 ? p : []
+          ]);
+          var F, M;
+          return {
+            ...e,
+            state: "idle",
+            items: [
+              ...e.items,
+              ...(F = t.items) !== null && F !== void 0 ? F : []
+            ],
+            selectedKeys: r,
+            sortDescriptor: (M = t.sortDescriptor) !== null && M !== void 0 ? M : e.sortDescriptor,
+            abortController: void 0,
+            cursor: t.cursor
+          };
+        case "error":
+          return t.abortController !== e.abortController ? e : {
+            ...e,
+            state: "error",
+            error: t.error
+          };
+        case "loading":
+        case "sorting":
+        case "filtering":
+          var K;
+          (K = e.abortController) === null || K === void 0 || K.abort();
+          var h;
+          return {
+            ...e,
+            filterText: (h = t.filterText) !== null && h !== void 0 ? h : e.filterText,
+            state: t.type,
+            // Reset items to an empty list if loading, but not when sorting.
+            items: t.type === "loading" ? [] : e.items,
+            abortController: t.abortController
+          };
+        case "loadingMore":
+          var I;
+          return (I = t.abortController) === null || I === void 0 || I.abort(), e;
+        case "update":
+          var $;
+          return {
+            ...e,
+            ...($ = t.updater) === null || $ === void 0 ? void 0 : $.call(t, e)
+          };
+        default:
+          throw new Error(`Invalid action "${t.type}" in state "${e.state}"`);
+      }
+    default:
+      throw new Error(`Invalid state "${e.state}"`);
+  }
+}
+function Yt(e) {
+  const { load: t, sort: r, initialSelectedKeys: s, initialSortDescriptor: o, getKey: n = (d) => d.id || d.key, initialFilterText: c = "" } = e;
+  let [l, u] = St(Xt, {
+    state: "idle",
+    error: void 0,
+    items: [],
+    selectedKeys: s === "all" ? "all" : new Set(s),
+    sortDescriptor: o,
+    filterText: c
+  });
+  const b = async (d, w) => {
+    let p = new AbortController();
+    try {
+      u({
+        ...d,
+        abortController: p
+      });
+      var F;
+      let h = (F = d.filterText) !== null && F !== void 0 ? F : l.filterText;
+      var M;
+      let I = await w({
+        items: l.items.slice(),
+        selectedKeys: l.selectedKeys,
+        sortDescriptor: (M = d.sortDescriptor) !== null && M !== void 0 ? M : l.sortDescriptor,
+        signal: p.signal,
+        cursor: d.type === "loadingMore" ? l.cursor : void 0,
+        filterText: h,
+        loadingState: l.state
+      });
+      var K;
+      let $ = (K = I.filterText) !== null && K !== void 0 ? K : h;
+      u({
+        type: "success",
+        ...I,
+        abortController: p
+      }), $ && $ !== h && !p.signal.aborted && b({
+        type: "filtering",
+        filterText: $
+      }, t);
+    } catch (h) {
+      u({
+        type: "error",
+        error: h,
+        abortController: p
+      });
+    }
+  };
+  let x = O(!1);
+  return H(() => {
+    x.current || (b({
+      type: "loading"
+    }, t), x.current = !0);
+  }, []), {
+    items: l.items,
+    selectedKeys: l.selectedKeys,
+    sortDescriptor: l.sortDescriptor,
+    isLoading: l.state === "loading" || l.state === "loadingMore" || l.state === "sorting" || l.state === "filtering",
+    loadingState: l.state,
+    error: l.error,
+    filterText: l.filterText,
+    getItem(d) {
+      return l.items.find((w) => n(w) === d);
+    },
+    reload() {
+      b({
+        type: "loading"
+      }, t);
+    },
+    loadMore() {
+      l.state === "loading" || l.state === "loadingMore" || l.state === "filtering" || l.cursor == null || b({
+        type: "loadingMore"
+      }, t);
+    },
+    sort(d) {
+      b({
+        type: "sorting",
+        sortDescriptor: d
+      }, r || t);
+    },
+    ...Jt({
+      ...e,
+      getKey: n,
+      cursor: l.cursor
+    }, (d) => {
+      u({
+        type: "update",
+        updater: d
+      });
+    }),
+    setFilterText(d) {
+      b({
+        type: "filtering",
+        filterText: d
+      }, t);
+    }
+  };
+}
+const Zt = /* @__PURE__ */ Qe(null);
+function _t(e, t, r, s) {
+  var o = this, n = O(null), c = O(0), l = O(0), u = O(null), b = O([]), x = O(), d = O(), w = O(e), p = O(!0);
+  w.current = e;
+  var F = typeof window < "u", M = !t && t !== 0 && F;
+  if (typeof e != "function") throw new TypeError("Expected a function");
+  t = +t || 0;
+  var K = !!(r = r || {}).leading, h = !("trailing" in r) || !!r.trailing, I = "maxWait" in r, $ = "debounceOnServer" in r && !!r.debounceOnServer, Q = I ? Math.max(+r.maxWait || 0, t) : null;
+  H(function() {
+    return p.current = !0, function() {
+      p.current = !1;
+    };
+  }, []);
+  var de = J(function() {
+    var D = function(y) {
+      var V = b.current, Z = x.current;
+      return b.current = x.current = null, c.current = y, l.current = l.current || y, d.current = w.current.apply(Z, V);
+    }, G = function(y, V) {
+      M && cancelAnimationFrame(u.current), u.current = M ? requestAnimationFrame(y) : setTimeout(y, V);
+    }, re = function(y) {
+      if (!p.current) return !1;
+      var V = y - n.current;
+      return !n.current || V >= t || V < 0 || I && y - c.current >= Q;
+    }, X = function(y) {
+      return u.current = null, h && b.current ? D(y) : (b.current = x.current = null, d.current);
+    }, Y = function y() {
+      var V = Date.now();
+      if (K && l.current === c.current && le(), re(V)) return X(V);
+      if (p.current) {
+        var Z = t - (V - n.current), N = I ? Math.min(Z, Q - (V - c.current)) : Z;
+        G(y, N);
+      }
+    }, le = function() {
+    }, q = function() {
+      if (F || $) {
+        var y = Date.now(), V = re(y);
+        if (b.current = [].slice.call(arguments), x.current = o, n.current = y, V) {
+          if (!u.current && p.current) return c.current = n.current, G(Y, t), K ? D(n.current) : d.current;
+          if (I) return G(Y, t), D(n.current);
+        }
+        return u.current || G(Y, t), d.current;
+      }
+    };
+    return q.cancel = function() {
+      var y = u.current;
+      y && (M ? cancelAnimationFrame(u.current) : clearTimeout(u.current)), c.current = 0, b.current = n.current = x.current = u.current = null;
+    }, q.isPending = function() {
+      return !!u.current;
+    }, q.flush = function() {
+      return u.current ? X(Date.now()) : d.current;
+    }, q;
+  }, [K, I, t, Q, h, M, F, $, s]);
+  return de;
+}
+const { withProvider: er, withContext: W } = /* @__PURE__ */ Ot({
+  key: "combobox"
+}), tr = /* @__PURE__ */ er("div", "root"), rr = /* @__PURE__ */ W("div", "trigger"), or = /* @__PURE__ */ W("div", "leadingElement"), nr = /* @__PURE__ */ W("div", "content"), sr = /* @__PURE__ */ W("div", "tagGroup"), lr = /* @__PURE__ */ W("div", "input"), ir = /* @__PURE__ */ W("div", "popover"), cr = /* @__PURE__ */ W("div", "listBox"), ar = /* @__PURE__ */ W("div", "section"), ur = /* @__PURE__ */ W("div", "option"), dr = /* @__PURE__ */ W("div", "optionIndicator"), fr = /* @__PURE__ */ W("div", "optionContent"), Be = /* @__PURE__ */ Ht({
+  clearSelection: {
+    id: "Nimbus.ComboBox.clearSelection",
+    description: "aria-label for clear selection button in ComboBox",
+    defaultMessage: "Clear selection"
+  },
+  toggleOptions: {
+    id: "Nimbus.ComboBox.toggleOptions",
+    description: "aria-label for toggle button to open/close options",
+    defaultMessage: "Toggle options"
+  },
+  selectedValues: {
+    id: "Nimbus.ComboBox.selectedValues",
+    description: "aria-label for selected values tag group",
+    defaultMessage: "Selected values"
+  },
+  options: {
+    id: "Nimbus.ComboBox.options",
+    description: "aria-label for combobox menu options",
+    defaultMessage: "Options menu"
+  }
+});
+function Ze(e) {
+  if (typeof e == "string" || typeof e == "number")
+    return e;
+  if ("id" in e)
+    return e.id;
+  throw new Error(
+    "ComboBox - Item must have an 'id' property or provide getKey function"
+  );
+}
+function mr(e) {
+  return typeof e == "string" ? e : "name" in e ? String(e.name) : "label" in e ? String(e.label) : (console.warn(
+    "ComboBox - Item should have 'name' or 'label' property. Provide a getTextValue function to ensure proper item display and filtering."
+  ), String(e));
+}
+function pr(e) {
+  return {
+    id: e,
+    name: e
+  };
+}
+const gr = (e) => e ? e instanceof Set ? e : new Set(Array.isArray(e) ? e : [e]) : /* @__PURE__ */ new Set(), yr = (e) => Array.from(e), Re = /* @__PURE__ */ Qe(null), Ae = () => {
+  const e = Ee(Re);
+  if (!e)
+    throw new Error(
+      "Nimbus - ComboBox components must be used within ComboBox.Root"
+    );
+  return e;
+}, _e = (e) => {
+  const {
+    name: t,
+    form: r,
+    selectedKeys: s,
+    selectionMode: o,
+    formValue: n,
+    allowsCustomOptions: c,
+    collection: l,
+    inputValue: u
+  } = e;
+  if (!t) return null;
+  const b = J(() => {
+    if (o === "single") {
+      const x = Array.from(s)[0];
+      return x ? n === "text" || c ? Array.from(l).find(
+        (w) => w.key === x
+      )?.textValue || u || "" : String(x) : "";
+    } else {
+      const x = Array.from(s);
+      return n === "text" || c ? x.map((d) => Array.from(l).find(
+        (p) => p.key === d
+      )?.textValue || "").filter(Boolean).join(",") : x.join(",");
+    }
+  }, [
+    o,
+    s,
+    n,
+    c,
+    l,
+    u
+  ]);
+  return /* @__PURE__ */ g(
+    "input",
+    {
+      type: "hidden",
+      name: t,
+      form: typeof r == "string" ? r : void 0,
+      value: b
+    }
+  );
+};
+_e.displayName = "ComboBoxHiddenInput";
+function et(e) {
+  let t;
+  [e, t] = kt(e, null, Zt);
+  const {
+    selectionMode: r = "single",
+    size: s = "md",
+    getKey: o = Ze,
+    getTextValue: n = mr,
+    children: c,
+    leadingElement: l,
+    inputValue: u,
+    onInputChange: b,
+    isLoading: x,
+    allowsEmptyMenu: d,
+    renderEmptyState: w,
+    async: p,
+    filter: F,
+    allowsCustomOptions: M = !1,
+    isDisabled: K = !1,
+    isInvalid: h = !1,
+    isRequired: I = !1,
+    isReadOnly: $ = !1
+  } = e, Q = Nt({ key: "combobox" }), [de, D] = Q.splitVariantProps(e), [G, re] = ue(D), X = O(null), Y = O(null), [le, q] = U([]), y = Yt({
+    getKey: o,
+    async load({ signal: B, filterText: z }) {
+      if (!p) return { items: [] };
+      const v = p.minSearchLength ?? 0;
+      if (!z || z.length < v)
+        return { items: [] };
+      try {
+        return { items: await p.load(z, B) };
+      } catch (A) {
+        if (A.name === "AbortError")
+          throw A;
+        const _ = A;
+        return p.onError?.(_), { items: [] };
+      }
+    }
+  }), [V, Z] = U(u), [N, xe] = U(!1), [ie, fe] = U([]), Te = p?.debounce ?? 300, ve = _t((B) => {
+    xe(!1), y.setFilterText(B);
+  }, Te), Ce = L(
+    (B) => {
+      Z(B), xe(!0), ve(B);
+    },
+    [ve]
+  ), R = p ? V : u, Se = p ? Ce : b, j = p ? N || y.loadingState === "loading" || y.loadingState === "loadingMore" || y.loadingState === "filtering" : x, we = p || M ? !0 : d, $e = L(() => j ? R?.length ? `loading results for "${R}"` : "loading results" : R?.length && p?.minSearchLength && R.length >= p.minSearchLength ? `no results for "${R}"` : p?.minSearchLength ? `enter at least ${p?.minSearchLength} characters` : "type to search", [p?.minSearchLength, j, R]), Ke = L(() => j ? R?.length ? `loading results for "${R}"` : "loading results" : 'hit "enter" to create an option', [j, R]), pe = (M ? Ke : p ? $e : void 0) ?? w, ce = J(() => {
+    const B = p ? Array.from(y.items) : e.items, z = B ? Array.from(B) : [], v = new Set(z.map((oe) => o(oe)));
+    let _ = [...le.filter(
+      (oe) => !v.has(o(oe))
+    ), ...z];
+    if (p && r === "multiple" && ie.length > 0) {
+      const oe = new Set(_.map((T) => o(T)));
+      _ = [...ie.filter(
+        (T) => !oe.has(o(T))
+      ), ..._];
+    }
+    return _;
+  }, [
+    p,
+    y.items,
+    e.items,
+    le,
+    ie,
+    r,
+    o
+  ]), ge = J(
+    () => ({
+      selectionMode: r,
+      size: s,
+      getKey: o,
+      getTextValue: n,
+      leadingElement: l,
+      triggerRef: X,
+      inputRef: Y,
+      isLoading: j,
+      isDisabled: K,
+      isRequired: I,
+      isInvalid: h,
+      isReadOnly: $
+    }),
+    [
+      r,
+      o,
+      n,
+      l,
+      X,
+      Y,
+      K,
+      I,
+      h,
+      $
+    ]
+  ), ye = J(() => {
+    if (ce)
+      return Array.from(ce).map((B) => {
+        const z = "id" in B, v = "textValue" in B;
+        return z && v ? B : {
+          ...B,
+          ...z ? {} : { id: o(B) },
+          ...v ? {} : { textValue: n(B) }
+        };
+      });
+  }, [ce, o, n]), Fe = J(
+    () => /* @__PURE__ */ g(
+      Re.Provider,
+      {
+        value: ge,
+        children: /* @__PURE__ */ g(Xe.Provider, { value: { items: ye }, children: typeof c == "function" ? c({
+          isOpen: !1,
+          isDisabled: K,
+          isInvalid: h,
+          isRequired: I,
+          defaultChildren: null
+        }) : c })
+      }
+    ),
+    [
+      c,
+      K,
+      h,
+      I,
+      ye,
+      ge
+    ]
+  );
+  return /* @__PURE__ */ g(
+    Ye,
+    {
+      values: [
+        [Le, {}],
+        [Me, {}],
+        [De, {}]
+      ],
+      children: /* @__PURE__ */ g(
+        Re.Provider,
+        {
+          value: ge,
+          children: /* @__PURE__ */ g(
+            tr,
+            {
+              ref: t,
+              ...de,
+              ...G,
+              size: s,
+              "data-disabled": K,
+              "data-invalid": h,
+              "data-required": I,
+              "data-readonly": $,
+              "data-open": e.isOpen,
+              role: "group",
+              children: /* @__PURE__ */ g(Tt, { content: Fe, children: (B) => (
+                // Pass the built collection to ComboBoxRootInner which handles all behavior
+                /* @__PURE__ */ g(
+                  br,
+                  {
+                    ...re,
+                    size: s,
+                    filter: F,
+                    selectionMode: r,
+                    inputValue: R,
+                    onInputChange: Se,
+                    getKey: o,
+                    getTextValue: n,
+                    allowsEmptyMenu: we,
+                    renderEmptyState: pe,
+                    isDisabled: K,
+                    isRequired: I,
+                    isInvalid: h,
+                    isReadOnly: $,
+                    collection: B,
+                    allowsCustomOptions: M,
+                    asyncConfig: p,
+                    onAsyncSelectedItemsChange: p && r === "multiple" ? fe : void 0,
+                    onAddCustomItem: q,
+                    onAddAsyncSelectedItem: fe
+                  }
+                )
+              ) })
+            }
+          )
+        }
+      )
+    }
+  );
+}
+et.displayName = "ComboBox.Root";
+const br = (e) => {
+  const t = Ut(), {
+    selectionMode: r = "single",
+    items: s,
+    collection: o,
+    getKey: n = Ze,
+    children: c,
+    selectedKeys: l = [],
+    onSelectionChange: u,
+    disabledKeys: b,
+    inputValue: x = "",
+    onInputChange: d,
+    filter: w,
+    placeholder: p,
+    menuTrigger: F = "input",
+    shouldCloseOnBlur: M = !0,
+    shouldCloseOnSelect: K = !0,
+    isOpen: h,
+    defaultOpen: I = !1,
+    onOpenChange: $,
+    allowsEmptyMenu: Q = !1,
+    renderEmptyState: de,
+    allowsCustomOptions: D = !1,
+    isValidNewOption: G,
+    getNewOptionData: re = pr,
+    onCreateOption: X,
+    "aria-label": Y,
+    "aria-labelledby": le,
+    "aria-describedby": q,
+    isDisabled: y = !1,
+    isRequired: V = !1,
+    isInvalid: Z = !1,
+    isReadOnly: N = !1,
+    shouldFocusWrap: xe = !0,
+    autoFocus: ie = !1,
+    name: fe,
+    formValue: Te,
+    validationBehavior: ve = "aria",
+    form: Ce,
+    validate: R,
+    isLoading: Se,
+    asyncConfig: j,
+    onAsyncSelectedItemsChange: we,
+    onAddCustomItem: $e,
+    onAddAsyncSelectedItem: Ke
+  } = e, me = Je(), pe = Je(), ce = O(null), ge = O(null), ye = J(
+    () => gr(l),
+    [l]
+  ), Fe = !!u, [B, z] = U(
+    ye
+  ), v = Fe ? ye : B, A = d !== void 0, _ = () => {
+    if (x) return x;
+    if (A || r !== "single") return "";
+    const i = Array.from(v);
+    if (i.length === 0) return "";
+    const a = i[0];
+    return o.getItem(a)?.textValue ?? "";
+  }, [oe, ee] = U(
+    _
+  ), T = A ? x : oe, te = O(T), [at, Ne] = U(I), C = h ?? at, [Oe, be] = U(
+    null
+  ), P = L(
+    (i) => {
+      h === void 0 && Ne(i), $?.(i);
+    },
+    [h, $]
+  ), ut = J(() => {
+    if (T.trim() === "")
+      return o;
+    if (r === "single") {
+      const a = Array.from(v);
+      if (a.length > 0) {
+        const f = a[0];
+        if (o.getItem(f)?.textValue === T)
+          return o;
+      }
+    }
+    if (w) {
+      const a = Array.from(o), f = Array.from(w(a, T)), S = new Set(f.map((Ie) => Ie.key));
+      return o.filter?.((Ie, Ve) => S.has(Ve.key)) ?? o;
+    }
+    const i = T.toLowerCase();
+    return o.filter?.((a) => a.toLowerCase().includes(i)) ?? o;
+  }, [o, T, w, r, v]), dt = J(
+    () => r === "multiple" ? Array.from(v).map((i) => o.getItem(i)?.value).filter((i) => i !== void 0) : [],
+    [r, v, o]
+  ), [ft, mt] = U(null), pt = L(() => {
+    const i = h === void 0 ? !C : !h;
+    h === void 0 ? Ne((a) => !a) : $?.(!h), i && (ne.current?.focus(), be("first"));
+  }, [h, C, $]), gt = L(
+    (i) => {
+      A || ee(i), d?.(i), F === "input" && i !== te.current && P(!0), te.current = i;
+    },
+    [A, d, F, P]
+  ), k = L(
+    (i, a) => {
+      let f = i === "all" ? new Set(Array.from(o).map((E) => E.key)) : i;
+      const S = a ?? v, Ie = f.size > 0 && Array.from(f).every((E) => S.has(E)) && f.size < S.size;
+      if (r === "multiple" && f.size === 1 && !Ie) {
+        const E = Array.from(f)[0], ae = S.has(E), se = new Set(S);
+        ae ? se.delete(E) : se.add(E), f = se;
+      }
+      const Ve = yr(f);
+      if (u ? u(Ve) : z(f), j && r === "multiple" && we) {
+        const E = Array.from(f).map((ae) => o.getItem(ae)?.value).filter((ae) => ae !== void 0);
+        we(E);
+      }
+      if (r === "single") {
+        const E = Array.from(f)[0];
+        if (E !== null) {
+          const se = o.getItem(E)?.textValue ?? "";
+          A || (ee(se), te.current = se), d?.(se);
+        }
+        K && P(!1);
+      }
+    },
+    [
+      o,
+      r,
+      v,
+      u,
+      d,
+      K,
+      P,
+      A
+    ]
+  ), m = Qt({
+    selectionMode: r,
+    collection: ut,
+    selectedKeys: v,
+    onSelectionChange: k,
+    disabledKeys: b
+  }), yt = L(() => {
+    m.selectionManager.setSelectedKeys(/* @__PURE__ */ new Set()), r === "single" && (A || (ee(""), te.current = ""), d?.(""));
+  }, [m.selectionManager, r, A, d]), ze = L(
+    (i) => {
+      $e?.((S) => [...S, i]), j && r === "multiple" && Ke?.((S) => [...S, i]);
+      const a = n(i), f = v;
+      if (r === "single")
+        k(/* @__PURE__ */ new Set([a]), f);
+      else {
+        const S = new Set(f);
+        S.add(a), k(S, f);
+      }
+    },
+    [
+      $e,
+      j,
+      r,
+      Ke,
+      n,
+      v,
+      k
+    ]
+  ), ke = L(() => {
+    if (!D) return !1;
+    const i = T.trim();
+    if (!i || Array.from(o).some(
+      (S) => S.textValue?.toLowerCase() === i.toLowerCase()
+    ) || G && !G(i))
+      return !1;
+    const f = re(i);
+    return ze(f), r === "multiple" ? (A || (ee(""), te.current = ""), d?.("")) : (A || (ee(i), te.current = i), d?.(i)), X?.(f), !0;
+  }, [
+    D,
+    re,
+    G,
+    T,
+    o,
+    r,
+    d,
+    X,
+    ze,
+    A,
+    ee,
+    te
+  ]), bt = L(
+    (i) => {
+      if (y || N) return;
+      const a = v, f = new Set(a);
+      i.forEach((S) => f.delete(S)), k(f, a), f.size === 0 && ne.current?.focus();
+    },
+    [v, k, y, N]
+  ), ht = L(
+    (i) => {
+      switch (i.key) {
+        case "ArrowDown":
+          if (i.preventDefault(), !C)
+            P(!0), be("first");
+          else {
+            const a = m.selectionManager.focusedKey, f = a ? m.collection.getKeyAfter(a) : m.collection.getFirstKey();
+            m.selectionManager.setFocusedKey(
+              f ?? m.collection.getFirstKey()
+            );
+          }
+          break;
+        case "ArrowUp":
+          if (i.preventDefault(), !C)
+            P(!0), be("last");
+          else {
+            const a = m.selectionManager.focusedKey, f = a ? m.collection.getKeyBefore(a) : m.collection.getLastKey();
+            m.selectionManager.setFocusedKey(
+              f ?? m.collection.getLastKey()
+            );
+          }
+          break;
+        case "Enter":
+          if (C && m.selectionManager.focusedKey) {
+            i.preventDefault();
+            const a = m.selectionManager.focusedKey;
+            if (r === "multiple") {
+              const f = new Set(v);
+              f.has(a) ? f.delete(a) : f.add(a), k(f);
+            } else
+              k(/* @__PURE__ */ new Set([a])), m.selectionManager.setFocusedKey(null);
+          } else C && !m.selectionManager.focusedKey && D && ke() && i.preventDefault();
+          break;
+        case "Escape":
+          C && (i.preventDefault(), P(!1), m.selectionManager.setFocusedKey(null));
+          break;
+        case "Home":
+          if (C) {
+            i.preventDefault();
+            const a = m.collection.getFirstKey();
+            m.selectionManager.setFocusedKey(a);
+          }
+          break;
+        case "End":
+          if (C) {
+            i.preventDefault();
+            const a = m.collection.getLastKey();
+            m.selectionManager.setFocusedKey(a);
+          }
+          break;
+        case "Backspace":
+          if (T === "") {
+            const a = Array.from(v);
+            if (a.length > 0)
+              if (i.preventDefault(), r === "single")
+                k(/* @__PURE__ */ new Set());
+              else {
+                const f = new Set(a);
+                f.delete(a[a.length - 1]), k(f);
+              }
+          }
+          break;
+      }
+    },
+    [
+      C,
+      m.selectionManager,
+      m.collection,
+      k,
+      P,
+      be,
+      r,
+      T,
+      v,
+      D,
+      ke
+    ]
+  ), xt = L(() => {
+    F === "focus" && !y && !N && P(!0), r === "single" && T && ne.current && ne.current.select();
+  }, [
+    F,
+    y,
+    N,
+    P,
+    r,
+    T
+  ]), vt = L(
+    (i) => {
+      if (!M) return;
+      const a = i.currentTarget;
+      setTimeout(() => {
+        const f = document.activeElement;
+        a.contains(f) || P(!1);
+      }, 150);
+    },
+    [M, P]
+  ), We = O(null);
+  H(() => {
+    ie && ne.current && !y && ne.current.focus();
+  }, [ie, y]);
+  const Ge = O(C);
+  H(() => {
+    h === void 0 && Ge.current !== C && (Ge.current = C, $?.(C));
+  }, [C, h, $]), H(() => {
+    if (r !== "single") return;
+    const i = Array.from(m.selectionManager.selectedKeys), a = i.length > 0 ? i[0] : null;
+    if (a === We.current) return;
+    We.current = a;
+    const f = a !== null ? m.collection.getItem(a) : null;
+    if (a !== null && !f)
+      return;
+    const S = f?.textValue ?? "";
+    A ? d?.(S) : (ee(S), te.current = S);
+  }, [
+    r,
+    m.selectionManager.selectedKeys,
+    m.collection,
+    A,
+    d
+  ]), H(() => {
+    if (C && Oe) {
+      const i = Oe === "first" ? m.collection.getFirstKey() : m.collection.getLastKey();
+      m.selectionManager.setFocusedKey(i ?? null), be(null);
+    }
+  }, [C, Oe, m.collection, m.selectionManager]), H(() => {
+    C ? m.selectionManager.setFocused(!0) : (m.selectionManager.setFocused(!1), m.selectionManager.setFocusedKey(null));
+  }, [C, m.selectionManager]);
+  const qe = O(!1);
+  m.collection.size > 0 && (qe.current = !0), H(() => {
+    if (!C || Q || Se || !qe.current) return;
+    m.collection.size > 0 || P(!1);
+  }, [
+    C,
+    Q,
+    Se,
+    m.collection.size,
+    P,
+    T
+  ]);
+  const { triggerRef: je, inputRef: ne } = Ae();
+  H(() => {
+    const i = je.current;
+    if (!i) return;
+    const a = () => {
+      const S = i.offsetWidth;
+      mt(`${S}px`);
+    };
+    a();
+    const f = new ResizeObserver(a);
+    return f.observe(i), () => {
+      f.disconnect();
+    };
+  }, []);
+  const Ct = [
+    // InputContext: Props for ComboBox.Input component
+    // Configures the input field with ARIA attributes, event handlers, and validation
+    [
+      Me,
+      {
+        ref: ne,
+        role: "combobox",
+        // ARIA role for autocomplete input
+        "aria-autocomplete": "list",
+        // Indicates suggestions are in a list
+        "aria-controls": r === "multiple" ? `${pe} ${me}` : me,
+        // Single-select: controls only listbox
+        "aria-expanded": C,
+        // Announces menu open/closed state
+        "aria-activedescendant": m.selectionManager.focusedKey ? `${me}-option-${m.selectionManager.focusedKey}` : void 0,
+        "aria-describedby": r === "multiple" ? `${pe} ${q ?? ""}` : q,
+        "aria-label": Y,
+        "aria-labelledby": le,
+        value: T,
+        onChange: (i) => gt(i.target.value),
+        onKeyDown: ht,
+        onFocus: xt,
+        onBlur: vt,
+        disabled: y,
+        readOnly: N,
+        required: V,
+        "aria-invalid": Z,
+        placeholder: p,
+        name: fe,
+        form: Ce,
+        validationbehavior: ve,
+        validate: R
+      }
+    ],
+    // TagGroupContext: Props for ComboBox.TagGroup component (multi-select only)
+    // Renders selected items as removable tags
+    [
+      De,
+      {
+        id: pe,
+        "aria-label": t.formatMessage(Be.selectedValues),
+        items: dt,
+        // Selected items to display as tags
+        onRemove: bt
+        // Handle tag removal
+      }
+    ],
+    // ButtonContext: Props for toggle and clear buttons
+    // Uses "slots" pattern to configure multiple buttons via single context
+    [
+      Le,
+      {
+        slots: {
+          toggle: {
+            onPress: pt,
+            "aria-label": t.formatMessage(Be.toggleOptions),
+            isDisabled: y || N,
+            isPressed: C
+            // Visual indicator that menu is open
+          },
+          clear: {
+            onPress: yt,
+            "aria-label": t.formatMessage(Be.clearSelection),
+            style: v.size > 0 ? void 0 : { display: "none" },
+            isDisabled: y || N || m.selectionManager.selectedKeys.size === 0
+            // Disabled when nothing selected
+          }
+        }
+      }
+    ],
+    // PopoverContext: Props for ComboBox.Popover component
+    // Controls menu positioning, portal rendering, and open/close behavior
+    [
+      qt,
+      {
+        isOpen: C,
+        // No-op onOpenChange: We control state internally, prevent React Aria from managing its own state
+        onOpenChange: () => {
+        },
+        ref: ge,
+        triggerRef: je,
+        // Popover positions relative to this element
+        scrollRef: ce,
+        // Enables scroll-into-view for keyboard navigation
+        isNonModal: !0,
+        // Non-modal: doesn't trap focus, allows interaction outside
+        trigger: "ComboBox",
+        // Identifies this as a combobox popover (not tooltip, dialog, etc.)
+        placement: "bottom start",
+        // Default placement below trigger, aligned to start
+        style: {
+          "--nimbus-combobox-trigger-width": ft
+        },
+        // CSS custom property for menu width
+        clearContexts: [
+          // Clear these contexts so popover content doesn't inherit combobox contexts
+          Gt,
+          Le,
+          Me,
+          Wt,
+          jt
+        ]
+      }
+    ],
+    // SelectableCollectionContext: Enables virtual focus for keyboard navigation
+    // Virtual focus uses aria-activedescendant instead of moving browser focus
+    [zt, { shouldUseVirtualFocus: !0 }],
+    // ListBoxContext: Props for ComboBox.ListBox component
+    // Configures the option list with items, ARIA attributes, and behaviors
+    [
+      Xe,
+      {
+        items: s,
+        // Items to render (merged from outer component)
+        id: me,
+        // ID referenced by aria-controls on input
+        ref: ce,
+        // Ref for scroll positioning
+        renderEmptyState: de,
+        // Custom empty state renderer
+        shouldFocusWrap: xe,
+        // Whether to wrap focus from last to first item
+        "aria-label": t.formatMessage(Be.options)
+      }
+    ],
+    // ListStateContext: React Aria's collection state for managing selection and focus
+    [It, m]
+  ];
+  return /* @__PURE__ */ he(
+    Ye,
+    {
+      values: Ct,
+      children: [
+        /* @__PURE__ */ g(
+          _e,
+          {
+            name: fe,
+            form: Ce,
+            selectedKeys: v,
+            selectionMode: r,
+            formValue: Te,
+            allowsCustomOptions: D,
+            collection: m.collection,
+            inputValue: T
+          }
+        ),
+        c
+      ]
+    }
+  );
+}, tt = (e) => {
+  const [t, r] = ue(e), s = Ee(Me), { inputRef: o } = Ae();
+  let n = "", c = "";
+  s && typeof s == "object" && "value" in s && (n = s.value || "", c = s.placeholder || "");
+  const l = Math.max(n.length || c.length || 1, 1);
+  return /* @__PURE__ */ g(lr, { asChild: !0, ...t, children: /* @__PURE__ */ g(
+    Dt,
+    {
+      ref: o,
+      ...r,
+      size: l,
+      "data-empty": !(n.length || c.length)
+    }
+  ) });
+};
+tt.displayName = "ComboBox.Input";
+const hr = ({
+  children: e
+}) => /* @__PURE__ */ g(or, { children: e }), rt = (e) => {
+  const { selectionMode: t, size: r, getKey: s, getTextValue: o, isDisabled: n, isReadOnly: c } = Ae(), [l, u] = ue(e), b = Ee(De), x = (b && "items" in b ? b.items : void 0) ?? [];
+  return t !== "multiple" ? null : /* @__PURE__ */ g(sr, { ...l, ...u, asChild: !0, children: /* @__PURE__ */ g(Pe.Root, { size: r, children: /* @__PURE__ */ g(Pe.TagList, { items: x, display: "contents", children: (d) => {
+    const w = s(d), p = o(d);
+    return /* @__PURE__ */ g(
+      Pe.Tag,
+      {
+        id: w,
+        textValue: p,
+        isDisabled: n || c,
+        maxW: "100%",
+        children: p
+      }
+    );
+  } }) }) });
+};
+rt.displayName = "ComboBox.TagGroup";
+const ot = ({
+  children: e,
+  ...t
+}) => {
+  const { triggerRef: r, leadingElement: s, inputRef: o, isLoading: n, isDisabled: c } = Ae();
+  return /* @__PURE__ */ he(rr, { ref: r, onClick: (u) => {
+    !c && u.target instanceof HTMLElement && !u.target.closest("button") && o.current?.focus();
+  }, ...t, children: [
+    s && /* @__PURE__ */ g(hr, { children: s }),
+    /* @__PURE__ */ he(nr, { children: [
+      /* @__PURE__ */ g(rt, {}),
+      /* @__PURE__ */ g(tt, {})
+    ] }),
+    /* @__PURE__ */ g(
+      Ue,
+      {
+        slot: "clear",
+        size: "2xs",
+        variant: "ghost",
+        colorPalette: "primary",
+        children: /* @__PURE__ */ g(Vt, {})
+      }
+    ),
+    /* @__PURE__ */ g(
+      Ue,
+      {
+        slot: "toggle",
+        size: "2xs",
+        variant: "ghost",
+        colorPalette: "neutral",
+        excludeFromTabOrder: !0,
+        children: n ? /* @__PURE__ */ g(Et, { size: "xs", margin: "50" }) : /* @__PURE__ */ g(Pt, {})
+      }
+    ),
+    e
+  ] });
+};
+ot.displayName = "ComboBox.Trigger";
+const nt = ({
+  children: e,
+  ref: t,
+  ...r
+}) => {
+  const [s, o] = ue(r);
+  return /* @__PURE__ */ g(ir, { asChild: !0, ...s, children: /* @__PURE__ */ g(
+    Rt,
+    {
+      ref: t,
+      isNonModal: !0,
+      autoFocus: !0,
+      ...o,
+      children: e
+    }
+  ) });
+};
+nt.displayName = "ComboBox.Popover";
+function st({
+  children: e,
+  ref: t,
+  ...r
+}) {
+  const [s, o] = ue(r);
+  return /* @__PURE__ */ g(cr, { ...s, ref: t, asChild: !0, children: /* @__PURE__ */ g(Bt, { ...o, children: typeof e == "function" ? (c) => {
+    const l = e(c), u = c;
+    return wt(l) && (u.id || u.textValue) ? $t(
+      l,
+      {
+        ...l.props,
+        ...u.id ? { id: u.id } : {},
+        ...u.textValue ? { textValue: u.textValue } : {}
+      }
+    ) : l;
+  } : e }) });
+}
+st.displayName = "ComboBox.ListBox";
+function lt({
+  children: e,
+  ref: t,
+  ...r
+}) {
+  const [s, o] = ue(r);
+  return /* @__PURE__ */ g(ur, { ...s, asChild: !0, children: /* @__PURE__ */ g(Mt, { ref: t, ...o, children: (n) => {
+    const c = typeof e == "function" ? e({
+      ...n
+    }) : e;
+    return n.selectionMode === "multiple" ? /* @__PURE__ */ he(He, { children: [
+      /* @__PURE__ */ g(dr, { children: /* @__PURE__ */ g("span", { "data-selected": n.isSelected, children: n.isSelected && /* @__PURE__ */ g(Lt, {}) }) }),
+      /* @__PURE__ */ g(fr, { children: c })
+    ] }) : /* @__PURE__ */ g(He, { children: c });
+  } }) });
+}
+lt.displayName = "ComboBox.Option";
+function it({
+  children: e,
+  label: t,
+  items: r,
+  ref: s,
+  ...o
+}) {
+  if (r && typeof e != "function")
+    throw new Error(
+      'ComboBox.Section: When "items" is provided, "children" must be a function'
+    );
+  return /* @__PURE__ */ he(At, { ref: s, ...o, children: [
+    t && /* @__PURE__ */ g(ar, { asChild: !0, children: /* @__PURE__ */ g(Kt, { children: t }) }),
+    r ? /* @__PURE__ */ g(Ft, { items: r, children: (n) => typeof e == "function" ? e(n) : null }) : e
+  ] });
+}
+it.displayName = "ComboBox.Section";
+function ct(e, t) {
+  if (!t.trim()) return e;
+  const r = t.toLowerCase(), s = [];
+  for (const o of e)
+    o.textValue.toLowerCase().includes(r) && s.push(o);
+  return s;
+}
+function xr(e, t) {
+  if (!t.trim()) return e;
+  const r = t.toLowerCase(), s = [];
+  for (const o of e)
+    o.textValue.toLowerCase().startsWith(r) && s.push(o);
+  return s;
+}
+function vr(e, t) {
+  if (!t.trim()) return e;
+  const r = [];
+  for (const s of e)
+    s.textValue.includes(t) && r.push(s);
+  return r;
+}
+function Cr(e, t) {
+  if (!t.trim()) return e;
+  const r = t.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), s = new RegExp(`\\b${r}`, "i"), o = [];
+  for (const n of e)
+    s.test(n.textValue) && o.push(n);
+  return o;
+}
+function Sr(e, t) {
+  if (!t.trim()) return e;
+  const r = t.toLowerCase(), s = [];
+  for (const o of e) {
+    const n = o.textValue.toLowerCase();
+    let c = 0;
+    for (let l = 0; l < n.length && c < r.length; l++)
+      n[l] === r[c] && c++;
+    c === r.length && s.push(o);
+  }
+  return s;
+}
+function wr(e) {
+  return (t, r) => {
+    if (!r.trim()) return t;
+    const s = r.toLowerCase(), o = [];
+    for (const n of t) {
+      const c = n.value;
+      if (!c) continue;
+      e.some((u) => {
+        const b = u.split(".").reduce((d, w) => d && typeof d == "object" ? d[w] : void 0, c);
+        return b == null ? !1 : String(b).toLowerCase().includes(s);
+      }) && o.push(n);
+    }
+    return o;
+  };
+}
+function $r(e) {
+  return (t, r) => {
+    if (!r.trim()) return t;
+    const s = [];
+    for (const o of t) {
+      const n = e(o, r);
+      n > 0 && s.push({ node: o, score: n });
+    }
+    return s.sort((o, n) => n.score - o.score), s.map((o) => o.node);
+  };
+}
+function Kr(e = ct) {
+  return (t, r) => {
+    if (!r.trim()) return t;
+    const s = r.split(/\s+/).filter((c) => c.length > 0);
+    if (s.length === 0) return t;
+    const o = /* @__PURE__ */ new Set();
+    for (const c of s) {
+      const l = e(t, c);
+      for (const u of l)
+        o.add(u.key);
+    }
+    const n = [];
+    for (const c of t)
+      o.has(c.key) && n.push(c);
+    return n;
+  };
+}
+function Ir(e) {
+  return (t, r) => {
+    if (!r.trim()) return t;
+    const s = [];
+    let o = null;
+    const n = [], c = () => {
+      o && n.length > 0 && (s.push(o), s.push(...n)), n.length = 0;
+    };
+    for (const l of t)
+      if (l.type === "section")
+        c(), o = l;
+      else {
+        const u = Array.from(e([l], r));
+        u.length > 0 && n.push(...u);
+      }
+    return c(), s;
+  };
+}
+const Zr = {
+  /**
+   * # ComboBox.Root
+   *
+   * The root component that provides state management and context for the combobox.
+   * Handles selection state, input filtering, popover open/close, and keyboard navigation.
+   *
+   * @example
+   * ```tsx
+   * <ComboBox.Root items={items}>
+   *   <ComboBox.Trigger />
+   *   <ComboBox.Popover>
+   *     <ComboBox.ListBox>
+   *       {(item) => <ComboBox.Option>{item.name}</ComboBox.Option>}
+   *     </ComboBox.ListBox>
+   *   </ComboBox.Popover>
+   * </ComboBox.Root>
+   * ```
+   */
+  Root: et,
+  /**
+   * # ComboBox.Trigger
+   *
+   * The trigger element that contains the input field and controls for the combobox.
+   * Automatically renders tag group (multi-select), input field, toggle button, and clear button.
+   *
+   * @example
+   * ```tsx
+   * <ComboBox.Root items={items}>
+   *   <ComboBox.Trigger />
+   *   <ComboBox.Popover>...</ComboBox.Popover>
+   * </ComboBox.Root>
+   * ```
+   */
+  Trigger: ot,
+  /**
+   * # ComboBox.Popover
+   *
+   * The popover container that displays the dropdown options list.
+   * Renders in a React portal and handles positioning relative to the trigger.
+   *
+   * @example
+   * ```tsx
+   * <ComboBox.Popover>
+   *   <ComboBox.ListBox>
+   *     {(item) => <ComboBox.Option>{item.name}</ComboBox.Option>}
+   *   </ComboBox.ListBox>
+   * </ComboBox.Popover>
+   * ```
+   */
+  Popover: nt,
+  /**
+   * # ComboBox.ListBox
+   *
+   * The container for dropdown options that displays filtered results.
+   *
+   * Use the render prop pattern - do **NOT** manually map over items as this is less performant.
+   *
+   * @example
+   * ```tsx
+   * <ComboBox.ListBox>
+   *   {(item) => <ComboBox.Option>{item.name}</ComboBox.Option>}
+   * </ComboBox.ListBox>
+   * ```
+   */
+  ListBox: st,
+  /**
+   * # ComboBox.Option
+   *
+   * An individual selectable option within the listbox.
+   * Displays a checkmark indicator for selected items in multi-select mode.
+   *
+   * @example
+   * ```tsx
+   * <ComboBox.Option>Option text</ComboBox.Option>
+   * ```
+   *
+   * @example Render prop pattern
+   * ```tsx
+   * <ComboBox.Option>
+   *   {({ isSelected }) => (
+   *     <span>Option 1 {isSelected && "✓"}</span>
+   *   )}
+   * </ComboBox.Option>
+   * ```
+   */
+  Option: lt,
+  /**
+   * # ComboBox.Section
+   *
+   * Groups related options together with an optional heading.
+   * Supports render prop pattern for dynamic option rendering within sections.
+   *
+   * @example
+   * ```tsx
+   * <ComboBox.Section label="Category Name">
+   *   <ComboBox.Option id="opt-1">Option 1</ComboBox.Option>
+   *   <ComboBox.Option id="opt-2">Option 2</ComboBox.Option>
+   * </ComboBox.Section>
+   * ```
+   *
+   * @example Render prop pattern
+   * ```tsx
+   * <ComboBox.Section items={categoryItems}>
+   *   {(item) => <ComboBox.Option>{item.name}</ComboBox.Option>}
+   * </ComboBox.Section>
+   * ```
+   */
+  Section: it,
+  /**
+   * # ComboBox.filters
+   *
+   * Built-in filter functions and utilities for customizing ComboBox filtering behavior.
+   * These filters can be passed to the `filter` prop on ComboBox.Root to control how options are filtered based on user input.
+   *
+   * **Available Filters:**
+   * - `filterByText`: Default substring matching (case-insensitive)
+   * - `filterByStartsWith`: Prefix matching
+   * - `filterByCaseSensitive`: Exact case substring matching
+   * - `filterByWordBoundary`: Word boundary matching
+   * - `filterByFuzzy`: Fuzzy matching (characters in order)
+   * - `createMultiPropertyFilter`: Search across multiple object properties
+   * - `createRankedFilter`: Custom scoring/ranking logic
+   * - `createMultiTermFilter`: OR logic for multiple search terms
+   * - `createSectionAwareFilter`: Preserves section structure while filtering
+   *
+   * @example Basic filter usage
+   * ```tsx
+   * import { ComboBox } from '@commercetools/nimbus';
+   *
+   * function MyComponent() {
+   *   return (
+   *     <ComboBox.Root
+   *       items={items}
+   *       filter={ComboBox.filters.filterByStartsWith}
+   *     >
+   *       <ComboBox.Trigger />
+   *       <ComboBox.Popover>
+   *         <ComboBox.ListBox>
+   *           {(item) => <ComboBox.Option>{item.name}</ComboBox.Option>}
+   *         </ComboBox.ListBox>
+   *       </ComboBox.Popover>
+   *     </ComboBox.Root>
+   *   );
+   * }
+   * ```
+   *
+   * @example Multi-property search
+   * ```tsx
+   * const productFilter = ComboBox.filters.createMultiPropertyFilter<Product>([
+   *   'name',
+   *   'category',
+   *   'description'
+   * ]);
+   *
+   * function ProductSearch() {
+   *   return (
+   *     <ComboBox.Root items={products} filter={productFilter}>
+   *       <ComboBox.Trigger />
+   *       <ComboBox.Popover>
+   *         <ComboBox.ListBox>
+   *           {(item) => <ComboBox.Option>{item.name}</ComboBox.Option>}
+   *         </ComboBox.ListBox>
+   *       </ComboBox.Popover>
+   *     </ComboBox.Root>
+   *   );
+   * }
+   * ```
+   *
+   * @example Section-aware filtering
+   * ```tsx
+   * const sectionFilter = ComboBox.filters.createSectionAwareFilter(
+   *   ComboBox.filters.filterByFuzzy
+   * );
+   *
+   * function SectionedSearch() {
+   *   return (
+   *     <ComboBox.Root items={sectionsWithItems} filter={sectionFilter}>
+   *       <ComboBox.Trigger />
+   *       <ComboBox.Popover>
+   *         <ComboBox.ListBox>
+   *           {(section) => (
+   *             <ComboBox.Section>
+   *               {(item) => <ComboBox.Option>{item.name}</ComboBox.Option>}
+   *             </ComboBox.Section>
+   *           )}
+   *         </ComboBox.ListBox>
+   *       </ComboBox.Popover>
+   *     </ComboBox.Root>
+   *   );
+   * }
+   * ```
+   */
+  filters: {
+    filterByText: ct,
+    filterByStartsWith: xr,
+    filterByCaseSensitive: vr,
+    filterByWordBoundary: Cr,
+    filterByFuzzy: Sr,
+    createMultiPropertyFilter: wr,
+    createRankedFilter: $r,
+    createMultiTermFilter: Kr,
+    createSectionAwareFilter: Ir
+  }
+};
+export {
+  Zr as C
+};
+//# sourceMappingURL=combobox-B_Qx3gRo.es.js.map