@als-tp/als-react-ts-ui 0.3.1 → 0.5.0

package/dist/als-react-ts-ui452.js

@@ -0,0 +1,597 @@
+import * as o from "react";
+import { useControlled as Ze } from "./als-react-ts-ui282.js";
+import { useIsoLayoutEffect as _ } from "./als-react-ts-ui193.js";
+import { useOnFirstRender as rn } from "./als-react-ts-ui396.js";
+import { useStableCallback as E } from "./als-react-ts-ui192.js";
+import { useMergedRefs as on } from "./als-react-ts-ui287.js";
+import { visuallyHidden as ln } from "./als-react-ts-ui375.js";
+import { useRefWithInit as xt } from "./als-react-ts-ui240.js";
+import { useValueAsRef as sn } from "./als-react-ts-ui337.js";
+import { createGenericEventDetails as le, createChangeEventDetails as V } from "./als-react-ts-ui246.js";
+import { ComboboxRootContext as un, ComboboxFloatingContext as an, ComboboxDerivedItemsContext as cn, ComboboxInputValueContext as fn } from "./als-react-ts-ui454.js";
+import { selectors as T } from "./als-react-ts-ui455.js";
+import { useOpenChangeComplete as dn } from "./als-react-ts-ui253.js";
+import { useFieldRootContext as mn } from "./als-react-ts-ui398.js";
+import { useField as pn } from "./als-react-ts-ui403.js";
+import { useFormContext as gn } from "./als-react-ts-ui402.js";
+import { useLabelableId as In } from "./als-react-ts-ui400.js";
+import { createSingleSelectionCollatorFilter as hn, createCollatorItemFilter as Cn } from "./als-react-ts-ui479.js";
+import { useCoreFilter as xn } from "./als-react-ts-ui453.js";
+import { useTransitionStatus as yn } from "./als-react-ts-ui344.js";
+import { useOpenInteractionType as vn } from "./als-react-ts-ui327.js";
+import { useValueChanged as Se } from "./als-react-ts-ui406.js";
+import { stringifyAsLabel as q, isGroupedItems as Vn, stringifyAsValue as $e } from "./als-react-ts-ui404.js";
+import { defaultItemEquality as bn, itemIncludes as Ae, removeItem as Pn, findItemIndex as yt } from "./als-react-ts-ui405.js";
+import { INITIAL_LAST_HIGHLIGHT as z, NO_ACTIVE_VALUE as Rn } from "./als-react-ts-ui480.js";
+import { jsx as $, jsxs as En } from "react/jsx-runtime";
+import { EMPTY_ARRAY as se, NOOP as F, EMPTY_OBJECT as Sn } from "./als-react-ts-ui303.js";
+import { Store as An } from "./als-react-ts-ui407.js";
+import { useStore as k } from "./als-react-ts-ui408.js";
+import { useFloatingRootContext as On } from "./als-react-ts-ui385.js";
+import { useClick as Fn } from "./als-react-ts-ui262.js";
+import { useDismiss as Mn } from "./als-react-ts-ui330.js";
+import { useListNavigation as Hn } from "./als-react-ts-ui391.js";
+import { useInteractions as Tn } from "./als-react-ts-ui263.js";
+import { inputClear as D, inputChange as De, itemPress as qn, none as Y } from "./als-react-ts-ui248.js";
+import { getTarget as vt, contains as et } from "./als-react-ts-ui331.js";
+function hr(M) {
+  const {
+    id: Vt,
+    onOpenChangeComplete: tt,
+    defaultSelectedValue: j = null,
+    selectedValue: bt,
+    onSelectedValueChange: Pt,
+    defaultInputValue: nt,
+    inputValue: rt,
+    selectionMode: a = "none",
+    onItemHighlighted: Rt,
+    name: Et,
+    disabled: St = !1,
+    readOnly: w = !1,
+    required: ue = !1,
+    inputRef: At,
+    grid: B = !1,
+    items: s,
+    filteredItems: ae,
+    filter: ce,
+    openOnInputClick: fe = !0,
+    autoHighlight: it = !1,
+    keepHighlight: Ot = !1,
+    highlightItemOnHover: Ft = !0,
+    itemToStringLabel: f,
+    itemToStringValue: ee,
+    isItemEqualToValue: W = bn,
+    virtualized: Oe = !1,
+    inline: de = !1,
+    fillInputOnItemPress: Mt = !0,
+    modal: Fe = !1,
+    limit: S = -1,
+    autoComplete: ot = "list",
+    locale: Ht,
+    submitOnItemClick: Me = !1
+  } = M, {
+    clearErrors: lt
+  } = gn(), {
+    setDirty: me,
+    validityData: pe,
+    shouldValidateOnChange: ge,
+    setFilled: He,
+    name: Tt,
+    disabled: qt,
+    validation: b
+  } = mn(), J = In({
+    id: Vt
+  }), Ie = xn({
+    locale: Ht
+  }), [L, he] = o.useState(!1), [kt, Ce] = o.useState(null), Te = o.useRef([]), st = o.useRef([]), qe = o.useRef(null), I = o.useRef(null), wt = o.useRef(null), ut = o.useRef(!0), at = o.useRef(!1), ct = o.useRef(null), ft = o.useRef(null), ke = o.useRef(null), P = o.useRef(z), we = o.useRef(null), K = o.useRef([]), dt = o.useRef([]), N = qt || St, R = Tt ?? Et, d = a === "multiple", y = a === "single", X = rt !== void 0 || nt !== void 0, Z = s !== void 0, Le = ae !== void 0;
+  let p;
+  it === "always" ? p = "always" : p = it ? "input-change" : !1;
+  const [r, xe] = Ze({
+    controlled: bt,
+    default: d ? j ?? se : j,
+    name: "Combobox",
+    state: "selectedValue"
+  }), ye = o.useMemo(() => ce === null ? () => !0 : ce !== void 0 ? ce : y && !L ? hn(Ie, f, r) : Cn(Ie, f), [ce, y, r, L, Ie, f]), mt = xt(() => X ? nt ?? "" : y ? q(r, f) : "").current, [h, Lt] = Ze({
+    controlled: rt,
+    default: mt,
+    name: "Combobox",
+    state: "inputValue"
+  }), [c, Nt] = Ze({
+    controlled: M.open,
+    default: M.defaultOpen,
+    name: "Combobox",
+    state: "open"
+  }), A = Vn(s), g = kt ?? (h === "" ? "" : String(h).trim()), Ne = y ? q(r, f) : "", pt = y && !L && g !== "" && Ne !== "" && Ne.length === g.length && Ie.contains(Ne, g), te = pt ? "" : g, gt = Z && Le && pt, H = o.useMemo(() => s ? A ? s.flatMap((e) => e.items) : s : se, [s, A]), ne = o.useMemo(() => {
+    if (ae && !gt)
+      return ae;
+    if (!s)
+      return se;
+    if (A) {
+      const t = s, n = [];
+      let l = 0;
+      for (const u of t) {
+        if (S > -1 && l >= S)
+          break;
+        const m = te === "" ? u.items : u.items.filter((Ee) => ye(Ee, te, f));
+        if (m.length === 0)
+          continue;
+        const G = S > -1 ? S - l : 1 / 0, Q = m.slice(0, G);
+        if (Q.length > 0) {
+          const Ee = {
+            ...u,
+            items: Q
+          };
+          n.push(Ee), l += Q.length;
+        }
+      }
+      return n;
+    }
+    if (te === "")
+      return S > -1 ? H.slice(0, S) : (
+        // 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.
+        H
+      );
+    const e = [];
+    for (const t of H) {
+      if (S > -1 && e.length >= S)
+        break;
+      ye(t, te, f) && e.push(t);
+    }
+    return e;
+  }, [ae, gt, s, A, te, S, ye, f, H]), v = o.useMemo(() => A ? ne.flatMap((t) => t.items) : ne, [ne, A]), i = xt(() => new An({
+    id: J,
+    selectedValue: r,
+    open: c,
+    filter: ye,
+    query: g,
+    items: s,
+    selectionMode: a,
+    listRef: Te,
+    labelsRef: st,
+    popupRef: qe,
+    emptyRef: wt,
+    inputRef: I,
+    keyboardActiveRef: ut,
+    chipsContainerRef: ct,
+    clearRef: ft,
+    valuesRef: K,
+    allValuesRef: dt,
+    selectionEventRef: ke,
+    name: R,
+    disabled: N,
+    readOnly: w,
+    required: ue,
+    grid: B,
+    isGrouped: A,
+    virtualized: Oe,
+    openOnInputClick: fe,
+    itemToStringLabel: f,
+    isItemEqualToValue: W,
+    modal: Fe,
+    autoHighlight: p,
+    submitOnItemClick: Me,
+    hasInputValue: X,
+    mounted: !1,
+    forceMounted: !1,
+    transitionStatus: "idle",
+    inline: de,
+    activeIndex: null,
+    selectedIndex: null,
+    popupProps: {},
+    inputProps: {},
+    triggerProps: {},
+    positionerElement: null,
+    listElement: null,
+    triggerElement: null,
+    inputElement: null,
+    popupSide: null,
+    openMethod: null,
+    inputInsidePopup: !0,
+    onOpenChangeComplete: tt || F,
+    // Placeholder callbacks replaced on first render
+    setOpen: F,
+    setInputValue: F,
+    setSelectedValue: F,
+    setIndices: F,
+    onItemHighlighted: F,
+    handleSelection: F,
+    getItemProps: () => Sn,
+    forceMount: F,
+    requestSubmit: F
+  })).current, re = a === "none" ? h : r, Ue = E(Rt), Ge = E(tt), ve = k(i, T.activeIndex), Ut = k(i, T.selectedIndex), Ve = k(i, T.positionerElement), It = k(i, T.listElement), ie = k(i, T.triggerElement), Qe = k(i, T.inputElement), O = k(i, T.inline), U = k(i, T.inputInsidePopup), Gt = sn(ie), {
+    mounted: ht,
+    setMounted: Qt,
+    transitionStatus: _e
+  } = yn(c), {
+    openMethod: Ct,
+    triggerProps: ze,
+    reset: _t
+  } = vn(c);
+  pn({
+    id: J,
+    name: R,
+    commit: b.commit,
+    value: re,
+    controlRef: U ? Gt : I,
+    getValue: () => re
+  });
+  const be = E(() => {
+    s ? st.current = v.map((e) => q(e, f)) : i.set("forceMounted", !0);
+  }), zt = o.useRef(r);
+  _(() => {
+    r !== zt.current && be();
+  }, [be, r]);
+  const C = E((e) => {
+    i.update(e);
+    const t = e.type || "none";
+    if (e.activeIndex !== void 0)
+      if (e.activeIndex === null)
+        P.current !== z && (P.current = z, Ue(void 0, le(t, void 0, {
+          index: -1
+        })));
+      else {
+        const n = K.current[e.activeIndex];
+        P.current = {
+          value: n,
+          index: e.activeIndex
+        }, Ue(n, le(t, void 0, {
+          index: e.activeIndex
+        }));
+      }
+  }), x = E((e, t) => {
+    if (at.current = t.reason === D, M.onInputValueChange?.(e, t), !t.isCanceled) {
+      if (t.reason === De) {
+        const n = e.trim() !== "";
+        n && he(!0), we.current = {
+          hasQuery: n
+        }, n && p && i.state.activeIndex == null && i.set("activeIndex", 0);
+      }
+      Lt(e);
+    }
+  }), oe = E((e, t) => {
+    c !== e && (t.reason === "escape-key" && Z && v.length === 0 && !i.state.emptyRef.current && t.allowPropagation(), M.onOpenChange?.(e, t), !t.isCanceled && (!e && L && (y ? (Ce(g), g === "" && he(!1)) : d && (O || U ? C({
+      activeIndex: null
+    }) : Ce(g), x("", V(D, t.event)))), Nt(e)));
+  }), Pe = E((e, t) => {
+    if (Pt?.(e, t), t.isCanceled)
+      return;
+    xe(e), (a === "none" && qe.current && Mt || y && !i.state.inputInsidePopup) && x(q(e, f), V(t.reason, t.event)), y && e != null && t.reason !== De && L && Ce(g);
+  }), Yt = E((e, t) => {
+    let n = t;
+    if (n === void 0) {
+      if (ve === null)
+        return;
+      n = K.current[ve];
+    }
+    const l = vt(e), u = ke.current ?? e;
+    ke.current = null;
+    const m = V(qn, u), G = l?.closest("a")?.getAttribute("href");
+    if (G) {
+      G.startsWith("#") && oe(!1, m);
+      return;
+    }
+    if (d) {
+      const Q = Array.isArray(r) ? r : [], nn = Ae(Q, n, i.state.isItemEqualToValue) ? Pn(Q, n, i.state.isItemEqualToValue) : [...Q, n];
+      if (Pe(nn, m), !(I.current ? I.current.value.trim() !== "" : !1))
+        return;
+      i.state.inputInsidePopup ? x("", V(D, m.event)) : oe(!1, m);
+    } else
+      Pe(n, m), oe(!1, m);
+  }), Ye = E(() => {
+    if (!i.state.submitOnItemClick)
+      return;
+    const e = i.state.inputElement?.form;
+    e && typeof e.requestSubmit == "function" && e.requestSubmit();
+  }), je = E(() => {
+    if (Qt(!1), Ge?.(!1), he(!1), _t(), Ce(null), C(a === "none" ? {
+      activeIndex: null,
+      selectedIndex: null
+    } : {
+      activeIndex: null
+    }), d && I.current && I.current.value !== "" && !at.current && x("", V(D)), y)
+      if (i.state.inputInsidePopup)
+        I.current && I.current.value !== "" && x("", V(D));
+      else {
+        const e = q(r, f);
+        I.current && I.current.value !== e && x(e, V(e === "" ? D : Y));
+      }
+  }), jt = o.useMemo(() => O && Ve ? {
+    current: Ve.closest('[role="dialog"]')
+  } : qe, [O, Ve]);
+  dn({
+    enabled: !M.actionsRef,
+    open: c,
+    ref: jt,
+    onComplete() {
+      c || je();
+    }
+  }), o.useImperativeHandle(M.actionsRef, () => ({
+    unmount: je
+  }), [je]), _(function() {
+    if (c || a === "none")
+      return;
+    const t = s ? H : dt.current;
+    if (d) {
+      const n = Array.isArray(r) ? r : [], l = n[n.length - 1], u = yt(t, l, W);
+      C({
+        selectedIndex: u === -1 ? null : u
+      });
+    } else {
+      const n = yt(t, r, W);
+      C({
+        selectedIndex: n === -1 ? null : n
+      });
+    }
+  }, [c, r, s, a, H, d, W, C]), _(() => {
+    s && (K.current = v, Te.current.length = v.length);
+  }, [s, v]), _(() => {
+    const e = we.current;
+    if (e && (e.hasQuery ? p && i.set("activeIndex", 0) : p === "always" && i.set("activeIndex", 0), we.current = null), !c && !O)
+      return;
+    const n = Z || Le ? v : K.current, l = i.state.activeIndex;
+    if (l == null) {
+      if (p === "always" && n.length > 0) {
+        i.set("activeIndex", 0);
+        return;
+      }
+      P.current !== z && (P.current = z, i.state.onItemHighlighted(void 0, le(Y, void 0, {
+        index: -1
+      })));
+      return;
+    }
+    if (l >= n.length) {
+      P.current !== z && (P.current = z, i.state.onItemHighlighted(void 0, le(Y, void 0, {
+        index: -1
+      }))), i.set("activeIndex", null);
+      return;
+    }
+    const u = n[l], m = P.current.value, G = m !== Rn && i.state.isItemEqualToValue(u, m);
+    (P.current.index !== l || !G) && (P.current = {
+      value: u,
+      index: l
+    }, i.state.onItemHighlighted(u, le(Y, void 0, {
+      index: l
+    })));
+  }, [ve, p, Le, Z, v, O, c, i]), _(() => {
+    if (!s || a === "none")
+      return;
+    const e = H;
+    if (d) {
+      const l = Array.isArray(r) ? r : se, u = l.filter((m) => Ae(e, m, i.state.isItemEqualToValue));
+      u.length !== l.length && xe(u);
+      return;
+    }
+    if (r == null ? !0 : Ae(e, r, i.state.isItemEqualToValue))
+      return;
+    let n = null;
+    if (j != null && Ae(e, j, i.state.isItemEqualToValue) && (n = j), xe(n), !i.state.inputInsidePopup) {
+      const l = q(n, f);
+      I.current && I.current.value !== l && x(l, V(Y));
+    }
+  }, [s, H, d, a, r, j, xe, f, i, x]), _(() => {
+    if (a === "none") {
+      He(String(h) !== "");
+      return;
+    }
+    He(d ? Array.isArray(r) && r.length > 0 : r != null);
+  }, [He, a, h, r, d]), o.useEffect(() => {
+    Z && p && v.length === 0 && C({
+      activeIndex: null
+    });
+  }, [Z, p, v.length, C]), Se(g, () => {
+    !c || g === "" || g === String(mt) || he(!0);
+  }), Se(r, () => {
+    if (a !== "none" && (lt(R), me(r !== pe.initialValue), ge() ? b.commit(r) : b.commit(r, !0), d && i.state.selectedIndex !== null && (!Array.isArray(r) || r.length === 0) && C({
+      activeIndex: null,
+      selectedIndex: null
+    }), y && !X && !U)) {
+      const e = q(r, f);
+      h !== e && x(e, V(Y));
+    }
+  }), Se(h, () => {
+    a === "none" && (lt(R), me(h !== pe.initialValue), ge() ? b.commit(h) : b.commit(h, !0));
+  }), Se(s, () => {
+    if (!y || X || U || L)
+      return;
+    const e = q(r, f);
+    h !== e && x(e, V(Y));
+  });
+  const Re = On({
+    open: O ? !0 : c,
+    onOpenChange: oe,
+    elements: {
+      reference: U ? ie : Qe,
+      floating: Ve
+    }
+  });
+  let Be, We;
+  O || (Be = B ? "grid" : "listbox", We = c ? "true" : "false");
+  const Bt = o.useMemo(() => {
+    const e = Qe?.tagName === "INPUT", t = e || c, n = e ? {
+      autoComplete: "off",
+      spellCheck: "false",
+      autoCorrect: "off",
+      autoCapitalize: "none"
+    } : {};
+    return t && (n.role = "combobox", n["aria-expanded"] = We, n["aria-haspopup"] = Be, n["aria-controls"] = c ? It?.id : void 0, n["aria-autocomplete"] = ot), {
+      reference: n,
+      floating: {
+        role: "presentation"
+      }
+    };
+  }, [Qe, c, We, Be, It?.id, ot]), Wt = Fn(Re, {
+    enabled: !w && !N && fe,
+    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: U ? 0 : 50
+  }), Jt = Mn(Re, {
+    enabled: !w && !N && !O,
+    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: O ? !0 : void 0,
+    outsidePress(e) {
+      const t = vt(e);
+      return !et(ie, t) && !et(ft.current, t) && !et(ct.current, t);
+    }
+  }), Kt = Hn(Re, {
+    enabled: !w && !N,
+    id: J,
+    listRef: Te,
+    activeIndex: ve,
+    selectedIndex: Ut,
+    virtual: !0,
+    loopFocus: !0,
+    allowEscape: !p,
+    focusItemOnOpen: L || a === "none" && !p ? !1 : "auto",
+    focusItemOnHover: Ft,
+    // `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: B ? 2 : 1,
+    orientation: B ? "horizontal" : void 0,
+    disabledIndices: se,
+    onNavigate(e, t) {
+      !t && !c || _e === "ending" || Ot && e === null && t && t.type === "pointerleave" || C(t ? {
+        activeIndex: e,
+        type: ut.current ? "keyboard" : "pointer"
+      } : {
+        activeIndex: e
+      });
+    }
+  }), {
+    getReferenceProps: Je,
+    getFloatingProps: Ke,
+    getItemProps: Xe
+  } = Tn([Bt, Wt, Jt, Kt]);
+  rn(() => {
+    i.update({
+      inline: de,
+      popupProps: Ke(),
+      inputProps: Je(),
+      triggerProps: ze,
+      getItemProps: Xe,
+      setOpen: oe,
+      setInputValue: x,
+      setSelectedValue: Pe,
+      setIndices: C,
+      onItemHighlighted: Ue,
+      handleSelection: Yt,
+      forceMount: be,
+      requestSubmit: Ye
+    });
+  }), _(() => {
+    i.update({
+      id: J,
+      selectedValue: r,
+      open: c,
+      mounted: ht,
+      transitionStatus: _e,
+      items: s,
+      inline: de,
+      popupProps: Ke(),
+      inputProps: Je(),
+      triggerProps: ze,
+      openMethod: Ct,
+      getItemProps: Xe,
+      selectionMode: a,
+      name: R,
+      disabled: N,
+      readOnly: w,
+      required: ue,
+      grid: B,
+      isGrouped: A,
+      virtualized: Oe,
+      onOpenChangeComplete: Ge,
+      openOnInputClick: fe,
+      itemToStringLabel: f,
+      modal: Fe,
+      autoHighlight: p,
+      isItemEqualToValue: W,
+      submitOnItemClick: Me,
+      hasInputValue: X,
+      requestSubmit: Ye
+    });
+  }, [i, J, r, c, ht, _e, s, Ke, Je, Xe, Ct, ze, a, R, N, w, ue, b, B, A, Oe, Ge, fe, f, Fe, W, Me, X, de, Ye, p]);
+  const Xt = on(At, b.inputRef), Zt = o.useMemo(() => ({
+    query: g,
+    filteredItems: ne,
+    flatFilteredItems: v
+  }), [g, ne, v]), $t = o.useMemo(() => Array.isArray(re) ? "" : $e(re, ee), [re, ee]), Dt = d && Array.isArray(r) && r.length > 0, en = o.useMemo(() => !d || !Array.isArray(r) || !R ? null : r.map((e) => {
+    const t = $e(e, ee);
+    return /* @__PURE__ */ $("input", {
+      type: "hidden",
+      name: R,
+      value: t
+    }, t);
+  }), [d, r, R, ee]), tn = /* @__PURE__ */ En(o.Fragment, {
+    children: [M.children, /* @__PURE__ */ $("input", {
+      ...b.getInputValidationProps({
+        // Move focus when the hidden input is focused.
+        onFocus() {
+          if (U) {
+            ie?.focus();
+            return;
+          }
+          (I.current || ie)?.focus();
+        },
+        // Handle browser autofill.
+        onChange(e) {
+          if (e.nativeEvent.defaultPrevented)
+            return;
+          const t = e.target.value, n = V(De, e.nativeEvent);
+          function l() {
+            if (d)
+              return;
+            if (a === "none") {
+              me(t !== pe.initialValue), x(t, n), ge() && b.commit(t);
+              return;
+            }
+            const u = K.current.find((m) => $e(m, ee).toLowerCase() === t.toLowerCase());
+            u != null && (me(u !== pe.initialValue), Pe?.(u, n), ge() && b.commit(u));
+          }
+          s ? l() : (be(), queueMicrotask(l));
+        }
+      }),
+      id: J,
+      name: d || a === "none" ? void 0 : R,
+      disabled: N,
+      required: ue && !Dt,
+      readOnly: w,
+      value: $t,
+      ref: Xt,
+      style: ln,
+      tabIndex: -1,
+      "aria-hidden": !0
+    }), en]
+  });
+  return /* @__PURE__ */ $(un.Provider, {
+    value: i,
+    children: /* @__PURE__ */ $(an.Provider, {
+      value: Re,
+      children: /* @__PURE__ */ $(cn.Provider, {
+        value: Zt,
+        children: /* @__PURE__ */ $(fn.Provider, {
+          value: h,
+          children: tn
+        })
+      })
+    })
+  });
+}
+export {
+  hr as AriaCombobox
+};

