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

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

@@ -0,0 +1,9 @@
+import { jsx as o } from "react/jsx-runtime";
+import r from "./als-react-ts-ui64.js";
+function l(s) {
+  return /* @__PURE__ */ o("div", { className: r.root });
+}
+export {
+  l as ALSCollapsible,
+  l as default
+};

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

@@ -0,0 +1,142 @@
+import * as o from "react";
+import { inertValue as ce } from "./als-react-ts-ui194.js";
+import { useIsoLayoutEffect as ae } from "./als-react-ts-ui161.js";
+import { useScrollLock as ue } from "./als-react-ts-ui236.js";
+import { useStableCallback as D } from "./als-react-ts-ui160.js";
+import { useSelectRootContext as me, useSelectFloatingContext as fe } from "./als-react-ts-ui253.js";
+import { CompositeList as pe } from "./als-react-ts-ui163.js";
+import { popupStateMapping as de } from "./als-react-ts-ui188.js";
+import { useAnchorPositioning as ge } from "./als-react-ts-ui272.js";
+import { SelectPositionerContext as he } from "./als-react-ts-ui273.js";
+import { InternalBackdrop as Ie } from "./als-react-ts-ui195.js";
+import { useRenderElement as Ae } from "./als-react-ts-ui166.js";
+import { DROPDOWN_COLLISION_AVOIDANCE as Re } from "./als-react-ts-ui198.js";
+import { clearStyles as P } from "./als-react-ts-ui274.js";
+import { selectors as t } from "./als-react-ts-ui257.js";
+import { createChangeEventDetails as Se } from "./als-react-ts-ui167.js";
+import { findItemIndex as ve, itemIncludes as R } from "./als-react-ts-ui261.js";
+import { jsx as T, jsxs as xe } from "react/jsx-runtime";
+import { useStore as c } from "./als-react-ts-ui267.js";
+import { none as Ee } from "./als-react-ts-ui168.js";
+const Ve = {
+  position: "fixed"
+}, be = /* @__PURE__ */ o.forwardRef(function(S, O) {
+  const {
+    anchor: k,
+    positionMethod: N = "absolute",
+    className: ye,
+    render: Ce,
+    side: W = "bottom",
+    align: z = "center",
+    sideOffset: L = 0,
+    alignOffset: H = 0,
+    collisionBoundary: U = "clipping-ancestors",
+    collisionPadding: _,
+    arrowPadding: j = 5,
+    sticky: q = !1,
+    disableAnchorTracking: B,
+    alignItemWithTrigger: g = !0,
+    collisionAvoidance: F = Re,
+    ...X
+  } = S, {
+    store: e,
+    listRef: G,
+    labelsRef: J,
+    alignItemWithTriggerActiveRef: K,
+    selectedItemTextRef: v,
+    valuesRef: f,
+    initialValueRef: Q,
+    popupRef: Y,
+    setValue: x
+  } = me(), Z = fe(), a = c(e, t.open), n = c(e, t.mounted), E = c(e, t.modal), m = c(e, t.value), V = c(e, t.touchModality), $ = c(e, t.positionerElement), b = c(e, t.triggerElement), p = c(e, t.isItemEqualToValue), ee = o.useRef(null), te = o.useRef(null), [w, h] = o.useState(g), i = n && w && !V;
+  !n && w !== g && h(g), ae(() => {
+    n || (t.scrollUpArrowVisible(e.state) && e.set("scrollUpArrowVisible", !1), t.scrollDownArrowVisible(e.state) && e.set("scrollDownArrowVisible", !1));
+  }, [e, n]), o.useImperativeHandle(K, () => i), ue((i || E) && a && !V, b);
+  const r = ge({
+    anchor: k,
+    floatingRootContext: Z,
+    positionMethod: N,
+    mounted: n,
+    side: W,
+    sideOffset: L,
+    align: z,
+    alignOffset: H,
+    arrowPadding: j,
+    collisionBoundary: U,
+    collisionPadding: _,
+    sticky: q,
+    disableAnchorTracking: B ?? i,
+    collisionAvoidance: F,
+    keepMounted: !0
+  }), d = i ? "none" : r.side, y = i ? Ve : r.positionerStyles, oe = o.useMemo(() => {
+    const s = {};
+    return a || (s.pointerEvents = "none"), {
+      role: "presentation",
+      hidden: !n,
+      style: {
+        ...y,
+        ...s
+      }
+    };
+  }, [a, n, y]), ne = o.useMemo(() => ({
+    open: a,
+    side: d,
+    align: r.align,
+    anchorHidden: r.anchorHidden
+  }), [a, d, r.align, r.anchorHidden]), ie = D((s) => {
+    e.set("positionerElement", s);
+  }), re = Ae("div", S, {
+    ref: [O, ie],
+    state: ne,
+    stateAttributesMapping: de,
+    props: [oe, X]
+  }), I = o.useRef(0), se = D((s) => {
+    if (s.size === 0 && I.current === 0 || f.current.length === 0)
+      return;
+    const A = I.current;
+    if (I.current = s.size, s.size === A)
+      return;
+    const C = Se(Ee);
+    if (A !== 0 && !e.state.multiple && m !== null && ve(f.current, m, p) === -1) {
+      const u = Q.current, M = u != null && R(f.current, u, p) ? u : null;
+      x(M, C), M === null && (e.set("selectedIndex", null), v.current = null);
+    }
+    if (A !== 0 && e.state.multiple && Array.isArray(m)) {
+      const l = m.filter((u) => R(f.current, u, p));
+      (l.length !== m.length || l.some((u) => !R(m, u, p))) && (x(l, C), l.length === 0 && (e.set("selectedIndex", null), v.current = null));
+    }
+    if (a && i) {
+      e.update({
+        scrollUpArrowVisible: !1,
+        scrollDownArrowVisible: !1
+      });
+      const l = {
+        height: ""
+      };
+      P($, l), P(Y.current, l);
+    }
+  }), le = o.useMemo(() => ({
+    ...r,
+    side: d,
+    alignItemWithTriggerActive: i,
+    setControlledAlignItemWithTrigger: h,
+    scrollUpArrowRef: ee,
+    scrollDownArrowRef: te
+  }), [r, d, i, h]);
+  return /* @__PURE__ */ T(pe, {
+    elementsRef: G,
+    labelsRef: J,
+    onMapChange: se,
+    children: /* @__PURE__ */ xe(he.Provider, {
+      value: le,
+      children: [n && E && /* @__PURE__ */ T(Ie, {
+        inert: ce(!a),
+        cutout: b
+      }), re]
+    })
+  });
+});
+process.env.NODE_ENV !== "production" && (be.displayName = "SelectPositioner");
+export {
+  be as SelectPositioner
+};

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

