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

package/dist/jsx/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,58 +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 <SelectProvider scope={__scopeSelect} open={open}>{children}</SelectProvider>;
-}, "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 {
@@ -85,217 +68,679 @@ 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 <Primitive.button type="button" role="combobox" aria-controls={context.contentId} aria-expanded={context.open} aria-autocomplete="none" dir={context.dir} disabled={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();
-    }
-  })} />;
+  return <Button componentName={TRIGGER_NAME} aria-expanded={context.open} aria-autocomplete="none" disabled={disabled} data-disabled={disabled ? "" : void 0} {...triggerProps} 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 <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 <XStack aria-hidden {...iconProps} ref={forwardedRef}>{children || "\u25BC"}</XStack>;
+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 <SelectValueFrame ref={composedRefs} pointerEvents="none">{context.value === void 0 && placeholder !== void 0 ? placeholder : children}</SelectValueFrame>;
+}));
+SelectValue.displayName = VALUE_NAME;
+const SelectIcon = styled(XStack, {
+  name: "SelectIcon",
+  "aria-hidden": true,
+  children: <Paragraph>{"\u25BC"}</Paragraph>
 });
-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 <FloatingPortal>{context.open ? <FloatingOverlay lockScroll>{children}</FloatingOverlay> : <div style={{ display: "none" }}>{children}</div>}</FloatingPortal>;
 });
