@tamagui/select 1.0.1-beta.36 → 1.0.1-beta.39

package/dist/esm/Select.js

@@ -1,21 +1,54 @@
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 import {
+  FloatingFocusManager,
+  FloatingOverlay,
+  FloatingPortal,
+  autoUpdate,
+  detectOverflow,
+  flip,
   offset,
-  useFloating
+  size,
+  useClick,
+  useDismiss,
+  useFloating,
+  useInteractions,
+  useListNavigation,
+  useRole,
+  useTypeahead
 } from "@floating-ui/react-dom-interactions";
 import { usePrevious } from "@radix-ui/react-use-previous";
+import { Button } from "@tamagui/button";
 import { useComposedRefs } from "@tamagui/compose-refs";
-import { composeEventHandlers, useIsomorphicLayoutEffect } from "@tamagui/core";
+import {
+  getVariableValue,
+  styled,
+  useIsomorphicLayoutEffect,
+  withStaticProperties
+} from "@tamagui/core";
 import { useId } from "@tamagui/core";
 import { createContextScope } from "@tamagui/create-context";
 import { Separator } from "@tamagui/separator";
-import { XStack } from "@tamagui/stacks";
+import { ThemeableStack, XStack, YStack } from "@tamagui/stacks";
+import { Paragraph } from "@tamagui/text";
 import { useControllableState } from "@tamagui/use-controllable-state";
 import * as React from "react";
 import * as ReactDOM from "react-dom";
-const OPEN_KEYS = [" ", "Enter", "ArrowUp", "ArrowDown"];
-const SELECTION_KEYS = [" ", "Enter"];
+const isFirefox = typeof navigator !== "undefined" && navigator.userAgent.toLowerCase().includes("firefox");
+if (isFirefox) {
+  document.body.classList.add("firefox");
+}
+function getVisualOffsetTop() {
+  return !/^((?!chrome|android).)*safari/i.test(navigator.userAgent) ? visualViewport.offsetTop : 0;
+}
+__name(getVisualOffsetTop, "getVisualOffsetTop");
+const getSelectItemSize = /* @__PURE__ */ __name((val, { tokens }) => {
+  const padding = getVariableValue(tokens.size[val]);
+  return {
+    paddingHorizontal: padding / 2,
+    paddingVertical: padding / 4
+  };
+}, "getSelectItemSize");
 const SELECT_NAME = "Select";
 const WINDOW_PADDING = 8;
 const SCROLL_ARROW_VELOCITY = 8;
@@ -24,61 +57,8 @@ const MIN_HEIGHT = 80;
 const FALLBACK_THRESHOLD = 16;
 const [createSelectContext, createSelectScope] = createContextScope(SELECT_NAME);
 const [SelectProvider, useSelectContext] = createSelectContext(SELECT_NAME);
