@tamagui/select 1.116.1 → 1.116.2

package/dist/cjs/BubbleSelect.js

@@ -0,0 +1,34 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: !0 }) : target,
+  mod
+));
+var import_compose_refs = require("@tamagui/compose-refs"), import_use_previous = require("@tamagui/use-previous"), React = __toESM(require("react"));
+const BubbleSelect = React.forwardRef((props, forwardedRef) => {
+  const { value, ...selectProps } = props, ref = React.useRef(null), composedRefs = (0, import_compose_refs.useComposedRefs)(forwardedRef, ref), prevValue = (0, import_use_previous.usePrevious)(value);
+  return React.useEffect(() => {
+    const select = ref.current, selectProto = window.HTMLSelectElement.prototype, setValue = Object.getOwnPropertyDescriptor(
+      selectProto,
+      "value"
+    ).set;
+    if (prevValue !== value && setValue) {
+      const event = new Event("change", { bubbles: !0 });
+      setValue.call(select, value), select.dispatchEvent(event);
+    }
+  }, [prevValue, value]), null;
+});
+//# sourceMappingURL=BubbleSelect.js.map

package/dist/cjs/Select.js

@@ -0,0 +1,325 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: !0 }) : target,
+  mod
+)), __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var Select_exports = {};
+__export(Select_exports, {
+  Select: () => Select,
+  SelectGroupFrame: () => SelectGroupFrame,
+  SelectIcon: () => SelectIcon,
+  SelectSeparator: () => SelectSeparator
+});
+module.exports = __toCommonJS(Select_exports);
+var import_adapt = require("@tamagui/adapt"), import_compose_refs = require("@tamagui/compose-refs"), import_constants = require("@tamagui/constants"), import_core = require("@tamagui/core"), import_focusable = require("@tamagui/focusable"), import_get_token = require("@tamagui/get-token"), import_helpers = require("@tamagui/helpers"), import_list_item = require("@tamagui/list-item"), import_separator = require("@tamagui/separator"), import_sheet = require("@tamagui/sheet"), import_stacks = require("@tamagui/stacks"), import_text = require("@tamagui/text"), import_use_controllable_state = require("@tamagui/use-controllable-state"), import_use_debounce = require("@tamagui/use-debounce"), React = __toESM(require("react")), import_context = require("./context"), import_SelectContent = require("./SelectContent"), import_SelectImpl = require("./SelectImpl"), import_SelectItem = require("./SelectItem"), import_SelectItemText = require("./SelectItemText"), import_SelectScrollButton = require("./SelectScrollButton"), import_SelectTrigger = require("./SelectTrigger"), import_SelectViewport = require("./SelectViewport"), import_useSelectBreakpointActive = require("./useSelectBreakpointActive"), import_jsx_runtime = require("react/jsx-runtime");
+const VALUE_NAME = "SelectValue", SelectValueFrame = (0, import_core.styled)(import_text.SizableText, {
+  name: VALUE_NAME,
+  userSelect: "none"
+}), SelectValue = SelectValueFrame.styleable(
+  function({
+    __scopeSelect,
+    children: childrenProp,
+    placeholder,
+    ...props
+  }, forwardedRef) {
+    const context = (0, import_context.useSelectContext)(VALUE_NAME, __scopeSelect), itemParentContext = (0, import_context.useSelectItemParentContext)(VALUE_NAME, __scopeSelect), composedRefs = (0, import_compose_refs.useComposedRefs)(forwardedRef, context.onValueNodeChange), children = childrenProp ?? context.selectedItem, selectValueChildren = context.value == null || context.value === "" ? placeholder ?? children : children;
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+      SelectValueFrame,
+      {
+        ...!props.unstyled && {
+          size: itemParentContext.size,
+          ellipse: !0,
+          // we don't want events from the portalled `SelectValue` children to bubble
+          // through the item they came from
+          pointerEvents: "none"
+        },
+        ref: composedRefs,
+        ...props,
+        children: unwrapSelectItem(selectValueChildren)
+      }
+    );
+  }
+);
+function unwrapSelectItem(selectValueChildren) {
+  return React.Children.map(selectValueChildren, (child) => {
+    if (child) {
+      if (child.type?.staticConfig?.componentName === import_SelectItemText.ITEM_TEXT_NAME)
+        return child.props.children;
+      if (child.props?.children)
+        return unwrapSelectItem(child.props.children);
+    }
+    return child;
+  });
+}
+const SelectIcon = (0, import_core.styled)(import_stacks.XStack, {
+  name: "SelectIcon",
+  // @ts-ignore
+  "aria-hidden": !0,
+  children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_text.Paragraph, { children: "\u25BC" })
+}), ITEM_INDICATOR_NAME = "SelectItemIndicator", SelectItemIndicatorFrame = (0, import_core.styled)(import_stacks.XStack, {
+  name: import_SelectItemText.ITEM_TEXT_NAME
+}), SelectItemIndicator = React.forwardRef(
+  (props, forwardedRef) => {
+    const { __scopeSelect, ...itemIndicatorProps } = props, context = (0, import_context.useSelectItemParentContext)(ITEM_INDICATOR_NAME, __scopeSelect), itemContext = (0, import_SelectItem.useSelectItemContext)(ITEM_INDICATOR_NAME, __scopeSelect);
+    return context.shouldRenderWebNative ? null : itemContext.isSelected ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(SelectItemIndicatorFrame, { "aria-hidden": !0, ...itemIndicatorProps, ref: forwardedRef }) : null;
+  }
+);
+SelectItemIndicator.displayName = ITEM_INDICATOR_NAME;
+const GROUP_NAME = "SelectGroup", [SelectGroupContextProvider, useSelectGroupContext] = (0, import_context.createSelectContext)(GROUP_NAME), SelectGroupFrame = (0, import_core.styled)(import_stacks.YStack, {
+  name: GROUP_NAME,
+  width: "100%"
+}), NativeSelectTextFrame = (0, import_core.styled)(import_text.SizableText, {
+  tag: "select",
+  backgroundColor: "$background",
+  borderColor: "$borderColor",
+  hoverStyle: {
+    backgroundColor: "$backgroundHover"
+  }
+}), NativeSelectFrame = (0, import_core.styled)(import_stacks.ThemeableStack, {
+  name: "NativeSelect",
+  bordered: !0,
+  userSelect: "none",
+  outlineWidth: 0,
+  paddingRight: 10,
+  variants: {
+    size: {
+      "...size": (val, extras) => {
+        const { tokens } = extras, paddingHorizontal = (0, import_core.getVariableValue)(tokens.space[val]);
+        return {
+          borderRadius: tokens.radius[val] ?? val,
+          minHeight: tokens.size[val],
+          paddingRight: paddingHorizontal + 20,
+          paddingLeft: paddingHorizontal,
+          paddingVertical: (0, import_get_token.getSpace)(val, {
+            shift: -3
+          })
+        };
+      }
+    }
+  },
+  defaultVariants: {
+    size: "$2"
+  }
+}), SelectGroup = React.forwardRef(
+  (props, forwardedRef) => {
+    const { __scopeSelect, ...groupProps } = props, groupId = React.useId(), context = (0, import_context.useSelectContext)(GROUP_NAME, __scopeSelect), itemParentContext = (0, import_context.useSelectItemParentContext)(GROUP_NAME, __scopeSelect), size = itemParentContext.size ?? "$true", nativeSelectRef = React.useRef(null), content = itemParentContext.shouldRenderWebNative ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+      NativeSelectFrame,
+      {
+        asChild: !0,
+        size,
+        value: context.value,
+        id: itemParentContext.id,
+        children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+          NativeSelectTextFrame,
+          {
+            onChange: (event) => {
+              itemParentContext.onChange(event.currentTarget.value);
+            },
+            size,
+            ref: nativeSelectRef,
+            style: {
+              color: "var(--color)",
+              // @ts-ignore
+              appearance: "none"
+            },
+            children: props.children
+          }
+        )
+      }
+    ) : /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+      SelectGroupFrame,
+      {
+        role: "group",
+        "aria-labelledby": groupId,
+        ...groupProps,
+        ref: forwardedRef
+      }
+    );
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(SelectGroupContextProvider, { scope: __scopeSelect, id: groupId || "", children: content });
+  }
+);
+SelectGroup.displayName = GROUP_NAME;
+const LABEL_NAME = "SelectLabel", SelectLabel = React.forwardRef(
+  (props, forwardedRef) => {
+    const { __scopeSelect, ...labelProps } = props, context = (0, import_context.useSelectItemParentContext)(LABEL_NAME, __scopeSelect), groupContext = useSelectGroupContext(LABEL_NAME, __scopeSelect);
+    return context.shouldRenderWebNative ? null : /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+      import_list_item.ListItem,
+      {
+        tag: "div",
+        componentName: LABEL_NAME,
+        fontWeight: "800",
+        id: groupContext.id,
+        size: context.size,
+        ...labelProps,
+        ref: forwardedRef
+      }
+    );
+  }
+);
+SelectLabel.displayName = LABEL_NAME;
+const SelectSeparator = (0, import_core.styled)(import_separator.Separator, {
+  name: "SelectSeparator"
+}), SelectSheetController = (props) => {
+  const context = (0, import_context.useSelectContext)("SelectSheetController", props.__scopeSelect), showSheet = (0, import_useSelectBreakpointActive.useShowSelectSheet)(context), isAdapted = (0, import_adapt.useAdaptIsActive)(), getShowSheet = (0, import_core.useGet)(showSheet);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    import_sheet.SheetController,
+    {
+      onOpenChange: (val) => {
+        getShowSheet() && props.onOpenChange(val);
+      },
+      open: context.open,
+      hidden: isAdapted === !1,
+      children: props.children
+    }
+  );
+}, SelectSheetImpl = (props) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, { children: props.children }), Select = (0, import_helpers.withStaticProperties)(
+  function(props) {
+    const internalId = React.useId(), scopeKey = props.__scopeSelect ? Object.keys(props.__scopeSelect)[0] ?? internalId : internalId;
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_adapt.AdaptParent, { scope: `${scopeKey}SheetContents`, portal: !0, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(SelectInner, { scopeKey, ...props }) });
+  },
+  {
+    Adapt: import_adapt.Adapt,
+    Content: import_SelectContent.SelectContent,
+    Group: SelectGroup,
+    Icon: SelectIcon,
+    Item: import_SelectItem.SelectItem,
+    ItemIndicator: SelectItemIndicator,
+    ItemText: import_SelectItemText.SelectItemText,
+    Label: SelectLabel,
+    ScrollDownButton: import_SelectScrollButton.SelectScrollDownButton,
+    ScrollUpButton: import_SelectScrollButton.SelectScrollUpButton,
+    Trigger: import_SelectTrigger.SelectTrigger,
+    Value: SelectValue,
+    Viewport: import_SelectViewport.SelectViewport,
+    Sheet: import_sheet.Sheet.Controlled
+  }
+);
+function useEmitter() {
+  const listeners = React.useRef();
+  listeners.current || (listeners.current = /* @__PURE__ */ new Set());
+  const emit = (value) => {
+    listeners.current.forEach((l) => l(value));
+  }, subscribe = React.useCallback((listener) => (listeners.current.add(listener), () => {
+    listeners.current.delete(listener);
+  }), []);
+  return [emit, subscribe];
+}
+function SelectInner(props) {
+  const {
+    __scopeSelect,
+    native,
+    children,
+    open: openProp,
+    defaultOpen,
+    onOpenChange,
+    value: valueProp,
+    defaultValue,
+    onValueChange,
+    disablePreventBodyScroll,
+    size: sizeProp = "$true",
+    onActiveChange,
+    dir,
+    id
+  } = props, SelectImpl = (0, import_adapt.useAdaptIsActive)() || !import_constants.isWeb ? SelectSheetImpl : import_SelectImpl.SelectInlineImpl, forceUpdate = React.useReducer(() => ({}), {})[1], [selectedItem, setSelectedItem] = React.useState(null), [open, setOpen] = (0, import_use_controllable_state.useControllableState)({
+    prop: openProp,
+    defaultProp: defaultOpen || !1,
+    onChange: onOpenChange
+  }), [value, setValue] = (0, import_use_controllable_state.useControllableState)({
+    prop: valueProp,
+    defaultProp: defaultValue || "",
+    onChange: onValueChange,
+    transition: !0
+  });
+  React.useEffect(() => {
+    open && emitValue(value);
+  }, [open]), React.useEffect(() => {
+    emitValue(value);
+  }, [value]);
+  const [activeIndex, setActiveIndex] = React.useState(0), [emitValue, valueSubscribe] = useEmitter(), [emitActiveIndex, activeIndexSubscribe] = useEmitter(), selectedIndexRef = React.useRef(null), activeIndexRef = React.useRef(null), listContentRef = React.useRef([]), [selectedIndex, setSelectedIndex] = React.useState(0), [valueNode, setValueNode] = React.useState(null);
+  (0, import_constants.useIsomorphicLayoutEffect)(() => {
+    selectedIndexRef.current = selectedIndex, activeIndexRef.current = activeIndex;
+  });
+  const shouldRenderWebNative = import_constants.isWeb && (native === !0 || native === "web" || Array.isArray(native) && native.includes("web")), setActiveIndexDebounced = (0, import_use_debounce.useDebounce)(
+    (index) => {
+      setActiveIndex((prev) => prev !== index ? (typeof index == "number" && emitActiveIndex(index), index) : prev);
+    },
+    1,
+    {},
+    []
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    import_context.SelectItemParentProvider,
+    {
+      scope: __scopeSelect,
+      initialValue: React.useMemo(() => value, [open]),
+      size: sizeProp,
+      activeIndexSubscribe,
+      valueSubscribe,
+      setOpen,
+      id,
+      onChange: React.useCallback((val) => {
+        setValue(val), emitValue(val);
+      }, []),
+      onActiveChange: (0, import_core.useEvent)((...args) => {
+        onActiveChange?.(...args);
+      }),
+      setSelectedIndex,
+      setValueAtIndex: React.useCallback((index, value2) => {
+        listContentRef.current[index] = value2;
+      }, []),
+      shouldRenderWebNative,
+      children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        import_context.SelectProvider,
+        {
+          scope: __scopeSelect,
+          disablePreventBodyScroll,
+          dir,
+          blockSelection: !1,
+          fallback: !1,
+          selectedItem,
+          setSelectedItem,
+          forceUpdate,
+          valueNode,
+          onValueNodeChange: setValueNode,
+          scopeKey: props.scopeKey,
+          activeIndex,
+          selectedIndex,
+          setActiveIndex: setActiveIndexDebounced,
+          value,
+          open,
+          native,
+          children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(SelectSheetController, { onOpenChange: setOpen, __scopeSelect, children: shouldRenderWebNative ? children : /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+            SelectImpl,
+            {
+              activeIndexRef,
+              listContentRef,
+              selectedIndexRef,
+              ...props,
+              open,
+              value,
+              children
+            }
+          ) })
+        }
+      )
+    }
+  );
+}
+//# sourceMappingURL=Select.js.map