@@ -0,0 +1,199 @@
+import * as s from "react";
+import * as Dt from "react-dom";
+import { useTimeout as Nt } from "./als-react-ts-ui229.js";
+import { isWebKit as Wt } from "./als-react-ts-ui275.js";
+import { useStableCallback as $t } from "./als-react-ts-ui160.js";
+import { ownerDocument as lt } from "./als-react-ts-ui268.js";
+import { isMouseWithinBounds as kt } from "./als-react-ts-ui276.js";
+import { useIsoLayoutEffect as _ } from "./als-react-ts-ui161.js";
+import { useAnimationFrame as zt } from "./als-react-ts-ui223.js";
+import { useSelectRootContext as _t, useSelectFloatingContext as jt } from "./als-react-ts-ui253.js";
+import { popupStateMapping as Kt } from "./als-react-ts-ui188.js";
+import { useSelectPositionerContext as Vt } from "./als-react-ts-ui273.js";
+import { styleDisableScrollbar as ct } from "./als-react-ts-ui277.js";
+import { transitionStatusMapping as Yt } from "./als-react-ts-ui189.js";
+import { useOpenChangeComplete as qt } from "./als-react-ts-ui183.js";
+import { useRenderElement as Ut } from "./als-react-ts-ui166.js";
+import { selectors as u } from "./als-react-ts-ui257.js";
+import { clearStyles as at, LIST_FUNCTIONAL_STYLES as Xt } from "./als-react-ts-ui274.js";
+import { createChangeEventDetails as Zt } from "./als-react-ts-ui167.js";
+import { useToolbarRootContext as Gt } from "./als-react-ts-ui278.js";
+import { COMPOSITE_KEYS as Jt } from "./als-react-ts-ui178.js";
+import { getDisabledMountTransitionStyles as Qt } from "./als-react-ts-ui279.js";
+import { jsxs as te, jsx as ee } from "react/jsx-runtime";
+import { getWindow as mt } from "./als-react-ts-ui221.js";
+import { FloatingFocusManager as oe } from "./als-react-ts-ui193.js";
+import { useStore as g } from "./als-react-ts-ui267.js";
+import { windowResize as ne } from "./als-react-ts-ui168.js";
+const re = {
+  ...Kt,
+  ...Yt
+}, ie = /* @__PURE__ */ s.forwardRef(function(j, pt) {
+  const {
+    render: le,
+    className: ce,
+    ...ut
+  } = j, {
+    store: r,
+    popupRef: p,
+    onOpenChangeComplete: gt,
+    setOpen: K,
+    valueRef: V,
+    selectedItemTextRef: Y,
+    keyboardActiveRef: q,
+    multiple: ft,
+    handleScrollArrowVisibility: H,
+    scrollHandlerRef: U
+  } = _t(), {
+    side: X,
+    align: Z,
+    alignItemWithTriggerActive: l,
+    setControlledAlignItemWithTrigger: G,
+    scrollDownArrowRef: ht,
+    scrollUpArrowRef: dt
+  } = Vt(), xt = Gt() != null, Tt = jt(), yt = Nt(), Rt = g(r, u.id), P = g(r, u.open), f = g(r, u.mounted), St = g(r, u.popupProps), O = g(r, u.transitionStatus), w = g(r, u.triggerElement), t = g(r, u.positionerElement), R = g(r, u.listElement), F = s.useRef(0), B = s.useRef(!1), Ht = s.useRef(0), C = s.useRef(!1), L = s.useRef({}), J = zt(), Q = $t((e) => {
+    if (!t || !p.current || !C.current)
+      return;
+    if (B.current || !l) {
+      H();
+      return;
+    }
+    const i = t.style.top === "0px", b = t.style.bottom === "0px", M = t.getBoundingClientRect().height, I = lt(t), c = getComputedStyle(t), h = parseFloat(c.marginTop), A = parseFloat(c.marginBottom), d = I.documentElement.clientHeight - h - A, n = e.scrollTop, D = e.scrollHeight, N = e.clientHeight, x = D - N;
+    let a = null, m = null, E = !1;
+    if (i) {
+      const S = x - n, T = M + S, o = Math.min(T, d);
+      a = o, o !== d ? m = x : E = !0;
+    } else if (b) {
+      const S = n - 0, T = M + S, o = Math.min(T, d), W = T - d;
+      a = o, o !== d ? m = 0 : (E = !0, n < x && (m = n - (S - W)));
+    }
+    a != null && (t.style.height = `${a}px`), m != null && (e.scrollTop = m), E && (B.current = !0), H();
+  });
+  s.useImperativeHandle(U, () => Q, [Q]), qt({
+    open: P,
+    ref: p,
+    onComplete() {
+      P && gt?.(!0);
+    }
+  });
+  const Ct = s.useMemo(() => ({
+    open: P,
+    transitionStatus: O,
+    side: X,
+    align: Z
+  }), [P, O, X, Z]);
+  _(() => {
+    !t || !p.current || Object.keys(L.current).length || (L.current = {
+      top: t.style.top || "0",
+      left: t.style.left || "0",
+      right: t.style.right,
+      height: t.style.height,
+      bottom: t.style.bottom,
+      minHeight: t.style.minHeight,
+      maxHeight: t.style.maxHeight,
+      marginTop: t.style.marginTop,
+      marginBottom: t.style.marginBottom
+    });
+  }, [p, t]), _(() => {
+    f || l || (C.current = !1, B.current = !1, F.current = 0, Ht.current = 0, at(t, L.current));
+  }, [f, l, t, p]), _(() => {
+    const e = p.current;
+    if (!(!f || !w || !t || !e)) {
+      if (!l) {
+        C.current = !0, J.request(H);
+        return;
+      }
+      queueMicrotask(() => {
+        const i = getComputedStyle(t), b = getComputedStyle(e), M = lt(w), I = mt(t), c = w.getBoundingClientRect(), h = t.getBoundingClientRect(), A = c.left, d = c.height, n = R || e, D = n.scrollHeight, N = parseFloat(b.borderBottomWidth), x = parseFloat(i.marginTop) || 10, a = parseFloat(i.marginBottom) || 10, m = parseFloat(i.minHeight) || 100, E = 5, S = 5, T = 20, o = M.documentElement.clientHeight - x - a, W = M.documentElement.clientWidth, Et = o - c.bottom + d, tt = Y.current, et = V.current;
+        let ot = 0, nt = 0;
+        if (tt && et) {
+          const v = et.getBoundingClientRect(), z = tt.getBoundingClientRect(), Lt = v.left - A, At = z.left - h.left, Ot = v.top - c.top + v.height / 2, It = z.top - h.top + z.height / 2;
+          ot = Lt - At, nt = It - Ot;
+        }
+        const $ = Et + nt + a + N;
+        let y = Math.min(o, $);
+        const vt = o - x - a, k = $ - y, rt = Math.max(E, A + ot), Pt = W - S, wt = Math.max(0, rt + h.width - Pt);
+        t.style.left = `${rt - wt}px`, t.style.height = `${y}px`, t.style.maxHeight = "auto", t.style.marginTop = `${x}px`, t.style.marginBottom = `${a}px`, e.style.height = "100%";
+        const it = n.scrollHeight - n.clientHeight, st = k >= it;
+        st && (y = Math.min(o, h.height) - (k - it));
+        const Ft = c.top < T || c.bottom > o - T || y < Math.min(D, m), Bt = (I.visualViewport?.scale ?? 1) !== 1 && Wt;
+        if (Ft || Bt) {
+          C.current = !0, at(t, L.current), Dt.flushSync(() => G(!1));
+          return;
+        }
+        if (st) {
+          const v = Math.max(0, o - $);
+          t.style.top = h.height >= vt ? "0" : `${v}px`, t.style.height = `${y}px`, n.scrollTop = n.scrollHeight - n.clientHeight, F.current = Math.max(m, y);
+        } else
+          t.style.bottom = "0", F.current = Math.max(m, y), n.scrollTop = k;
+        F.current === o && (B.current = !0), H(), setTimeout(() => {
+          C.current = !0;
+        });
+      });
+    }
+  }, [r, f, t, w, V, Y, p, H, l, G, J, ht, dt, R]), s.useEffect(() => {
+    if (!l || !t || !f)
+      return;
+    const e = mt(t);
+    function i(b) {
+      K(!1, Zt(ne, b));
+    }
+    return e.addEventListener("resize", i), () => {
+      e.removeEventListener("resize", i);
+    };
+  }, [K, l, t, f]);
+  const bt = {
+    ...R ? {
+      role: "presentation",
+      "aria-orientation": void 0
+    } : {
+      role: "listbox",
+      "aria-multiselectable": ft || void 0,
+      id: `${Rt}-list`
+    },
+    onKeyDown(e) {
+      q.current = !0, xt && Jt.has(e.key) && e.stopPropagation();
+    },
+    onMouseMove() {
+      q.current = !1;
+    },
+    onPointerLeave(e) {
+      if (kt(e) || e.pointerType === "touch")
+        return;
+      const i = e.currentTarget;
+      yt.start(0, () => {
+        r.set("activeIndex", null), i.focus({
+          preventScroll: !0
+        });
+      });
+    },
+    onScroll(e) {
+      R || U.current?.(e.currentTarget);
+    },
+    ...l && {
+      style: R ? {
+        height: "100%"
+      } : Xt
+    }
+  }, Mt = Ut("div", j, {
+    ref: [pt, p],
+    state: Ct,
+    stateAttributesMapping: re,
+    props: [St, bt, Qt(O), {
+      className: !R && l ? ct.className : void 0
+    }, ut]
+  });
+  return /* @__PURE__ */ te(s.Fragment, {
+    children: [ct.element, /* @__PURE__ */ ee(oe, {
+      context: Tt,
+      modal: !1,
+      disabled: !f,
+      restoreFocus: !0,
+      children: Mt
+    })]
+  });
+});
+process.env.NODE_ENV !== "production" && (ie.displayName = "SelectPopup");
+export {
+  ie as SelectPopup
+};

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

