@base-ui/react 1.0.0 → 1.2.0

package/esm/floating-ui-react/hooks/useHoverReferenceInteraction.js

@@ -1,9 +1,12 @@
+'use client';
+
 import * as React from 'react';
 import * as ReactDOM from 'react-dom';
 import { isElement } from '@floating-ui/utils/dom';
 import { useValueAsRef } from '@base-ui/utils/useValueAsRef';
 import { useStableCallback } from '@base-ui/utils/useStableCallback';
-import { contains, getDocument, isMouseLikePointerType } from "../utils.js";
+import { ownerDocument } from '@base-ui/utils/owner';
+import { contains, isMouseLikePointerType, isTargetInsideEnabledTrigger } from "../utils.js";
 import { createChangeEventDetails } from "../../utils/createBaseUIEventDetails.js";
 import { REASONS } from "../../utils/reasons.js";
 import { getDelay } from "./useHover.js";
@@ -41,50 +44,43 @@ export function useHoverReferenceInteraction(context, props = {}) {
     isActiveTrigger = true
   } = props;
   const tree = useFloatingTree(externalTree);
-  const {
-    pointerTypeRef,
-    interactedInsideRef,
-    handlerRef: closeHandlerRef,
-    blockMouseMoveRef,
-    performedPointerEventsMutationRef,
-    unbindMouseMoveRef,
-    restTimeoutPendingRef,
-    openChangeTimeout,
-    restTimeout,
-    handleCloseOptionsRef
-  } = useHoverInteractionSharedState(store);
+  const instance = useHoverInteractionSharedState(store);
   const handleCloseRef = useValueAsRef(handleClose);
   const delayRef = useValueAsRef(delay);
   const restMsRef = useValueAsRef(restMs);
