dune-react 0.0.1 → 0.0.3

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/select/positioner/SelectPositioner.js

@@ -0,0 +1,206 @@
+import * as React from "react";
+import { inertValue } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/inertValue.js";
+import { useIsoLayoutEffect } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/useIsoLayoutEffect.js";
+import { useScrollLock } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/useScrollLock.js";
+import { useStableCallback } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/useStableCallback.js";
+import { useSelectRootContext, useSelectFloatingContext } from "../root/SelectRootContext.js";
+import { CompositeList } from "../../composite/list/CompositeList.js";
+import { popupStateMapping } from "../../utils/popupStateMapping.js";
+import { useAnchorPositioning } from "../../utils/useAnchorPositioning.js";
+import { SelectPositionerContext } from "./SelectPositionerContext.js";
+import { InternalBackdrop } from "../../utils/InternalBackdrop.js";
+import { useRenderElement } from "../../utils/useRenderElement.js";
+import { DROPDOWN_COLLISION_AVOIDANCE } from "../../utils/constants.js";
+import { getDisabledMountTransitionStyles } from "../../utils/getDisabledMountTransitionStyles.js";
+import { clearStyles } from "../popup/utils.js";
+import { selectors } from "../store.js";
+import { createChangeEventDetails } from "../../utils/createBaseUIEventDetails.js";
+import { findItemIndex, selectedValueIncludes } from "../../utils/itemEquality.js";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useStore } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/store/useStore.js";
+import { none } from "../../utils/reason-parts.js";
+const FIXED = {
+  position: "fixed"
+};
+const SelectPositioner = /* @__PURE__ */ React.forwardRef(function SelectPositioner2(componentProps, forwardedRef) {
+  const {
+    anchor,
+    positionMethod = "absolute",
+    className,
+    render,
+    side = "bottom",
+    align = "center",
+    sideOffset = 0,
+    alignOffset = 0,
+    collisionBoundary = "clipping-ancestors",
+    collisionPadding,
+    arrowPadding = 5,
+    sticky = false,
+    disableAnchorTracking,
+    alignItemWithTrigger = true,
+    collisionAvoidance = DROPDOWN_COLLISION_AVOIDANCE,
+    ...elementProps
+  } = componentProps;
+  const {
+    store,
+    listRef,
+    labelsRef,
+    alignItemWithTriggerActiveRef,
+    selectedItemTextRef,
+    valuesRef,
+    initialValueRef,
+    popupRef,
+    setValue
+  } = useSelectRootContext();
+  const floatingRootContext = useSelectFloatingContext();
+  const open = useStore(store, selectors.open);
+  const mounted = useStore(store, selectors.mounted);
+  const modal = useStore(store, selectors.modal);
+  const value = useStore(store, selectors.value);
+  const openMethod = useStore(store, selectors.openMethod);
+  const positionerElement = useStore(store, selectors.positionerElement);
+  const triggerElement = useStore(store, selectors.triggerElement);
+  const isItemEqualToValue = useStore(store, selectors.isItemEqualToValue);
+  const transitionStatus = useStore(store, selectors.transitionStatus);
+  const scrollUpArrowRef = React.useRef(null);
+  const scrollDownArrowRef = React.useRef(null);
+  const [controlledAlignItemWithTrigger, setControlledAlignItemWithTrigger] = React.useState(alignItemWithTrigger);
+  const alignItemWithTriggerActive = mounted && controlledAlignItemWithTrigger && openMethod !== "touch";
+  if (!mounted && controlledAlignItemWithTrigger !== alignItemWithTrigger) {
+    setControlledAlignItemWithTrigger(alignItemWithTrigger);
+  }
+  useIsoLayoutEffect(() => {
+    if (!mounted) {
+      if (selectors.scrollUpArrowVisible(store.state)) {
+        store.set("scrollUpArrowVisible", false);
+      }
+      if (selectors.scrollDownArrowVisible(store.state)) {
+        store.set("scrollDownArrowVisible", false);
+      }
+    }
+  }, [store, mounted]);
+  React.useImperativeHandle(alignItemWithTriggerActiveRef, () => alignItemWithTriggerActive);
+  useScrollLock((alignItemWithTriggerActive || modal) && open && openMethod !== "touch", triggerElement);
+  const positioning = useAnchorPositioning({
+    anchor,
+    floatingRootContext,
+    positionMethod,
+    mounted,
+    side,
+    sideOffset,
+    align,
+    alignOffset,
+    arrowPadding,
+    collisionBoundary,
+    collisionPadding,
+    sticky,
+    disableAnchorTracking: disableAnchorTracking ?? alignItemWithTriggerActive,
+    collisionAvoidance,
+    keepMounted: true
+  });
+  const renderedSide = alignItemWithTriggerActive ? "none" : positioning.side;
+  const positionerStyles = alignItemWithTriggerActive ? FIXED : positioning.positionerStyles;
+  const defaultProps = React.useMemo(() => {
+    const hiddenStyles = {};
+    if (!open) {
+      hiddenStyles.pointerEvents = "none";
+    }
+    return {
+      role: "presentation",
+      hidden: !mounted,
+      style: {
+        ...positionerStyles,
+        ...hiddenStyles
+      }
+    };
+  }, [open, mounted, positionerStyles]);
+  const state = {
+    open,
+    side: renderedSide,
+    align: positioning.align,
+    anchorHidden: positioning.anchorHidden
+  };
+  const setPositionerElement = useStableCallback((element2) => {
+    store.set("positionerElement", element2);
+  });
+  const element = useRenderElement("div", componentProps, {
+    ref: [forwardedRef, setPositionerElement],
+    state,
+    stateAttributesMapping: popupStateMapping,
+    props: [defaultProps, getDisabledMountTransitionStyles(transitionStatus), elementProps]
+  });
+  const prevMapSizeRef = React.useRef(0);
+  const onMapChange = useStableCallback((map) => {
+    if (map.size === 0 && prevMapSizeRef.current === 0) {
+      return;
+    }
+    if (valuesRef.current.length === 0) {
+      return;
+    }
+    const prevSize = prevMapSizeRef.current;
+    prevMapSizeRef.current = map.size;
+    if (map.size === prevSize) {
+      return;
+    }
+    const eventDetails = createChangeEventDetails(none);
+    if (prevSize !== 0 && !store.state.multiple && value !== null) {
+      const selectedValueIndex = findItemIndex(valuesRef.current, value, isItemEqualToValue);
+      if (selectedValueIndex === -1) {
+        const initialSelectedValue = initialValueRef.current;
+        const hasInitial = initialSelectedValue != null && findItemIndex(valuesRef.current, initialSelectedValue, isItemEqualToValue) !== -1;
+        const nextValue = hasInitial ? initialSelectedValue : null;
+        setValue(nextValue, eventDetails);
+        if (nextValue === null) {
+          store.set("selectedIndex", null);
+          selectedItemTextRef.current = null;
+        }
+      }
+    }
+    if (prevSize !== 0 && store.state.multiple && Array.isArray(value)) {
+      const hasVisibleItem = (selectedItemValue) => findItemIndex(valuesRef.current, selectedItemValue, isItemEqualToValue) !== -1;
+      const nextValue = value.filter((selectedItemValue) => hasVisibleItem(selectedItemValue));
+      if (nextValue.length !== value.length || nextValue.some((selectedItemValue) => !selectedValueIncludes(value, selectedItemValue, isItemEqualToValue))) {
+        setValue(nextValue, eventDetails);
+        if (nextValue.length === 0) {
+          store.set("selectedIndex", null);
+          selectedItemTextRef.current = null;
+        }
+      }
+    }
+    if (open && alignItemWithTriggerActive) {
+      store.update({
+        scrollUpArrowVisible: false,
+        scrollDownArrowVisible: false
+      });
+      const stylesToClear = {
+        height: ""
+      };
+      clearStyles(positionerElement, stylesToClear);
+      clearStyles(popupRef.current, stylesToClear);
+    }
+  });
+  const contextValue = React.useMemo(() => ({
+    ...positioning,
+    side: renderedSide,
+    alignItemWithTriggerActive,
+    setControlledAlignItemWithTrigger,
+    scrollUpArrowRef,
+    scrollDownArrowRef
+  }), [positioning, renderedSide, alignItemWithTriggerActive, setControlledAlignItemWithTrigger]);
+  return /* @__PURE__ */ jsx(CompositeList, {
+    elementsRef: listRef,
+    labelsRef,
+    onMapChange,
+    children: /* @__PURE__ */ jsxs(SelectPositionerContext.Provider, {
+      value: contextValue,
+      children: [mounted && modal && /* @__PURE__ */ jsx(InternalBackdrop, {
+        inert: inertValue(!open),
+        cutout: triggerElement
+      }), element]
+    })
+  });
+});
+if (process.env.NODE_ENV !== "production") SelectPositioner.displayName = "SelectPositioner";
+export {
+  SelectPositioner
+};

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/select/positioner/SelectPositionerContext.js