@@ -0,0 +1,146 @@
+import * as r from "react";
+import { useIsoLayoutEffect as T } from "./als-react-ts-ui161.js";
+import { useValueAsRef as J } from "./als-react-ts-ui225.js";
+import { isMouseWithinBounds as Q } from "./als-react-ts-ui276.js";
+import { useTimeout as X } from "./als-react-ts-ui229.js";
+import { useSelectRootContext as Y } from "./als-react-ts-ui253.js";
+import { useCompositeListItem as Z, IndexGuessBehavior as $ } from "./als-react-ts-ui173.js";
+import { useRenderElement as ee } from "./als-react-ts-ui166.js";
+import { SelectItemContext as te } from "./als-react-ts-ui280.js";
+import { selectors as v } from "./als-react-ts-ui257.js";
+import { createChangeEventDetails as S } from "./als-react-ts-ui167.js";
+import { compareItemEquality as ne, removeItem as oe } from "./als-react-ts-ui261.js";
+import { jsx as re } from "react/jsx-runtime";
+import { useButton as se } from "./als-react-ts-ui179.js";
+import { useStore as x } from "./als-react-ts-ui267.js";
+import { itemPress as E } from "./als-react-ts-ui168.js";
+const ue = /* @__PURE__ */ r.memo(/* @__PURE__ */ r.forwardRef(function(g, A) {
+  const {
+    render: le,
+    className: ce,
+    value: s = null,
+    label: D,
+    disabled: i = !1,
+    nativeButton: C = !1,
+    ...F
+  } = g, I = r.useRef(null), a = Z({
+    label: D,
+    textRef: I,
+    indexGuessBehavior: $.GuessFromOrder
+  }), {
+    store: t,
+    getItemProps: k,
+    setOpen: N,
+    setValue: w,
+    selectionRef: R,
+    typingRef: q,
+    valuesRef: U,
+    keyboardActiveRef: V,
+    multiple: y
+  } = Y(), G = X(), l = x(t, v.isActive, a.index), o = x(t, v.isSelected, a.index, s), P = x(t, v.isSelectedByFocus, a.index), h = x(t, v.isItemEqualToValue), n = a.index, c = n !== -1, L = r.useRef(null), b = J(n);
+  T(() => {
+    if (!c)
+      return;
+    const e = U.current;
+    return e[n] = s, () => {
+      delete e[n];
+    };
+  }, [c, n, s, U]), T(() => {
+    if (!c)
+      return;
+    const e = t.state.value;
+    let u = e;
+    y && Array.isArray(e) && e.length > 0 && (u = e[e.length - 1]), u !== void 0 && ne(u, s, h) && t.set("selectedIndex", n);
+  }, [c, n, y, h, t, s]);
+  const O = r.useMemo(() => ({
+    disabled: i,
+    selected: o,
+    highlighted: l
+  }), [i, o, l]), M = k({
+    active: l,
+    selected: o
+  });
+  M.onFocus = void 0, M.id = void 0;
+  const d = r.useRef(null), f = r.useRef("mouse"), m = r.useRef(!1), {
+    getButtonProps: K,
+    buttonRef: W
+  } = se({
+    disabled: i,
+    focusableWhenDisabled: !0,
+    native: C
+  });
+  function B(e) {
+    const u = t.state.value;
+    if (y) {
+      const p = Array.isArray(u) ? u : [], H = o ? oe(p, s, h) : [...p, s];
+      w(H, S(E, e));
+    } else
+      w(s, S(E, e)), N(!1, S(E, e));
+  }
+  const j = {
+    role: "option",
+    "aria-selected": o,
+    "aria-disabled": i || void 0,
+    tabIndex: l ? 0 : -1,
+    onFocus() {
+      t.set("activeIndex", n);
+    },
+    onMouseEnter() {
+      !V.current && t.state.selectedIndex === null && t.set("activeIndex", n);
+    },
+    onMouseMove() {
+      t.set("activeIndex", n);
+    },
+    onMouseLeave(e) {
+      V.current || Q(e) || G.start(0, () => {
+        t.state.activeIndex === n && t.set("activeIndex", null);
+      });
+    },
+    onTouchStart() {
+      R.current = {
+        allowSelectedMouseUp: !1,
+        allowUnselectedMouseUp: !1
+      };
+    },
+    onKeyDown(e) {
+      d.current = e.key, t.set("activeIndex", n);
+    },
+    onClick(e) {
+      m.current = !1, !(e.type === "keydown" && d.current === null) && (i || d.current === " " && q.current || f.current !== "touch" && !l || (d.current = null, B(e.nativeEvent)));
+    },
+    onPointerEnter(e) {
+      f.current = e.pointerType;
+    },
+    onPointerDown(e) {
+      f.current = e.pointerType, m.current = !0;
+    },
+    onMouseUp(e) {
+      if (i)
+        return;
+      if (m.current) {
+        m.current = !1;
+        return;
+      }
+      const u = !R.current.allowSelectedMouseUp && o, p = !R.current.allowUnselectedMouseUp && !o;
+      u || p || f.current !== "touch" && !l || B(e.nativeEvent);
+    }
+  }, _ = ee("div", g, {
+    ref: [W, A, a.ref, L],
+    state: O,
+    props: [M, j, F, K]
+  }), z = r.useMemo(() => ({
+    selected: o,
+    indexRef: b,
+    textRef: I,
+    selectedByFocus: P,
+    hasRegistered: c
+  }), [o, b, I, P, c]);
+  return /* @__PURE__ */ re(te.Provider, {
+    value: z,
+    children: _
+  });
+}));
+process.env.NODE_ENV !== "production" && (ue.displayName = "SelectItem");
+export {
+  ue as SelectItem
+};

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