-const Select = /* @__PURE__ */ __name((props) => {
-  const {
-    __scopeSelect,
-    children,
-    open: openProp,
-    defaultOpen,
-    onOpenChange,
-    value: valueProp,
-    defaultValue,
-    onValueChange,
-    dir: dir2,
-    name,
-    autoComplete
-  } = props;
-  const [open, setOpen] = useControllableState({
-    prop: openProp,
-    defaultProp: defaultOpen || false,
-    onChange: onOpenChange
-  });
-  const [value, setValue] = useControllableState({
-    prop: valueProp,
-    defaultProp: defaultValue || "",
-    onChange: onValueChange
-  });
-  const selectedIndexRef = React.useRef(null);
-  const activeIndexRef = React.useRef(null);
-  const prevActiveIndex = usePrevious(activeIndex);
-  const [showArrows, setShowArrows] = React.useState(false);
-  const [scrollTop, setScrollTop] = React.useState(0);
-  const [activeIndex, setActiveIndex] = React.useState(null);
-  const [selectedIndex, setSelectedIndex] = React.useState(Math.max(0, listContentRef.current.indexOf(value)));
-  useIsomorphicLayoutEffect(() => {
-    selectedIndexRef.current = selectedIndex;
-    activeIndexRef.current = activeIndex;
-  });
-  useEffect(() => {
-    const frame = requestAnimationFrame(() => {
-      setShowArrows(open);
-      if (!open) {
-        setScrollTop(0);
-        setMiddlewareType("align");
-        setActiveIndex(null);
-        setControlledScrolling(false);
-      }
-    });
-    return () => cancelAnimationFrame(frame);
-  }, [open]);
-  const showUpArrow = showArrows && scrollTop > SCROLL_ARROW_THRESHOLD;
-  const showDownArrow = showArrows && floatingRef.current && scrollTop < floatingRef.current.scrollHeight - floatingRef.current.clientHeight - SCROLL_ARROW_THRESHOLD;
-  return /* @__PURE__ */ React.createElement(SelectProvider, {
-    scope: __scopeSelect,
-    open
-  }, children);
-}, "Select");
-Select.displayName = SELECT_NAME;
+const OPEN_KEYS = [" ", "Enter", "ArrowUp", "ArrowDown"];
+const SELECTION_KEYS = [" ", "Enter"];
 const TRIGGER_NAME = "SelectTrigger";
 const SelectTrigger = React.forwardRef((props, forwardedRef) => {
   const {
@@ -88,137 +68,189 @@ const SelectTrigger = React.forwardRef((props, forwardedRef) => {
     ...triggerProps
   } = props;
   const context = useSelectContext(TRIGGER_NAME, __scopeSelect);
-  const composedRefs = useComposedRefs(forwardedRef, context.onTriggerChange);
-  const getItems = useCollection(__scopeSelect);
-  const handleOpen = /* @__PURE__ */ __name(() => {
-    if (!disabled) {
-      context.onOpenChange(true);
-      resetTypeahead();
-    }
-  }, "handleOpen");
-  return /* @__PURE__ */ React.createElement(Primitive.button, {
-    type: "button",
-    role: "combobox",
-    "aria-controls": context.contentId,
+  return /* @__PURE__ */ React.createElement(Button, {
+    componentName: TRIGGER_NAME,
     "aria-expanded": context.open,
     "aria-autocomplete": "none",
-    dir: context.dir,
     disabled,
     "data-disabled": disabled ? "" : void 0,
     ...triggerProps,
-    ref: composedRefs,
-    onPointerDown: composeEventHandlers(triggerProps.onPointerDown, (event) => {
-      ;
-      event.target.releasePointerCapture(event.pointerId);
-      if (event.button === 0 && event.ctrlKey === false) {
-        handleOpen();
-        context.triggerPointerDownPosRef.current = {
-          x: Math.round(event.pageX),
-          y: Math.round(event.pageY)
-        };
-        event.preventDefault();
-      }
-    }),
-    onKeyDown: composeEventHandlers(triggerProps.onKeyDown, (event) => {
-      const isTypingAhead = searchRef.current !== "";
-      const isModifierKey = event.ctrlKey || event.altKey || event.metaKey;
-      if (!isModifierKey && event.key.length === 1)
-        handleTypeaheadSearch(event.key);
-      if (isTypingAhead && event.key === " ")
-        return;
-      if (OPEN_KEYS.includes(event.key)) {
-        handleOpen();
-        event.preventDefault();
-      }
-    })
+    ref: forwardedRef,
+    ...context.interactions.getReferenceProps()
   });
 });
 SelectTrigger.displayName = TRIGGER_NAME;
 const VALUE_NAME = "SelectValue";
-const SelectValue = React.forwardRef((props, forwardedRef) => {
-  const { __scopeSelect, className, style, ...valueProps } = props;
-  return /* @__PURE__ */ React.createElement(XStack, {
-    ...valueProps,
-    pointerEvents: "none"
-  });
+const SelectValueFrame = styled(Paragraph, {
+  name: VALUE_NAME
 });
-const ICON_NAME = "SelectIcon";
-const SelectIcon = React.forwardRef((props, forwardedRef) => {
-  const { __scopeSelect, children, ...iconProps } = props;
-  return /* @__PURE__ */ React.createElement(XStack, {
-    "aria-hidden": true,
-    ...iconProps,
-    ref: forwardedRef
-  }, children || "\u25BC");
+const SelectValue = SelectValueFrame.extractable(React.forwardRef(({ __scopeSelect, children, placeholder }, forwardedRef) => {
+  const context = useSelectContext(VALUE_NAME, __scopeSelect);
+  const { onValueNodeHasChildrenChange } = context;
+  const hasChildren = children !== void 0;
+  const composedRefs = useComposedRefs(forwardedRef, context.onValueNodeChange);
+  React.useLayoutEffect(() => {
+    onValueNodeHasChildrenChange(hasChildren);
+  }, [onValueNodeHasChildrenChange, hasChildren]);
+  return /* @__PURE__ */ React.createElement(SelectValueFrame, {
+    ref: composedRefs,
+    pointerEvents: "none"
+  }, context.value === void 0 && placeholder !== void 0 ? placeholder : children);
+}));
+SelectValue.displayName = VALUE_NAME;
+const SelectIcon = styled(XStack, {
+  name: "SelectIcon",
+  "aria-hidden": true,
+  children: /* @__PURE__ */ React.createElement(Paragraph, null, "\u25BC")
 });
-SelectIcon.displayName = ICON_NAME;
 const CONTENT_NAME = "SelectContent";
-const SelectContent = React.forwardRef((props, forwardedRef) => {
-  const context = useSelectContext(CONTENT_NAME, props.__scopeSelect);
-  return props.children;
+const SelectContent = React.forwardRef(({ children, __scopeSelect }, forwardedRef) => {
+  const context = useSelectContext(CONTENT_NAME, __scopeSelect);
+  return /* @__PURE__ */ React.createElement(FloatingPortal, null, context.open ? /* @__PURE__ */ React.createElement(FloatingOverlay, {
+    lockScroll: true
+  }, children) : /* @__PURE__ */ React.createElement("div", {
+    style: { display: "none" }
+  }, children));
 });
-const GROUP_NAME = "SelectGroup";
-const [SelectGroupContextProvider, useSelectGroupContext] = createSelectContext(GROUP_NAME);
-const SelectGroup = React.forwardRef((props, forwardedRef) => {
-  const { __scopeSelect, ...groupProps } = props;
-  const groupId = useId();
-  return /* @__PURE__ */ React.createElement(SelectGroupContextProvider, {
-    scope: __scopeSelect,
-    id: groupId
-  }, /* @__PURE__ */ React.createElement(Primitive.div, {
-    role: "group",
-    "aria-labelledby": groupId,
-    ...groupProps,
-    ref: forwardedRef
-  }));
+const VIEWPORT_NAME = "SelectViewport";
+const SelectViewportFrame = styled(ThemeableStack, {
+  name: VIEWPORT_NAME,
+  backgroundColor: "$background",
+  elevate: true,
+  variants: {
+    size: {
+      "...size": (val, { tokens }) => {
+        var _a;
+        return {
+          borderRadius: (_a = tokens.size[val]) != null ? _a : val
+        };
+      }
+    }
+  },
+  defaultVariants: {
+    size: "$2"
+  }
 });
-SelectGroup.displayName = GROUP_NAME;
-const LABEL_NAME = "SelectLabel";
-const SelectLabel = React.forwardRef((props, forwardedRef) => {
-  const { __scopeSelect, ...labelProps } = props;
-  const groupContext = useSelectGroupContext(LABEL_NAME, __scopeSelect);
-  return /* @__PURE__ */ React.createElement(Primitive.div, {
-    id: groupContext.id,
-    ...labelProps,
-    ref: forwardedRef
-  });
+const SelectViewport = React.forwardRef((props, forwardedRef) => {
+  const { __scopeSelect, children, ...viewportProps } = props;
+  const context = useSelectContext(VIEWPORT_NAME, __scopeSelect);
+  const composedRefs = useComposedRefs(forwardedRef);
+  const prevScrollTopRef = React.useRef(0);
+  return /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement("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}`
+    }
+  }), /* @__PURE__ */ React.createElement(FloatingFocusManager, {
+    context: context.floatingContext,
+    preventTabbing: true
+  }, /* @__PURE__ */ React.createElement("div", {
+    ...context.interactions.getFloatingProps()
+  }, /* @__PURE__ */ React.createElement(SelectViewportFrame, {
+    "data-radix-select-viewport": "",
+    role: "presentation",
+    ...viewportProps,
+    ref: composedRefs
+  }, children))));
 });
-SelectLabel.displayName = LABEL_NAME;
+SelectViewport.displayName = VIEWPORT_NAME;
 const ITEM_NAME = "SelectItem";
 const [SelectItemContextProvider, useSelectItemContext] = createSelectContext(ITEM_NAME);
+const SelectItemFrame = styled(YStack, {
+  name: ITEM_NAME,
+  tag: "li",
+  role: "option",
+  width: "100%",
+  hoverStyle: {
+    backgroundColor: "$backgroundHover"
+  },
+  focusStyle: {
+    backgroundColor: "$backgroundFocus"
+  },
+  variants: {
+    size: {
+      "...size": getSelectItemSize
+    }
+  },
+  defaultVariants: {
+    size: "$4"
+  }
+});
 const SelectItem = React.forwardRef((props, forwardedRef) => {
-  const { __scopeSelect, value, disabled = false, textValue: textValueProp, ...itemProps } = props;
+  const {
+    __scopeSelect,
+    value,
+    disabled = false,
+    textValue: textValueProp,
+    index,
+    ...itemProps
+  } = props;
   const context = useSelectContext(ITEM_NAME, __scopeSelect);
-  const contentContext = useSelectContentContext(ITEM_NAME, __scopeSelect);
   const isSelected = context.value === value;
   const [textValue, setTextValue] = React.useState(textValueProp != null ? textValueProp : "");
   const [isFocused, setIsFocused] = React.useState(false);
-  const composedRefs = useComposedRefs(forwardedRef, isSelected ? contentContext.onSelectedItemChange : void 0);
   const textId = useId();
-  const handleSelect = /* @__PURE__ */ __name(() => {
-    if (!disabled) {
-      context.onValueChange(value);
-      context.onOpenChange(false);
+  const {
+    selectedIndex,
+    setSelectedIndex,
+    listRef,
+    open,
+    setOpen,
+    onChange,
+    activeIndex,
+    setActiveIndex,
+    dataRef
+  } = context;
+  const composedRefs = useComposedRefs(forwardedRef, (node) => {
+    console.log("node", node);
+    if (node instanceof HTMLElement) {
+      listRef.current[index] = node;
     }
-  }, "handleSelect");
+  });
+  const timeoutRef = React.useRef();
+  const [allowMouseUp, setAllowMouseUp] = React.useState(false);
+  function handleSelect() {
+    console.log("handling select!");
+    setSelectedIndex(index);
+    onChange(value);
+    setOpen(false);
+  }
+  __name(handleSelect, "handleSelect");
+  React.useEffect(() => {
+    clearTimeout(timeoutRef.current);
+    if (open) {
+      if (selectedIndex !== index) {
+        setAllowMouseUp(true);
+      } else {
+        timeoutRef.current = setTimeout(() => {
+          setAllowMouseUp(true);
+        }, 300);
+      }
+    } else {
+      setAllowMouseUp(false);
+    }
+  }, [open, index, setActiveIndex, selectedIndex]);
+  function handleKeyDown(event) {
+    console.log("item key down");
+    if (event.key === "Enter" || event.key === " " && !dataRef.current.typing) {
+      event.preventDefault();
+      handleSelect();
+    }
+  }
+  __name(handleKeyDown, "handleKeyDown");
+  const selectItemProps = context.interactions.getItemProps({
+    onClick: allowMouseUp ? handleSelect : void 0,
+    onMouseUp: allowMouseUp ? handleSelect : void 0,
+    onKeyDown: handleKeyDown
+  });
   return /* @__PURE__ */ React.createElement(SelectItemContextProvider, {
     scope: __scopeSelect,
     value,
-    textId,
+    textId: textId || "",
     isSelected,
     onItemTextChange: React.useCallback((node) => {
-      setTextValue((prevTextValue) => {
-        var _a;
-        return prevTextValue || ((_a = node == null ? void 0 : node.textContent) != null ? _a : "").trim();
-      });
     }, [])
-  }, /* @__PURE__ */ React.createElement(Collection.ItemSlot, {
-    scope: __scopeSelect,
-    value,
-    disabled,
-    textValue
-  }, /* @__PURE__ */ React.createElement(Primitive.div, {
-    role: "option",
+  }, /* @__PURE__ */ React.createElement(SelectItemFrame, {
+    ref: composedRefs,
     "aria-labelledby": textId,
     "aria-selected": isSelected && isFocused,
     "data-state": isSelected ? "active" : "inactive",
@@ -226,166 +258,594 @@ const SelectItem = React.forwardRef((props, forwardedRef) => {
     "data-disabled": disabled ? "" : void 0,
     tabIndex: disabled ? void 0 : -1,
     ...itemProps,
-    ref: composedRefs,
-    onFocus: composeEventHandlers(itemProps.onFocus, () => setIsFocused(true)),
-    onBlur: composeEventHandlers(itemProps.onBlur, () => setIsFocused(false)),
-    onPointerUp: composeEventHandlers(itemProps.onPointerUp, handleSelect),
-    onPointerMove: composeEventHandlers(itemProps.onPointerMove, (event) => {
-      if (disabled) {
-        contentContext.onItemLeave();
-      } else {
-        event.currentTarget.focus({ preventScroll: true });
-      }
-    }),
-    onPointerLeave: composeEventHandlers(itemProps.onPointerLeave, (event) => {
-      if (event.currentTarget === document.activeElement) {
-        contentContext.onItemLeave();
-      }
-    }),
-    onKeyDown: composeEventHandlers(itemProps.onKeyDown, (event) => {
-      const isTypingAhead = contentContext.searchRef.current !== "";
-      if (isTypingAhead && event.key === " ")
-        return;
-      if (SELECTION_KEYS.includes(event.key))
-        handleSelect();
-      if (event.key === " ")
-        event.preventDefault();
-    })
-  })));
+    ...selectItemProps
+  }));
 });
 SelectItem.displayName = ITEM_NAME;
 const ITEM_TEXT_NAME = "SelectItemText";
+const SelectItemTextFrame = styled(Paragraph, {
+  name: ITEM_TEXT_NAME,
+  cursor: "default"
+});
 const SelectItemText = React.forwardRef((props, forwardedRef) => {
-  var _a;
   const { __scopeSelect, className, style, ...itemTextProps } = props;
   const context = useSelectContext(ITEM_TEXT_NAME, __scopeSelect);
-  const contentContext = useSelectContentContext(ITEM_TEXT_NAME, __scopeSelect);
   const itemContext = useSelectItemContext(ITEM_TEXT_NAME, __scopeSelect);
   const ref = React.useRef(null);
-  const composedRefs = useComposedRefs(forwardedRef, ref, itemContext.onItemTextChange, itemContext.isSelected ? contentContext.onSelectedItemTextChange : void 0);
-  return /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(Primitive.span, {
+  const composedRefs = useComposedRefs(forwardedRef, ref, itemContext.onItemTextChange);
+  return /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(SelectItemTextFrame, {
     id: itemContext.textId,
     ...itemTextProps,
     ref: composedRefs
-  }), itemContext.isSelected && context.valueNode && !context.valueNodeHasChildren ? ReactDOM.createPortal(itemTextProps.children, context.valueNode) : null, context.bubbleSelect ? ReactDOM.createPortal(/* @__PURE__ */ React.createElement("option", {
-    value: itemContext.value
-  }, (_a = ref.current) == null ? void 0 : _a.textContent), context.bubbleSelect) : null);
+  }), itemContext.isSelected && context.valueNode && !context.valueNodeHasChildren ? ReactDOM.createPortal(itemTextProps.children, context.valueNode) : null);
 });
 SelectItemText.displayName = ITEM_TEXT_NAME;
 const ITEM_INDICATOR_NAME = "SelectItemIndicator";
+const SelectItemIndicatorFrame = styled(XStack, {
+  name: ITEM_TEXT_NAME
+});
 const SelectItemIndicator = React.forwardRef((props, forwardedRef) => {
   const { __scopeSelect, ...itemIndicatorProps } = props;
   const itemContext = useSelectItemContext(ITEM_INDICATOR_NAME, __scopeSelect);
-  return itemContext.isSelected ? /* @__PURE__ */ React.createElement(Primitive.span, {
+  return itemContext.isSelected ? /* @__PURE__ */ React.createElement(SelectItemIndicatorFrame, {
     "aria-hidden": true,
     ...itemIndicatorProps,
     ref: forwardedRef
   }) : null;
 });
 SelectItemIndicator.displayName = ITEM_INDICATOR_NAME;
+const GROUP_NAME = "SelectGroup";
+const [SelectGroupContextProvider, useSelectGroupContext] = createSelectContext(GROUP_NAME);
+const SelectGroupFrame = styled(YStack, {
+  name: GROUP_NAME,
+  width: "100%"
+});
+const SelectGroup = React.forwardRef((props, forwardedRef) => {
+  const { __scopeSelect, ...groupProps } = props;
+  const groupId = useId();
+  return /* @__PURE__ */ React.createElement(SelectGroupContextProvider, {
+    scope: __scopeSelect,
+    id: groupId || ""
+  }, /* @__PURE__ */ React.createElement(SelectGroupFrame, {
+    role: "group",
+    "aria-labelledby": groupId,
+    ...groupProps,
+    ref: forwardedRef
+  }));
+});
+SelectGroup.displayName = GROUP_NAME;
+const LABEL_NAME = "SelectLabel";
+const SelectLabelFrame = styled(SelectItemTextFrame, {
+  name: LABEL_NAME,
+  variants: {
+    size: {
+      "...size": (val, extras) => {
+        const size2 = getSelectItemSize(val, extras);
+        return {
+          ...size2,
+          paddingTop: size2.paddingVertical * 4
+        };
+      }
+    }
+  },
+  defaultVariants: {
+    size: "$4"
+  }
+});
+const SelectLabel = React.forwardRef((props, forwardedRef) => {
+  const { __scopeSelect, ...labelProps } = props;
+  const groupContext = useSelectGroupContext(LABEL_NAME, __scopeSelect);
+  return /* @__PURE__ */ React.createElement(SelectLabelFrame, {
+    id: groupContext.id,
+    ...labelProps,
+    ref: forwardedRef
+  });
+});
+SelectLabel.displayName = LABEL_NAME;
 const SCROLL_UP_BUTTON_NAME = "SelectScrollUpButton";
 const SelectScrollUpButton = React.forwardRef((props, forwardedRef) => {
-  const contentContext = useSelectContentContext(SCROLL_UP_BUTTON_NAME, props.__scopeSelect);
-  const [canScrollUp, setCanScrollUp] = React.useState(false);
-  const composedRefs = useComposedRefs(forwardedRef, contentContext.onScrollButtonChange);
-  return canScrollUp ? /* @__PURE__ */ React.createElement(SelectScrollButtonImpl, {
+  return /* @__PURE__ */ React.createElement(SelectScrollButtonImpl, {
+    componentName: SCROLL_UP_BUTTON_NAME,
     ...props,
-    ref: composedRefs,
-    onAutoScroll: () => {
-      const { viewport, selectedItem } = contentContext;
-      if (viewport && selectedItem) {
-        viewport.scrollTop = viewport.scrollTop - selectedItem.offsetHeight;
-      }
-    }
-  }) : null;
+    dir: "up",
+    ref: forwardedRef
+  });
 });
 SelectScrollUpButton.displayName = SCROLL_UP_BUTTON_NAME;
 const SCROLL_DOWN_BUTTON_NAME = "SelectScrollDownButton";
 const SelectScrollDownButton = React.forwardRef((props, forwardedRef) => {
-  const contentContext = useSelectContentContext(SCROLL_DOWN_BUTTON_NAME, props.__scopeSelect);
-  const [canScrollDown, setCanScrollDown] = React.useState(false);
-  const composedRefs = useComposedRefs(forwardedRef, contentContext.onScrollButtonChange);
-  return canScrollDown ? /* @__PURE__ */ React.createElement(SelectScrollButtonImpl, {
+  return /* @__PURE__ */ React.createElement(SelectScrollButtonImpl, {
+    componentName: SCROLL_DOWN_BUTTON_NAME,
     ...props,
-    ref: composedRefs,
-    onAutoScroll: () => {
-      const { viewport, selectedItem } = contentContext;
-      if (viewport && selectedItem) {
-        viewport.scrollTop = viewport.scrollTop + selectedItem.offsetHeight;
-      }
-    }
-  }) : null;
+    dir: "down",
+    ref: forwardedRef
+  });
 });
 SelectScrollDownButton.displayName = SCROLL_DOWN_BUTTON_NAME;
 const SelectScrollButtonImpl = React.forwardRef((props, forwardedRef) => {
-  const { __scopeSelect, onAutoScroll, ...scrollIndicatorProps } = props;
-  const contentContext = useSelectContentContext("SelectScrollButton", __scopeSelect);
-  const autoScrollTimerRef = React.useRef(null);
+  var _a, _b;
+  const { __scopeSelect, dir, componentName, ...scrollIndicatorProps } = props;
+  const { floatingRef, increaseHeight, forceUpdate, ...context } = useSelectContext(componentName, __scopeSelect);
   const intervalRef = React.useRef();
   const loopingRef = React.useRef(false);
+  const isVisible = context[dir === "down" ? "canScrollDown" : "canScrollUp"];
   const { x, y, reference, floating, strategy, update, refs } = useFloating({
     strategy: "fixed",
     placement: dir === "up" ? "top" : "bottom",
-    middleware: [offset(({ floating: floating2 }) => -floating2.height)]
+    middleware: [offset(({ rects }) => -rects.floating.height)]
   });
-  return /* @__PURE__ */ React.createElement(Primitive.div, {
+  const composedRefs = useComposedRefs(forwardedRef, floating);
+  React.useLayoutEffect(() => {
+    reference(floatingRef.current);
+  }, [reference, floatingRef.current]);
+  React.useEffect(() => {
+    if (!refs.reference.current || !refs.floating.current || !isVisible) {
+      return;
+    }
+    const cleanup = autoUpdate(refs.reference.current, refs.floating.current, update, {
+      animationFrame: true
+    });
+    return () => {
+      clearInterval(intervalRef.current);
+      loopingRef.current = false;
+      cleanup();
+    };
+  }, [isVisible, update, refs.floating, refs.reference]);
+  if (!isVisible) {
+    return null;
+  }
+  const handleScrollArrowChange = /* @__PURE__ */ __name(() => {
+    const floating2 = floatingRef.current;
+    const isUp = dir === "up";
+    if (floating2) {
+      const value = isUp ? -SCROLL_ARROW_VELOCITY : SCROLL_ARROW_VELOCITY;
+      const multi = isUp && floating2.scrollTop <= SCROLL_ARROW_THRESHOLD * 2 || !isUp && floating2.scrollTop >= floating2.scrollHeight - floating2.clientHeight - SCROLL_ARROW_THRESHOLD * 2 ? 2 : 1;
+      floating2.scrollTop += multi * (isUp ? -SCROLL_ARROW_VELOCITY : SCROLL_ARROW_VELOCITY);
+      increaseHeight(floating2, multi === 2 ? value * 2 : value);
+      forceUpdate();
+    }
+  }, "handleScrollArrowChange");
+  return /* @__PURE__ */ React.createElement(YStack, {
+    ref: composedRefs,
+    componentName,
     "aria-hidden": true,
     ...scrollIndicatorProps,
-    ref: forwardedRef,
-    style: { flexShrink: 0, ...scrollIndicatorProps.style },
-    onPointerMove: composeEventHandlers(scrollIndicatorProps.onPointerMove, () => {
-      contentContext.onItemLeave();
-      if (autoScrollTimerRef.current === null) {
-        autoScrollTimerRef.current = window.setInterval(onAutoScroll, 50);
+    position: strategy,
+    left: x || 0,
+    top: y || 0,
+    width: `calc(${((_b = (_a = floatingRef.current) == null ? void 0 : _a.offsetWidth) != null ? _b : 0) - 2}px)`,
+    background: `linear-gradient(to ${dir === "up" ? "bottom" : "top"}, #29282b 50%, rgba(53, 54, 55, 0.01))`,
+    onPointerMove: () => {
+      if (!loopingRef.current) {
+        intervalRef.current = setInterval(handleScrollArrowChange, 1e3 / 60);
+        loopingRef.current = true;
       }
-    }),
-    onPointerLeave: composeEventHandlers(scrollIndicatorProps.onPointerLeave, () => {
-      clearAutoScrollTimer();
-    })
+    },
+    onPointerLeave: () => {
+      loopingRef.current = false;
+      clearInterval(intervalRef.current);
+    }
   });
 });
-const SEPARATOR_NAME = "SelectSeparator";
-const SelectSeparator = Separator;
-SelectSeparator.displayName = SEPARATOR_NAME;
-const BubbleSelect = React.forwardRef((props, forwardedRef) => {
-  const { value, ...selectProps } = props;
-  const ref = React.useRef(null);
-  const composedRefs = useComposedRefs(forwardedRef, ref);
-  const prevValue = usePrevious(value);
+const SelectSeparator = styled(Separator, {
+  name: "SelectSeparator"
+});
+const Select = withStaticProperties((props) => {
+  var _a;
+  const {
+    __scopeSelect,
+    children,
+    open: openProp,
+    defaultOpen,
+    onOpenChange,
+    value: valueProp,
+    defaultValue,
+    onValueChange,
+    dir,
+    name,
+    autoComplete
+  } = props;
+  const [open, setOpen] = useControllableState({
+    prop: openProp,
+    defaultProp: defaultOpen || false,
+    onChange: onOpenChange
+  });
+  const [value, setValue] = useControllableState({
+    prop: valueProp,
+    defaultProp: defaultValue || "",
+    onChange: onValueChange
+  });
+  const [activeIndex, setActiveIndex] = React.useState(null);
+  const selectedIndexRef = React.useRef(null);
+  const activeIndexRef = React.useRef(null);
+  const prevActiveIndex = usePrevious(activeIndex);
+  const [showArrows, setShowArrows] = React.useState(false);
+  const [scrollTop, setScrollTop] = React.useState(0);
+  const listItemsRef = React.useRef([]);
+  const listContentRef = React.useRef([
+    "Select...",
+    ...(_a = React.Children.map(children, (child) => React.Children.map(React.isValidElement(child) && child.props.children, (child2) => child2.props.value))) != null ? _a : []
+  ]);
+  const [selectedIndex, setSelectedIndex] = React.useState(Math.max(0, listContentRef.current.indexOf(value)));
+  const [controlledScrolling, setControlledScrolling] = React.useState(false);
+  const [middlewareType, setMiddlewareType] = React.useState("align");
+  useIsomorphicLayoutEffect(() => {
+    selectedIndexRef.current = selectedIndex;
+    activeIndexRef.current = activeIndex;
+  });
   React.useEffect(() => {
-    const select = ref.current;
-    const selectProto = window.HTMLSelectElement.prototype;
-    const descriptor = Object.getOwnPropertyDescriptor(selectProto, "value");
-    const setValue = descriptor.set;
-    if (prevValue !== value && setValue) {
-      const event = new Event("change", { bubbles: true });
-      setValue.call(select, value);
-      select.dispatchEvent(event);
+    const frame = requestAnimationFrame(() => {
+      setShowArrows(open);
+      if (!open) {
+        setScrollTop(0);
+        setMiddlewareType("align");
+        setActiveIndex(null);
+        setControlledScrolling(false);
+      }
+    });
+    return () => {
+      cancelAnimationFrame(frame);
+    };
+  }, [open]);
+  function getFloatingPadding(floating2) {
+    var _a2;
+    if (!floating2) {
+      return 0;
     }
-  }, [prevValue, value]);
-  return null;
-  return /* @__PURE__ */ React.createElement(VisuallyHidden, {
-    asChild: true
-  }, /* @__PURE__ */ React.createElement("select", {
-    ...selectProps,
-    ref: composedRefs,
-    defaultValue: value
-  }));
+    return Number((_a2 = getComputedStyle(floating2).paddingLeft) == null ? void 0 : _a2.replace("px", ""));
+  }
+  __name(getFloatingPadding, "getFloatingPadding");
+  const { x, y, reference, floating, strategy, context, refs, middlewareData, update } = useFloating({
+    open,
+    onOpenChange: setOpen,
+    placement: "bottom",
+    middleware: middlewareType === "align" ? [
+      offset(({ rects }) => {
+        var _a2;
+        const index = (_a2 = activeIndexRef.current) != null ? _a2 : selectedIndexRef.current;
+        if (index == null) {
+          return 0;
+        }
+        const item = listItemsRef.current[index];
+        if (item == null) {
+          return 0;
+        }
+        const offsetTop = item.offsetTop;
+        const itemHeight = item.offsetHeight;
+        const height = rects.reference.height;
+        return -offsetTop - height - (itemHeight - height) / 2;
+      }),
+      {
+        name: "size",
+        async fn(args) {
+          var _a2;
+          const {
+            elements: { floating: floating2 },
+            rects: { reference: reference2 },
+            middlewareData: middlewareData2
+          } = args;
+          const overflow = await detectOverflow(args, {
+            padding: WINDOW_PADDING
+          });
+          const top = Math.max(0, overflow.top);
+          const bottom = Math.max(0, overflow.bottom);
+          const nextY = args.y + top;
+          if ((_a2 = middlewareData2.size) == null ? void 0 : _a2.skip) {
+            return {
+              y: nextY,
+              data: {
+                y: middlewareData2.size.y
+              }
+            };
+          }
+          Object.assign(floating2.style, {
+            maxHeight: `${floating2.scrollHeight - Math.abs(top + bottom)}px`,
+            minWidth: `${reference2.width + getFloatingPadding(floating2) * 2}px`
+          });
+          return {
+            y: nextY,
+            data: {
+              y: top,
+              skip: true
+            },
+            reset: {
+              rects: true
+            }
+          };
+        }
+      }
+    ] : [
+      offset(5),
+      flip(),
+      size({
+        apply({ rects, availableHeight, elements }) {
+          Object.assign(elements.floating.style, {
+            width: `${rects.reference.width}px`,
+            maxHeight: `${availableHeight}px`
+          });
+        },
+        padding: WINDOW_PADDING
+      })
+    ]
+  });
+  const floatingRef = refs.floating;
+  const forceUpdate = React.useReducer(() => ({}), {})[1];
+  const showUpArrow = showArrows && scrollTop > SCROLL_ARROW_THRESHOLD;
+  const showDownArrow = showArrows && floatingRef.current && scrollTop < floatingRef.current.scrollHeight - floatingRef.current.clientHeight - SCROLL_ARROW_THRESHOLD;
+  console.log("Select", {
+    activeIndex,
+    selectedIndex
+  });
+  const interactions = useInteractions([
+    useClick(context, { pointerDown: true }),
+    useRole(context, { role: "listbox" }),
+    useDismiss(context),
+    useListNavigation(context, {
+      listRef: listItemsRef,
+      activeIndex,
+      selectedIndex,
+      onNavigate: setActiveIndex
+    }),
+    useTypeahead(context, {
+      listRef: listContentRef,
+      onMatch: open ? setActiveIndex : setSelectedIndex,
+      selectedIndex,
+      activeIndex
+    })
+  ]);
+  const increaseHeight = React.useCallback((floating2, amount = 0) => {
+    if (middlewareType === "fallback") {
+      return;
+    }
+    const currentMaxHeight = Number(floating2.style.maxHeight.replace("px", ""));
+    const currentTop = Number(floating2.style.top.replace("px", ""));
+    const rect = floating2.getBoundingClientRect();
+    const rectTop = rect.top;
+    const rectBottom = rect.bottom;
+    const visualMaxHeight = visualViewport.height - WINDOW_PADDING * 2;
+    if (amount < 0 && selectedIndexRef.current != null && Math.round(rectBottom) < Math.round(visualViewport.height + getVisualOffsetTop() - WINDOW_PADDING)) {
+      floating2.style.maxHeight = `${Math.min(visualMaxHeight, currentMaxHeight - amount)}px`;
+    }
+    if (amount > 0 && Math.round(rectTop) > Math.round(WINDOW_PADDING - getVisualOffsetTop()) && floating2.scrollHeight > floating2.offsetHeight) {
+      const nextTop = Math.max(WINDOW_PADDING + getVisualOffsetTop(), currentTop - amount);
+      const nextMaxHeight = Math.min(visualMaxHeight, currentMaxHeight + amount);
+      Object.assign(floating2.style, {
+        maxHeight: `${nextMaxHeight}px`,
+        top: `${nextTop}px`
+      });
+      if (nextTop - WINDOW_PADDING > getVisualOffsetTop()) {
+        floating2.scrollTop -= nextMaxHeight - currentMaxHeight + getFloatingPadding(floating2);
+      }
+      return currentTop - nextTop;
+    }
+  }, [middlewareType]);
+  const touchPageYRef = React.useRef(null);
+  const handleWheel = React.useCallback((event) => {
+    var _a2, _b;
+    const pinching = event.ctrlKey;
+    const currentTarget = event.currentTarget;
+    function isWheelEvent(event2) {
+      return typeof event2.deltaY === "number";
+    }
+    __name(isWheelEvent, "isWheelEvent");
+    function isTouchEvent(event2) {
+      return event2.touches != null;
+    }
+    __name(isTouchEvent, "isTouchEvent");
+    if (Math.abs(((_a2 = currentTarget == null ? void 0 : currentTarget.offsetHeight) != null ? _a2 : 0) - (visualViewport.height - WINDOW_PADDING * 2)) > 1 && !pinching) {
+      event.preventDefault();
+    } else if (isWheelEvent(event) && isFirefox) {
+      currentTarget.scrollTop += event.deltaY;
+    }
+    if (!pinching) {
+      let delta = 5;
+      if (isTouchEvent(event)) {
+        const currentPageY = touchPageYRef.current;
+        const pageY = (_b = event.touches[0]) == null ? void 0 : _b.pageY;
+        if (pageY != null) {
+          touchPageYRef.current = pageY;
+          if (currentPageY != null) {
+            delta = currentPageY - pageY;
+          }
+        }
+      }
+      increaseHeight(currentTarget, isWheelEvent(event) ? event.deltaY : delta);
+      setScrollTop(currentTarget.scrollTop);
+      forceUpdate();
+    }
+  }, [increaseHeight, forceUpdate]);
+  React.useEffect(() => {
+    function onTouchEnd() {
+      touchPageYRef.current = null;
+    }
+    __name(onTouchEnd, "onTouchEnd");
+    const floating2 = floatingRef.current;
+    if (open && floating2 && middlewareType === "align") {
+      floating2.addEventListener("wheel", handleWheel);
+      floating2.addEventListener("touchmove", handleWheel);
+      floating2.addEventListener("touchend", onTouchEnd, { passive: true });
+      return () => {
+        floating2.removeEventListener("wheel", handleWheel);
+        floating2.removeEventListener("touchmove", handleWheel);
+        floating2.removeEventListener("touchend", onTouchEnd);
+      };
+    }
+  }, [open, floatingRef, handleWheel, middlewareType]);
+  React.useEffect(() => {
+    window.addEventListener("resize", update);
+    return () => {
+      window.removeEventListener("resize", update);
+    };
+  }, [update]);
+  React.useLayoutEffect(() => {
+    var _a2, _b, _c;
+    const floating2 = floatingRef.current;
+    if (open && controlledScrolling && floating2) {
+      const item = activeIndex != null ? listItemsRef.current[activeIndex] : selectedIndex != null ? listItemsRef.current[selectedIndex] : null;
+      if (item && prevActiveIndex != null) {
+        const itemHeight = (_b = (_a2 = listItemsRef.current[prevActiveIndex]) == null ? void 0 : _a2.offsetHeight) != null ? _b : 0;
+        const floatingHeight = floating2.offsetHeight;
+        const top = item.offsetTop;
+        const bottom = top + itemHeight;
+        if (top < floating2.scrollTop + 20) {
+          const diff = floating2.scrollTop - top + 20;
+          floating2.scrollTop -= diff;
+          if (activeIndex != selectedIndex && activeIndex != null) {
+            increaseHeight(floating2, -diff);
+          }
+        } else if (bottom > floatingHeight + floating2.scrollTop - 20) {
+          const diff = bottom - floatingHeight - floating2.scrollTop + 20;
+          floating2.scrollTop += diff;
+          if (activeIndex != selectedIndex && activeIndex != null) {
+            floating2.scrollTop -= (_c = increaseHeight(floating2, diff)) != null ? _c : 0;
+          }
+        }
+      }
+    }
+  }, [
+    open,
+    controlledScrolling,
+    prevActiveIndex,
+    activeIndex,
+    selectedIndex,
+    floatingRef,
+    increaseHeight
+  ]);
+  React.useLayoutEffect(() => {
+    var _a2;
+    const floating2 = refs.floating.current;
+    const reference2 = refs.reference.current;
+    if (open && floating2 && reference2 && floating2.offsetHeight < floating2.scrollHeight) {
+      const referenceRect = reference2.getBoundingClientRect();
+      if (middlewareType === "fallback") {
+        const item = listItemsRef.current[selectedIndex];
+        if (item) {
+          floating2.scrollTop = item.offsetTop - floating2.clientHeight + referenceRect.height;
+        }
+        return;
+      }
+      floating2.scrollTop = (_a2 = middlewareData.size) == null ? void 0 : _a2.y;
+      const closeToBottom = visualViewport.height + getVisualOffsetTop() - referenceRect.bottom < FALLBACK_THRESHOLD;
+      const closeToTop = referenceRect.top < FALLBACK_THRESHOLD;
+      if (floating2.offsetHeight < MIN_HEIGHT || closeToTop || closeToBottom) {
+        setMiddlewareType("fallback");
+      }
+    }
+  }, [
+    open,
+    increaseHeight,
+    selectedIndex,
+    middlewareType,
+    refs.floating,
+    refs.reference,
+    middlewareData
+  ]);
+  React.useLayoutEffect(() => {
+    console.log("focusin", selectedIndex, listItemsRef.current[selectedIndex], listItemsRef.current);
+    if (open && selectedIndex != null) {
+      requestAnimationFrame(() => {
+        var _a2;
+        (_a2 = listItemsRef.current[selectedIndex]) == null ? void 0 : _a2.focus({ preventScroll: true });
+      });
+    }
+  }, [listItemsRef, selectedIndex, open]);
+  React.useEffect(() => {
+    const frame = requestAnimationFrame(() => {
+      setShowArrows(open);
+      if (!open) {
+        setScrollTop(0);
+        setMiddlewareType("align");
+        setActiveIndex(null);
+        setControlledScrolling(false);
+      }
+    });
+    return () => cancelAnimationFrame(frame);
+  }, [open]);
+  const [valueNode, setValueNode] = React.useState(null);
+  const [valueNodeHasChildren, setValueNodeHasChildren] = React.useState(false);
+  return /* @__PURE__ */ React.createElement(SelectProvider, {
+    scope: __scopeSelect,
+    increaseHeight,
+    forceUpdate,
+    floatingRef,
+    valueNode,
+    onValueNodeChange: setValueNode,
+    valueNodeHasChildren,
+    onValueNodeHasChildrenChange: setValueNodeHasChildren,
+    interactions: {
+      ...interactions,
+      getReferenceProps() {
+        return interactions.getReferenceProps({
+          ref: reference,
+          className: "SelectTrigger",
+          onKeyDown(event) {
+            if (event.key === "Enter" || event.key === " " && !context.dataRef.current.typing) {
+              event.preventDefault();
+              setOpen(true);
+            }
+          }
+        });
+      },
+      getFloatingProps() {
+        return interactions.getFloatingProps({
+          ref: floating,
+          className: "Select",
+          style: {
+            position: strategy,
+            top: y != null ? y : "",
+            left: x != null ? x : ""
+          },
+          onPointerEnter() {
+            setControlledScrolling(false);
+          },
+          onPointerMove() {
+            setControlledScrolling(false);
+          },
+          onKeyDown() {
+            setControlledScrolling(true);
+          },
+          onScroll(event) {
+            setScrollTop(event.currentTarget.scrollTop);
+          }
+        });
+      }
+    },
+    floatingContext: context,
+    activeIndex,
+    canScrollDown: !!showDownArrow,
+    canScrollUp: !!showUpArrow,
+    controlledScrolling: true,
+    dataRef: context.dataRef,
+    listRef: listItemsRef,
+    onChange: setValue,
+    selectedIndex: 0,
+    setActiveIndex,
+    setOpen,
+    setSelectedIndex,
+    value,
+    open
+  }, children);
+}, {
+  Content: SelectContent,
+  Group: SelectGroup,
+  Icon: SelectIcon,
+  Item: SelectItem,
+  ItemIndicator: SelectItemIndicator,
+  ItemText: SelectItemText,
+  Label: SelectLabel,
+  ScrollDownButton: SelectScrollDownButton,
+  ScrollUpButton: SelectScrollUpButton,
+  Trigger: SelectTrigger,
+  Value: SelectValue,
+  Viewport: SelectViewport
 });
+Select.displayName = SELECT_NAME;
 export {
   Select,
-  SelectContent,
-  SelectGroup,
   SelectIcon,
-  SelectItem,
-  SelectItemIndicator,
-  SelectItemText,
-  SelectLabel,
-  SelectScrollDownButton,
-  SelectScrollUpButton,
   SelectSeparator,
   SelectTrigger,
-  SelectValue,
+  SelectViewportFrame,
   createSelectScope
 };
 //# sourceMappingURL=Select.js.map