@@ -0,0 +1,15 @@
+import formatErrorMessage from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/formatErrorMessage.js";
+import * as React from "react";
+const SelectPositionerContext = /* @__PURE__ */ React.createContext(void 0);
+if (process.env.NODE_ENV !== "production") SelectPositionerContext.displayName = "SelectPositionerContext";
+function useSelectPositionerContext() {
+  const context = React.useContext(SelectPositionerContext);
+  if (!context) {
+    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: SelectPositionerContext is missing. SelectPositioner parts must be placed within <Select.Positioner>." : formatErrorMessage(59));
+  }
+  return context;
+}
+export {
+  SelectPositionerContext,
+  useSelectPositionerContext
+};

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/select/root/SelectRoot.js

@@ -0,0 +1,455 @@
+import * as React from "react";
+import { visuallyHiddenInput, visuallyHidden } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/visuallyHidden.js";
+import { useMergedRefs } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/useMergedRefs.js";
+import { useRefWithInit } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/useRefWithInit.js";
+import { useOnFirstRender } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/useOnFirstRender.js";
+import { useControlled } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/useControlled.js";
+import { useIsoLayoutEffect } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/useIsoLayoutEffect.js";
+import { useStableCallback } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/useStableCallback.js";
+import { useValueAsRef } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/useValueAsRef.js";
+import { SelectRootContext, SelectFloatingContext } from "./SelectRootContext.js";
+import { useFieldRootContext } from "../../field/root/FieldRootContext.js";
+import { useLabelableId } from "../../labelable-provider/useLabelableId.js";
+import { useTransitionStatus } from "../../utils/useTransitionStatus.js";
+import { selectors } from "../store.js";
+import { createChangeEventDetails } from "../../utils/createBaseUIEventDetails.js";
+import { useOpenChangeComplete } from "../../utils/useOpenChangeComplete.js";
+import { useFormContext } from "../../form/FormContext.js";
+import { useField } from "../../field/useField.js";
+import { stringifyAsValue } from "../../utils/resolveValueLabel.js";
+import { defaultItemEquality, findItemIndex } from "../../utils/itemEquality.js";
+import { useValueChanged } from "../../utils/useValueChanged.js";
+import { useOpenInteractionType } from "../../utils/useOpenInteractionType.js";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useFloatingRootContext } from "../../floating-ui-react/hooks/useFloatingRootContext.js";
+import { useClick } from "../../floating-ui-react/hooks/useClick.js";
+import { useDismiss } from "../../floating-ui-react/hooks/useDismiss.js";
+import { useListNavigation } from "../../floating-ui-react/hooks/useListNavigation.js";
+import { useTypeahead } from "../../floating-ui-react/hooks/useTypeahead.js";
+import { useInteractions } from "../../floating-ui-react/hooks/useInteractions.js";
+import { EMPTY_ARRAY, EMPTY_OBJECT } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/empty.js";
+import { useStore } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/store/useStore.js";
+import { mergeProps } from "../../merge-props/mergeProps.js";
+import { none, focusOut, outsidePress } from "../../utils/reason-parts.js";
+import { Store } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/store/Store.js";
+function SelectRoot(props) {
+  const {
+    id,
+    value: valueProp,
+    defaultValue = null,
+    onValueChange,
+    open: openProp,
+    defaultOpen = false,
+    onOpenChange,
+    name: nameProp,
+    autoComplete,
+    disabled: disabledProp = false,
+    readOnly = false,
+    required = false,
+    modal = true,
+    actionsRef,
+    inputRef,
+    onOpenChangeComplete,
+    items,
+    multiple = false,
+    itemToStringLabel,
+    itemToStringValue,
+    isItemEqualToValue = defaultItemEquality,
+    highlightItemOnHover = true,
+    children
+  } = props;
+  const {
+    clearErrors
+  } = useFormContext();
+  const {
+    setDirty,
+    setTouched,
+    setFocused,
+    shouldValidateOnChange,
+    validityData,
+    setFilled,
+    name: fieldName,
+    disabled: fieldDisabled,
+    validation,
+    validationMode
+  } = useFieldRootContext();
+  const generatedId = useLabelableId({
+    id
+  });
+  const disabled = fieldDisabled || disabledProp;
+  const name = fieldName ?? nameProp;
+  const [value, setValueUnwrapped] = useControlled({
+    controlled: valueProp,
+    default: multiple ? defaultValue ?? EMPTY_ARRAY : defaultValue,
+    name: "Select",
+    state: "value"
+  });
+  const [open, setOpenUnwrapped] = useControlled({
+    controlled: openProp,
+    default: defaultOpen,
+    name: "Select",
+    state: "open"
+  });
+  const listRef = React.useRef([]);
+  const labelsRef = React.useRef([]);
+  const popupRef = React.useRef(null);
+  const scrollHandlerRef = React.useRef(null);
+  const scrollArrowsMountedCountRef = React.useRef(0);
+  const valueRef = React.useRef(null);
+  const valuesRef = React.useRef([]);
+  const typingRef = React.useRef(false);
+  const keyboardActiveRef = React.useRef(false);
+  const selectedItemTextRef = React.useRef(null);
+  const selectionRef = React.useRef({
+    allowSelectedMouseUp: false,
+    allowUnselectedMouseUp: false
+  });
+  const alignItemWithTriggerActiveRef = React.useRef(false);
+  const {
+    mounted,
+    setMounted,
+    transitionStatus
+  } = useTransitionStatus(open);
+  const {
+    openMethod,
+    triggerProps: interactionTypeProps
+  } = useOpenInteractionType(open);
+  const store = useRefWithInit(() => new Store({
+    id: generatedId,
+    labelId: void 0,
+    modal,
+    multiple,
+    itemToStringLabel,
+    itemToStringValue,
+    isItemEqualToValue,
+    value,
+    open,
+    mounted,
+    transitionStatus,
+    items,
+    forceMount: false,
+    openMethod: null,
+    activeIndex: null,
+    selectedIndex: null,
+    popupProps: {},
+    triggerProps: {},
+    triggerElement: null,
+    positionerElement: null,
+    listElement: null,
+    scrollUpArrowVisible: false,
+    scrollDownArrowVisible: false,
+    hasScrollArrows: false
+  })).current;
+  const activeIndex = useStore(store, selectors.activeIndex);
+  const selectedIndex = useStore(store, selectors.selectedIndex);
+  const triggerElement = useStore(store, selectors.triggerElement);
+  const positionerElement = useStore(store, selectors.positionerElement);
+  const serializedValue = React.useMemo(() => {
+    if (multiple && Array.isArray(value) && value.length === 0) {
+      return "";
+    }
+    return stringifyAsValue(value, itemToStringValue);
+  }, [multiple, value, itemToStringValue]);
+  const fieldStringValue = React.useMemo(() => {
+    if (multiple && Array.isArray(value)) {
+      return value.map((currentValue) => stringifyAsValue(currentValue, itemToStringValue));
+    }
+    return stringifyAsValue(value, itemToStringValue);
+  }, [multiple, value, itemToStringValue]);
+  const controlRef = useValueAsRef(store.state.triggerElement);
+  useField({
+    id: generatedId,
+    commit: validation.commit,
+    value,
+    controlRef,
+    name,
+    getValue: () => fieldStringValue
+  });
+  const initialValueRef = React.useRef(value);
+  useIsoLayoutEffect(() => {
+    if (value !== initialValueRef.current) {
+      store.set("forceMount", true);
+    }
+  }, [store, value]);
+  useIsoLayoutEffect(() => {
+    setFilled(multiple ? Array.isArray(value) && value.length > 0 : value != null);
+  }, [multiple, value, setFilled]);
+  useIsoLayoutEffect(function syncSelectedIndex() {
+    if (open) {
+      return;
+    }
+    const registry = valuesRef.current;
+    if (multiple) {
+      const currentValue = Array.isArray(value) ? value : [];
+      if (currentValue.length === 0) {
+        store.set("selectedIndex", null);
+        return;
+      }
+      const lastValue = currentValue[currentValue.length - 1];
+      const lastIndex = findItemIndex(registry, lastValue, isItemEqualToValue);
+      store.set("selectedIndex", lastIndex === -1 ? null : lastIndex);
+      return;
+    }
+    const index = findItemIndex(registry, value, isItemEqualToValue);
+    store.set("selectedIndex", index === -1 ? null : index);
+  }, [multiple, open, value, valuesRef, isItemEqualToValue, store]);
+  useValueChanged(value, () => {
+    clearErrors(name);
+    setDirty(value !== validityData.initialValue);
+    if (shouldValidateOnChange()) {
+      validation.commit(value);
+    } else {
+      validation.commit(value, true);
+    }
+  });
+  const setOpen = useStableCallback((nextOpen, eventDetails) => {
+    onOpenChange == null ? void 0 : onOpenChange(nextOpen, eventDetails);
+    if (eventDetails.isCanceled) {
+      return;
+    }
+    setOpenUnwrapped(nextOpen);
+    if (!nextOpen && (eventDetails.reason === focusOut || eventDetails.reason === outsidePress)) {
+      setTouched(true);
+      setFocused(false);
+      if (validationMode === "onBlur") {
+        validation.commit(value);
+      }
+    }
+    if (!nextOpen && store.state.activeIndex !== null) {
+      const activeOption = listRef.current[store.state.activeIndex];
+      queueMicrotask(() => {
+        activeOption == null ? void 0 : activeOption.setAttribute("tabindex", "-1");
+      });
+    }
+  });
+  const handleUnmount = useStableCallback(() => {
+    setMounted(false);
+    store.set("activeIndex", null);
+    onOpenChangeComplete == null ? void 0 : onOpenChangeComplete(false);
+  });
+  useOpenChangeComplete({
+    enabled: !actionsRef,
+    open,
+    ref: popupRef,
+    onComplete() {
+      if (!open) {
+        handleUnmount();
+      }
+    }
+  });
+  React.useImperativeHandle(actionsRef, () => ({
+    unmount: handleUnmount
+  }), [handleUnmount]);
+  const setValue = useStableCallback((nextValue, eventDetails) => {
+    onValueChange == null ? void 0 : onValueChange(nextValue, eventDetails);
+    if (eventDetails.isCanceled) {
+      return;
+    }
+    setValueUnwrapped(nextValue);
+  });
+  const handleScrollArrowVisibility = useStableCallback(() => {
+    const scroller = store.state.listElement || popupRef.current;
+    if (!scroller) {
+      return;
+    }
+    const viewportTop = scroller.scrollTop;
+    const viewportBottom = scroller.scrollTop + scroller.clientHeight;
+    const shouldShowUp = viewportTop > 1;
+    const shouldShowDown = viewportBottom < scroller.scrollHeight - 1;
+    if (store.state.scrollUpArrowVisible !== shouldShowUp) {
+      store.set("scrollUpArrowVisible", shouldShowUp);
+    }
+    if (store.state.scrollDownArrowVisible !== shouldShowDown) {
+      store.set("scrollDownArrowVisible", shouldShowDown);
+    }
+  });
+  const floatingContext = useFloatingRootContext({
+    open,
+    onOpenChange: setOpen,
+    elements: {
+      reference: triggerElement,
+      floating: positionerElement
+    }
+  });
+  const click = useClick(floatingContext, {
+    enabled: !readOnly && !disabled,
+    event: "mousedown"
+  });
+  const dismiss = useDismiss(floatingContext, {
+    bubbles: false
+  });
+  const listNavigation = useListNavigation(floatingContext, {
+    enabled: !readOnly && !disabled,
+    listRef,
+    activeIndex,
+    selectedIndex,
+    disabledIndices: EMPTY_ARRAY,
+    onNavigate(nextActiveIndex) {
+      if (nextActiveIndex === null && !open) {
+        return;
+      }
+      store.set("activeIndex", nextActiveIndex);
+    },
+    // Implement our own listeners since `onPointerLeave` on each option fires while scrolling with
+    // the `alignItemWithTrigger=true`, causing a performance issue on Chrome.
+    focusItemOnHover: false
+  });
+  const typeahead = useTypeahead(floatingContext, {
+    enabled: !readOnly && !disabled && (open || !multiple),
+    listRef: labelsRef,
+    activeIndex,
+    selectedIndex,
+    onMatch(index) {
+      if (open) {
+        store.set("activeIndex", index);
+      } else {
+        setValue(valuesRef.current[index], createChangeEventDetails("none"));
+      }
+    },
+    onTypingChange(typing) {
+      typingRef.current = typing;
+    }
+  });
+  const {
+    getReferenceProps,
+    getFloatingProps,
+    getItemProps
+  } = useInteractions([click, dismiss, listNavigation, typeahead]);
+  const mergedTriggerProps = React.useMemo(() => {
+    return mergeProps(getReferenceProps(), interactionTypeProps, generatedId ? {
+      id: generatedId
+    } : EMPTY_OBJECT);
+  }, [getReferenceProps, interactionTypeProps, generatedId]);
+  useOnFirstRender(() => {
+    store.update({
+      popupProps: getFloatingProps(),
+      triggerProps: mergedTriggerProps
+    });
+  });
+  useIsoLayoutEffect(() => {
+    store.update({
+      id: generatedId,
+      modal,
+      multiple,
+      value,
+      open,
+      mounted,
+      transitionStatus,
+      popupProps: getFloatingProps(),
+      triggerProps: mergedTriggerProps,
+      items,
+      itemToStringLabel,
+      itemToStringValue,
+      isItemEqualToValue,
+      openMethod
+    });
+  }, [store, generatedId, modal, multiple, value, open, mounted, transitionStatus, getFloatingProps, mergedTriggerProps, items, itemToStringLabel, itemToStringValue, isItemEqualToValue, openMethod]);
+  const contextValue = React.useMemo(() => ({
+    store,
+    name,
+    required,
+    disabled,
+    readOnly,
+    multiple,
+    itemToStringLabel,
+    itemToStringValue,
+    highlightItemOnHover,
+    setValue,
+    setOpen,
+    listRef,
+    popupRef,
+    scrollHandlerRef,
+    handleScrollArrowVisibility,
+    scrollArrowsMountedCountRef,
+    getItemProps,
+    events: floatingContext.context.events,
+    valueRef,
+    valuesRef,
+    labelsRef,
+    typingRef,
+    selectionRef,
+    selectedItemTextRef,
+    validation,
+    onOpenChangeComplete,
+    keyboardActiveRef,
+    alignItemWithTriggerActiveRef,
+    initialValueRef
+  }), [store, name, required, disabled, readOnly, multiple, itemToStringLabel, itemToStringValue, highlightItemOnHover, setValue, setOpen, getItemProps, floatingContext.context.events, validation, onOpenChangeComplete, handleScrollArrowVisibility]);
+  const ref = useMergedRefs(inputRef, validation.inputRef);
+  const hasMultipleSelection = multiple && Array.isArray(value) && value.length > 0;
+  const hiddenInputName = multiple ? void 0 : name;
+  const hiddenInputs = React.useMemo(() => {
+    if (!multiple || !Array.isArray(value) || !name) {
+      return null;
+    }
+    return value.map((v) => {
+      const currentSerializedValue = stringifyAsValue(v, itemToStringValue);
+      return /* @__PURE__ */ jsx("input", {
+        type: "hidden",
+        name,
+        value: currentSerializedValue
+      }, currentSerializedValue);
+    });
+  }, [multiple, value, name, itemToStringValue]);
+  return /* @__PURE__ */ jsx(SelectRootContext.Provider, {
+    value: contextValue,
+    children: /* @__PURE__ */ jsxs(SelectFloatingContext.Provider, {
+      value: floatingContext,
+      children: [children, /* @__PURE__ */ jsx("input", {
+        ...validation.getInputValidationProps({
+          onFocus() {
+            var _a;
+            (_a = store.state.triggerElement) == null ? void 0 : _a.focus({
+              // Supported in Chrome from 144 (January 2026)
+              // @ts-expect-error - focusVisible is not yet in the lib.dom.d.ts
+              focusVisible: true
+            });
+          },
+          // Handle browser autofill.
+          onChange(event) {
+            if (event.nativeEvent.defaultPrevented) {
+              return;
+            }
+            const nextValue = event.target.value;
+            const details = createChangeEventDetails(none, event.nativeEvent);
+            function handleChange() {
+              if (multiple) {
+                return;
+              }
+              const matchingValue = valuesRef.current.find((v) => {
+                const candidate = stringifyAsValue(v, itemToStringValue);
+                if (candidate.toLowerCase() === nextValue.toLowerCase()) {
+                  return true;
+                }
+                return false;
+              });
+              if (matchingValue != null) {
+                setDirty(matchingValue !== validityData.initialValue);
+                setValue(matchingValue, details);
+                if (shouldValidateOnChange()) {
+                  validation.commit(matchingValue);
+                }
+              }
+            }
+            store.set("forceMount", true);
+            queueMicrotask(handleChange);
+          }
+        }),
+        id: generatedId && hiddenInputName == null ? `${generatedId}-hidden-input` : void 0,
+        name: hiddenInputName,
+        autoComplete,
+        value: serializedValue,
+        disabled,
+        required: required && !hasMultipleSelection,
+        readOnly,
+        ref,
+        style: name ? visuallyHiddenInput : visuallyHidden,
+        tabIndex: -1,
+        "aria-hidden": true
+      }), hiddenInputs]
+    })
+  });
+}
+export {
+  SelectRoot
+};