@@ -0,0 +1,31 @@
+import * as t from "react";
+import { useSelectRootContext as a } from "./als-react-ts-ui253.js";
+import { useSelectItemContext as d } from "./als-react-ts-ui280.js";
+import { useRenderElement as x } from "./als-react-ts-ui166.js";
+const p = /* @__PURE__ */ t.memo(/* @__PURE__ */ t.forwardRef(function(r, m) {
+  const {
+    indexRef: o,
+    textRef: l,
+    selectedByFocus: c,
+    hasRegistered: n
+  } = d(), {
+    selectedItemTextRef: e
+  } = a(), {
+    className: I,
+    render: S,
+    ...f
+  } = r, i = t.useCallback((s) => {
+    if (!s || !n)
+      return;
+    const u = e.current === null || !e.current.isConnected;
+    (c || u && o.current === 0) && (e.current = s);
+  }, [e, o, c, n]);
+  return x("div", r, {
+    ref: [i, m, l],
+    props: f
+  });
+}));
+process.env.NODE_ENV !== "production" && (p.displayName = "SelectItemText");
+export {
+  p as SelectItemText
+};

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

@@ -0,0 +1,52 @@
+import * as t from "react";
+import { useSelectItemContext as d } from "./als-react-ts-ui280.js";
+import { useTransitionStatus as I } from "./als-react-ts-ui218.js";
+import { useOpenChangeComplete as R } from "./als-react-ts-ui183.js";
+import { useRenderElement as M } from "./als-react-ts-ui166.js";
+import { transitionStatusMapping as N } from "./als-react-ts-ui189.js";
+import { jsx as S } from "react/jsx-runtime";
+const h = /* @__PURE__ */ t.forwardRef(function(n, r) {
+  const s = n.keepMounted ?? !1, {
+    selected: i
+  } = d();
+  return s || i ? /* @__PURE__ */ S(p, {
+    ...n,
+    ref: r
+  }) : null;
+});
+process.env.NODE_ENV !== "production" && (h.displayName = "SelectItemIndicator");
+const p = /* @__PURE__ */ t.memo(/* @__PURE__ */ t.forwardRef((o, n) => {
+  const {
+    render: r,
+    className: s,
+    keepMounted: i,
+    ...a
+  } = o, {
+    selected: e
+  } = d(), c = t.useRef(null), {
+    transitionStatus: m,
+    setMounted: u
+  } = I(e), f = t.useMemo(() => ({
+    selected: e,
+    transitionStatus: m
+  }), [e, m]), l = M("span", o, {
+    ref: [n, c],
+    state: f,
+    props: [{
+      "aria-hidden": !0,
+      children: "✔️"
+    }, a],
+    stateAttributesMapping: N
+  });
+  return R({
+    open: e,
+    ref: c,
+    onComplete() {
+      e || u(!1);
+    }
+  }), l;
+}));
+process.env.NODE_ENV !== "production" && (p.displayName = "Inner");
+export {
+  h as SelectItemIndicator
+};

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

