@tamagui/select 1.114.4 → 1.115.0

package/dist/cjs/SelectImpl.cjs

@@ -0,0 +1,272 @@
+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.cjs"),
+  import_context = require("./context.cjs"),
+  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
+    })
+  });
+};

package/dist/cjs/SelectImpl.native.cjs

@@ -0,0 +1,29 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __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 __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: !0
+}), mod);
+var SelectImpl_native_exports = {};
+__export(SelectImpl_native_exports, {
+  SelectInlineImpl: () => SelectInlineImpl
+});
+module.exports = __toCommonJS(SelectImpl_native_exports);
+var import_jsx_runtime = require("react/jsx-runtime");
+const SelectInlineImpl = props => (process.env.NODE_ENV === "development" && console.warn("Sheet not implemented inline on native"), /* @__PURE__ */(0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, {
+  children: props.children
+}));

package/dist/cjs/SelectImpl.native.cjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/SelectImpl.native.tsx"],
+  "mappings": ";;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAWS;AAJF,MAAM,mBAAmB,CAAC,WAC3B,QAAQ,IAAI,aAAa,iBAC3B,QAAQ,KAAK,wCAAwC,GAEhD,2EAAG,gBAAM,UAAS;",
+  "names": []
+}

package/dist/cjs/SelectItem.cjs

@@ -0,0 +1,158 @@
+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 SelectItem_exports = {};
+__export(SelectItem_exports, {
+  SelectItem: () => SelectItem,
+  SelectItemContextProvider: () => SelectItemContextProvider,
+  useSelectItemContext: () => useSelectItemContext
+});
+module.exports = __toCommonJS(SelectItem_exports);
+var import_compose_refs = require("@tamagui/compose-refs"),
+  import_constants = require("@tamagui/constants"),
+  import_list_item = require("@tamagui/list-item"),
+  React = __toESM(require("react")),
+  import_context = require("./context.cjs"),
+  import_jsx_runtime = require("react/jsx-runtime");
+const ITEM_NAME = "SelectItem",
+  [SelectItemContextProvider, useSelectItemContext] = (0, import_context.createSelectContext)(ITEM_NAME),
+  SelectItem = import_list_item.ListItemFrame.styleable(function (props, forwardedRef) {
+    const {
+        __scopeSelect,
+        value,
+        disabled = !1,
+        textValue: textValueProp,
+        index,
+        ...restProps
+      } = props,
+      {
+        props: listItemProps
+      } = (0, import_list_item.useListItem)({
+        ...(!props.unstyled && {
+          ellipse: !0
+        }),
+        ...restProps
+      }),
+      context = (0, import_context.useSelectItemParentContext)(ITEM_NAME, __scopeSelect),
+      {
+        setSelectedIndex,
+        listRef,
+        setOpen,
+        onChange,
+        activeIndexSubscribe,
+        valueSubscribe,
+        allowMouseUpRef,
+        allowSelectRef,
+        setValueAtIndex,
+        selectTimeoutRef,
+        dataRef,
+        interactions,
+        shouldRenderWebNative,
+        size,
+        onActiveChange,
+        initialValue
+      } = context,
+      [isSelected, setSelected] = React.useState(initialValue === value);
+    React.useEffect(() => activeIndexSubscribe(i => {
+      index === i && (onActiveChange(value, index), listRef?.current[index]?.focus());
+    }), [index]), React.useEffect(() => valueSubscribe(val => {
+      setSelected(val === value);
+    }), [value]);
+    const textId = React.useId(),
+      composedRefs = (0, import_compose_refs.useComposedRefs)(forwardedRef, node => {
+        import_constants.isWeb && node instanceof HTMLElement && listRef && (listRef.current[index] = node);
+      });
+    (0, import_constants.useIsomorphicLayoutEffect)(() => {
+      setValueAtIndex(index, value);
+    }, [index, setValueAtIndex, value]);
+    function handleSelect() {
+      setSelectedIndex(index), onChange(value), setOpen(!1);
+    }
+    const selectItemProps = React.useMemo(() => interactions ? interactions.getItemProps({
+      onTouchMove() {
+        allowSelectRef.current = !0, allowMouseUpRef.current = !1;
+      },
+      onTouchEnd() {
+        allowSelectRef.current = !1, allowMouseUpRef.current = !0;
+      },
+      onKeyDown(event) {
+        event.key === "Enter" || event.key === " " && !dataRef?.current.typing ? (event.preventDefault(), handleSelect()) : allowSelectRef.current = !0;
+      },
+      onClick() {
+        allowSelectRef.current && handleSelect();
+      },
+      onMouseUp() {
+        allowMouseUpRef.current && (allowSelectRef.current && handleSelect(), clearTimeout(selectTimeoutRef.current), selectTimeoutRef.current = setTimeout(() => {
+          allowSelectRef.current = !0;
+        }));
+      }
+    }) : {
+      onPress: handleSelect
+    }, [handleSelect]);
+    return /* @__PURE__ */(0, import_jsx_runtime.jsx)(SelectItemContextProvider, {
+      scope: __scopeSelect,
+      value,
+      textId: textId || "",
+      isSelected,
+      children: shouldRenderWebNative ? /* @__PURE__ */(0, import_jsx_runtime.jsx)("option", {
+        value,
+        children: props.children
+      }) : /* @__PURE__ */(0, import_jsx_runtime.jsx)(import_list_item.ListItemFrame, {
+        tag: "div",
+        componentName: ITEM_NAME,
+        ref: composedRefs,
+        "aria-labelledby": textId,
+        "aria-selected": isSelected,
+        "data-state": isSelected ? "active" : "inactive",
+        "aria-disabled": disabled || void 0,
+        "data-disabled": disabled ? "" : void 0,
+        tabIndex: disabled ? void 0 : -1,
+        ...(!props.unstyled && {
+          backgrounded: !0,
+          pressTheme: !0,
+          hoverTheme: !0,
+          focusTheme: !0,
+          cursor: "default",
+          size,
+          outlineOffset: -0.5,
+          focusVisibleStyle: {
+            outlineColor: "$outlineColor",
+            outlineWidth: 1,
+            outlineStyle: "solid"
+          }
+        }),
+        ...listItemProps,
+        ...selectItemProps
+      })
+    });
+  }, {
+    disableTheme: !0
+  });