-const GROUP_NAME = "SelectGroup";
-const [SelectGroupContextProvider, useSelectGroupContext] = createSelectContext(GROUP_NAME);
-const SelectGroup = React.forwardRef((props, forwardedRef) => {
-  const { __scopeSelect, ...groupProps } = props;
-  const groupId = useId();
-  return <SelectGroupContextProvider scope={__scopeSelect} id={groupId}><Primitive.div role="group" aria-labelledby={groupId} {...groupProps} ref={forwardedRef} /></SelectGroupContextProvider>;
+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 <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 <>
+    <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}`
+    }} />
+    <FloatingFocusManager context={context.floatingContext} preventTabbing><div {...context.interactions.getFloatingProps()}><SelectViewportFrame data-radix-select-viewport="" role="presentation" {...viewportProps} ref={composedRefs}>{children}</SelectViewportFrame></div></FloatingFocusManager>
+  </>;
 });
-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");
-  return <SelectItemContextProvider scope={__scopeSelect} value={value} textId={textId} isSelected={isSelected} onItemTextChange={React.useCallback((node) => {
-    setTextValue((prevTextValue) => {
-      var _a;
-      return prevTextValue || ((_a = node == null ? void 0 : node.textContent) != null ? _a : "").trim();
-    });
-  }, [])}><Collection.ItemSlot scope={__scopeSelect} value={value} disabled={disabled} textValue={textValue}><Primitive.div role="option" aria-labelledby={textId} aria-selected={isSelected && isFocused} data-state={isSelected ? "active" : "inactive"} aria-disabled={disabled || void 0} 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();
+  });
+  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 {
-      event.currentTarget.focus({ preventScroll: true });
+      setAllowMouseUp(false);
     }
-  })} 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 === " ")
+  }, [open, index, setActiveIndex, selectedIndex]);
+  function handleKeyDown(event) {
+    console.log("item key down");
+    if (event.key === "Enter" || event.key === " " && !dataRef.current.typing) {
       event.preventDefault();
-  })} /></Collection.ItemSlot></SelectItemContextProvider>;
+      handleSelect();
+    }
+  }
+  __name(handleKeyDown, "handleKeyDown");
+  const selectItemProps = context.interactions.getItemProps({
+    onClick: allowMouseUp ? handleSelect : void 0,
+    onMouseUp: allowMouseUp ? handleSelect : void 0,
+    onKeyDown: handleKeyDown
+  });
+  return <SelectItemContextProvider scope={__scopeSelect} value={value} textId={textId || ""} isSelected={isSelected} onItemTextChange={React.useCallback((node) => {
+  }, [])}><SelectItemFrame ref={composedRefs} aria-labelledby={textId} aria-selected={isSelected && isFocused} data-state={isSelected ? "active" : "inactive"} aria-disabled={disabled || void 0} data-disabled={disabled ? "" : void 0} tabIndex={disabled ? void 0 : -1} {...itemProps} {...selectItemProps} /></SelectItemContextProvider>;
 });
 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);
+  const composedRefs = useComposedRefs(forwardedRef, ref, itemContext.onItemTextChange);
   return <>
-    <Primitive.span id={itemContext.textId} {...itemTextProps} ref={composedRefs} />
+    <SelectItemTextFrame id={itemContext.textId} {...itemTextProps} ref={composedRefs} />
     {itemContext.isSelected && context.valueNode && !context.valueNodeHasChildren ? ReactDOM.createPortal(itemTextProps.children, context.valueNode) : null}
-    {context.bubbleSelect ? ReactDOM.createPortal(<option value={itemContext.value}>{(_a = ref.current) == null ? void 0 : _a.textContent}</option>, context.bubbleSelect) : 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 ? <Primitive.span aria-hidden {...itemIndicatorProps} ref={forwardedRef} /> : null;
+  return itemContext.isSelected ? <SelectItemIndicatorFrame aria-hidden {...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 <SelectGroupContextProvider scope={__scopeSelect} id={groupId || ""}><SelectGroupFrame role="group" aria-labelledby={groupId} {...groupProps} ref={forwardedRef} /></SelectGroupContextProvider>;
+});
+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 <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 ? <SelectScrollButtonImpl {...props} ref={composedRefs} onAutoScroll={() => {
-    const { viewport, selectedItem } = contentContext;
-    if (viewport && selectedItem) {
-      viewport.scrollTop = viewport.scrollTop - selectedItem.offsetHeight;
-    }
-  }} /> : null;
+  return <SelectScrollButtonImpl componentName={SCROLL_UP_BUTTON_NAME} {...props} 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 ? <SelectScrollButtonImpl {...props} ref={composedRefs} onAutoScroll={() => {
-    const { viewport, selectedItem } = contentContext;
-    if (viewport && selectedItem) {
-      viewport.scrollTop = viewport.scrollTop + selectedItem.offsetHeight;
-    }
-  }} /> : null;
+  return <SelectScrollButtonImpl componentName={SCROLL_DOWN_BUTTON_NAME} {...props} 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 <Primitive.div aria-hidden {...scrollIndicatorProps} ref={forwardedRef} style={{ flexShrink: 0, ...scrollIndicatorProps.style }} onPointerMove={composeEventHandlers(scrollIndicatorProps.onPointerMove, () => {
-    contentContext.onItemLeave();
-    if (autoScrollTimerRef.current === null) {
-      autoScrollTimerRef.current = window.setInterval(onAutoScroll, 50);
+  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 <YStack ref={composedRefs} componentName={componentName} aria-hidden {...scrollIndicatorProps} 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;
+    }
+    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();
     }
-  }, [prevValue, value]);
-  return null;
-  return <VisuallyHidden asChild><select {...selectProps} ref={composedRefs} defaultValue={value} /></VisuallyHidden>;
+  }, [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 <SelectProvider scope={__scopeSelect} increaseHeight={increaseHeight} forceUpdate={forceUpdate} floatingRef={floatingRef} valueNode={valueNode} onValueNodeChange={setValueNode} valueNodeHasChildren={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={activeIndex} canScrollDown={!!showDownArrow} canScrollUp={!!showUpArrow} controlledScrolling dataRef={context.dataRef} listRef={listItemsRef} onChange={setValue} selectedIndex={0} setActiveIndex={setActiveIndex} setOpen={setOpen} setSelectedIndex={setSelectedIndex} value={value} open={open}>{children}</SelectProvider>;
+}, {
+  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
 };