@@ -0,0 +1,28 @@
+import * as r from "react";
+import { SelectGroupContext as c } from "./als-react-ts-ui281.js";
+import { useRenderElement as p } from "./als-react-ts-ui166.js";
+import { jsx as m } from "react/jsx-runtime";
+const u = /* @__PURE__ */ r.forwardRef(function(o, l) {
+  const {
+    className: d,
+    render: f,
+    ...s
+  } = o, [e, t] = r.useState(), n = r.useMemo(() => ({
+    labelId: e,
+    setLabelId: t
+  }), [e, t]), a = p("div", o, {
+    ref: l,
+    props: [{
+      role: "group",
+      "aria-labelledby": e
+    }, s]
+  });
+  return /* @__PURE__ */ m(c.Provider, {
+    value: n,
+    children: a
+  });
+});
+process.env.NODE_ENV !== "production" && (u.displayName = "SelectGroup");
+export {
+  u as SelectGroup
+};

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

@@ -0,0 +1,27 @@
+import * as n from "react";
+import { useIsoLayoutEffect as p } from "./als-react-ts-ui161.js";
+import { useBaseUiId as c } from "./als-react-ts-ui170.js";
+import { useSelectGroupContext as i } from "./als-react-ts-ui281.js";
+import { useRenderElement as l } from "./als-react-ts-ui166.js";
+const a = /* @__PURE__ */ n.forwardRef(function(o, t) {
+  const {
+    className: u,
+    render: d,
+    id: s,
+    ...m
+  } = o, {
+    setLabelId: r
+  } = i(), e = c(s);
+  return p(() => {
+    r(e);
+  }, [e, r]), l("div", o, {
+    ref: t,
+    props: [{
+      id: e
+    }, m]
+  });
+});
+process.env.NODE_ENV !== "production" && (a.displayName = "SelectGroupLabel");
+export {
+  a as SelectGroupLabel
+};

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

