@ledgerhq/lumen-ui-react 0.1.16 → 0.1.17

package/dist/node_modules/@base-ui/react/esm/combobox/root/AriaCombobox.js

@@ -0,0 +1,596 @@
+import * as o from "react";
+import { useControlled as Xe } from "../../../../utils/esm/useControlled.js";
+import { useIsoLayoutEffect as Z } from "../../../../utils/esm/useIsoLayoutEffect.js";
+import { useOnFirstRender as dn } from "../../../../utils/esm/useOnFirstRender.js";
+import { useStableCallback as E } from "../../../../utils/esm/useStableCallback.js";
+import { useMergedRefs as mn } from "../../../../utils/esm/useMergedRefs.js";
+import { visuallyHiddenInput as pn, visuallyHidden as gn } from "../../../../utils/esm/visuallyHidden.js";
+import { useRefWithInit as Ct } from "../../../../utils/esm/useRefWithInit.js";
+import { useValueAsRef as In } from "../../../../utils/esm/useValueAsRef.js";
+import { createGenericEventDetails as oe, createChangeEventDetails as S } from "../../utils/createBaseUIEventDetails.js";
+import { ComboboxRootContext as hn, ComboboxFloatingContext as Cn, ComboboxDerivedItemsContext as yn, ComboboxInputValueContext as vn } from "./ComboboxRootContext.js";
+import { selectors as F } from "../store.js";
+import { useOpenChangeComplete as xn } from "../../utils/useOpenChangeComplete.js";
+import { useFieldRootContext as Rn } from "../../field/root/FieldRootContext.js";
+import { useField as Vn } from "../../field/useField.js";
+import { useFormContext as bn } from "../../form/FormContext.js";
+import { useLabelableId as Pn } from "../../labelable-provider/useLabelableId.js";
+import { createSingleSelectionCollatorFilter as En, createCollatorItemFilter as Sn } from "./utils/index.js";
+import { useCoreFilter as An } from "./utils/useFilter.js";
+import { useTransitionStatus as On } from "../../utils/useTransitionStatus.js";
+import { useOpenInteractionType as Fn } from "../../utils/useOpenInteractionType.js";
+import { useValueChanged as Ee } from "../../utils/useValueChanged.js";
+import { stringifyAsLabel as z, isGroupedItems as Mn, stringifyAsValue as le } from "../../utils/resolveValueLabel.js";
+import { selectedValueIncludes as Tn, removeItem as Hn, findItemIndex as yt, defaultItemEquality as wn, compareItemEquality as kn } from "../../utils/itemEquality.js";
+import { INITIAL_LAST_HIGHLIGHT as B, NO_ACTIVE_VALUE as qn } from "./utils/constants.js";
+import { jsx as D, jsxs as Ln } from "react/jsx-runtime";
+import { EMPTY_ARRAY as Se, NOOP as M, EMPTY_OBJECT as Gn } from "../../../../utils/esm/empty.js";
+import { useStore as T } from "../../../../utils/esm/store/useStore.js";
+import { useFloatingRootContext as Nn } from "../../floating-ui-react/hooks/useFloatingRootContext.js";
+import { useClick as Un } from "../../floating-ui-react/hooks/useClick.js";
+import { useDismiss as Qn } from "../../floating-ui-react/hooks/useDismiss.js";
+import { useListNavigation as _n } from "../../floating-ui-react/hooks/useListNavigation.js";
+import { useInteractions as zn } from "../../floating-ui-react/hooks/useInteractions.js";
+import { Store as Bn } from "../../../../utils/esm/store/Store.js";
+import { inputClear as ee, inputChange as vt, focusOut as Yn, outsidePress as jn, itemPress as Wn, none as Y, inputPress as Jn } from "../../utils/reason-parts.js";
+import { getTarget as xt, contains as Ae } from "../../floating-ui-react/utils/element.js";
+function Mi(H) {
+  const {
+    id: Rt,
+    onOpenChangeComplete: Ze,
+    defaultSelectedValue: De = null,
+    selectedValue: Vt,
+    onSelectedValueChange: bt,
+    defaultInputValue: et,
+    inputValue: tt,
+    selectionMode: s = "none",
+    onItemHighlighted: Pt,
+    name: Et,
+    disabled: St = !1,
+    readOnly: L = !1,
+    required: se = !1,
+    inputRef: At,
+    grid: j = !1,
+    items: u,
+    filteredItems: ue,
+    filter: ae,
+    openOnInputClick: ce = !0,
+    autoHighlight: nt = !1,
+    keepHighlight: Ot = !1,
+    highlightItemOnHover: Ft = !0,
+    loopFocus: it = !0,
+    itemToStringLabel: d,
+    itemToStringValue: w,
+    isItemEqualToValue: W = wn,
+    virtualized: Oe = !1,
+    inline: fe = !1,
+    fillInputOnItemPress: Mt = !0,
+    modal: Fe = !1,
+    limit: A = -1,
+    autoComplete: rt = "list",
+    formAutoComplete: Tt,
+    locale: Ht,
+    submitOnItemClick: Me = !1
+  } = H, {
+    clearErrors: ot
+  } = bn(), {
+    setDirty: de,
+    validityData: me,
+    shouldValidateOnChange: pe,
+    setFilled: Te,
+    name: wt,
+    disabled: kt,
+    setTouched: qt,
+    setFocused: Lt,
+    validationMode: Gt,
+    validation: h
+  } = Rn(), G = Pn({
+    id: Rt
+  }), ge = An({
+    locale: Ht
+  }), [N, Ie] = o.useState(!1), [Nt, he] = o.useState(null), He = o.useRef([]), lt = o.useRef([]), we = o.useRef(null), C = o.useRef(null), Ut = o.useRef(null), Qt = o.useRef(null), _t = o.useRef(null), st = o.useRef(!0), ut = o.useRef(!1), at = o.useRef(null), ct = o.useRef(null), ke = o.useRef(null), V = o.useRef(B), qe = o.useRef(null), J = o.useRef([]), ft = o.useRef([]), U = kt || St, b = wt ?? Et, g = s === "multiple", y = s === "single", $ = tt !== void 0 || et !== void 0, k = u !== void 0, Le = ue !== void 0;
+  let m;
+  nt === "always" ? m = "always" : m = nt ? "input-change" : !1;
+  const [n, zt] = Xe({
+    controlled: Vt,
+    default: g ? De ?? Se : De,
+    name: "Combobox",
+    state: "selectedValue"
+  }), Ce = o.useMemo(() => ae === null ? () => !0 : ae !== void 0 ? ae : y && !N ? En(ge, d, n) : Sn(ge, d), [ae, y, n, N, ge, d]), dt = Ct(() => $ ? et ?? "" : y ? z(n, d) : "").current, [I, Bt] = Xe({
+    controlled: tt,
+    default: dt,
+    name: "Combobox",
+    state: "inputValue"
+  }), [a, Yt] = Xe({
+    controlled: H.open,
+    default: H.defaultOpen,
+    name: "Combobox",
+    state: "open"
+  }), O = Mn(u), p = Nt ?? (I === "" ? "" : String(I).trim()), Ge = y ? z(n, d) : "", mt = y && !N && p !== "" && Ge !== "" && Ge.length === p.length && ge.contains(Ge, p), te = mt ? "" : p, pt = k && Le && mt, K = o.useMemo(() => u ? O ? u.flatMap((e) => e.items) : u : Se, [u, O]), ne = o.useMemo(() => {
+    if (ue && !pt)
+      return ue;
+    if (!u)
+      return Se;
+    if (O) {
+      const t = u, r = [];
+      let l = 0;
+      for (const c of t) {
+        if (A > -1 && l >= A)
+          break;
+        const f = te === "" ? c.items : c.items.filter((Pe) => Ce(Pe, te, d));
+        if (f.length === 0)
+          continue;
+        const Q = A > -1 ? A - l : 1 / 0, _ = f.slice(0, Q);
+        if (_.length > 0) {
+          const Pe = {
+            ...c,
+            items: _
+          };
+          r.push(Pe), l += _.length;
+        }
+      }
+      return r;
+    }
+    if (te === "")
+      return A > -1 ? K.slice(0, A) : (
+        // The cast here is done as `flatItems` is readonly.
+        // valuesRef.current, a mutable ref, can be set to `flatFilteredItems`, which may
+        // reference this exact readonly value, creating a mutation risk.
+        // However, <Combobox.Item> can never mutate this value as the mutating effect
+        // bails early when `items` is provided, and this is only ever returned
+        // when `items` is provided due to the early return at the top of this hook.
+        K
+      );
+    const e = [];
+    for (const t of K) {
+      if (A > -1 && e.length >= A)
+        break;
+      Ce(t, te, d) && e.push(t);
+    }
+    return e;
+  }, [ue, pt, u, O, te, A, Ce, d, K]), v = o.useMemo(() => O ? ne.flatMap((t) => t.items) : ne, [ne, O]), i = Ct(() => new Bn({
+    id: G,
+    labelId: void 0,
+    selectedValue: n,
+    open: a,
+    filter: Ce,
+    query: p,
+    items: u,
+    selectionMode: s,
+    listRef: He,
+    labelsRef: lt,
+    popupRef: we,
+    emptyRef: _t,
+    inputRef: C,
+    startDismissRef: Ut,
+    endDismissRef: Qt,
+    keyboardActiveRef: st,
+    chipsContainerRef: at,
+    clearRef: ct,
+    valuesRef: J,
+    allValuesRef: ft,
+    selectionEventRef: ke,
+    name: b,
+    disabled: U,
+    readOnly: L,
+    required: se,
+    grid: j,
+    isGrouped: O,
+    virtualized: Oe,
+    openOnInputClick: ce,
+    itemToStringLabel: d,
+    isItemEqualToValue: W,
+    modal: Fe,
+    autoHighlight: m,
+    submitOnItemClick: Me,
+    hasInputValue: $,
+    mounted: !1,
+    forceMounted: !1,
+    transitionStatus: "idle",
+    inline: fe,
+    activeIndex: null,
+    selectedIndex: null,
+    popupProps: {},
+    inputProps: {},
+    triggerProps: {},
+    positionerElement: null,
+    listElement: null,
+    triggerElement: null,
+    inputElement: null,
+    inputGroupElement: null,
+    popupSide: null,
+    openMethod: null,
+    inputInsidePopup: !0,
+    onOpenChangeComplete: Ze || M,
+    // Placeholder callbacks replaced on first render
+    setOpen: M,
+    setInputValue: M,
+    setSelectedValue: M,
+    setIndices: M,
+    onItemHighlighted: M,
+    handleSelection: M,
+    getItemProps: () => Gn,
+    forceMount: M,
+    requestSubmit: M
+  })).current, X = s === "none" ? I : n, jt = o.useMemo(() => s === "none" ? X : Array.isArray(n) ? n.map((e) => le(e, w)) : le(n, w), [X, w, s, n]), Ne = E(Pt), Ue = E(Ze), ye = T(i, F.activeIndex), Wt = T(i, F.selectedIndex), ve = T(i, F.positionerElement), gt = T(i, F.listElement), ie = T(i, F.triggerElement), xe = T(i, F.inputElement), Jt = T(i, F.inputGroupElement), x = T(i, F.inline), q = T(i, F.inputInsidePopup), $t = In(ie), {
+    mounted: It,
+    setMounted: Kt,
+    transitionStatus: Qe
+  } = On(a), {
+    openMethod: ht,
+    triggerProps: _e
+  } = Fn(a);
+  Vn({
+    id: G,
+    name: b,
+    commit: h.commit,
+    value: X,
+    controlRef: q ? $t : C,
+    getValue: () => jt
+  });
+  const Re = E(() => {
+    u ? lt.current = v.map((e) => z(e, d)) : i.set("forceMounted", !0);
+  }), Xt = o.useRef(n);
+  Z(() => {
+    n !== Xt.current && Re();
+  }, [Re, n]);
+  const R = E((e) => {
+    i.update(e);
+    const t = e.type || "none";
+    if (e.activeIndex !== void 0)
+      if (e.activeIndex === null)
+        V.current !== B && (V.current = B, Ne(void 0, oe(t, void 0, {
+          index: -1
+        })));
+      else {
+        const r = J.current[e.activeIndex];
+        V.current = {
+          value: r,
+          index: e.activeIndex
+        }, Ne(r, oe(t, void 0, {
+          index: e.activeIndex
+        }));
+      }
+  }), P = E((e, t) => {
+    if (ut.current = t.reason === ee, H.onInputValueChange?.(e, t), !t.isCanceled) {
+      if (t.reason === vt) {
+        const r = t.event, l = r.inputType;
+        if (r.type === "compositionend" || l != null && l !== "" && l !== "insertReplacementText") {
+          const f = e.trim() !== "";
+          f && Ie(!0), qe.current = {
+            hasQuery: f
+          }, f && m && i.state.activeIndex == null && i.set("activeIndex", 0);
+        }
+      }
+      Bt(e);
+    }
+  }), re = E((e, t) => {
+    if (a !== e && (t.reason === "escape-key" && k && v.length === 0 && !i.state.emptyRef.current && t.allowPropagation(), H.onOpenChange?.(e, t), !t.isCanceled && (!e && N && (y ? (x || he(p), p === "" && Ie(!1)) : g && (x || q ? R({
+      activeIndex: null
+    }) : he(p), P("", S(ee, t.event)))), Yt(e), !e && q && (t.reason === Yn || t.reason === jn) && (qt(!0), Lt(!1), Gt === "onBlur")))) {
+      const r = s === "none" ? I : n;
+      h.commit(r);
+    }
+  }), Ve = E((e, t) => {
+    if (bt?.(e, t), t.isCanceled)
+      return;
+    zt(e), (s === "none" && we.current && Mt || y && !i.state.inputInsidePopup) && P(z(e, d), S(t.reason, t.event)), y && e != null && t.reason !== vt && N && !x && he(p);
+  }), Zt = E((e, t) => {
+    let r = t;
+    if (r === void 0) {
+      if (ye === null)
+        return;
+      r = J.current[ye];
+    }
+    const l = xt(e), c = ke.current ?? e;
+    ke.current = null;
+    const f = S(Wn, c), Q = l?.closest("a")?.getAttribute("href");
+    if (Q) {
+      Q.startsWith("#") && re(!1, f);
+      return;
+    }
+    if (g) {
+      const _ = Array.isArray(n) ? n : [], fn = Tn(_, r, i.state.isItemEqualToValue) ? Hn(_, r, i.state.isItemEqualToValue) : [..._, r];
+      if (Ve(fn, f), !(C.current ? C.current.value.trim() !== "" : !1))
+        return;
+      i.state.inputInsidePopup ? P("", S(ee, f.event)) : re(!1, f);
+    } else
+      Ve(r, f), re(!1, f);
+  }), ze = E(() => {
+    if (!i.state.submitOnItemClick)
+      return;
+    const e = i.state.inputElement?.form;
+    e && typeof e.requestSubmit == "function" && e.requestSubmit();
+  }), Be = E(() => {
+    if (Kt(!1), Ue?.(!1), Ie(!1), he(null), R(s === "none" ? {
+      activeIndex: null,
+      selectedIndex: null
+    } : {
+      activeIndex: null
+    }), g && C.current && C.current.value !== "" && !ut.current && P("", S(ee)), y)
+      if (i.state.inputInsidePopup)
+        C.current && C.current.value !== "" && P("", S(ee));
+      else {
+        const e = z(n, d);
+        C.current && C.current.value !== e && P(e, S(e === "" ? ee : Y));
+      }
+  }), Dt = o.useMemo(() => x && ve ? {
+    current: ve.closest('[role="dialog"]')
+  } : we, [x, ve]);
+  xn({
+    enabled: !H.actionsRef,
+    open: a,
+    ref: Dt,
+    onComplete() {
+      a || Be();
+    }
+  }), o.useImperativeHandle(H.actionsRef, () => ({
+    unmount: Be
+  }), [Be]), Z(function() {
+    if (a || s === "none")
+      return;
+    const t = u ? K : ft.current;
+    if (g) {
+      const r = Array.isArray(n) ? n : [], l = r[r.length - 1], c = yt(t, l, W);
+      R({
+        selectedIndex: c === -1 ? null : c
+      });
+    } else {
+      const r = yt(t, n, W);
+      R({
+        selectedIndex: r === -1 ? null : r
+      });
+    }
+  }, [a, n, u, s, K, g, W, R]), Z(() => {
+    u && (J.current = v, He.current.length = v.length);
+  }, [u, v]), Z(() => {
+    const e = qe.current;
+    if (e && (e.hasQuery ? m && i.set("activeIndex", 0) : m === "always" && i.set("activeIndex", 0), qe.current = null), !a && !x)
+      return;
+    const r = k || Le ? v : J.current, l = i.state.activeIndex;
+    if (l == null) {
+      if (m === "always" && r.length > 0) {
+        i.set("activeIndex", 0);
+        return;
+      }
+      V.current !== B && (V.current = B, i.state.onItemHighlighted(void 0, oe(Y, void 0, {
+        index: -1
+      })));
+      return;
+    }
+    if (l >= r.length) {
+      V.current !== B && (V.current = B, i.state.onItemHighlighted(void 0, oe(Y, void 0, {
+        index: -1
+      }))), i.set("activeIndex", null);
+      return;
+    }
+    const c = r[l], f = V.current.value, Q = f !== qn && kn(c, f, i.state.isItemEqualToValue);
+    (V.current.index !== l || !Q) && (V.current = {
+      value: c,
+      index: l
+    }, i.state.onItemHighlighted(c, oe(Y, void 0, {
+      index: l
+    })));
+  }, [ye, m, Le, k, v, x, a, i]), Z(() => {
+    if (s === "none") {
+      Te(String(I) !== "");
+      return;
+    }
+    Te(g ? Array.isArray(n) && n.length > 0 : n != null);
+  }, [Te, s, I, n, g]), o.useEffect(() => {
+    k && m && v.length === 0 && R({
+      activeIndex: null
+    });
+  }, [k, m, v.length, R]), Ee(p, () => {
+    !a || p === "" || p === String(dt) || Ie(!0);
+  }), Ee(n, () => {
+    if (s !== "none" && (ot(b), de(n !== me.initialValue), pe() ? h.commit(n) : h.commit(n, !0), y && !$ && !q)) {
+      const e = z(n, d);
+      I !== e && P(e, S(Y));
+    }
+  }), Ee(I, () => {
+    s === "none" && (ot(b), de(I !== me.initialValue), pe() ? h.commit(I) : h.commit(I, !0));
+  }), Ee(u, () => {
+    if (!y || $ || q || N)
+      return;
+    const e = z(n, d);
+    I !== e && P(e, S(Y));
+  });
+  const be = Nn({
+    open: x ? !0 : a,
+    onOpenChange: re,
+    elements: {
+      reference: q ? ie : xe,
+      floating: ve
+    }
+  });
+  let Ye, je;
+  x || (Ye = j ? "grid" : "listbox", je = a ? "true" : "false");
+  const en = o.useMemo(() => {
+    const e = xe?.tagName === "INPUT", t = xe == null || e, r = t || a, l = t ? {
+      autoComplete: "off",
+      spellCheck: "false",
+      autoCorrect: "off",
+      autoCapitalize: "none"
+    } : {};
+    return r && (l.role = "combobox", l["aria-expanded"] = je, l["aria-haspopup"] = Ye, l["aria-controls"] = a ? gt?.id : void 0, l["aria-autocomplete"] = rt), {
+      reference: l,
+      floating: {
+        role: "presentation"
+      }
+    };
+  }, [xe, a, je, Ye, gt?.id, rt]), tn = Un(be, {
+    enabled: !L && !U && ce,
+    event: "mousedown-only",
+    toggle: !1,
+    // Apply a small delay for touch to let iOS viewport centering settle.
+    // This avoids top-bottom flip flickers if the preferred position is "top" when first tapping.
+    touchOpenDelay: q ? 0 : 50,
+    reason: Jn
+  }), nn = Qn(be, {
+    enabled: !L && !U && !x,
+    outsidePressEvent: {
+      mouse: "sloppy",
+      // The visual viewport (affected by the mobile software keyboard) can be
+      // somewhat small. The user may want to scroll the screen to see more of
+      // the popup.
+      touch: "intentional"
+    },
+    // Without a popup, let the Escape key bubble the event up to other popups' handlers.
+    bubbles: x ? !0 : void 0,
+    outsidePress(e) {
+      const t = xt(e);
+      return !Ae(ie, t) && !Ae(ct.current, t) && !Ae(at.current, t) && !Ae(Jt, t);
+    }
+  }), rn = _n(be, {
+    enabled: !L && !U,
+    id: G,
+    listRef: He,
+    activeIndex: ye,
+    selectedIndex: Wt,
+    virtual: !0,
+    loopFocus: it,
+    allowEscape: it && !m,
+    focusItemOnOpen: N || s === "none" && !m ? !1 : "auto",
+    focusItemOnHover: Ft,
+    resetOnPointerLeave: !Ot,
+    // `cols` > 1 enables grid navigation.
+    // Since <Combobox.Row> infers column sizes (and is required when building a grid),
+    // it works correctly even with a value of `2`.
+    // Floating UI tests don't require `role="row"` wrappers, so retains the number API.
+    cols: j ? 2 : 1,
+    orientation: j ? "horizontal" : void 0,
+    disabledIndices: Se,
+    onNavigate(e, t) {
+      !t && !a || Qe === "ending" || R(t ? {
+        activeIndex: e,
+        type: st.current ? "keyboard" : "pointer"
+      } : {
+        activeIndex: e
+      });
+    }
+  }), {
+    getReferenceProps: We,
+    getFloatingProps: Je,
+    getItemProps: $e
+  } = zn([en, tn, nn, rn]);
+  dn(() => {
+    i.update({
+      inline: fe,
+      popupProps: Je(),
+      inputProps: We(),
+      triggerProps: _e,
+      getItemProps: $e,
+      setOpen: re,
+      setInputValue: P,
+      setSelectedValue: Ve,
+      setIndices: R,
+      onItemHighlighted: Ne,
+      handleSelection: Zt,
+      forceMount: Re,
+      requestSubmit: ze
+    });
+  }), Z(() => {
+    i.update({
+      id: G,
+      selectedValue: n,
+      open: a,
+      mounted: It,
+      transitionStatus: Qe,
+      items: u,
+      inline: fe,
+      popupProps: Je(),
+      inputProps: We(),
+      triggerProps: _e,
+      openMethod: ht,
+      getItemProps: $e,
+      selectionMode: s,
+      name: b,
+      disabled: U,
+      readOnly: L,
+      required: se,
+      grid: j,
+      isGrouped: O,
+      virtualized: Oe,
+      onOpenChangeComplete: Ue,
+      openOnInputClick: ce,
+      itemToStringLabel: d,
+      modal: Fe,
+      autoHighlight: m,
+      isItemEqualToValue: W,
+      submitOnItemClick: Me,
+      hasInputValue: $,
+      requestSubmit: ze
+    });
+  }, [i, G, n, a, It, Qe, u, Je, We, $e, ht, _e, s, b, U, L, se, h, j, O, Oe, Ue, ce, d, Fe, W, Me, $, fe, ze, m]);
+  const on = mn(At, h.inputRef), ln = o.useMemo(() => ({
+    query: p,
+    hasItems: k,
+    filteredItems: ne,
+    flatFilteredItems: v
+  }), [p, k, ne, v]), sn = o.useMemo(() => Array.isArray(X) ? "" : le(X, w), [X, w]), un = g && Array.isArray(n) && n.length > 0, Ke = g || s === "none" ? void 0 : b, an = o.useMemo(() => !g || !Array.isArray(n) || !b ? null : n.map((e) => {
+    const t = le(e, w);
+    return /* @__PURE__ */ D("input", {
+      type: "hidden",
+      name: b,
+      value: t
+    }, t);
+  }), [g, n, b, w]), cn = /* @__PURE__ */ Ln(o.Fragment, {
+    children: [H.children, /* @__PURE__ */ D("input", {
+      ...h.getInputValidationProps({
+        // Move focus when the hidden input is focused.
+        onFocus() {
+          if (q) {
+            ie?.focus();
+            return;
+          }
+          (C.current || ie)?.focus();
+        },
+        // Handle browser autofill.
+        onChange(e) {
+          if (e.nativeEvent.defaultPrevented)
+            return;
+          const t = e.target.value, r = S(Y, e.nativeEvent);
+          function l() {
+            if (g)
+              return;
+            if (s === "none") {
+              de(t !== me.initialValue), P(t, r), pe() && h.commit(t);
+              return;
+            }
+            const c = J.current.find((f) => le(f, w).toLowerCase() === t.toLowerCase());
+            c != null && (de(c !== me.initialValue), Ve?.(c, r), pe() && h.commit(c));
+          }
+          u ? l() : (Re(), queueMicrotask(l));
+        }
+      }),
+      id: G && Ke == null ? `${G}-hidden-input` : void 0,
+      name: Ke,
+      autoComplete: Tt,
+      disabled: U,
+      required: se && !un,
+      readOnly: L,
+      value: sn,
+      ref: on,
+      style: Ke ? pn : gn,
+      tabIndex: -1,
+      "aria-hidden": !0
+    }), an]
+  });
+  return /* @__PURE__ */ D(hn.Provider, {
+    value: i,
+    children: /* @__PURE__ */ D(Cn.Provider, {
+      value: be,
+      children: /* @__PURE__ */ D(yn.Provider, {
+        value: ln,
+        children: /* @__PURE__ */ D(vn.Provider, {
+          value: I,
+          children: cn
+        })
+      })
+    })
+  });
+}
+export {
+  Mi as AriaCombobox
+};

