@base-ui/react 1.6.0 → 1.8.0

package/floating-ui-react/components/FloatingTree.d.mts

@@ -19,25 +19,7 @@ export interface FloatingNodeProps {
   children?: React.ReactNode;
   id: string | undefined;
 }
-/**
- * Provides parent node context for nested floating elements.
- * @see https://floating-ui.com/docs/FloatingTree
- * @internal
- */
-export declare function FloatingNode(props: FloatingNodeProps): React.JSX.Element;
 export interface FloatingTreeProps {
   children?: React.ReactNode;
   externalTree?: FloatingTreeStore | undefined;
-}
-/**
- * Provides context for nested floating elements when they are not children of
- * each other on the DOM.
- * This is not necessary in all cases, except when there must be explicit communication between parent and child floating elements. It is necessary for:
- * - The `bubbles` option in the `useDismiss()` Hook
- * - Nested virtual list navigation
- * - Nested floating elements that each open on hover
- * - Custom communication between parent and child floating elements
- * @see https://floating-ui.com/docs/FloatingTree
- * @internal
- */
-export declare function FloatingTree(props: FloatingTreeProps): React.JSX.Element;
+}

package/floating-ui-react/components/FloatingTree.d.ts

@@ -19,25 +19,7 @@ export interface FloatingNodeProps {
   children?: React.ReactNode;
   id: string | undefined;
 }
-/**
- * Provides parent node context for nested floating elements.
- * @see https://floating-ui.com/docs/FloatingTree
- * @internal
- */
-export declare function FloatingNode(props: FloatingNodeProps): React.JSX.Element;
 export interface FloatingTreeProps {
   children?: React.ReactNode;
   externalTree?: FloatingTreeStore | undefined;
-}
-/**
- * Provides context for nested floating elements when they are not children of
- * each other on the DOM.
- * This is not necessary in all cases, except when there must be explicit communication between parent and child floating elements. It is necessary for:
- * - The `bubbles` option in the `useDismiss()` Hook
- * - Nested virtual list navigation
- * - Nested floating elements that each open on hover
- * - Custom communication between parent and child floating elements
- * @see https://floating-ui.com/docs/FloatingTree
- * @internal
- */
-export declare function FloatingTree(props: FloatingTreeProps): React.JSX.Element;
+}

package/floating-ui-react/hooks/useClick.js