package/dist/cjs/SelectContent.js

@@ -0,0 +1,45 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: !0 }) : target,
+  mod
+)), __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var SelectContent_exports = {};
+__export(SelectContent_exports, {
+  SelectContent: () => SelectContent
+});
+module.exports = __toCommonJS(SelectContent_exports);
+var import_react = __toESM(require("react")), import_react2 = require("@floating-ui/react"), import_core = require("@tamagui/core"), import_focus_scope = require("@tamagui/focus-scope"), import_context = require("./context"), import_useSelectBreakpointActive = require("./useSelectBreakpointActive"), import_jsx_runtime = require("react/jsx-runtime");
+const CONTENT_NAME = "SelectContent", SelectContent = ({
+  children,
+  __scopeSelect,
+  zIndex = 1e3,
+  ...focusScopeProps
+}) => {
+  const context = (0, import_context.useSelectContext)(CONTENT_NAME, __scopeSelect), itemParentContext = (0, import_context.useSelectItemParentContext)(CONTENT_NAME, __scopeSelect), themeName = (0, import_core.useThemeName)(), showSheet = (0, import_useSelectBreakpointActive.useShowSelectSheet)(context), contents = /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_core.Theme, { forceClassName: !0, name: themeName, children }), touch = (0, import_core.useIsTouchDevice)(), overlayStyle = import_react.default.useMemo(() => ({ zIndex, pointerEvents: context.open ? "auto" : "none" }), [context.open]);
+  return itemParentContext.shouldRenderWebNative ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, { children }) : showSheet ? context.open ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, { children: contents }) : null : /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react2.FloatingPortal, { children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    import_react2.FloatingOverlay,
+    {
+      style: overlayStyle,
+      lockScroll: !context.disablePreventBodyScroll && !!context.open && !touch,
+      children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_focus_scope.FocusScope, { loop: !0, enabled: !!context.open, trapped: !0, ...focusScopeProps, children: contents })
+    }
+  ) });
+};
+//# sourceMappingURL=SelectContent.js.map

