@gv-tech/ui-web 2.10.0 → 2.12.0

package/dist/select.es.js

@@ -0,0 +1,908 @@
+import { j as r } from "./jsx-runtime-tc70JA_2.mjs";
+import * as t from "react";
+import * as Pe from "react-dom";
+import { c as Ne } from "./index-rKs9bXHr.mjs";
+import { P as j, c as b, a as mt } from "./index-K9FzbxYw.mjs";
+import { c as ht } from "./index-DFdF7K7v.mjs";
+import { u as L } from "./index-DLcqcWxM.mjs";
+import { c as gt } from "./index-IZ2gq03c.mjs";
+import { u as vt } from "./index-CD6_IrA-.mjs";
+import { D as xt } from "./index-Dfzl8TxY.mjs";
+import { h as St, u as wt, R as yt, F as Ct } from "./index-CRyCZJLa.mjs";
+import { u as Ie } from "./index-DnFcfnA9.mjs";
+import { A as It, c as Re, C as Tt, R as Nt, a as bt } from "./index-CwfE56Ep.mjs";
+import { P as Pt } from "./index-C7HEunrh.mjs";
+import { u as Rt } from "./index-0ioNhtNM.mjs";
+import { u as be } from "./index-p6xVFRb4.mjs";
+import { u as G } from "./index-CCKe-Mpx.mjs";
+import { u as Et } from "./index-BZPx6jYI.mjs";
+import { V as _t } from "./index-DKN_vhyX.mjs";
+import { ChevronDown as Ee, ChevronUp as jt, Check as Mt } from "lucide-react";
+import { c as z } from "./utils-B6yFEsav.mjs";
+var At = [" ", "Enter", "ArrowUp", "ArrowDown"], Ot = [" ", "Enter"], Q = "Select", [ie, de, Dt] = ht(Q), [oe] = gt(Q, [
+  Dt,
+  Re
+]), pe = Re(), [Lt, Y] = oe(Q), [kt, Bt] = oe(Q), _e = (o) => {
+  const {
+    __scopeSelect: n,
+    children: e,
+    open: l,
+    defaultOpen: a,
+    onOpenChange: p,
+    value: s,
+    defaultValue: c,
+    onValueChange: i,
+    dir: f,
+    name: v,
+    autoComplete: w,
+    disabled: P,
+    required: T,
+    form: C
+  } = o, d = pe(n), [h, x] = t.useState(null), [m, g] = t.useState(null), [U, M] = t.useState(!1), ne = vt(f), [R, O] = be({
+    prop: l,
+    defaultProp: a ?? !1,
+    onChange: p,
+    caller: Q
+  }), [W, X] = be({
+    prop: s,
+    defaultProp: c,
+    onChange: i,
+    caller: Q
+  }), k = t.useRef(null), B = h ? C || !!h.closest("form") : !0, [K, V] = t.useState(/* @__PURE__ */ new Set()), H = Array.from(K).map((E) => E.props.value).join(";");
+  return /* @__PURE__ */ r.jsx(Nt, { ...d, children: /* @__PURE__ */ r.jsxs(
+    Lt,
+    {
+      required: T,
+      scope: n,
+      trigger: h,
+      onTriggerChange: x,
+      valueNode: m,
+      onValueNodeChange: g,
+      valueNodeHasChildren: U,
+      onValueNodeHasChildrenChange: M,
+      contentId: Ie(),
+      value: W,
+      onValueChange: X,
+      open: R,
+      onOpenChange: O,
+      dir: ne,
+      triggerPointerDownPosRef: k,
+      disabled: P,
+      children: [
+        /* @__PURE__ */ r.jsx(ie.Provider, { scope: n, children: /* @__PURE__ */ r.jsx(
+          kt,
+          {
+            scope: o.__scopeSelect,
+            onNativeOptionAdd: t.useCallback((E) => {
+              V((D) => new Set(D).add(E));
+            }, []),
+            onNativeOptionRemove: t.useCallback((E) => {
+              V((D) => {
+                const F = new Set(D);
+                return F.delete(E), F;
+              });
+            }, []),
+            children: e
+          }
+        ) }),
+        B ? /* @__PURE__ */ r.jsxs(
+          tt,
+          {
+            "aria-hidden": !0,
+            required: T,
+            tabIndex: -1,
+            name: v,
+            autoComplete: w,
+            value: W,
+            onChange: (E) => X(E.target.value),
+            disabled: P,
+            form: C,
+            children: [
+              W === void 0 ? /* @__PURE__ */ r.jsx("option", { value: "" }) : null,
+              Array.from(K)
+            ]
+          },
+          H
+        ) : null
+      ]
+    }
+  ) });
+};
+_e.displayName = Q;
+var je = "SelectTrigger", Me = t.forwardRef(
+  (o, n) => {
+    const { __scopeSelect: e, disabled: l = !1, ...a } = o, p = pe(e), s = Y(je, e), c = s.disabled || l, i = L(n, s.onTriggerChange), f = de(e), v = t.useRef("touch"), [w, P, T] = nt((d) => {
+      const h = f().filter((g) => !g.disabled), x = h.find((g) => g.value === s.value), m = rt(h, d, x);
+      m !== void 0 && s.onValueChange(m.value);
+    }), C = (d) => {
+      c || (s.onOpenChange(!0), T()), d && (s.triggerPointerDownPosRef.current = {
+        x: Math.round(d.pageX),
+        y: Math.round(d.pageY)
+      });
+    };
+    return /* @__PURE__ */ r.jsx(It, { asChild: !0, ...p, children: /* @__PURE__ */ r.jsx(
+      j.button,
+      {
+        type: "button",
+        role: "combobox",
+        "aria-controls": s.contentId,
+        "aria-expanded": s.open,
+        "aria-required": s.required,
+        "aria-autocomplete": "none",
+        dir: s.dir,
+        "data-state": s.open ? "open" : "closed",
+        disabled: c,
+        "data-disabled": c ? "" : void 0,
+        "data-placeholder": ot(s.value) ? "" : void 0,
+        ...a,
+        ref: i,
+        onClick: b(a.onClick, (d) => {
+          d.currentTarget.focus(), v.current !== "mouse" && C(d);
+        }),
+        onPointerDown: b(a.onPointerDown, (d) => {
+          v.current = d.pointerType;
+          const h = d.target;
+          h.hasPointerCapture(d.pointerId) && h.releasePointerCapture(d.pointerId), d.button === 0 && d.ctrlKey === !1 && d.pointerType === "mouse" && (C(d), d.preventDefault());
+        }),
+        onKeyDown: b(a.onKeyDown, (d) => {
+          const h = w.current !== "";
+          !(d.ctrlKey || d.altKey || d.metaKey) && d.key.length === 1 && P(d.key), !(h && d.key === " ") && At.includes(d.key) && (C(), d.preventDefault());
+        })
+      }
+    ) });
+  }
+);
+Me.displayName = je;
+var Ae = "SelectValue", Oe = t.forwardRef(
+  (o, n) => {
+    const { __scopeSelect: e, className: l, style: a, children: p, placeholder: s = "", ...c } = o, i = Y(Ae, e), { onValueNodeHasChildrenChange: f } = i, v = p !== void 0, w = L(n, i.onValueNodeChange);
+    return G(() => {
+      f(v);
+    }, [f, v]), /* @__PURE__ */ r.jsx(
+      j.span,
+      {
+        ...c,
+        ref: w,
+        style: { pointerEvents: "none" },
+        children: ot(i.value) ? /* @__PURE__ */ r.jsx(r.Fragment, { children: s }) : p
+      }
+    );
+  }
+);
+Oe.displayName = Ae;
+var Vt = "SelectIcon", De = t.forwardRef(
+  (o, n) => {
+    const { __scopeSelect: e, children: l, ...a } = o;
+    return /* @__PURE__ */ r.jsx(j.span, { "aria-hidden": !0, ...a, ref: n, children: l || "▼" });
+  }
+);
+De.displayName = Vt;
+var Ht = "SelectPortal", Le = (o) => /* @__PURE__ */ r.jsx(Pt, { asChild: !0, ...o });
+Le.displayName = Ht;
+var ee = "SelectContent", ke = t.forwardRef(
+  (o, n) => {
+    const e = Y(ee, o.__scopeSelect), [l, a] = t.useState();
+    if (G(() => {
+      a(new DocumentFragment());
+    }, []), !e.open) {
+      const p = l;
+      return p ? Pe.createPortal(
+        /* @__PURE__ */ r.jsx(Be, { scope: o.__scopeSelect, children: /* @__PURE__ */ r.jsx(ie.Slot, { scope: o.__scopeSelect, children: /* @__PURE__ */ r.jsx("div", { children: o.children }) }) }),
+        p
+      ) : null;
+    }
+    return /* @__PURE__ */ r.jsx(Ve, { ...o, ref: n });
+  }
+);
+ke.displayName = ee;
+var A = 10, [Be, q] = oe(ee), Ft = "SelectContentImpl", Ut = mt("SelectContent.RemoveScroll"), Ve = t.forwardRef(
+  (o, n) => {
+    const {
+      __scopeSelect: e,
+      position: l = "item-aligned",
+      onCloseAutoFocus: a,
+      onEscapeKeyDown: p,
+      onPointerDownOutside: s,
+      //
+      // PopperContent props
+      side: c,
+      sideOffset: i,
+      align: f,
+      alignOffset: v,
+      arrowPadding: w,
+      collisionBoundary: P,
+      collisionPadding: T,
+      sticky: C,
+      hideWhenDetached: d,
+      avoidCollisions: h,
+      //
+      ...x
+    } = o, m = Y(ee, e), [g, U] = t.useState(null), [M, ne] = t.useState(null), R = L(n, (u) => U(u)), [O, W] = t.useState(null), [X, k] = t.useState(
+      null
+    ), B = de(e), [K, V] = t.useState(!1), H = t.useRef(!1);
+    t.useEffect(() => {
+      if (g) return St(g);
+    }, [g]), wt();
+    const E = t.useCallback(
+      (u) => {
+        const [I, ..._] = B().map((N) => N.ref.current), [S] = _.slice(-1), y = document.activeElement;
+        for (const N of u)
+          if (N === y || (N?.scrollIntoView({ block: "nearest" }), N === I && M && (M.scrollTop = 0), N === S && M && (M.scrollTop = M.scrollHeight), N?.focus(), document.activeElement !== y)) return;
+      },
+      [B, M]
+    ), D = t.useCallback(
+      () => E([O, g]),
+      [E, O, g]
+    );
+    t.useEffect(() => {
+      K && D();
+    }, [K, D]);
+    const { onOpenChange: F, triggerPointerDownPosRef: $ } = m;
+    t.useEffect(() => {
+      if (g) {
+        let u = { x: 0, y: 0 };
+        const I = (S) => {
+          u = {
+            x: Math.abs(Math.round(S.pageX) - ($.current?.x ?? 0)),
+            y: Math.abs(Math.round(S.pageY) - ($.current?.y ?? 0))
+          };
+        }, _ = (S) => {
+          u.x <= 10 && u.y <= 10 ? S.preventDefault() : g.contains(S.target) || F(!1), document.removeEventListener("pointermove", I), $.current = null;
+        };
+        return $.current !== null && (document.addEventListener("pointermove", I), document.addEventListener("pointerup", _, { capture: !0, once: !0 })), () => {
+          document.removeEventListener("pointermove", I), document.removeEventListener("pointerup", _, { capture: !0 });
+        };
+      }
+    }, [g, F, $]), t.useEffect(() => {
+      const u = () => F(!1);
+      return window.addEventListener("blur", u), window.addEventListener("resize", u), () => {
+        window.removeEventListener("blur", u), window.removeEventListener("resize", u);
+      };
+    }, [F]);
+    const [ue, ae] = nt((u) => {
+      const I = B().filter((y) => !y.disabled), _ = I.find((y) => y.ref.current === document.activeElement), S = rt(I, u, _);
+      S && setTimeout(() => S.ref.current.focus());
+    }), fe = t.useCallback(
+      (u, I, _) => {
+        const S = !H.current && !_;
+        (m.value !== void 0 && m.value === I || S) && (W(u), S && (H.current = !0));
+      },
+      [m.value]
+    ), me = t.useCallback(() => g?.focus(), [g]), te = t.useCallback(
+      (u, I, _) => {
+        const S = !H.current && !_;
+        (m.value !== void 0 && m.value === I || S) && k(u);
+      },
+      [m.value]
+    ), le = l === "popper" ? xe : He, re = le === xe ? {
+      side: c,
+      sideOffset: i,
+      align: f,
+      alignOffset: v,
+      arrowPadding: w,
+      collisionBoundary: P,
+      collisionPadding: T,
+      sticky: C,
+      hideWhenDetached: d,
+      avoidCollisions: h
+    } : {};
+    return /* @__PURE__ */ r.jsx(
+      Be,
+      {
+        scope: e,
+        content: g,
+        viewport: M,
+        onViewportChange: ne,
+        itemRefCallback: fe,
+        selectedItem: O,
+        onItemLeave: me,
+        itemTextRefCallback: te,
+        focusSelectedItem: D,
+        selectedItemText: X,
+        position: l,
+        isPositioned: K,
+        searchRef: ue,
+        children: /* @__PURE__ */ r.jsx(yt, { as: Ut, allowPinchZoom: !0, children: /* @__PURE__ */ r.jsx(
+          Ct,
+          {
+            asChild: !0,
+            trapped: m.open,
+            onMountAutoFocus: (u) => {
+              u.preventDefault();
+            },
+            onUnmountAutoFocus: b(a, (u) => {
+              m.trigger?.focus({ preventScroll: !0 }), u.preventDefault();
+            }),
+            children: /* @__PURE__ */ r.jsx(
+              xt,
+              {
+                asChild: !0,
+                disableOutsidePointerEvents: !0,
+                onEscapeKeyDown: p,
+                onPointerDownOutside: s,
+                onFocusOutside: (u) => u.preventDefault(),
+                onDismiss: () => m.onOpenChange(!1),
+                children: /* @__PURE__ */ r.jsx(
+                  le,
+                  {
+                    role: "listbox",
+                    id: m.contentId,
+                    "data-state": m.open ? "open" : "closed",
+                    dir: m.dir,
+                    onContextMenu: (u) => u.preventDefault(),
+                    ...x,
+                    ...re,
+                    onPlaced: () => V(!0),
+                    ref: R,
+                    style: {
+                      // flex layout so we can place the scroll buttons properly
+                      display: "flex",
+                      flexDirection: "column",
+                      // reset the outline by default as the content MAY get focused
+                      outline: "none",
+                      ...x.style
+                    },
+                    onKeyDown: b(x.onKeyDown, (u) => {
+                      const I = u.ctrlKey || u.altKey || u.metaKey;
+                      if (u.key === "Tab" && u.preventDefault(), !I && u.key.length === 1 && ae(u.key), ["ArrowUp", "ArrowDown", "Home", "End"].includes(u.key)) {
+                        let S = B().filter((y) => !y.disabled).map((y) => y.ref.current);
+                        if (["ArrowUp", "End"].includes(u.key) && (S = S.slice().reverse()), ["ArrowUp", "ArrowDown"].includes(u.key)) {
+                          const y = u.target, N = S.indexOf(y);
+                          S = S.slice(N + 1);
+                        }
+                        setTimeout(() => E(S)), u.preventDefault();
+                      }
+                    })
+                  }
+                )
+              }
+            )
+          }
+        ) })
+      }
+    );
+  }
+);
+Ve.displayName = Ft;
+var Wt = "SelectItemAlignedPosition", He = t.forwardRef((o, n) => {
+  const { __scopeSelect: e, onPlaced: l, ...a } = o, p = Y(ee, e), s = q(ee, e), [c, i] = t.useState(null), [f, v] = t.useState(null), w = L(n, (R) => v(R)), P = de(e), T = t.useRef(!1), C = t.useRef(!0), { viewport: d, selectedItem: h, selectedItemText: x, focusSelectedItem: m } = s, g = t.useCallback(() => {
+    if (p.trigger && p.valueNode && c && f && d && h && x) {
+      const R = p.trigger.getBoundingClientRect(), O = f.getBoundingClientRect(), W = p.valueNode.getBoundingClientRect(), X = x.getBoundingClientRect();
+      if (p.dir !== "rtl") {
+        const y = X.left - O.left, N = W.left - y, Z = R.left - N, J = R.width + Z, he = Math.max(J, O.width), ge = window.innerWidth - A, ve = Ne(N, [
+          A,
+          // Prevents the content from going off the starting edge of the
+          // viewport. It may still go off the ending edge, but this can be
+          // controlled by the user since they may want to manage overflow in a
+          // specific way.
+          // https://github.com/radix-ui/primitives/issues/2049
+          Math.max(A, ge - he)
+        ]);
+        c.style.minWidth = J + "px", c.style.left = ve + "px";
+      } else {
+        const y = O.right - X.right, N = window.innerWidth - W.right - y, Z = window.innerWidth - R.right - N, J = R.width + Z, he = Math.max(J, O.width), ge = window.innerWidth - A, ve = Ne(N, [
+          A,
+          Math.max(A, ge - he)
+        ]);
+        c.style.minWidth = J + "px", c.style.right = ve + "px";
+      }
+      const k = P(), B = window.innerHeight - A * 2, K = d.scrollHeight, V = window.getComputedStyle(f), H = parseInt(V.borderTopWidth, 10), E = parseInt(V.paddingTop, 10), D = parseInt(V.borderBottomWidth, 10), F = parseInt(V.paddingBottom, 10), $ = H + E + K + F + D, ue = Math.min(h.offsetHeight * 5, $), ae = window.getComputedStyle(d), fe = parseInt(ae.paddingTop, 10), me = parseInt(ae.paddingBottom, 10), te = R.top + R.height / 2 - A, le = B - te, re = h.offsetHeight / 2, u = h.offsetTop + re, I = H + E + u, _ = $ - I;
+      if (I <= te) {
+        const y = k.length > 0 && h === k[k.length - 1].ref.current;
+        c.style.bottom = "0px";
+        const N = f.clientHeight - d.offsetTop - d.offsetHeight, Z = Math.max(
+          le,
+          re + // viewport might have padding bottom, include it to avoid a scrollable viewport
+          (y ? me : 0) + N + D
+        ), J = I + Z;
+        c.style.height = J + "px";
+      } else {
+        const y = k.length > 0 && h === k[0].ref.current;
+        c.style.top = "0px";
+        const Z = Math.max(
+          te,
+          H + d.offsetTop + // viewport might have padding top, include it to avoid a scrollable viewport
+          (y ? fe : 0) + re
+        ) + _;
+        c.style.height = Z + "px", d.scrollTop = I - te + d.offsetTop;
+      }
+      c.style.margin = `${A}px 0`, c.style.minHeight = ue + "px", c.style.maxHeight = B + "px", l?.(), requestAnimationFrame(() => T.current = !0);
+    }
+  }, [
+    P,
+    p.trigger,
+    p.valueNode,
+    c,
+    f,
+    d,
+    h,
+    x,
+    p.dir,
+    l
+  ]);
+  G(() => g(), [g]);
+  const [U, M] = t.useState();
+  G(() => {
+    f && M(window.getComputedStyle(f).zIndex);
+  }, [f]);
+  const ne = t.useCallback(
+    (R) => {
+      R && C.current === !0 && (g(), m?.(), C.current = !1);
+    },
+    [g, m]
+  );
+  return /* @__PURE__ */ r.jsx(
+    $t,
+    {
+      scope: e,
+      contentWrapper: c,
+      shouldExpandOnScrollRef: T,
+      onScrollButtonChange: ne,
+      children: /* @__PURE__ */ r.jsx(
+        "div",
+        {
+          ref: i,
+          style: {
+            display: "flex",
+            flexDirection: "column",
+            position: "fixed",
+            zIndex: U
+          },
+          children: /* @__PURE__ */ r.jsx(
+            j.div,
+            {
+              ...a,
+              ref: w,
+              style: {
+                // When we get the height of the content, it includes borders. If we were to set
+                // the height without having `boxSizing: 'border-box'` it would be too big.
+                boxSizing: "border-box",
+                // We need to ensure the content doesn't get taller than the wrapper
+                maxHeight: "100%",
+                ...a.style
+              }
+            }
+          )
+        }
+      )
+    }
+  );
+});
+He.displayName = Wt;
+var Kt = "SelectPopperPosition", xe = t.forwardRef((o, n) => {
+  const {
+    __scopeSelect: e,
+    align: l = "start",
+    collisionPadding: a = A,
+    ...p
+  } = o, s = pe(e);
+  return /* @__PURE__ */ r.jsx(
+    Tt,
+    {
+      ...s,
+      ...p,
+      ref: n,
+      align: l,
+      collisionPadding: a,
+      style: {
+        // Ensure border-box for floating-ui calculations
+        boxSizing: "border-box",
+        ...p.style,
+        "--radix-select-content-transform-origin": "var(--radix-popper-transform-origin)",
+        "--radix-select-content-available-width": "var(--radix-popper-available-width)",
+        "--radix-select-content-available-height": "var(--radix-popper-available-height)",
+        "--radix-select-trigger-width": "var(--radix-popper-anchor-width)",
+        "--radix-select-trigger-height": "var(--radix-popper-anchor-height)"
+      }
+    }
+  );
+});
+xe.displayName = Kt;
+var [$t, Te] = oe(ee, {}), Se = "SelectViewport", Fe = t.forwardRef(
+  (o, n) => {
+    const { __scopeSelect: e, nonce: l, ...a } = o, p = q(Se, e), s = Te(Se, e), c = L(n, p.onViewportChange), i = t.useRef(0);
+    return /* @__PURE__ */ r.jsxs(r.Fragment, { children: [
+      /* @__PURE__ */ r.jsx(
+        "style",
+        {
+          dangerouslySetInnerHTML: {
+            __html: "[data-radix-select-viewport]{scrollbar-width:none;-ms-overflow-style:none;-webkit-overflow-scrolling:touch;}[data-radix-select-viewport]::-webkit-scrollbar{display:none}"
+          },
+          nonce: l
+        }
+      ),
+      /* @__PURE__ */ r.jsx(ie.Slot, { scope: e, children: /* @__PURE__ */ r.jsx(
+        j.div,
+        {
+          "data-radix-select-viewport": "",
+          role: "presentation",
+          ...a,
+          ref: c,
+          style: {
+            // we use position: 'relative' here on the `viewport` so that when we call
+            // `selectedItem.offsetTop` in calculations, the offset is relative to the viewport
+            // (independent of the scrollUpButton).
+            position: "relative",
+            flex: 1,
+            // Viewport should only be scrollable in the vertical direction.
+            // This won't work in vertical writing modes, so we'll need to
+            // revisit this if/when that is supported
+            // https://developer.chrome.com/blog/vertical-form-controls
+            overflow: "hidden auto",
+            ...a.style
+          },
+          onScroll: b(a.onScroll, (f) => {
+            const v = f.currentTarget, { contentWrapper: w, shouldExpandOnScrollRef: P } = s;
+            if (P?.current && w) {
+              const T = Math.abs(i.current - v.scrollTop);
+              if (T > 0) {
+                const C = window.innerHeight - A * 2, d = parseFloat(w.style.minHeight), h = parseFloat(w.style.height), x = Math.max(d, h);
+                if (x < C) {
+                  const m = x + T, g = Math.min(C, m), U = m - g;
+                  w.style.height = g + "px", w.style.bottom === "0px" && (v.scrollTop = U > 0 ? U : 0, w.style.justifyContent = "flex-end");
+                }
+              }
+            }
+            i.current = v.scrollTop;
+          })
+        }
+      ) })
+    ] });
+  }
+);
+Fe.displayName = Se;
+var Ue = "SelectGroup", [Gt, zt] = oe(Ue), We = t.forwardRef(
+  (o, n) => {
+    const { __scopeSelect: e, ...l } = o, a = Ie();
+    return /* @__PURE__ */ r.jsx(Gt, { scope: e, id: a, children: /* @__PURE__ */ r.jsx(j.div, { role: "group", "aria-labelledby": a, ...l, ref: n }) });
+  }
+);
+We.displayName = Ue;
+var Ke = "SelectLabel", $e = t.forwardRef(
+  (o, n) => {
+    const { __scopeSelect: e, ...l } = o, a = zt(Ke, e);
+    return /* @__PURE__ */ r.jsx(j.div, { id: a.id, ...l, ref: n });
+  }
+);
+$e.displayName = Ke;
+var ce = "SelectItem", [Yt, Ge] = oe(ce), ze = t.forwardRef(
+  (o, n) => {
+    const {
+      __scopeSelect: e,
+      value: l,
+      disabled: a = !1,
+      textValue: p,
+      ...s
+    } = o, c = Y(ce, e), i = q(ce, e), f = c.value === l, [v, w] = t.useState(p ?? ""), [P, T] = t.useState(!1), C = L(
+      n,
+      (m) => i.itemRefCallback?.(m, l, a)
+    ), d = Ie(), h = t.useRef("touch"), x = () => {
+      a || (c.onValueChange(l), c.onOpenChange(!1));
+    };
+    if (l === "")
+      throw new Error(
+        "A <Select.Item /> must have a value prop that is not an empty string. This is because the Select value can be set to an empty string to clear the selection and show the placeholder."
+      );
+    return /* @__PURE__ */ r.jsx(
+      Yt,
+      {
+        scope: e,
+        value: l,
+        disabled: a,
+        textId: d,
+        isSelected: f,
+        onItemTextChange: t.useCallback((m) => {
+          w((g) => g || (m?.textContent ?? "").trim());
+        }, []),
+        children: /* @__PURE__ */ r.jsx(
+          ie.ItemSlot,
+          {
+            scope: e,
+            value: l,
+            disabled: a,
+            textValue: v,
+            children: /* @__PURE__ */ r.jsx(
+              j.div,
+              {
+                role: "option",
+                "aria-labelledby": d,
+                "data-highlighted": P ? "" : void 0,
+                "aria-selected": f && P,
+                "data-state": f ? "checked" : "unchecked",
+                "aria-disabled": a || void 0,
+                "data-disabled": a ? "" : void 0,
+                tabIndex: a ? void 0 : -1,
+                ...s,
+                ref: C,
+                onFocus: b(s.onFocus, () => T(!0)),
+                onBlur: b(s.onBlur, () => T(!1)),
+                onClick: b(s.onClick, () => {
+                  h.current !== "mouse" && x();
+                }),
+                onPointerUp: b(s.onPointerUp, () => {
+                  h.current === "mouse" && x();
+                }),
+                onPointerDown: b(s.onPointerDown, (m) => {
+                  h.current = m.pointerType;
+                }),
+                onPointerMove: b(s.onPointerMove, (m) => {
+                  h.current = m.pointerType, a ? i.onItemLeave?.() : h.current === "mouse" && m.currentTarget.focus({ preventScroll: !0 });
+                }),
+                onPointerLeave: b(s.onPointerLeave, (m) => {
+                  m.currentTarget === document.activeElement && i.onItemLeave?.();
+                }),
+                onKeyDown: b(s.onKeyDown, (m) => {
+                  i.searchRef?.current !== "" && m.key === " " || (Ot.includes(m.key) && x(), m.key === " " && m.preventDefault());
+                })
+              }
+            )
+          }
+        )
+      }
+    );
+  }
+);
+ze.displayName = ce;
+var se = "SelectItemText", Ye = t.forwardRef(
+  (o, n) => {
+    const { __scopeSelect: e, className: l, style: a, ...p } = o, s = Y(se, e), c = q(se, e), i = Ge(se, e), f = Bt(se, e), [v, w] = t.useState(null), P = L(
+      n,
+      (x) => w(x),
+      i.onItemTextChange,
+      (x) => c.itemTextRefCallback?.(x, i.value, i.disabled)
+    ), T = v?.textContent, C = t.useMemo(
+      () => /* @__PURE__ */ r.jsx("option", { value: i.value, disabled: i.disabled, children: T }, i.value),
+      [i.disabled, i.value, T]
+    ), { onNativeOptionAdd: d, onNativeOptionRemove: h } = f;
+    return G(() => (d(C), () => h(C)), [d, h, C]), /* @__PURE__ */ r.jsxs(r.Fragment, { children: [
+      /* @__PURE__ */ r.jsx(j.span, { id: i.textId, ...p, ref: P }),
+      i.isSelected && s.valueNode && !s.valueNodeHasChildren ? Pe.createPortal(p.children, s.valueNode) : null
+    ] });
+  }
+);
+Ye.displayName = se;
+var qe = "SelectItemIndicator", Xe = t.forwardRef(
+  (o, n) => {
+    const { __scopeSelect: e, ...l } = o;
+    return Ge(qe, e).isSelected ? /* @__PURE__ */ r.jsx(j.span, { "aria-hidden": !0, ...l, ref: n }) : null;
+  }
+);
+Xe.displayName = qe;
+var we = "SelectScrollUpButton", Ze = t.forwardRef((o, n) => {
+  const e = q(we, o.__scopeSelect), l = Te(we, o.__scopeSelect), [a, p] = t.useState(!1), s = L(n, l.onScrollButtonChange);
+  return G(() => {
+    if (e.viewport && e.isPositioned) {
+      let c = function() {
+        const f = i.scrollTop > 0;
+        p(f);
+      };
+      const i = e.viewport;
+      return c(), i.addEventListener("scroll", c), () => i.removeEventListener("scroll", c);
+    }
+  }, [e.viewport, e.isPositioned]), a ? /* @__PURE__ */ r.jsx(
+    Qe,
+    {
+      ...o,
+      ref: s,
+      onAutoScroll: () => {
+        const { viewport: c, selectedItem: i } = e;
+        c && i && (c.scrollTop = c.scrollTop - i.offsetHeight);
+      }
+    }
+  ) : null;
+});
+Ze.displayName = we;
+var ye = "SelectScrollDownButton", Je = t.forwardRef((o, n) => {
+  const e = q(ye, o.__scopeSelect), l = Te(ye, o.__scopeSelect), [a, p] = t.useState(!1), s = L(n, l.onScrollButtonChange);
+  return G(() => {
+    if (e.viewport && e.isPositioned) {
+      let c = function() {
+        const f = i.scrollHeight - i.clientHeight, v = Math.ceil(i.scrollTop) < f;
+        p(v);
+      };
+      const i = e.viewport;
+      return c(), i.addEventListener("scroll", c), () => i.removeEventListener("scroll", c);
+    }
+  }, [e.viewport, e.isPositioned]), a ? /* @__PURE__ */ r.jsx(
+    Qe,
+    {
+      ...o,
+      ref: s,
+      onAutoScroll: () => {
+        const { viewport: c, selectedItem: i } = e;
+        c && i && (c.scrollTop = c.scrollTop + i.offsetHeight);
+      }
+    }
+  ) : null;
+});
+Je.displayName = ye;
+var Qe = t.forwardRef((o, n) => {
+  const { __scopeSelect: e, onAutoScroll: l, ...a } = o, p = q("SelectScrollButton", e), s = t.useRef(null), c = de(e), i = t.useCallback(() => {
+    s.current !== null && (window.clearInterval(s.current), s.current = null);
+  }, []);
+  return t.useEffect(() => () => i(), [i]), G(() => {
+    c().find((v) => v.ref.current === document.activeElement)?.ref.current?.scrollIntoView({ block: "nearest" });
+  }, [c]), /* @__PURE__ */ r.jsx(
+    j.div,
+    {
+      "aria-hidden": !0,
+      ...a,
+      ref: n,
+      style: { flexShrink: 0, ...a.style },
+      onPointerDown: b(a.onPointerDown, () => {
+        s.current === null && (s.current = window.setInterval(l, 50));
+      }),
+      onPointerMove: b(a.onPointerMove, () => {
+        p.onItemLeave?.(), s.current === null && (s.current = window.setInterval(l, 50));
+      }),
+      onPointerLeave: b(a.onPointerLeave, () => {
+        i();
+      })
+    }
+  );
+}), qt = "SelectSeparator", et = t.forwardRef(
+  (o, n) => {
+    const { __scopeSelect: e, ...l } = o;
+    return /* @__PURE__ */ r.jsx(j.div, { "aria-hidden": !0, ...l, ref: n });
+  }
+);
+et.displayName = qt;
+var Ce = "SelectArrow", Xt = t.forwardRef(
+  (o, n) => {
+    const { __scopeSelect: e, ...l } = o, a = pe(e), p = Y(Ce, e), s = q(Ce, e);
+    return p.open && s.position === "popper" ? /* @__PURE__ */ r.jsx(bt, { ...a, ...l, ref: n }) : null;
+  }
+);
+Xt.displayName = Ce;
+var Zt = "SelectBubbleInput", tt = t.forwardRef(
+  ({ __scopeSelect: o, value: n, ...e }, l) => {
+    const a = t.useRef(null), p = L(l, a), s = Et(n);
+    return t.useEffect(() => {
+      const c = a.current;
+      if (!c) return;
+      const i = window.HTMLSelectElement.prototype, v = Object.getOwnPropertyDescriptor(
+        i,
+        "value"
+      ).set;
+      if (s !== n && v) {
+        const w = new Event("change", { bubbles: !0 });
+        v.call(c, n), c.dispatchEvent(w);
+      }
+    }, [s, n]), /* @__PURE__ */ r.jsx(
+      j.select,
+      {
+        ...e,
+        style: { ..._t, ...e.style },
+        ref: p,
+        defaultValue: n
+      }
+    );
+  }
+);
+tt.displayName = Zt;
+function ot(o) {
+  return o === "" || o === void 0;
+}
+function nt(o) {
+  const n = Rt(o), e = t.useRef(""), l = t.useRef(0), a = t.useCallback(
+    (s) => {
+      const c = e.current + s;
+      n(c), (function i(f) {
+        e.current = f, window.clearTimeout(l.current), f !== "" && (l.current = window.setTimeout(() => i(""), 1e3));
+      })(c);
+    },
+    [n]
+  ), p = t.useCallback(() => {
+    e.current = "", window.clearTimeout(l.current);
+  }, []);
+  return t.useEffect(() => () => window.clearTimeout(l.current), []), [e, a, p];
+}
+function rt(o, n, e) {
+  const a = n.length > 1 && Array.from(n).every((f) => f === n[0]) ? n[0] : n, p = e ? o.indexOf(e) : -1;
+  let s = Jt(o, Math.max(p, 0));
+  a.length === 1 && (s = s.filter((f) => f !== e));
+  const i = s.find(
+    (f) => f.textValue.toLowerCase().startsWith(a.toLowerCase())
+  );
+  return i !== e ? i : void 0;
+}
+function Jt(o, n) {
+  return o.map((e, l) => o[(n + l) % o.length]);
+}
+var Qt = _e, st = Me, eo = Oe, to = De, oo = Le, at = ke, no = Fe, ro = We, lt = $e, ct = ze, so = Ye, ao = Xe, it = Ze, dt = Je, pt = et;
+const Mo = Qt, Ao = ro, Oo = eo, lo = t.forwardRef(({ className: o, children: n, ...e }, l) => /* @__PURE__ */ r.jsxs(
+  st,
+  {
+    ref: l,
+    className: z(
+      "border-input ring-offset-background data-[placeholder]:text-muted-foreground focus:ring-ring flex h-9 w-full items-center justify-between rounded-md border bg-transparent px-3 py-2 text-sm whitespace-nowrap shadow-sm focus:ring-1 focus:outline-none disabled:cursor-not-allowed disabled:opacity-50 [&>span]:line-clamp-1",
+      o
+    ),
+    ...e,
+    children: [
+      n,
+      /* @__PURE__ */ r.jsx(to, { asChild: !0, children: /* @__PURE__ */ r.jsx(Ee, { className: "h-4 w-4 opacity-50" }) })
+    ]
+  }
+));
+lo.displayName = st.displayName;
+const ut = t.forwardRef(({ className: o, ...n }, e) => /* @__PURE__ */ r.jsx(
+  it,
+  {
+    ref: e,
+    className: z("flex cursor-default items-center justify-center py-1", o),
+    ...n,
+    children: /* @__PURE__ */ r.jsx(jt, { className: "h-4 w-4" })
+  }
+));
+ut.displayName = it.displayName;
+const ft = t.forwardRef(({ className: o, ...n }, e) => /* @__PURE__ */ r.jsx(
+  dt,
+  {
+    ref: e,
+    className: z("flex cursor-default items-center justify-center py-1", o),
+    ...n,
+    children: /* @__PURE__ */ r.jsx(Ee, { className: "h-4 w-4" })
+  }
+));
+ft.displayName = dt.displayName;
+const co = t.forwardRef(({ className: o, children: n, position: e = "popper", ...l }, a) => /* @__PURE__ */ r.jsx(oo, { children: /* @__PURE__ */ r.jsxs(
+  at,
+  {
+    ref: a,
+    className: z(
+      "bg-popover text-popover-foreground data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 relative z-50 max-h-[--radix-select-content-available-height] min-w-[8rem] origin-[--radix-select-content-transform-origin] overflow-x-hidden overflow-y-auto rounded-md border shadow-md",
+      e === "popper" && "data-[side=bottom]:translate-y-1 data-[side=left]:-translate-x-1 data-[side=right]:translate-x-1 data-[side=top]:-translate-y-1",
+      o
+    ),
+    position: e,
+    ...l,
+    children: [
+      /* @__PURE__ */ r.jsx(ut, {}),
+      /* @__PURE__ */ r.jsx(
+        no,
+        {
+          className: z(
+            "p-1",
+            e === "popper" && "h-[var(--radix-select-trigger-height)] w-full min-w-[var(--radix-select-trigger-width)]"
+          ),
+          children: n
+        }
+      ),
+      /* @__PURE__ */ r.jsx(ft, {})
+    ]
+  }
+) }));
+co.displayName = at.displayName;
+const io = t.forwardRef(({ className: o, ...n }, e) => /* @__PURE__ */ r.jsx(lt, { ref: e, className: z("px-2 py-1.5 text-sm font-semibold", o), ...n }));
+io.displayName = lt.displayName;
+const po = t.forwardRef(({ className: o, children: n, ...e }, l) => /* @__PURE__ */ r.jsxs(
+  ct,
+  {
+    ref: l,
+    className: z(
+      "focus:bg-accent focus:text-accent-foreground relative flex w-full cursor-default items-center rounded-sm py-1.5 pr-8 pl-2 text-sm outline-none select-none data-[disabled]:pointer-events-none data-[disabled]:opacity-50",
+      o
+    ),
+    ...e,
+    children: [
+      /* @__PURE__ */ r.jsx("span", { className: "absolute right-2 flex h-3.5 w-3.5 items-center justify-center", children: /* @__PURE__ */ r.jsx(ao, { children: /* @__PURE__ */ r.jsx(Mt, { className: "h-4 w-4" }) }) }),
+      /* @__PURE__ */ r.jsx(so, { children: n })
+    ]
+  }
+));
+po.displayName = ct.displayName;
+const uo = t.forwardRef(({ className: o, ...n }, e) => /* @__PURE__ */ r.jsx(pt, { ref: e, className: z("bg-muted -mx-1 my-1 h-px", o), ...n }));
+uo.displayName = pt.displayName;
+export {
+  Mo as Select,
+  co as SelectContent,
+  Ao as SelectGroup,
+  po as SelectItem,
+  io as SelectLabel,
+  ft as SelectScrollDownButton,
+  ut as SelectScrollUpButton,
+  uo as SelectSeparator,
+  lo as SelectTrigger,
+  Oo as SelectValue
+};