@base-ui/react 1.1.0 → 1.2.0

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';

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

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

@@ -1,9 +1,10 @@
+'use client';
+
 import * as React from 'react';
 import { useStableCallback } from '@base-ui/utils/useStableCallback';
 import { useIsoLayoutEffect } from '@base-ui/utils/useIsoLayoutEffect';
 import { useTimeout } from '@base-ui/utils/useTimeout';
-import { stopEvent } from "../utils.js";
-import { EMPTY_ARRAY } from "../../utils/constants.js";
+import { contains, stopEvent } from "../utils.js";
 /**
  * Provides a matching callback that can be used to focus an item as the user
  * types, often used in tandem with `useListNavigation()`.
@@ -11,17 +12,15 @@ import { EMPTY_ARRAY } from "../../utils/constants.js";
  */
 export function useTypeahead(context, props) {
   const store = 'rootStore' in context ? context.rootStore : context;
-  const open = store.useState('open');
   const dataRef = store.context.dataRef;
+  const open = store.useState('open');
   const {
     listRef,
     activeIndex,
     onMatch: onMatchProp,
     onTypingChange,
     enabled = true,
-    findMatch = null,
     resetMs = 750,
-    ignoreKeys = EMPTY_ARRAY,
     selectedIndex = null
   } = props;
   const timeout = useTimeout();
@@ -29,12 +28,15 @@ export function useTypeahead(context, props) {
   const prevIndexRef = React.useRef(selectedIndex ?? activeIndex ?? -1);
   const matchIndexRef = React.useRef(null);
   useIsoLayoutEffect(() => {
-    if (open) {
-      timeout.clear();
-      matchIndexRef.current = null;
+    if (!open && selectedIndex !== null) {
+      return;
+    }
+    timeout.clear();
+    matchIndexRef.current = null;
+    if (stringRef.current !== '') {
       stringRef.current = '';
     }
-  }, [open, timeout]);
+  }, [open, selectedIndex, timeout]);
   useIsoLayoutEffect(() => {
     // Sync arrow key navigation but not typeahead navigation.
     if (open && stringRef.current === '') {
@@ -54,7 +56,7 @@ export function useTypeahead(context, props) {
   });
   const onKeyDown = useStableCallback(event => {
     function getMatchingIndex(list, orderedList, string) {
-      const str = findMatch ? findMatch(orderedList, string) : orderedList.find(text => text?.toLocaleLowerCase().indexOf(string.toLocaleLowerCase()) === 0);
+      const str = orderedList.find(text => text?.toLocaleLowerCase().indexOf(string.toLocaleLowerCase()) === 0);
       return str ? list.indexOf(str) : -1;
     }
     const listContent = listRef.current;
@@ -65,7 +67,7 @@ export function useTypeahead(context, props) {
         stopEvent(event);
       }
     }
-    if (listContent == null || ignoreKeys.includes(event.key) ||
+    if (listContent == null ||
     // Character key.
     event.key.length !== 1 ||
     // Modifier key.
@@ -77,6 +79,12 @@ export function useTypeahead(context, props) {
       setTypingChange(true);
     }
 
+    // Capture whether this is a new typing session before mutating the string.
+    const isNewSession = stringRef.current === '';
+    if (isNewSession) {
+      prevIndexRef.current = selectedIndex ?? activeIndex ?? -1;
+    }
+
     // Bail out if the list contains a word like "llama" or "aaron". TODO:
     // allow it in this case, too.
     const allowRapidSuccessionOfFirstLetter = listContent.every(text => text ? text[0]?.toLocaleLowerCase() !== text[1]?.toLocaleLowerCase() : true);
@@ -93,7 +101,11 @@ export function useTypeahead(context, props) {
       prevIndexRef.current = matchIndexRef.current;
       setTypingChange(false);
     });
-    const prevIndex = prevIndexRef.current;
+
+    // Compute the starting index for this search.
+    // If this is a new typing session (string is empty), base it on the current
+    // selection/active item; otherwise continue from the last matched index.
+    const prevIndex = isNewSession ? selectedIndex ?? activeIndex ?? -1 : prevIndexRef.current;
     const index = getMatchingIndex(listContent, [...listContent.slice((prevIndex || 0) + 1), ...listContent.slice(0, (prevIndex || 0) + 1)], stringRef.current);
     if (index !== -1) {
       onMatchProp?.(index);
@@ -103,9 +115,28 @@ export function useTypeahead(context, props) {
       setTypingChange(false);
     }
   });
+  const onBlur = useStableCallback(event => {
+    const next = event.relatedTarget;
+    const currentDomReferenceElement = store.select('domReferenceElement');
+    const currentFloatingElement = store.select('floatingElement');
+    const withinReference = contains(currentDomReferenceElement, next);
+    const withinFloating = contains(currentFloatingElement, next);
+
+    // Keep the session if focus moves within the composite (reference <-> floating).
+    if (withinReference || withinFloating) {
+      return;
+    }
+
+    // End the current typing session when focus leaves the composite entirely.
+    timeout.clear();
+    stringRef.current = '';
+    prevIndexRef.current = matchIndexRef.current;
+    setTypingChange(false);
+  });
   const reference = React.useMemo(() => ({
-    onKeyDown
-  }), [onKeyDown]);
+    onKeyDown,
+    onBlur
+  }), [onKeyDown, onBlur]);
   const floating = React.useMemo(() => {
     return {
       onKeyDown,
@@ -113,9 +144,10 @@ export function useTypeahead(context, props) {
         if (event.key === ' ') {
           setTypingChange(false);
         }
-      }
+      },
+      onBlur
     };
-  }, [onKeyDown, setTypingChange]);
+  }, [onKeyDown, onBlur, setTypingChange]);
   return React.useMemo(() => enabled ? {
     reference,
     floating

package/esm/floating-ui-react/middleware/arrow.d.ts

@@ -10,7 +10,7 @@ export interface ArrowOptions {
    * Useful when the floating element has rounded corners.
    * @default 0
    */
-  padding?: Padding;
+  padding?: Padding | undefined;
   /**
    * Which element to use as the offset parent.
    * @default 'real'

package/esm/floating-ui-react/safePolygon.d.ts

@@ -1,8 +1,8 @@
 import type { HandleClose } from "./hooks/useHover.js";
 export interface SafePolygonOptions {
-  buffer?: number;
-  blockPointerEvents?: boolean;
-  requireIntent?: boolean;
+  buffer?: number | undefined;
+  blockPointerEvents?: boolean | undefined;
+  requireIntent?: boolean | undefined;
 }
 /**
  * Generates a safe polygon area that the user can traverse without closing the

package/esm/floating-ui-react/types.d.ts

@@ -48,10 +48,10 @@ export interface FloatingEvents {
   off(event: string, handler: (data: any) => void): void;
 }
 export interface ContextData {
-  openEvent?: Event;
-  floatingContext?: FloatingContext;
+  openEvent?: Event | undefined;
+  floatingContext?: FloatingContext | undefined;
   /** @deprecated use `onTypingChange` prop in `useTypeahead` */
-  typing?: boolean;
+  typing?: boolean | undefined;
   [key: string]: any;
 }
 export type FloatingRootContext = FloatingRootStore;
@@ -69,14 +69,14 @@ export type FloatingContext = Omit<UsePositionFloatingReturn<ReferenceType>, 're
 export interface FloatingNodeType {
   id: string | undefined;
   parentId: string | null;
-  context?: FloatingContext;
+  context?: FloatingContext | undefined;
 }
 export type FloatingTreeType = FloatingTreeStore;
 export interface ElementProps {
-  reference?: React.HTMLProps<Element>;
-  floating?: React.HTMLProps<HTMLElement>;
-  item?: React.HTMLProps<HTMLElement> | ((props: ExtendedUserProps) => React.HTMLProps<HTMLElement>);
-  trigger?: React.HTMLProps<Element>;
+  reference?: React.HTMLProps<Element> | undefined;
+  floating?: React.HTMLProps<HTMLElement> | undefined;
+  item?: (React.HTMLProps<HTMLElement> | ((props: ExtendedUserProps) => React.HTMLProps<HTMLElement>)) | undefined;
+  trigger?: React.HTMLProps<Element> | undefined;
 }
 export type ReferenceType = Element | VirtualElement;
 export type UseFloatingData = Prettify<UseFloatingReturn>;
@@ -92,7 +92,7 @@ export type UseFloatingReturn = Prettify<UsePositionFloatingReturn & {
   elements: ExtendedElements;
 }>;
 export interface UseFloatingOptions extends Omit<UsePositionOptions, 'elements'> {
-  rootContext?: FloatingRootContext;
+  rootContext?: FloatingRootContext | undefined;
   /**
    * Object of external elements as an alternative to the `refs` object setters.
    */
@@ -100,12 +100,12 @@ export interface UseFloatingOptions extends Omit<UsePositionOptions, 'elements'>
     /**
      * Externally passed reference element. Store in state.
      */
-    reference?: ReferenceType | null;
+    reference?: (ReferenceType | null) | undefined;
     /**
      * Externally passed floating element. Store in state.
      */
-    floating?: HTMLElement | null;
-  };
+    floating?: (HTMLElement | null) | undefined;
+  } | undefined;
   /**
    * An event callback that is invoked when the floating element is opened or
    * closed.
@@ -114,9 +114,9 @@ export interface UseFloatingOptions extends Omit<UsePositionOptions, 'elements'>
   /**
    * Unique node id when using `FloatingTree`.
    */
-  nodeId?: string;
+  nodeId?: string | undefined;
   /**
    * External FlatingTree to use when the one provided by context can't be used.
    */
-  externalTree?: FloatingTreeStore;
+  externalTree?: FloatingTreeStore | undefined;
 }