package/dist/als-react-ts-ui453.js

@@ -0,0 +1,44 @@
+import "react";
+import { stringifyAsLabel as l } from "./als-react-ts-ui404.js";
+const f = /* @__PURE__ */ new Map();
+function h(e) {
+  return Array.isArray(e) ? e.map((c) => h(c)).join(",") : e == null ? "" : String(e);
+}
+function m(e = {}) {
+  const c = {
+    usage: "search",
+    sensitivity: "base",
+    ignorePunctuation: !0,
+    ...e
+  }, a = `${h(e.locale)}|${JSON.stringify(c)}`, g = f.get(a);
+  if (g)
+    return g;
+  const o = new Intl.Collator(e.locale, c), u = {
+    contains(i, t, s) {
+      if (!t)
+        return !0;
+      const r = l(i, s);
+      for (let n = 0; n <= r.length - t.length; n += 1)
+        if (o.compare(r.slice(n, n + t.length), t) === 0)
+          return !0;
+      return !1;
+    },
+    startsWith(i, t, s) {
+      if (!t)
+        return !0;
+      const r = l(i, s);
+      return o.compare(r.slice(0, t.length), t) === 0;
+    },
+    endsWith(i, t, s) {
+      if (!t)
+        return !0;
+      const r = l(i, s), n = t.length;
+      return r.length >= n && o.compare(r.slice(r.length - n), t) === 0;
+    }
+  };
+  return f.set(a, u), u;
+}
+const d = m;
+export {
+  d as useCoreFilter
+};

package/dist/als-react-ts-ui454.js

@@ -0,0 +1,41 @@
+import e from "./als-react-ts-ui259.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
+};