package/dist/cjs/SelectItemText.cjs

@@ -0,0 +1,89 @@
+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 SelectItemText_exports = {};
+__export(SelectItemText_exports, {
+  ITEM_TEXT_NAME: () => ITEM_TEXT_NAME,
+  SelectItemText: () => SelectItemText,
+  SelectItemTextFrame: () => SelectItemTextFrame
+});
+module.exports = __toCommonJS(SelectItemText_exports);
+var import_compose_refs = require("@tamagui/compose-refs"),
+  import_core = require("@tamagui/core"),
+  import_text = require("@tamagui/text"),
+  React = __toESM(require("react")),
+  import_context = require("./context.cjs"),
+  import_SelectItem = require("./SelectItem.cjs"),
+  import_jsx_runtime = require("react/jsx-runtime");
+const ITEM_TEXT_NAME = "SelectItemText",
+  SelectItemTextFrame = (0, import_core.styled)(import_text.SizableText, {
+    name: ITEM_TEXT_NAME,
+    variants: {
+      unstyled: {
+        false: {
+          userSelect: "none",
+          color: "$color",
+          ellipse: !0
+        }
+      }
+    },
+    defaultVariants: {
+      unstyled: process.env.TAMAGUI_HEADLESS === "1"
+    }
+  }),
+  SelectItemText = SelectItemTextFrame.styleable(function (props, forwardedRef) {
+    const {
+        __scopeSelect,
+        className,
+        ...itemTextProps
+      } = props,
+      context = (0, import_context.useSelectContext)(ITEM_TEXT_NAME, __scopeSelect),
+      itemParentContext = (0, import_context.useSelectItemParentContext)(ITEM_TEXT_NAME, __scopeSelect),
+      ref = React.useRef(null),
+      composedRefs = (0, import_compose_refs.useComposedRefs)(forwardedRef, ref),
+      itemContext = (0, import_SelectItem.useSelectItemContext)(ITEM_TEXT_NAME, __scopeSelect),
+      contents = React.useRef();
+    return contents.current = /* @__PURE__ */(0, import_jsx_runtime.jsx)(SelectItemTextFrame, {
+      className,
+      size: itemParentContext.size,
+      id: itemContext.textId,
+      ...itemTextProps,
+      ref: composedRefs
+    }), React.useEffect(() => {
+      itemParentContext.initialValue === itemContext.value && !context.selectedIndex && context.setSelectedItem(contents.current);
+    }, []), React.useEffect(() => itemParentContext.valueSubscribe(val => {
+      val === itemContext.value && context.setSelectedItem(contents.current);
+    }), [itemContext.value]), itemParentContext.shouldRenderWebNative ? /* @__PURE__ */(0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, {
+      children: props.children
+    }) : /* @__PURE__ */(0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, {
+      children: contents.current
+    });
+  });

package/dist/cjs/SelectScrollButton.cjs