package/dist/cjs/SelectImpl.js

@@ -0,0 +1,224 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: !0 }) : target,
+  mod
+)), __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var SelectImpl_exports = {};
+__export(SelectImpl_exports, {
+  SelectInlineImpl: () => SelectInlineImpl
+});
+module.exports = __toCommonJS(SelectImpl_exports);
+var import_react = require("@floating-ui/react"), import_constants = require("@tamagui/constants"), import_core = require("@tamagui/core"), React = __toESM(require("react")), import_react_dom = require("react-dom"), import_constants2 = require("./constants"), import_context = require("./context"), import_jsx_runtime = require("react/jsx-runtime");
+const SelectInlineImpl = (props) => {
+  const {
+    __scopeSelect,
+    children,
+    open = !1,
+    selectedIndexRef,
+    listContentRef
+  } = props, selectContext = (0, import_context.useSelectContext)("SelectSheetImpl", __scopeSelect), selectItemParentContext = (0, import_context.useSelectItemParentContext)(
+    "SelectSheetImpl",
+    __scopeSelect
+  ), { setActiveIndex, selectedIndex, activeIndex, forceUpdate } = selectContext, { setOpen, setSelectedIndex } = selectItemParentContext, [scrollTop, setScrollTop] = React.useState(0), touch = (0, import_core.useIsTouchDevice)(), listItemsRef = React.useRef([]), overflowRef = React.useRef(null), upArrowRef = React.useRef(null), downArrowRef = React.useRef(null), allowSelectRef = React.useRef(!1), allowMouseUpRef = React.useRef(!0), selectTimeoutRef = React.useRef(), state = React.useRef({
+    isMouseOutside: !1,
+    isTyping: !1
+  }), [controlledScrolling, setControlledScrolling] = React.useState(!1), [fallback, setFallback] = React.useState(!1), [innerOffset, setInnerOffset] = React.useState(0), [blockSelection, setBlockSelection] = React.useState(!1), floatingStyle = React.useRef({});
+  (0, import_constants.useIsomorphicLayoutEffect)(() => {
+    queueMicrotask(() => {
+      open || (setScrollTop(0), setFallback(!1), setActiveIndex(null), setControlledScrolling(!1));
+    });
+  }, [open, setActiveIndex]), import_constants.isWeb && import_constants.isClient && (0, import_constants.useIsomorphicLayoutEffect)(() => {
+    if (!open) return;
+    const mouseUp = (e) => {
+      state.current.isMouseOutside && setOpen(!1);
+    };
+    return document.addEventListener("mouseup", mouseUp), () => {
+      document.removeEventListener("mouseup", mouseUp);
+    };
+  }, [open]);
+  const { x, y, strategy, context, refs, update } = (0, import_react.useFloating)({
+    open,
+    onOpenChange: setOpen,
+    placement: "bottom-start",
+    whileElementsMounted: import_react.autoUpdate,
+    // biome-ignore lint/correctness/noConstantCondition: <explanation>
+    middleware: [
+      (0, import_react.size)({
+        apply({
+          rects: {
+            reference: { width }
+          }
+        }) {
+          Object.assign(floatingStyle.current, {
+            minWidth: width + 8
+          }), refs.floating.current && Object.assign(refs.floating.current.style, floatingStyle.current);
+        }
+      }),
+      (0, import_react.inner)({
+        listRef: listItemsRef,
+        overflowRef,
+        index: selectedIndex,
+        offset: innerOffset,
+        onFallbackChange: setFallback,
+        padding: 10,
+        minItemsVisible: touch ? 10 : 4,
+        referenceOverflowThreshold: 20
+      }),
+      (0, import_react.offset)({ crossAxis: -5 })
+    ]
+  }), floatingRef = refs.floating, showUpArrow = open && scrollTop > import_constants2.SCROLL_ARROW_THRESHOLD, showDownArrow = open && floatingRef.current && scrollTop < floatingRef.current.scrollHeight - floatingRef.current.clientHeight - import_constants2.SCROLL_ARROW_THRESHOLD, isScrollable = showDownArrow || showUpArrow;
+  (0, import_constants.useIsomorphicLayoutEffect)(() => (window.addEventListener("resize", update), open && update(), () => window.removeEventListener("resize", update)), [update, open]);
+  const onMatch = (0, import_core.useEvent)((index) => (open ? setActiveIndex : setSelectedIndex)(index)), interactionsProps = [
+    (0, import_react.useClick)(context, { event: "mousedown", keyboardHandlers: !1 }),
+    (0, import_react.useDismiss)(context, { outsidePress: !1 }),
+    (0, import_react.useRole)(context, { role: "listbox" }),
+    (0, import_react.useInnerOffset)(context, {
+      enabled: !fallback && isScrollable,
+      onChange: setInnerOffset,
+      overflowRef,
+      scrollRef: refs.floating
+    }),
+    (0, import_react.useListNavigation)(context, {
+      listRef: listItemsRef,
+      activeIndex: activeIndex || 0,
+      selectedIndex,
+      onNavigate: setActiveIndex,
+      scrollItemIntoView: !1
+    }),
+    (0, import_react.useTypeahead)(context, {
+      listRef: listContentRef,
+      onMatch,
+      selectedIndex,
+      activeIndex,
+      onTypingChange: (e) => {
+        state.current.isTyping = e;
+      }
+    })
+  ], interactions = (0, import_react.useInteractions)(
+    // unfortunately these memos will just always break due to floating-ui context always changing :/
+    React.useMemo(() => interactionsProps, interactionsProps)
+  ), interactionsContext = React.useMemo(() => ({
+    ...interactions,
+    getReferenceProps() {
+      return interactions.getReferenceProps({
+        ref: refs.reference,
+        className: "SelectTrigger",
+        onKeyDown(event) {
+          (event.key === "Enter" || event.code === "Space" || event.key === " " && !state.current.isTyping) && (event.preventDefault(), setOpen(!0));
+        }
+      });
+    },
+    getFloatingProps(props2) {
+      return interactions.getFloatingProps({
+        ref: refs.floating,
+        className: "Select",
+        ...props2,
+        style: {
+          position: strategy,
+          top: y ?? "",
+          left: x ?? "",
+          outline: 0,
+          scrollbarWidth: "none",
+          ...floatingStyle.current,
+          ...props2?.style
+        },
+        onPointerEnter() {
+          setControlledScrolling(!1), state.current.isMouseOutside = !1;
+        },
+        onPointerLeave() {
+          state.current.isMouseOutside = !0;
+        },
+        onPointerMove() {
+          state.current.isMouseOutside = !1, setControlledScrolling(!1);
+        },
+        onKeyDown() {
+          setControlledScrolling(!0);
+        },
+        onContextMenu(e) {
+          e.preventDefault();
+        },
+        onScroll(event) {
+          (0, import_react_dom.flushSync)(() => {
+            setScrollTop(event.currentTarget.scrollTop);
+          });
+        }
+      });
+    }
+  }), [refs.reference.current, x, y, refs.floating.current, interactions]);
+  return (0, import_constants.useIsomorphicLayoutEffect)(() => {
+    if (open)
+      return selectTimeoutRef.current = setTimeout(() => {
+        allowSelectRef.current = !0;
+      }, 300), () => {
+        clearTimeout(selectTimeoutRef.current);
+      };
+    allowSelectRef.current = !1, allowMouseUpRef.current = !0, setInnerOffset(0), setFallback(!1), setBlockSelection(!1);
+  }, [open]), (0, import_constants.useIsomorphicLayoutEffect)(() => {
+    !open && state.current.isMouseOutside && (state.current.isMouseOutside = !1);
+  }, [open]), (0, import_constants.useIsomorphicLayoutEffect)(() => {
+    function onPointerDown(e) {
+      const target = e.target;
+      refs.floating.current?.contains(target) || upArrowRef.current?.contains(target) || downArrowRef.current?.contains(target) || (setOpen(!1), setControlledScrolling(!1));
+    }
+    if (open)
+      return document.addEventListener("pointerdown", onPointerDown), () => {
+        document.removeEventListener("pointerdown", onPointerDown);
+      };
+  }, [open, refs, setOpen]), React.useEffect(() => {
+    open && controlledScrolling && activeIndex != null && listItemsRef.current[activeIndex]?.scrollIntoView({ block: "nearest" }), setScrollTop(refs.floating.current?.scrollTop ?? 0);
+  }, [open, refs, controlledScrolling, activeIndex]), React.useEffect(() => {
+    open && fallback && selectedIndex != null && listItemsRef.current[selectedIndex]?.scrollIntoView({ block: "nearest" });
+  }, [open, fallback, selectedIndex]), (0, import_constants.useIsomorphicLayoutEffect)(() => {
+    refs.floating.current && fallback && (refs.floating.current.style.maxHeight = "");
+  }, [refs, fallback]), /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    import_context.SelectProvider,
+    {
+      scope: __scopeSelect,
+      ...selectContext,
+      setScrollTop,
+      setInnerOffset,
+      fallback,
+      floatingContext: context,
+      activeIndex,
+      canScrollDown: !!showDownArrow,
+      canScrollUp: !!showUpArrow,
+      controlledScrolling,
+      blockSelection,
+      upArrowRef,
+      downArrowRef,
+      update,
+      children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        import_context.SelectItemParentProvider,
+        {
+          scope: __scopeSelect,
+          ...selectItemParentContext,
+          allowMouseUpRef,
+          allowSelectRef,
+          dataRef: context.dataRef,
+          interactions: interactionsContext,
+          listRef: listItemsRef,
+          selectTimeoutRef,
+          children
+        }
+      )
+    }
+  );
+};
+//# sourceMappingURL=SelectImpl.js.map