package/esm/floating-ui-react/utils/composite.d.ts

@@ -10,10 +10,10 @@ export declare function findNonDisabledListIndex(listRef: React.RefObject<Readon
   disabledIndices,
   amount
 }?: {
-  startingIndex?: number;
-  decrement?: boolean;
-  disabledIndices?: DisabledIndices;
-  amount?: number;
+  startingIndex?: number | undefined;
+  decrement?: boolean | undefined;
+  disabledIndices?: DisabledIndices | undefined;
+  amount?: number | undefined;
 }): number;
 export declare function getGridNavigatedIndex(listRef: React.RefObject<Array<HTMLElement | null>>, {
   event,
@@ -36,7 +36,7 @@ export declare function getGridNavigatedIndex(listRef: React.RefObject<Array<HTM
   minIndex: number;
   maxIndex: number;
   prevIndex: number;
-  stopEvent?: boolean;
+  stopEvent?: boolean | undefined;
 }): number;
 /** For each cell index, gets the item index that occupies that cell */
 export declare function createGridCellMap(sizes: Dimensions[], cols: number, dense: boolean): (number | undefined)[];

package/esm/floating-ui-react/utils/composite.js

@@ -1,4 +1,3 @@
-import _formatErrorMessage from "@base-ui/utils/formatErrorMessage";
 import { floor } from '@floating-ui/utils';
 import { stopEvent } from "./event.js";
 import { ARROW_DOWN, ARROW_LEFT, ARROW_RIGHT, ARROW_UP } from "./constants.js";
@@ -274,7 +273,7 @@ export function createGridCellMap(sizes, cols, dense) {
   }, index) => {
     if (width > cols) {
       if (process.env.NODE_ENV !== 'production') {
-        throw new Error(process.env.NODE_ENV !== "production" ? `[Floating UI]: Invalid grid - item width at index ${index} is greater than grid columns` : _formatErrorMessage(29, index));
+        throw new Error(`[Floating UI]: Invalid grid - item width at index ${index} is greater than grid columns`);
       }
     }
     let itemPlaced = false;

package/esm/floating-ui-react/utils/element.d.ts

@@ -1,9 +1,10 @@
+import { type PopupTriggerMap } from "../../utils/popups/index.js";
 export declare function activeElement(doc: Document): Element | null;
 export declare function contains(parent?: Element | null, child?: Element | null): boolean;
+export declare function isTargetInsideEnabledTrigger(target: EventTarget | null, triggerElements: PopupTriggerMap): boolean;
 export declare function getTarget(event: Event): EventTarget | null;
 export declare function isEventTargetWithin(event: Event, node: Node | null | undefined): boolean;
 export declare function isRootElement(element: Element): boolean;
-export declare function getDocument(node: Element | null): Document;
 export declare function isTypeableElement(element: unknown): boolean;
 export declare function isTypeableCombobox(element: Element | null): boolean;
 export declare function matchesFocusVisible(element: Element | null): boolean;