@@ -69,7 +69,11 @@ function useClick(context, props = {}) {
     }
     return {
       onPointerDown(event) {
-        pointerTypeRef.current = event.pointerType;
+        // Screen reader activations (Android TalkBack, desktop screen readers) report a
+        // mouse-like `pointerType`, but `ignoreMouse` must not drop them: hover logic cannot
+        // open for a virtual press since there is no real pointer movement to wait for.
+        // Virtual `touch` presses (iOS VoiceOver) keep their type so `touchOpenDelay` applies.
+        pointerTypeRef.current = (0, _event.isMouseLikePointerType)(event.pointerType, true) && (0, _event.isVirtualPointerEvent)(event.nativeEvent) ? 'virtual' : event.pointerType;
       },
       onMouseDown(event) {
         const pointerType = pointerTypeRef.current;

package/floating-ui-react/hooks/useClick.mjs

@@ -5,7 +5,7 @@ import { useAnimationFrame } from '@base-ui/utils/useAnimationFrame';
 import { useTimeout } from '@base-ui/utils/useTimeout';
 import { EMPTY_OBJECT } from '@base-ui/utils/empty';
 import { getTarget, isTypeableElement } from "../utils/element.mjs";
-import { isMouseLikePointerType } from "../utils/event.mjs";
+import { isMouseLikePointerType, isVirtualPointerEvent } from "../utils/event.mjs";
 import { createChangeEventDetails } from "../../internals/createBaseUIEventDetails.mjs";
 import { REASONS } from "../../internals/reasons.mjs";
 /**
@@ -63,7 +63,11 @@ export function useClick(context, props = {}) {
     }
     return {
       onPointerDown(event) {
-        pointerTypeRef.current = event.pointerType;
+        // Screen reader activations (Android TalkBack, desktop screen readers) report a
+        // mouse-like `pointerType`, but `ignoreMouse` must not drop them: hover logic cannot
+        // open for a virtual press since there is no real pointer movement to wait for.
+        // Virtual `touch` presses (iOS VoiceOver) keep their type so `touchOpenDelay` applies.
+        pointerTypeRef.current = isMouseLikePointerType(event.pointerType, true) && isVirtualPointerEvent(event.nativeEvent) ? 'virtual' : event.pointerType;
       },
       onMouseDown(event) {
         const pointerType = pointerTypeRef.current;

package/floating-ui-react/hooks/useDismiss.d.mts

@@ -45,7 +45,7 @@ export interface UseDismissProps {
   outsidePress?: boolean | ((event: MouseEvent | TouchEvent) => boolean) | undefined;
   /**
    * The type of event to use to determine an outside "press".
-   * - `intentional` requires the user to click outside intentionally, firing on `pointerup` for mouse, and requiring minimal `touchmove`s for touch.
+   * - `intentional` dismisses on an outside `click` whose press began while the floating element was open, ignoring the trailing click of a press that started before it opened. Touch requires minimal `touchmove`s, and press-less clicks (keyboard, assistive technology) are always accepted.
    * - `sloppy` fires on `pointerdown` for mouse, while for touch it fires on `touchend` (within 1 second) or while scrolling away after `touchstart`.
    */
   outsidePressEvent?: PressType | {

package/floating-ui-react/hooks/useDismiss.d.ts

@@ -45,7 +45,7 @@ export interface UseDismissProps {
   outsidePress?: boolean | ((event: MouseEvent | TouchEvent) => boolean) | undefined;
   /**
    * The type of event to use to determine an outside "press".
-   * - `intentional` requires the user to click outside intentionally, firing on `pointerup` for mouse, and requiring minimal `touchmove`s for touch.
+   * - `intentional` dismisses on an outside `click` whose press began while the floating element was open, ignoring the trailing click of a press that started before it opened. Touch requires minimal `touchmove`s, and press-less clicks (keyboard, assistive technology) are always accepted.
    * - `sloppy` fires on `pointerdown` for mouse, while for touch it fires on `touchend` (within 1 second) or while scrolling away after `touchstart`.
    */
   outsidePressEvent?: PressType | {

package/floating-ui-react/hooks/useDismiss.js

@@ -51,7 +51,8 @@ function useDismiss(context, props = {}) {
   const open = store.useState('open');
   const floatingElement = store.useState('floatingElement');
   const {
-    dataRef
+    dataRef,
+    events
   } = store.context;
   const tree = (0, _FloatingTree.useFloatingTree)(externalTree);
   const outsidePressFn = (0, _useStableCallback.useStableCallback)(typeof outsidePressProp === 'function' ? outsidePressProp : () => false);
@@ -66,6 +67,9 @@ function useDismiss(context, props = {}) {
   const pressStartPreventedRef = React.useRef(false);
   // Ignore only the very next outside click after dragging from inside to outside.
   const suppressNextOutsideClickRef = React.useRef(false);
+  // A click whose press began before the floating element opened is the tail of that
+  // gesture (e.g. the drag-release that opened it), not a new outside press.
+  const sawPressWhileOpenRef = React.useRef(false);
   const isComposingRef = React.useRef(false);
   const currentPointerTypeRef = React.useRef('');
   const touchStateRef = React.useRef(null);
@@ -143,14 +147,36 @@ function useDismiss(context, props = {}) {
       pressStartPreventedRef.current = true;
     }
   });
+
+  // A same-batch close+reopen never renders `open === false`, so only `openchange` can
+  // observe that session boundary. The effect below covers controlled flips.
+  React.useEffect(() => {
+    function handleOpenChange(details) {
+      // Only the closing half ends the session: `setOpen(true)` on an already-open
+      // element (hovering an inactive trigger) must not drop a press mid-gesture.
+      if (!details.open) {
+        sawPressWhileOpenRef.current = false;
+      }
+    }
+    events.on('openchange', handleOpenChange);
+    return () => {
+      events.off('openchange', handleOpenChange);
+    };
+  }, [events]);
   React.useEffect(() => {
     if (!open || !enabled) {
-      return undefined;
+      // Reset in the effect body, not the cleanup, which also runs when a dependency
+      // changes mid-gesture.
+      if (!open) {
+        sawPressWhileOpenRef.current = false;
+      }
+      return clearInsideReactTree;
     }
     dataRef.current.__escapeKeyBubbles = escapeKeyBubbles;
     dataRef.current.__outsidePressBubbles = outsidePressBubbles;
     const compositionTimeout = new _useTimeout.Timeout();
     const preventedPressSuppressionTimeout = new _useTimeout.Timeout();
+    const doc = (0, _owner.ownerDocument)(floatingElement);
     function handleCompositionStart() {
       compositionTimeout.clear();
       isComposingRef.current = true;
@@ -269,13 +295,22 @@ function useDismiss(context, props = {}) {
         return;
       }
 
-      // In intentional mode, a press that starts inside and ends outside gets
-      // one suppressed outside click. Run this after inside-target checks so
-      // inside clicks don't consume the one-shot suppression.
-      if (getOutsidePressEvent() === 'intentional' && suppressNextOutsideClickRef.current) {
-        preventedPressSuppressionTimeout.clear();
-        suppressNextOutsideClickRef.current = false;
-        return;
+      // Only `click` events reach this point in intentional mode.
+      if (getOutsidePressEvent() === 'intentional') {
+        // Press-less clicks (keyboard, assistive technology, `element.click()`) report no
+        // click count; `isVirtualClick` also catches the ones that do.
+        if (event.detail !== 0 && !(0, _event.isVirtualClick)(event) && !sawPressWhileOpenRef.current) {
+          return;
+        }
+
+        // A press that starts inside and ends outside gets one suppressed
+        // outside click. Run this after inside-target checks so inside clicks
+        // don't consume the one-shot suppression.
+        if (suppressNextOutsideClickRef.current) {
+          preventedPressSuppressionTimeout.clear();
+          suppressNextOutsideClickRef.current = false;
+          return;
+        }
       }
       if (typeof outsidePress === 'function' && !outsidePress(event)) {
         return;
@@ -329,7 +364,14 @@ function useDismiss(context, props = {}) {
     }
     function closeOnPressOutsideCapture(event) {
       cancelDismissOnEndTimeout.clear();
+
+      // Only `pointerdown` marks a press; `mousedown` is its compatibility event, and
+      // counting it would misattribute a gesture that started before open.
       if (event.type === 'pointerdown') {
+        // Only a primary press can produce a `click`.
+        if (event.button === 0) {
+          sawPressWhileOpenRef.current = true;
+        }
         currentPointerTypeRef.current = event.pointerType;
       }
       if (event.type === 'mousedown' && touchStateRef.current && !touchStateRef.current.dismissOnMouseDown) {
@@ -344,6 +386,11 @@ function useDismiss(context, props = {}) {
       });
     }
     function handlePressEndCapture(event) {
+      // A cancelled gesture produces no click. Not cleared on `pointerup`: the click
+      // fires after it and must still find the press.
+      if (event.type === 'pointercancel') {
+        sawPressWhileOpenRef.current = false;
+      }
       if (!pressStartedInsideRef.current) {
         return;
       }
@@ -415,17 +462,25 @@ function useDismiss(context, props = {}) {
     function handleTouchEndCapture(event) {
       addTargetEventListenerOnce(event, handleTouchEnd);
     }
-    const doc = (0, _owner.ownerDocument)(floatingElement);
-    const unsubscribe = (0, _mergeCleanups.mergeCleanups)(escapeKey && (0, _mergeCleanups.mergeCleanups)((0, _addEventListener.addEventListener)(doc, 'keydown', closeOnEscapeKeyDown), (0, _addEventListener.addEventListener)(doc, 'compositionstart', handleCompositionStart), (0, _addEventListener.addEventListener)(doc, 'compositionend', handleCompositionEnd)), outsidePressEnabled && (0, _mergeCleanups.mergeCleanups)((0, _addEventListener.addEventListener)(doc, 'click', closeOnPressOutsideCapture, true), (0, _addEventListener.addEventListener)(doc, 'pointerdown', closeOnPressOutsideCapture, true), (0, _addEventListener.addEventListener)(doc, 'pointerup', handlePressEndCapture, true), (0, _addEventListener.addEventListener)(doc, 'pointercancel', handlePressEndCapture, true), (0, _addEventListener.addEventListener)(doc, 'mousedown', closeOnPressOutsideCapture, true), (0, _addEventListener.addEventListener)(doc, 'mouseup', handlePressEndCapture, true), (0, _addEventListener.addEventListener)(doc, 'touchstart', handleTouchStartCapture, true), (0, _addEventListener.addEventListener)(doc, 'touchmove', handleTouchMoveCapture, true), (0, _addEventListener.addEventListener)(doc, 'touchend', handleTouchEndCapture, true)));
+    const unsubscribe = (0, _mergeCleanups.mergeCleanups)(escapeKey && (0, _mergeCleanups.mergeCleanups)((0, _addEventListener.addEventListener)(doc, 'keydown', closeOnEscapeKeyDown), (0, _addEventListener.addEventListener)(doc, 'compositionstart', handleCompositionStart), (0, _addEventListener.addEventListener)(doc, 'compositionend', handleCompositionEnd)), outsidePressEnabled && (0, _mergeCleanups.mergeCleanups)((0, _addEventListener.addEventListener)(doc, 'click', closeOnPressOutsideCapture, true), (0, _addEventListener.addEventListener)(doc, 'pointerdown', closeOnPressOutsideCapture, true), (0, _addEventListener.addEventListener)(doc, 'pointerup', handlePressEndCapture, true), (0, _addEventListener.addEventListener)(doc, 'pointercancel', handlePressEndCapture, true), (0, _addEventListener.addEventListener)(doc, 'mousedown', closeOnPressOutsideCapture, true), (0, _addEventListener.addEventListener)(doc, 'mouseup', handlePressEndCapture, true), (0, _addEventListener.addEventListener)(doc, 'touchstart', handleTouchStartCapture, {
+      capture: true,
+      passive: true
+    }), (0, _addEventListener.addEventListener)(doc, 'touchmove', handleTouchMoveCapture, {
+      capture: true,
+      passive: true
+    }), (0, _addEventListener.addEventListener)(doc, 'touchend', handleTouchEndCapture, {
+      capture: true,
+      passive: true
+    })));
     return () => {
       unsubscribe();
       compositionTimeout.clear();
       preventedPressSuppressionTimeout.clear();
       resetPressStartState();
       suppressNextOutsideClickRef.current = false;
+      clearInsideReactTree();
     };
   }, [dataRef, floatingElement, escapeKey, outsidePressEnabled, outsidePress, open, enabled, escapeKeyBubbles, outsidePressBubbles, closeOnEscapeKeyDown, clearInsideReactTree, getOutsidePressEventProp, hasBlockingChild, isEventWithinOwnElements, tree, store, cancelDismissOnEndTimeout]);
-  React.useEffect(clearInsideReactTree, [outsidePress, clearInsideReactTree]);
   const reference = React.useMemo(() => ({
     onKeyDown: closeOnEscapeKeyDown,
     onPointerDown: closeOnReferencePress,

package/floating-ui-react/hooks/useDismiss.mjs

@@ -14,7 +14,7 @@ import { createChangeEventDetails } from "../../internals/createBaseUIEventDetai
 import { REASONS } from "../../internals/reasons.mjs";
 import { createAttribute } from "../utils/createAttribute.mjs";
 import { contains, getTarget, isEventTargetWithin, isRootElement } from "../utils/element.mjs";
-import { isReactEvent } from "../utils/event.mjs";
+import { isReactEvent, isVirtualClick } from "../utils/event.mjs";
 import { getNodeChildren } from "../utils/nodes.mjs";
 function alwaysFalse() {
   return false;
@@ -44,7 +44,8 @@ export function useDismiss(context, props = {}) {
   const open = store.useState('open');
   const floatingElement = store.useState('floatingElement');
   const {
-    dataRef
+    dataRef,
+    events
   } = store.context;
   const tree = useFloatingTree(externalTree);
   const outsidePressFn = useStableCallback(typeof outsidePressProp === 'function' ? outsidePressProp : () => false);
@@ -59,6 +60,9 @@ export function useDismiss(context, props = {}) {
   const pressStartPreventedRef = React.useRef(false);
   // Ignore only the very next outside click after dragging from inside to outside.
   const suppressNextOutsideClickRef = React.useRef(false);
+  // A click whose press began before the floating element opened is the tail of that
+  // gesture (e.g. the drag-release that opened it), not a new outside press.
+  const sawPressWhileOpenRef = React.useRef(false);
   const isComposingRef = React.useRef(false);
   const currentPointerTypeRef = React.useRef('');
   const touchStateRef = React.useRef(null);
@@ -136,14 +140,36 @@ export function useDismiss(context, props = {}) {
       pressStartPreventedRef.current = true;
     }
   });
+
+  // A same-batch close+reopen never renders `open === false`, so only `openchange` can
+  // observe that session boundary. The effect below covers controlled flips.
+  React.useEffect(() => {
+    function handleOpenChange(details) {
+      // Only the closing half ends the session: `setOpen(true)` on an already-open
+      // element (hovering an inactive trigger) must not drop a press mid-gesture.
+      if (!details.open) {
+        sawPressWhileOpenRef.current = false;
+      }
+    }
+    events.on('openchange', handleOpenChange);
+    return () => {
+      events.off('openchange', handleOpenChange);
+    };
+  }, [events]);
   React.useEffect(() => {
     if (!open || !enabled) {
-      return undefined;
+      // Reset in the effect body, not the cleanup, which also runs when a dependency
+      // changes mid-gesture.
+      if (!open) {
+        sawPressWhileOpenRef.current = false;
+      }
+      return clearInsideReactTree;
     }
     dataRef.current.__escapeKeyBubbles = escapeKeyBubbles;
     dataRef.current.__outsidePressBubbles = outsidePressBubbles;
     const compositionTimeout = new Timeout();
     const preventedPressSuppressionTimeout = new Timeout();
+    const doc = ownerDocument(floatingElement);
     function handleCompositionStart() {
       compositionTimeout.clear();
       isComposingRef.current = true;
@@ -262,13 +288,22 @@ export function useDismiss(context, props = {}) {
         return;
       }
 
-      // In intentional mode, a press that starts inside and ends outside gets
-      // one suppressed outside click. Run this after inside-target checks so
-      // inside clicks don't consume the one-shot suppression.
-      if (getOutsidePressEvent() === 'intentional' && suppressNextOutsideClickRef.current) {
-        preventedPressSuppressionTimeout.clear();
-        suppressNextOutsideClickRef.current = false;
-        return;
+      // Only `click` events reach this point in intentional mode.
+      if (getOutsidePressEvent() === 'intentional') {
+        // Press-less clicks (keyboard, assistive technology, `element.click()`) report no
+        // click count; `isVirtualClick` also catches the ones that do.
+        if (event.detail !== 0 && !isVirtualClick(event) && !sawPressWhileOpenRef.current) {
+          return;
+        }
+
+        // A press that starts inside and ends outside gets one suppressed
+        // outside click. Run this after inside-target checks so inside clicks
+        // don't consume the one-shot suppression.
+        if (suppressNextOutsideClickRef.current) {
+          preventedPressSuppressionTimeout.clear();
+          suppressNextOutsideClickRef.current = false;
+          return;
+        }
       }
       if (typeof outsidePress === 'function' && !outsidePress(event)) {
         return;
@@ -322,7 +357,14 @@ export function useDismiss(context, props = {}) {
     }
     function closeOnPressOutsideCapture(event) {
       cancelDismissOnEndTimeout.clear();
+
+      // Only `pointerdown` marks a press; `mousedown` is its compatibility event, and
+      // counting it would misattribute a gesture that started before open.
       if (event.type === 'pointerdown') {
+        // Only a primary press can produce a `click`.
+        if (event.button === 0) {
+          sawPressWhileOpenRef.current = true;
+        }
         currentPointerTypeRef.current = event.pointerType;
       }
       if (event.type === 'mousedown' && touchStateRef.current && !touchStateRef.current.dismissOnMouseDown) {
@@ -337,6 +379,11 @@ export function useDismiss(context, props = {}) {
       });
     }
     function handlePressEndCapture(event) {
+      // A cancelled gesture produces no click. Not cleared on `pointerup`: the click
+      // fires after it and must still find the press.
+      if (event.type === 'pointercancel') {
+        sawPressWhileOpenRef.current = false;
+      }
       if (!pressStartedInsideRef.current) {
         return;
       }
@@ -408,17 +455,25 @@ export function useDismiss(context, props = {}) {
     function handleTouchEndCapture(event) {
       addTargetEventListenerOnce(event, handleTouchEnd);
     }
-    const doc = ownerDocument(floatingElement);
-    const unsubscribe = mergeCleanups(escapeKey && mergeCleanups(addEventListener(doc, 'keydown', closeOnEscapeKeyDown), addEventListener(doc, 'compositionstart', handleCompositionStart), addEventListener(doc, 'compositionend', handleCompositionEnd)), outsidePressEnabled && mergeCleanups(addEventListener(doc, 'click', closeOnPressOutsideCapture, true), addEventListener(doc, 'pointerdown', closeOnPressOutsideCapture, true), addEventListener(doc, 'pointerup', handlePressEndCapture, true), addEventListener(doc, 'pointercancel', handlePressEndCapture, true), addEventListener(doc, 'mousedown', closeOnPressOutsideCapture, true), addEventListener(doc, 'mouseup', handlePressEndCapture, true), addEventListener(doc, 'touchstart', handleTouchStartCapture, true), addEventListener(doc, 'touchmove', handleTouchMoveCapture, true), addEventListener(doc, 'touchend', handleTouchEndCapture, true)));
+    const unsubscribe = mergeCleanups(escapeKey && mergeCleanups(addEventListener(doc, 'keydown', closeOnEscapeKeyDown), addEventListener(doc, 'compositionstart', handleCompositionStart), addEventListener(doc, 'compositionend', handleCompositionEnd)), outsidePressEnabled && mergeCleanups(addEventListener(doc, 'click', closeOnPressOutsideCapture, true), addEventListener(doc, 'pointerdown', closeOnPressOutsideCapture, true), addEventListener(doc, 'pointerup', handlePressEndCapture, true), addEventListener(doc, 'pointercancel', handlePressEndCapture, true), addEventListener(doc, 'mousedown', closeOnPressOutsideCapture, true), addEventListener(doc, 'mouseup', handlePressEndCapture, true), addEventListener(doc, 'touchstart', handleTouchStartCapture, {
+      capture: true,
+      passive: true
+    }), addEventListener(doc, 'touchmove', handleTouchMoveCapture, {
+      capture: true,
+      passive: true
+    }), addEventListener(doc, 'touchend', handleTouchEndCapture, {
+      capture: true,
+      passive: true
+    })));
     return () => {
       unsubscribe();
       compositionTimeout.clear();
       preventedPressSuppressionTimeout.clear();
       resetPressStartState();
       suppressNextOutsideClickRef.current = false;
+      clearInsideReactTree();
     };
   }, [dataRef, floatingElement, escapeKey, outsidePressEnabled, outsidePress, open, enabled, escapeKeyBubbles, outsidePressBubbles, closeOnEscapeKeyDown, clearInsideReactTree, getOutsidePressEventProp, hasBlockingChild, isEventWithinOwnElements, tree, store, cancelDismissOnEndTimeout]);
-  React.useEffect(clearInsideReactTree, [outsidePress, clearInsideReactTree]);
   const reference = React.useMemo(() => ({
     onKeyDown: closeOnEscapeKeyDown,
     onPointerDown: closeOnReferencePress,

package/floating-ui-react/hooks/useFloating.d.mts

@@ -1,6 +1,14 @@
+import { FloatingRootStore } from "../components/FloatingRootStore.mjs";
 import type { UseFloatingOptions, UseFloatingReturn } from "../types.mjs";
 /**
  * Provides data to position a floating element and context to add interactions.
  * @see https://floating-ui.com/docs/useFloating
  */
-export declare function useFloating(options?: UseFloatingOptions): UseFloatingReturn;
+export declare function useFloating(options?: UseFloatingOptions): UseFloatingReturn;
+/**
+ * Base UI's private `useFloating` path. The caller must supply the root store, so this skips the
+ * internal root-context hook used by the public Floating UI-compatible API.
+ */
+export declare function useBaseUIFloating(options: UseFloatingOptions & {
+  rootContext: FloatingRootStore;
+}): UseFloatingReturn;

package/floating-ui-react/hooks/useFloating.d.ts

@@ -1,6 +1,14 @@
+import { FloatingRootStore } from "../components/FloatingRootStore.js";
 import type { UseFloatingOptions, UseFloatingReturn } from "../types.js";
 /**
  * Provides data to position a floating element and context to add interactions.
  * @see https://floating-ui.com/docs/useFloating
  */
-export declare function useFloating(options?: UseFloatingOptions): UseFloatingReturn;
+export declare function useFloating(options?: UseFloatingOptions): UseFloatingReturn;
+/**
+ * Base UI's private `useFloating` path. The caller must supply the root store, so this skips the
+ * internal root-context hook used by the public Floating UI-compatible API.
+ */
+export declare function useBaseUIFloating(options: UseFloatingOptions & {
+  rootContext: FloatingRootStore;
+}): UseFloatingReturn;

package/floating-ui-react/hooks/useFloating.js

@@ -5,6 +5,7 @@ var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWild
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.useBaseUIFloating = useBaseUIFloating;
 exports.useFloating = useFloating;
 var React = _interopRequireWildcard(require("react"));
 var _useIsoLayoutEffect = require("@base-ui/utils/useIsoLayoutEffect");
@@ -17,12 +18,23 @@ var _useFloatingRootContext = require("./useFloatingRootContext");
  * @see https://floating-ui.com/docs/useFloating
  */
 function useFloating(options = {}) {
+  const internalStore = (0, _useFloatingRootContext.useFloatingRootContext)(options);
+  const store = options.rootContext || internalStore;
+  return useFloatingWithStore(options, store);
+}
+
+/**
+ * Base UI's private `useFloating` path. The caller must supply the root store, so this skips the
+ * internal root-context hook used by the public Floating UI-compatible API.
+ */
+function useBaseUIFloating(options) {
+  return useFloatingWithStore(options, options.rootContext);
+}
+function useFloatingWithStore(options, store) {
   const {
     nodeId,
     externalTree
   } = options;
-  const internalStore = (0, _useFloatingRootContext.useFloatingRootContext)(options);
-  const store = options.rootContext || internalStore;
   const referenceElement = store.useState('referenceElement');
   const floatingElement = store.useState('floatingElement');
   const domReferenceElement = store.useState('domReferenceElement');

package/floating-ui-react/hooks/useFloating.mjs

@@ -12,12 +12,23 @@ import { useFloatingRootContext } from "./useFloatingRootContext.mjs";
  * @see https://floating-ui.com/docs/useFloating
  */
 export function useFloating(options = {}) {
+  const internalStore = useFloatingRootContext(options);
+  const store = options.rootContext || internalStore;
+  return useFloatingWithStore(options, store);
+}
+
+/**
+ * Base UI's private `useFloating` path. The caller must supply the root store, so this skips the
+ * internal root-context hook used by the public Floating UI-compatible API.
+ */
+export function useBaseUIFloating(options) {
+  return useFloatingWithStore(options, options.rootContext);
+}
+function useFloatingWithStore(options, store) {
   const {
     nodeId,
     externalTree
   } = options;
-  const internalStore = useFloatingRootContext(options);
-  const store = options.rootContext || internalStore;
   const referenceElement = store.useState('referenceElement');
   const floatingElement = store.useState('floatingElement');
   const domReferenceElement = store.useState('domReferenceElement');

package/floating-ui-react/hooks/useFloatingRootContext.js

@@ -42,8 +42,6 @@ function useFloatingRootContext(options) {
       open,
       floatingId
     };
-
-    // Only sync elements that are defined to avoid overwriting existing ones
     if (elements.reference !== undefined) {
       valuesToSync.referenceElement = elements.reference;
       valuesToSync.domReferenceElement = (0, _dom.isElement)(elements.reference) ? elements.reference : null;

package/floating-ui-react/hooks/useFloatingRootContext.mjs

@@ -37,8 +37,6 @@ export function useFloatingRootContext(options) {
       open,
       floatingId
     };
-
-    // Only sync elements that are defined to avoid overwriting existing ones
     if (elements.reference !== undefined) {
       valuesToSync.referenceElement = elements.reference;
       valuesToSync.domReferenceElement = isElement(elements.reference) ? elements.reference : null;

package/floating-ui-react/hooks/useFocus.js

@@ -52,6 +52,7 @@ function useFocus(context, props = {}) {
       const currentDomReference = store.select('domReferenceElement');
       if (!store.select('open') && (0, _dom.isHTMLElement)(currentDomReference) && currentDomReference === (0, _element.activeElement)((0, _owner.ownerDocument)(currentDomReference))) {
         blockFocusRef.current = true;
+        blockedReferenceRef.current = currentDomReference;
       }
     }
     function onKeyDown() {

package/floating-ui-react/hooks/useFocus.mjs

@@ -46,6 +46,7 @@ export function useFocus(context, props = {}) {
       const currentDomReference = store.select('domReferenceElement');
       if (!store.select('open') && isHTMLElement(currentDomReference) && currentDomReference === activeElement(ownerDocument(currentDomReference))) {
         blockFocusRef.current = true;
+        blockedReferenceRef.current = currentDomReference;
       }
     }
     function onKeyDown() {

package/floating-ui-react/hooks/useHoverReferenceInteraction.d.mts

@@ -26,6 +26,18 @@ export interface UseHoverReferenceInteractionProps {
    * paths). Return `false` to veto; any other return value permits the open.
    */
   shouldOpen?: (() => boolean) | undefined;
+  /**
+   * Regression workaround (#5152): also cancels a pending hover-open from the
+   * trigger's `mouseout`, backing up a `mouseleave` that Chrome can drop during
+   * a fast pointer sweep and leave a submenu stuck open.
+   *
+   * WARNING: only enable on single-trigger, hover-driven roots (e.g.
+   * `Menu.SubmenuTrigger`). It skips the `isClickLikeOpenEvent()` and
+   * `isInsideEnabledTrigger()` checks `mouseleave` applies, so on a
+   * multi-trigger or click-driven root it cancels legitimate opens/closes.
+   * @default false
+   */
+  guardStaleOpen?: boolean | undefined;
 }
 /**
  * Provides hover interactions that should be attached to reference or trigger

package/floating-ui-react/hooks/useHoverReferenceInteraction.d.ts

@@ -26,6 +26,18 @@ export interface UseHoverReferenceInteractionProps {
    * paths). Return `false` to veto; any other return value permits the open.
    */
   shouldOpen?: (() => boolean) | undefined;
+  /**
+   * Regression workaround (#5152): also cancels a pending hover-open from the
+   * trigger's `mouseout`, backing up a `mouseleave` that Chrome can drop during
+   * a fast pointer sweep and leave a submenu stuck open.
+   *
+   * WARNING: only enable on single-trigger, hover-driven roots (e.g.
+   * `Menu.SubmenuTrigger`). It skips the `isClickLikeOpenEvent()` and
+   * `isInsideEnabledTrigger()` checks `mouseleave` applies, so on a
+   * multi-trigger or click-driven root it cancels legitimate opens/closes.
+   * @default false
+   */
+  guardStaleOpen?: boolean | undefined;
 }
 /**
  * Provides hover interactions that should be attached to reference or trigger

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

@@ -42,7 +42,8 @@ function useHoverReferenceInteraction(context, props = {}) {
     isActiveTrigger = true,
     getHandleCloseContext,
     isClosing,
-    shouldOpen: shouldOpenProp
+    shouldOpen: shouldOpenProp,
+    guardStaleOpen = false
   } = props;
   const store = 'rootStore' in context ? context.rootStore : context;
   const {
@@ -92,7 +93,7 @@ function useHoverReferenceInteraction(context, props = {}) {
   });
   if (isActiveTrigger) {
     // eslint-disable-next-line no-underscore-dangle
-    instance.handleCloseOptions = handleCloseRef.current?.__options;
+    instance.handleCloseOptions = handleClose?.__options;
   }
   React.useEffect(() => cleanupMouseMoveHandler, [cleanupMouseMoveHandler]);
 
@@ -244,13 +245,24 @@ function useHoverReferenceInteraction(context, props = {}) {
         closeWithDelay(event);
       }
     }
+
+    // Backup cancellation for Chrome's dropped `mouseleave` — see `guardStaleOpen`.
+    function onMouseOut(event) {
+      if ((0, _element.contains)(trigger, event.relatedTarget)) {
+        return; // moved within the trigger's own subtree
+      }
+      instance.openChangeTimeout.clear();
+      instance.restTimeout.clear();
+      instance.restTimeoutPending = false;
+    }
+    const staleOpenGuard = guardStaleOpen ? (0, _addEventListener.addEventListener)(trigger, 'mouseout', onMouseOut) : undefined;
     if (move) {
       return (0, _mergeCleanups.mergeCleanups)((0, _addEventListener.addEventListener)(trigger, 'mousemove', onMouseEnter, {
         once: true
-      }), (0, _addEventListener.addEventListener)(trigger, 'mouseenter', onMouseEnter), (0, _addEventListener.addEventListener)(trigger, 'mouseleave', onMouseLeave));
+      }), (0, _addEventListener.addEventListener)(trigger, 'mouseenter', onMouseEnter), (0, _addEventListener.addEventListener)(trigger, 'mouseleave', onMouseLeave), staleOpenGuard);
     }
-    return (0, _mergeCleanups.mergeCleanups)((0, _addEventListener.addEventListener)(trigger, 'mouseenter', onMouseEnter), (0, _addEventListener.addEventListener)(trigger, 'mouseleave', onMouseLeave));
-  }, [cleanupMouseMoveHandler, clearPointerEvents, dataRef, delayRef, store, enabled, handleCloseRef, instance, isActiveTrigger, isOverInactiveTrigger, isClickLikeOpenEvent, mouseOnly, move, restMsRef, triggerElementRef, tree, enabledRef, getHandleCloseContext, isClosingRef, checkShouldOpen]);
+    return (0, _mergeCleanups.mergeCleanups)((0, _addEventListener.addEventListener)(trigger, 'mouseenter', onMouseEnter), (0, _addEventListener.addEventListener)(trigger, 'mouseleave', onMouseLeave), staleOpenGuard);
+  }, [cleanupMouseMoveHandler, clearPointerEvents, dataRef, delayRef, store, enabled, handleCloseRef, instance, isActiveTrigger, isOverInactiveTrigger, isClickLikeOpenEvent, mouseOnly, move, restMsRef, triggerElementRef, tree, enabledRef, getHandleCloseContext, isClosingRef, checkShouldOpen, guardStaleOpen]);
   return React.useMemo(() => {
     if (!enabled) {
       return undefined;