package/dist/node_modules/@base-ui/react/esm/combobox/root/ComboboxRoot.js

@@ -0,0 +1,23 @@
+import { AriaCombobox as n } from "./AriaCombobox.js";
+import { jsx as r } from "react/jsx-runtime";
+function p(e) {
+  const {
+    multiple: o = !1,
+    defaultValue: l,
+    value: t,
+    onValueChange: u,
+    autoComplete: a,
+    ...m
+  } = e;
+  return /* @__PURE__ */ r(n, {
+    ...m,
+    selectionMode: o ? "multiple" : "single",
+    selectedValue: t,
+    defaultSelectedValue: l,
+    onSelectedValueChange: u,
+    formAutoComplete: a
+  });
+}
+export {
+  p as ComboboxRoot
+};

package/dist/node_modules/@base-ui/react/esm/combobox/root/ComboboxRootContext.js

@@ -0,0 +1,41 @@
+import e from "../../../../utils/esm/formatErrorMessage.js";
+import * as t from "react";
+const n = /* @__PURE__ */ t.createContext(void 0);
+process.env.NODE_ENV !== "production" && (n.displayName = "ComboboxRootContext");
+const s = /* @__PURE__ */ t.createContext(void 0);
+process.env.NODE_ENV !== "production" && (s.displayName = "ComboboxFloatingContext");
+const r = /* @__PURE__ */ t.createContext(void 0);
+process.env.NODE_ENV !== "production" && (r.displayName = "ComboboxDerivedItemsContext");
+const i = /* @__PURE__ */ t.createContext("");
+process.env.NODE_ENV !== "production" && (i.displayName = "ComboboxInputValueContext");
+function b() {
+  const o = t.useContext(n);
+  if (!o)
+    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: ComboboxRootContext is missing. Combobox parts must be placed within <Combobox.Root>." : e(22));
+  return o;
+}
+function C() {
+  const o = t.useContext(s);
+  if (!o)
+    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: ComboboxFloatingContext is missing. Combobox parts must be placed within <Combobox.Root>." : e(23));
+  return o;
+}
+function m() {
+  const o = t.useContext(r);
+  if (!o)
+    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: ComboboxItemsContext is missing. Combobox parts must be placed within <Combobox.Root>." : e(24));
+  return o;
+}
+function c() {
+  return t.useContext(i);
+}
+export {
+  r as ComboboxDerivedItemsContext,
+  s as ComboboxFloatingContext,
+  i as ComboboxInputValueContext,
+  n as ComboboxRootContext,
+  m as useComboboxDerivedItemsContext,
+  C as useComboboxFloatingContext,
+  c as useComboboxInputValueContext,
+  b as useComboboxRootContext
+};

package/dist/node_modules/@base-ui/react/esm/combobox/root/utils/constants.js

@@ -0,0 +1,8 @@
+const I = /* @__PURE__ */ Symbol("none"), n = {
+  value: I,
+  index: -1
+};
+export {
+  n as INITIAL_LAST_HIGHLIGHT,
+  I as NO_ACTIVE_VALUE
+};

package/dist/node_modules/@base-ui/react/esm/combobox/root/utils/index.js

@@ -0,0 +1,23 @@
+import { stringifyAsLabel as o } from "../../../utils/resolveValueLabel.js";
+function f(r, e) {
+  return (t, i) => {
+    if (t == null)
+      return !1;
+    const n = o(t, e);
+    return r.contains(n, i);
+  };
+}
+function s(r, e, t) {
+  return (i, n) => {
+    if (i == null)
+      return !1;
+    if (!n)
+      return !0;
+    const u = o(i, e), l = t != null ? o(t, e) : "";
+    return l && r.contains(l, n) && l.length === n.length ? !0 : r.contains(u, n);
+  };
+}
+export {
+  f as createCollatorItemFilter,
+  s as createSingleSelectionCollatorFilter
+};