@@ -0,0 +1,24 @@
+import * as o from "react";
+import { useRenderElement as s } from "./als-react-ts-ui166.js";
+const i = /* @__PURE__ */ o.forwardRef(function(r, t) {
+  const {
+    className: m,
+    render: c,
+    orientation: e = "horizontal",
+    ...a
+  } = r, n = o.useMemo(() => ({
+    orientation: e
+  }), [e]);
+  return s("div", r, {
+    state: n,
+    ref: t,
+    props: [{
+      role: "separator",
+      "aria-orientation": e
+    }, a]
+  });
+});
+process.env.NODE_ENV !== "production" && (i.displayName = "Separator");
+export {
+  i as Separator
+};

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

@@ -0,0 +1,23 @@
+import * as s from "react";
+import { SelectPortalContext as f } from "./als-react-ts-ui271.js";
+import { useSelectRootContext as i } from "./als-react-ts-ui253.js";
+import { selectors as t } from "./als-react-ts-ui257.js";
+import { jsx as r } from "react/jsx-runtime";
+import { FloatingPortal as u } from "./als-react-ts-ui196.js";
+import { useStore as e } from "./als-react-ts-ui267.js";
+const a = /* @__PURE__ */ s.forwardRef(function(n, l) {
+  const {
+    store: o
+  } = i(), c = e(o, t.mounted), m = e(o, t.forceMount);
+  return c || m ? /* @__PURE__ */ r(f.Provider, {
+    value: !0,
+    children: /* @__PURE__ */ r(u, {
+      ref: l,
+      ...n
+    })
+  }) : null;
+});
+process.env.NODE_ENV !== "production" && (a.displayName = "SelectPortal");
+export {
+  a as SelectPortal
+};