@@ -0,0 +1,136 @@
+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 SelectScrollButton_exports = {};
+__export(SelectScrollButton_exports, {
+  SelectScrollDownButton: () => SelectScrollDownButton,
+  SelectScrollUpButton: () => SelectScrollUpButton
+});
+module.exports = __toCommonJS(SelectScrollButton_exports);
+var import_react = require("@floating-ui/react"),
+  import_compose_refs = require("@tamagui/compose-refs"),
+  import_stacks = require("@tamagui/stacks"),
+  React = __toESM(require("react")),
+  import_react_dom = require("react-dom"),
+  import_context = require("./context.cjs"),
+  import_jsx_runtime = require("react/jsx-runtime");
+const SCROLL_UP_BUTTON_NAME = "SelectScrollUpButton",
+  SelectScrollUpButton = React.forwardRef((props, forwardedRef) => /* @__PURE__ */(0, import_jsx_runtime.jsx)(SelectScrollButtonImpl, {
+    componentName: SCROLL_UP_BUTTON_NAME,
+    ...props,
+    dir: "up",
+    ref: forwardedRef
+  }));
+SelectScrollUpButton.displayName = SCROLL_UP_BUTTON_NAME;
+const SCROLL_DOWN_BUTTON_NAME = "SelectScrollDownButton",
+  SelectScrollDownButton = React.forwardRef((props, forwardedRef) => /* @__PURE__ */(0, import_jsx_runtime.jsx)(SelectScrollButtonImpl, {
+    componentName: SCROLL_DOWN_BUTTON_NAME,
+    ...props,
+    dir: "down",
+    ref: forwardedRef
+  }));
+SelectScrollDownButton.displayName = SCROLL_DOWN_BUTTON_NAME;
+const SelectScrollButtonImpl = React.memo(React.forwardRef((props, forwardedRef) => {
+  const {
+      __scopeSelect,
+      dir,
+      componentName,
+      ...scrollIndicatorProps
+    } = props,
+    {
+      forceUpdate,
+      open,
+      fallback,
+      setScrollTop,
+      setInnerOffset,
+      ...context
+    } = (0, import_context.useSelectContext)(componentName, __scopeSelect),
+    floatingRef = context.floatingContext?.refs.floating,
+    statusRef = React.useRef("idle"),
+    isVisible = context[dir === "down" ? "canScrollDown" : "canScrollUp"],
+    frameRef = React.useRef(),
+    {
+      x,
+      y,
+      refs,
+      strategy
+    } = (0, import_react.useFloating)({
+      open: open && isVisible,
+      strategy: "fixed",
+      elements: {
+        reference: floatingRef?.current
+      },
+      placement: dir === "up" ? "top" : "bottom",
+      middleware: [(0, import_react.offset)(({
+        rects
+      }) => -rects.floating.height)],
+      whileElementsMounted: (...args) => (0, import_react.autoUpdate)(...args, {
+        animationFrame: !0
+      })
+    }),
+    composedRef = (0, import_compose_refs.useComposedRefs)(forwardedRef, refs.setFloating);
+  if (!isVisible) return null;
+  const onScroll = amount => {
+    const floating = floatingRef;
+    floating && (fallback ? floating.current && (floating.current.scrollTop -= amount, (0, import_react_dom.flushSync)(() => setScrollTop(floating.current?.scrollTop ?? 0))) : (0, import_react_dom.flushSync)(() => setInnerOffset(value => value - amount)));
+  };
+  return /* @__PURE__ */(0, import_jsx_runtime.jsx)(import_stacks.YStack, {
+    ref: composedRef,
+    componentName,
+    "aria-hidden": !0,
+    ...scrollIndicatorProps,
+    zIndex: 1e3,
+    position: strategy,
+    left: x || 0,
+    top: y || 0,
+    width: `calc(${(floatingRef?.current?.offsetWidth ?? 0) - 2}px)`,
+    onPointerEnter: () => {
+      statusRef.current = "active";
+      let prevNow = Date.now();
+      function frame() {
+        const element = floatingRef?.current;
+        if (element) {
+          const currentNow = Date.now(),
+            msElapsed = currentNow - prevNow;
+          prevNow = currentNow;
+          const pixelsToScroll = msElapsed / 2,
+            remainingPixels = dir === "up" ? element.scrollTop : element.scrollHeight - element.clientHeight - element.scrollTop,
+            scrollRemaining = dir === "up" ? element.scrollTop - pixelsToScroll > 0 : element.scrollTop + pixelsToScroll < element.scrollHeight - element.clientHeight;
+          onScroll(dir === "up" ? Math.min(pixelsToScroll, remainingPixels) : Math.max(-pixelsToScroll, -remainingPixels)), scrollRemaining && (frameRef.current = requestAnimationFrame(frame));
+        }
+      }
+      cancelAnimationFrame(frameRef.current), frameRef.current = requestAnimationFrame(frame);
+    },
+    onPointerLeave: () => {
+      statusRef.current = "idle", cancelAnimationFrame(frameRef.current);
+    }
+  });
+}));