+  const enabledRef = useValueAsRef(enabled);
   if (isActiveTrigger) {
     // eslint-disable-next-line no-underscore-dangle
-    handleCloseOptionsRef.current = handleCloseRef.current?.__options;
+    instance.handleCloseOptions = handleCloseRef.current?.__options;
   }
   const isClickLikeOpenEvent = useStableCallback(() => {
-    if (interactedInsideRef.current) {
+    if (instance.interactedInside) {
       return true;
     }
     return dataRef.current.openEvent ? ['click', 'mousedown'].includes(dataRef.current.openEvent.type) : false;
   });
+  const isRelatedTargetInsideEnabledTrigger = useStableCallback(target => {
+    return isTargetInsideEnabledTrigger(target, store.context.triggerElements);
+  });
   const closeWithDelay = React.useCallback((event, runElseBranch = true) => {
-    const closeDelay = getDelay(delayRef.current, 'close', pointerTypeRef.current);
-    if (closeDelay && !closeHandlerRef.current) {
-      openChangeTimeout.start(closeDelay, () => store.setOpen(false, createChangeEventDetails(REASONS.triggerHover, event)));
+    const closeDelay = getDelay(delayRef.current, 'close', instance.pointerType);
+    if (closeDelay && !instance.handler) {
+      instance.openChangeTimeout.start(closeDelay, () => store.setOpen(false, createChangeEventDetails(REASONS.triggerHover, event)));
     } else if (runElseBranch) {
-      openChangeTimeout.clear();
+      instance.openChangeTimeout.clear();
       store.setOpen(false, createChangeEventDetails(REASONS.triggerHover, event));
     }
-  }, [delayRef, closeHandlerRef, store, pointerTypeRef, openChangeTimeout]);
+  }, [delayRef, store, instance]);
   const cleanupMouseMoveHandler = useStableCallback(() => {
-    unbindMouseMoveRef.current();
-    closeHandlerRef.current = undefined;
+    instance.unbindMouseMove();
+    instance.handler = undefined;
   });
   const clearPointerEvents = useStableCallback(() => {
-    if (performedPointerEventsMutationRef.current) {
-      const body = getDocument(store.select('domReferenceElement')).body;
+    if (instance.performedPointerEventsMutation) {
+      const body = ownerDocument(store.select('domReferenceElement')).body;
       body.style.pointerEvents = '';
       body.removeAttribute(safePolygonIdentifier);
-      performedPointerEventsMutationRef.current = false;
+      instance.performedPointerEventsMutation = false;
     }
   });
 
@@ -96,17 +92,17 @@ export function useHoverReferenceInteraction(context, props = {}) {
     }
     function onOpenChangeLocal(details) {
       if (!details.open) {
-        openChangeTimeout.clear();
-        restTimeout.clear();
-        blockMouseMoveRef.current = true;
-        restTimeoutPendingRef.current = false;
+        instance.openChangeTimeout.clear();
+        instance.restTimeout.clear();
+        instance.blockMouseMove = true;
+        instance.restTimeoutPending = false;
       }
     }
     events.on('openchange', onOpenChangeLocal);
     return () => {
       events.off('openchange', onOpenChangeLocal);
     };
-  }, [enabled, events, openChangeTimeout, restTimeout, blockMouseMoveRef, restTimeoutPendingRef]);
+  }, [enabled, events, instance]);
   const handleScrollMouseLeave = useStableCallback(event => {
     if (isClickLikeOpenEvent()) {
       return;
@@ -114,8 +110,7 @@ export function useHoverReferenceInteraction(context, props = {}) {
     if (!dataRef.current.floatingContext) {
       return;
     }
-    const triggerElements = store.context.triggerElements;
-    if (event.relatedTarget && triggerElements.hasElement(event.relatedTarget)) {
+    if (isRelatedTargetInsideEnabledTrigger(event.relatedTarget)) {
       return;
     }
     const currentTrigger = triggerElementRef.current;
@@ -142,9 +137,9 @@ export function useHoverReferenceInteraction(context, props = {}) {
       return undefined;
     }
     function onMouseEnter(event) {
-      openChangeTimeout.clear();
-      blockMouseMoveRef.current = false;
-      if (mouseOnly && !isMouseLikePointerType(pointerTypeRef.current)) {
+      instance.openChangeTimeout.clear();
+      instance.blockMouseMove = false;
+      if (mouseOnly && !isMouseLikePointerType(instance.pointerType)) {
         return;
       }
 
@@ -153,14 +148,19 @@ export function useHoverReferenceInteraction(context, props = {}) {
       if (getRestMs(restMsRef.current) > 0 && !getDelay(delayRef.current, 'open')) {
         return;
       }
-      const openDelay = getDelay(delayRef.current, 'open', pointerTypeRef.current);
+      const openDelay = getDelay(delayRef.current, 'open', instance.pointerType);
       const currentDomReference = store.select('domReferenceElement');
       const allTriggers = store.context.triggerElements;
       const isOverInactiveTrigger = (allTriggers.hasElement(event.target) || allTriggers.hasMatchingElement(t => contains(t, event.target))) && (!currentDomReference || !contains(currentDomReference, event.target));
       const triggerNode = event.currentTarget ?? null;
-      const shouldOpen = !store.select('open') || isOverInactiveTrigger;
-      if (openDelay) {
-        openChangeTimeout.start(openDelay, () => {
+      const isOpen = store.select('open');
+      const shouldOpen = !isOpen || isOverInactiveTrigger;
+
+      // When moving between triggers while already open, open immediately without delay
+      if (isOverInactiveTrigger && isOpen) {
+        store.setOpen(true, createChangeEventDetails(REASONS.triggerHover, event, triggerNode));
+      } else if (openDelay) {
+        instance.openChangeTimeout.start(openDelay, () => {
           if (shouldOpen) {
             store.setOpen(true, createChangeEventDetails(REASONS.triggerHover, event, triggerNode));
           }
@@ -174,21 +174,20 @@ export function useHoverReferenceInteraction(context, props = {}) {
         clearPointerEvents();
         return;
       }
-      unbindMouseMoveRef.current();
+      instance.unbindMouseMove();
       const domReferenceElement = store.select('domReferenceElement');
-      const doc = getDocument(domReferenceElement);
-      restTimeout.clear();
-      restTimeoutPendingRef.current = false;
-      const triggerElements = store.context.triggerElements;
-      if (event.relatedTarget && triggerElements.hasElement(event.relatedTarget)) {
+      const doc = ownerDocument(domReferenceElement);
+      instance.restTimeout.clear();
+      instance.restTimeoutPending = false;
+      if (isRelatedTargetInsideEnabledTrigger(event.relatedTarget)) {
         return;
       }
       if (handleCloseRef.current && dataRef.current.floatingContext) {
         if (!store.select('open')) {
-          openChangeTimeout.clear();
+          instance.openChangeTimeout.clear();
         }
         const currentTrigger = triggerElementRef.current;
-        closeHandlerRef.current = handleCloseRef.current({
+        instance.handler = handleCloseRef.current({
           ...dataRef.current.floatingContext,
           tree,
           x: event.clientX,
@@ -196,20 +195,20 @@ export function useHoverReferenceInteraction(context, props = {}) {
           onClose() {
             clearPointerEvents();
             cleanupMouseMoveHandler();
-            if (!isClickLikeOpenEvent() && currentTrigger === store.select('domReferenceElement')) {
+            if (enabledRef.current && !isClickLikeOpenEvent() && currentTrigger === store.select('domReferenceElement')) {
               closeWithDelay(event, true);
             }
           }
         });
-        const handler = closeHandlerRef.current;
+        const handler = instance.handler;
         handler(event);
         doc.addEventListener('mousemove', handler);
-        unbindMouseMoveRef.current = () => {
+        instance.unbindMouseMove = () => {
           doc.removeEventListener('mousemove', handler);
         };
         return;
       }
-      const shouldClose = pointerTypeRef.current === 'touch' ? !contains(store.select('floatingElement'), event.relatedTarget) : true;
+      const shouldClose = instance.pointerType === 'touch' ? !contains(store.select('floatingElement'), event.relatedTarget) : true;
       if (shouldClose) {
         closeWithDelay(event);
       }
@@ -235,10 +234,13 @@ export function useHoverReferenceInteraction(context, props = {}) {
       trigger.removeEventListener('mouseenter', onMouseEnter);
       trigger.removeEventListener('mouseleave', onMouseLeave);
     };
-  }, [cleanupMouseMoveHandler, clearPointerEvents, blockMouseMoveRef, dataRef, delayRef, closeWithDelay, store, enabled, handleCloseRef, handleScrollMouseLeave, isActiveTrigger, isClickLikeOpenEvent, mouseOnly, move, pointerTypeRef, restMsRef, restTimeout, restTimeoutPendingRef, openChangeTimeout, triggerElementRef, tree, unbindMouseMoveRef, closeHandlerRef]);
+  }, [cleanupMouseMoveHandler, clearPointerEvents, dataRef, delayRef, closeWithDelay, store, enabled, handleCloseRef, handleScrollMouseLeave, instance, isActiveTrigger, isClickLikeOpenEvent, isRelatedTargetInsideEnabledTrigger, mouseOnly, move, restMsRef, triggerElementRef, tree, enabledRef]);
   return React.useMemo(() => {
+    if (!enabled) {
+      return undefined;
+    }
     function setPointerRef(event) {
-      pointerTypeRef.current = event.pointerType;
+      instance.pointerType = event.pointerType;
     }
     return {
       onPointerDown: setPointerRef,
@@ -252,32 +254,40 @@ export function useHoverReferenceInteraction(context, props = {}) {
         const allTriggers = store.context.triggerElements;
         const currentOpen = store.select('open');
         const isOverInactiveTrigger = (allTriggers.hasElement(event.target) || allTriggers.hasMatchingElement(t => contains(t, event.target))) && (!currentDomReference || !contains(currentDomReference, event.target));
-        if (mouseOnly && !isMouseLikePointerType(pointerTypeRef.current)) {
+        if (mouseOnly && !isMouseLikePointerType(instance.pointerType)) {
           return;
         }
         if (currentOpen && !isOverInactiveTrigger || getRestMs(restMsRef.current) === 0) {
           return;
         }
-        if (!isOverInactiveTrigger && restTimeoutPendingRef.current && event.movementX ** 2 + event.movementY ** 2 < 2) {
+        if (!isOverInactiveTrigger && instance.restTimeoutPending && event.movementX ** 2 + event.movementY ** 2 < 2) {
           return;
         }
-        restTimeout.clear();
+        instance.restTimeout.clear();
         function handleMouseMove() {
-          if (!blockMouseMoveRef.current && (!currentOpen || isOverInactiveTrigger)) {
+          instance.restTimeoutPending = false;
+
+          // A delayed hover open should not override a click-like open that happened
+          // while the hover delay was pending.
+          if (isClickLikeOpenEvent()) {
+            return;
+          }
+          const latestOpen = store.select('open');
+          if (!instance.blockMouseMove && (!latestOpen || isOverInactiveTrigger)) {
             store.setOpen(true, createChangeEventDetails(REASONS.triggerHover, nativeEvent, trigger));
           }
         }
-        if (pointerTypeRef.current === 'touch') {
+        if (instance.pointerType === 'touch') {
           ReactDOM.flushSync(() => {
             handleMouseMove();
           });
         } else if (isOverInactiveTrigger && currentOpen) {
           handleMouseMove();
         } else {
-          restTimeoutPendingRef.current = true;
-          restTimeout.start(getRestMs(restMsRef.current), handleMouseMove);
+          instance.restTimeoutPending = true;
+          instance.restTimeout.start(getRestMs(restMsRef.current), handleMouseMove);
         }
       }
     };
-  }, [blockMouseMoveRef, mouseOnly, store, pointerTypeRef, restMsRef, restTimeout, restTimeoutPendingRef]);
+  }, [enabled, instance, isClickLikeOpenEvent, mouseOnly, store, restMsRef]);
 }

package/esm/floating-ui-react/hooks/useInteractions.d.ts

@@ -2,8 +2,8 @@ import * as React from 'react';
 import type { ElementProps } from "../types.js";
 import { ACTIVE_KEY, SELECTED_KEY } from "../utils/constants.js";
 export type ExtendedUserProps = {
-  [ACTIVE_KEY]?: boolean;
-  [SELECTED_KEY]?: boolean;
+  [ACTIVE_KEY]?: boolean | undefined;
+  [SELECTED_KEY]?: boolean | undefined;
 };
 export interface UseInteractionsReturn {
   getReferenceProps: (userProps?: React.HTMLProps<Element>) => Record<string, unknown>;

package/esm/floating-ui-react/hooks/useListNavigation.d.ts

@@ -1,13 +1,13 @@
 import * as React from 'react';
 import { FloatingTreeStore } from "../components/FloatingTreeStore.js";
-import type { Dimensions, ElementProps, FloatingContext, FloatingRootContext } from "../types.js";
+import type { ElementProps, FloatingContext, FloatingRootContext } from "../types.js";
 export declare const ESCAPE = "Escape";
 export interface UseListNavigationProps {
   /**
    * A ref that holds an array of list items.
    * @default empty list
    */
-  listRef: React.MutableRefObject<Array<HTMLElement | null>>;
+  listRef: React.RefObject<Array<HTMLElement | null>>;
   /**
    * The index of the currently active (focused or highlighted) item, which may
    * or may not be selected.
@@ -18,36 +18,36 @@ export interface UseListNavigationProps {
    * A callback that is called when the user navigates to a new active item,
    * passed in a new `activeIndex`.
    */
-  onNavigate?: (activeIndex: number | null, event: React.SyntheticEvent | undefined) => void;
+  onNavigate?: ((activeIndex: number | null, event: React.SyntheticEvent | undefined) => void) | undefined;
   /**
    * Whether the Hook is enabled, including all internal Effects and event
    * handlers.
    * @default true
    */
-  enabled?: boolean;
+  enabled?: boolean | undefined;
   /**
    * The currently selected item index, which may or may not be active.
    * @default null
    */
-  selectedIndex?: number | null;
+  selectedIndex?: (number | null) | undefined;
   /**
    * Whether to focus the item upon opening the floating element. 'auto' infers
    * what to do based on the input type (keyboard vs. pointer), while a boolean
    * value will force the value.
    * @default 'auto'
    */
-  focusItemOnOpen?: boolean | 'auto';
+  focusItemOnOpen?: (boolean | 'auto') | undefined;
   /**
    * Whether hovering an item synchronizes the focus.
    * @default true
    */
-  focusItemOnHover?: boolean;
+  focusItemOnHover?: boolean | undefined;
   /**
    * Whether pressing an arrow key on the navigation’s main axis opens the
    * floating element.
    * @default true
    */
-  openOnArrowKeyDown?: boolean;
+  openOnArrowKeyDown?: boolean | undefined;
   /**
    * By default elements with either a `disabled` or `aria-disabled` attribute
    * are skipped in the list navigation — however, this requires the items to
@@ -58,7 +58,7 @@ export interface UseListNavigationProps {
    * navigating via arrow keys, specify an empty array.
    * @default undefined
    */
-  disabledIndices?: ReadonlyArray<number> | ((index: number) => boolean);
+  disabledIndices?: (ReadonlyArray<number> | ((index: number) => boolean)) | undefined;
   /**
    * Determines whether focus can escape the list, such that nothing is selected
    * after navigating beyond the boundary of the list. In some
@@ -67,32 +67,32 @@ export interface UseListNavigationProps {
    * `loopFocus` must be `true`.
    * @default false
    */
-  allowEscape?: boolean;
+  allowEscape?: boolean | undefined;
   /**
    * Determines whether focus should loop around when navigating past the first
    * or last item.
    * @default false
    */
-  loopFocus?: boolean;
+  loopFocus?: boolean | undefined;
   /**
    * If the list is nested within another one (e.g. a nested submenu), the
    * navigation semantics change.
    * @default false
    */
-  nested?: boolean;
+  nested?: boolean | undefined;
   /**
    * Allows to specify the orientation of the parent list, which is used to
    * determine the direction of the navigation.
    * This is useful when list navigation is used within a Composite,
    * as the hook can't determine the orientation of the parent list automatically.
    */
-  parentOrientation?: UseListNavigationProps['orientation'];
+  parentOrientation?: UseListNavigationProps['orientation'] | undefined;
   /**
    * Whether the direction of the floating element’s navigation is in RTL
    * layout.
    * @default false
    */
-  rtl?: boolean;
+  rtl?: boolean | undefined;
   /**
    * Whether the focus is virtual (using `aria-activedescendant`).
    * Use this if you need focus to remain on the reference element
@@ -103,12 +103,12 @@ export interface UseListNavigationProps {
    * generated automatically.
    * @default false
    */
-  virtual?: boolean;
+  virtual?: boolean | undefined;
   /**
    * The orientation in which navigation occurs.
    * @default 'vertical'
    */
-  orientation?: 'vertical' | 'horizontal' | 'both';
+  orientation?: ('vertical' | 'horizontal' | 'both') | undefined;
   /**
    * Specifies how many columns the list has (i.e., it’s a grid). Use an
    * orientation of 'horizontal' (e.g. for an emoji picker/date picker, where
@@ -117,23 +117,7 @@ export interface UseListNavigationProps {
    * and ArrowDown).
    * @default 1
    */
-  cols?: number;
-  /**
-   * Whether to scroll the active item into view when navigating. The default
-   * value uses nearest options.
-   */
-  scrollItemIntoView?: boolean | ScrollIntoViewOptions;
-  /**
-   * Only for `cols > 1`, specify sizes for grid items.
-   * `{ width: 2, height: 2 }` means an item is 2 columns wide and 2 rows tall.
-   */
-  itemSizes?: Dimensions[];
-  /**
-   * Only relevant for `cols > 1` and items with different sizes, specify if
-   * the grid is dense (as defined in the CSS spec for `grid-auto-flow`).
-   * @default false
-   */
-  dense?: boolean;
+  cols?: number | undefined;
   /**
    * The id of the root component.
    */
@@ -142,11 +126,11 @@ export interface UseListNavigationProps {
    * Whether to clear the active index when the pointer leaves an item.
    * @default true
    */
-  resetOnPointerLeave?: boolean;
+  resetOnPointerLeave?: boolean | undefined;
   /**
    * External FlatingTree to use when the one provided by context can't be used.
    */
-  externalTree?: FloatingTreeStore;
+  externalTree?: FloatingTreeStore | undefined;
 }
 /**
  * Adds arrow key-based navigation of a list of items, either using real DOM

package/esm/floating-ui-react/hooks/useListNavigation.js

@@ -1,9 +1,12 @@
+'use client';
+
 import * as React from 'react';
 import { isHTMLElement } from '@floating-ui/utils/dom';
 import { useValueAsRef } from '@base-ui/utils/useValueAsRef';
 import { useStableCallback } from '@base-ui/utils/useStableCallback';
 import { useIsoLayoutEffect } from '@base-ui/utils/useIsoLayoutEffect';
-import { activeElement, contains, getDocument, getTarget, isTypeableCombobox, isVirtualClick, isVirtualPointerEvent, stopEvent, getFloatingFocusElement, isIndexOutOfListBounds, getMinListIndex, getMaxListIndex, getGridNavigatedIndex, isListIndexDisabled, createGridCellMap, getGridCellIndices, getGridCellIndexOfCorner, findNonDisabledListIndex } from "../utils.js";
+import { ownerDocument } from '@base-ui/utils/owner';
+import { activeElement, contains, getTarget, isTypeableCombobox, isVirtualClick, isVirtualPointerEvent, stopEvent, getFloatingFocusElement, isIndexOutOfListBounds, getMinListIndex, getMaxListIndex, getGridNavigatedIndex, isListIndexDisabled, createGridCellMap, getGridCellIndices, getGridCellIndexOfCorner, findNonDisabledListIndex } from "../utils.js";
 import { useFloatingParentNodeId, useFloatingTree } from "../components/FloatingTree.js";
 import { createChangeEventDetails } from "../../utils/createBaseUIEventDetails.js";
 import { REASONS } from "../../utils/reasons.js";
@@ -72,9 +75,6 @@ export function useListNavigation(context, props) {
     orientation = 'vertical',
     parentOrientation,
     cols = 1,
-    scrollItemIntoView = true,
-    itemSizes,
-    dense = false,
     id,
     resetOnPointerLeave = true,
     externalTree
@@ -114,7 +114,6 @@ export function useListNavigation(context, props) {
   const forceScrollIntoViewRef = React.useRef(false);
   const disabledIndicesRef = useValueAsRef(disabledIndices);
   const latestOpenRef = useValueAsRef(open);
-  const scrollItemIntoViewRef = useValueAsRef(scrollItemIntoView);
   const selectedIndexRef = useValueAsRef(selectedIndex);
   const resetOnPointerLeaveRef = useValueAsRef(resetOnPointerLeave);
   const focusItem = useStableCallback(() => {
@@ -142,17 +141,16 @@ export function useListNavigation(context, props) {
       if (!initialItem) {
         runFocus(waitedItem);
       }
-      const scrollIntoViewOptions = scrollItemIntoViewRef.current;
-      const shouldScrollIntoView = scrollIntoViewOptions &&
+      const shouldScrollIntoView =
       // eslint-disable-next-line @typescript-eslint/no-use-before-define
       item && (forceScrollIntoView || !isPointerModalityRef.current);
       if (shouldScrollIntoView) {
         // JSDOM doesn't support `.scrollIntoView()` but it's widely supported
         // by all browsers.
-        waitedItem.scrollIntoView?.(typeof scrollIntoViewOptions === 'boolean' ? {
+        waitedItem.scrollIntoView?.({
           block: 'nearest',
           inline: 'nearest'
-        } : scrollIntoViewOptions);
+        });
       }
     });
   });
@@ -242,7 +240,7 @@ export function useListNavigation(context, props) {
     }
     const nodes = tree.nodesRef.current;
     const parent = nodes.find(node => node.id === parentId)?.context?.elements.floating;
-    const activeEl = activeElement(getDocument(floatingElement));
+    const activeEl = activeElement(ownerDocument(floatingElement));
     const treeContainsActiveEl = nodes.some(node => node.context && contains(node.context.elements.floating, activeEl));
     if (parent && !treeContainsActiveEl && isPointerModalityRef.current) {
       parent.focus({
@@ -303,6 +301,9 @@ export function useListNavigation(context, props) {
         if (!resetOnPointerLeaveRef.current) {
           return;
         }
+        enqueueFocus(null, {
+          sync: true
+        });
         indexRef.current = -1;
         onNavigate(event);
         if (!virtual) {
@@ -369,7 +370,7 @@ export function useListNavigation(context, props) {
 
     // Grid navigation.
     if (cols > 1) {
-      const sizes = itemSizes || Array.from({
+      const sizes = Array.from({
         length: listRef.current.length
       }, () => ({
         width: 1,
@@ -377,7 +378,7 @@ export function useListNavigation(context, props) {
       }));
       // To calculate movements on the grid, we use hypothetical cell indices
       // as if every item was 1x1, then convert back to real indices.
-      const cellMap = createGridCellMap(sizes, cols, dense);
+      const cellMap = createGridCellMap(sizes, cols, false);
       const minGridIndex = cellMap.findIndex(index => index != null && !isListIndexDisabled(listRef, index, disabledIndices));
       // last enabled index
       const maxGridIndex = cellMap.reduce((foundIndex, index, cellIndex) => index != null && !isListIndexDisabled(listRef, index, disabledIndices) ? cellIndex : foundIndex, -1);

package/esm/floating-ui-react/hooks/useRole.d.ts

@@ -2,17 +2,11 @@ import type { ElementProps, FloatingContext, FloatingRootContext } from "../type
 type AriaRole = 'tooltip' | 'dialog' | 'alertdialog' | 'menu' | 'listbox' | 'grid' | 'tree';
 type ComponentRole = 'select' | 'label' | 'combobox';
 export interface UseRoleProps {
-  /**
-   * Whether the Hook is enabled, including all internal Effects and event
-   * handlers.
-   * @default true
-   */
-  enabled?: boolean;
   /**
    * The role of the floating element.
    * @default 'dialog'
    */
-  role?: AriaRole | ComponentRole;
+  role?: (AriaRole | ComponentRole) | undefined;
 }
 /**
  * Adds base screen reader props to the reference and floating elements for a

package/esm/floating-ui-react/hooks/useRole.js

@@ -17,7 +17,6 @@ export function useRole(context, props = {}) {
   const domReference = store.useState('domReferenceElement');
   const floatingElement = store.useState('floatingElement');
   const {
-    enabled = true,
     role = 'dialog'
   } = props;
   const defaultReferenceId = useId();
@@ -105,10 +104,10 @@ export function useRole(context, props = {}) {
     }
     return {};
   }, [floatingId, role]);
-  return React.useMemo(() => enabled ? {
+  return React.useMemo(() => ({
     reference,
     floating,
     item,
     trigger
-  } : {}, [enabled, reference, floating, trigger, item]);
+  }), [reference, floating, trigger, item]);
 }

package/esm/floating-ui-react/hooks/useSyncedFloatingRootContext.d.ts

@@ -7,11 +7,11 @@ export interface UseSyncedFloatingRootContextOptions<State extends PopupStoreSta
   /**
    * Whether to prevent the auto-emitted `openchange` event.
    */
-  noEmit?: boolean;
+  noEmit?: boolean | undefined;
   /**
    * Whether the Popup element is passed to Floating UI as the floating element instead of the default Positioner.
    */
-  treatPopupAsFloatingElement?: boolean;
+  treatPopupAsFloatingElement?: boolean | undefined;
   onOpenChange(open: boolean, eventDetails: BaseUIChangeEventDetails<string>): void;
 }
 /**

package/esm/floating-ui-react/hooks/useSyncedFloatingRootContext.js

@@ -1,3 +1,5 @@
+'use client';
+
 import { useId } from '@base-ui/utils/useId';
 import { useRefWithInit } from '@base-ui/utils/useRefWithInit';
 import { useIsoLayoutEffect } from '@base-ui/utils/useIsoLayoutEffect';
@@ -41,6 +43,9 @@ export function useSyncedFloatingRootContext(options) {
     if (isElement(referenceElement)) {
       valuesToSync.domReferenceElement = referenceElement;
     }
+    if (store.state.positionReference === store.state.referenceElement) {
+      valuesToSync.positionReference = referenceElement;
+    }
     store.update(valuesToSync);
   }, [open, floatingId, referenceElement, floatingElement, store]);
 

package/esm/floating-ui-react/hooks/useTypeahead.d.ts

@@ -6,7 +6,7 @@ export interface UseTypeaheadProps {
    * elements of the list.
    * @default empty list
    */
-  listRef: React.MutableRefObject<Array<string | null>>;
+  listRef: React.RefObject<Array<string | null>>;
   /**
    * The index of the active (focused or highlighted) item in the list.
    * @default null
@@ -15,37 +15,27 @@ export interface UseTypeaheadProps {
   /**
    * Callback invoked with the matching index if found as the user types.
    */
-  onMatch?: (index: number) => void;
+  onMatch?: ((index: number) => void) | undefined;
   /**
    * Callback invoked with the typing state as the user types.
    */
-  onTypingChange?: (isTyping: boolean) => void;
+  onTypingChange?: ((isTyping: boolean) => void) | undefined;
   /**
    * Whether the Hook is enabled, including all internal Effects and event
    * handlers.
    * @default true
    */
-  enabled?: boolean;
-  /**
-   * A function that returns the matching string from the list.
-   * @default lowercase-finder
-   */
-  findMatch?: null | ((list: Array<string | null>, typedString: string) => string | null | undefined);
+  enabled?: boolean | undefined;
   /**
    * The number of milliseconds to wait before resetting the typed string.
    * @default 750
    */
-  resetMs?: number;
-  /**
-   * An array of keys to ignore when typing.
-   * @default []
-   */
-  ignoreKeys?: Array<string>;
+  resetMs?: number | undefined;
   /**
    * The index of the selected item in the list, if available.
    * @default null
    */
-  selectedIndex?: number | null;
+  selectedIndex?: (number | null) | undefined;
 }
 /**
  * Provides a matching callback that can be used to focus an item as the user