@base-ui/react 1.4.1 → 1.5.0

package/esm/drawer/swipe-area/DrawerSwipeArea.js

@@ -66,11 +66,11 @@ function resolveTouchAction(direction) {
  */
 export const DrawerSwipeArea = /*#__PURE__*/React.forwardRef(function DrawerSwipeArea(componentProps, forwardedRef) {
   const {
-    className,
     render,
+    className,
+    style,
     disabled = false,
     swipeDirection: swipeDirectionProp,
-    style,
     ...elementProps
   } = componentProps;
   const {
@@ -96,13 +96,13 @@ export const DrawerSwipeArea = /*#__PURE__*/React.forwardRef(function DrawerSwip
   const swipeAreaId = useBaseUiId(componentProps.id);
   const registerTrigger = useTriggerRegistration(swipeAreaId, store);
   const open = store.useState('open');
-  const resolvedSwipeDirection = swipeDirectionProp ?? oppositeSwipeDirection[swipeDirection];
-  const dismissDirection = oppositeSwipeDirection[resolvedSwipeDirection];
-  const enabled = !disabled && (!open || swipeActive);
   const resetDragDelta = useStableCallback(() => {
     dragDeltaRef.current.x = 0;
     dragDeltaRef.current.y = 0;
   });
+  const resolvedSwipeDirection = swipeDirectionProp ?? oppositeSwipeDirection[swipeDirection];
+  const dismissDirection = oppositeSwipeDirection[resolvedSwipeDirection];
+  const enabled = !disabled && (!open || swipeActive);
   function disableDismissForSwipe() {
     releaseDismissTimeout.clear();
     store.context.outsidePressEnabledRef.current = false;
@@ -355,6 +355,7 @@ export const DrawerSwipeArea = /*#__PURE__*/React.forwardRef(function DrawerSwip
           return;
         }
         swipePointerProps.onPointerDown?.(event);
+
         // Prevent native text selection/drag gestures from competing with swipe-open dragging.
         if (event.cancelable) {
           event.preventDefault();

package/esm/drawer/viewport/DrawerViewport.js

@@ -48,8 +48,8 @@ const DRAWER_CONTENT_SELECTOR = `[${DRAWER_CONTENT_ATTRIBUTE}]`;
  */
 export const DrawerViewport = /*#__PURE__*/React.forwardRef(function DrawerViewport(props, forwardedRef) {
   const {
-    className,
     render,
+    className,
     style,
     children,
     ...elementProps
@@ -65,25 +65,25 @@ export const DrawerViewport = /*#__PURE__*/React.forwardRef(function DrawerViewp
     snapToSequentialPoints
   } = useDrawerRootContext();
   const providerContext = useDrawerProviderContext(true);
-  const visualStateStore = providerContext?.visualStateStore;
+  const {
+    snapPoints,
+    resolvedSnapPoints,
+    activeSnapPoint,
+    activeSnapPointOffset,
+    setActiveSnapPoint,
+    popupHeight
+  } = useDrawerSnapPoints();
   const open = store.useState('open');
   const mounted = store.useState('mounted');
   const nested = store.useState('nested');
   const nestedOpenDrawerCount = store.useState('nestedOpenDrawerCount');
   const viewportElement = store.useState('viewportElement');
   const popupElementState = store.useState('popupElement');
+  const visualStateStore = providerContext?.visualStateStore;
   const nestedDrawerOpen = nestedOpenDrawerCount > 0;
   const scrollAxis = swipeDirection === 'left' || swipeDirection === 'right' ? 'horizontal' : 'vertical';
   const isVerticalScrollAxis = scrollAxis === 'vertical';
   const crossScrollAxis = isVerticalScrollAxis ? 'horizontal' : 'vertical';
-  const {
-    snapPoints,
-    resolvedSnapPoints,
-    activeSnapPoint,
-    activeSnapPointOffset,
-    setActiveSnapPoint,
-    popupHeight
-  } = useDrawerSnapPoints();
   const [swipeRelease, setSwipeRelease] = React.useState(null);
   const pendingSwipeCloseSnapPointRef = React.useRef(undefined);
   const resetSwipeRef = React.useRef(null);
@@ -696,10 +696,8 @@ export const DrawerViewport = /*#__PURE__*/React.forwardRef(function DrawerViewp
     swiping: swipe.swiping,
     getDragStyles: swipe.getDragStyles,
     swipeStrength: swipeRelease ?? null,
-    setSwipeDismissed(dismissed) {
-      setSwipeDismissedElements(store.context.popupRef.current, store.context.backdropRef.current, dismissed);
-    }
-  }), [store, swipe.getDragStyles, swipe.swiping, swipeRelease]);
+    setSwipeDismissed
+  }), [setSwipeDismissed, swipe.getDragStyles, swipe.swiping, swipeRelease]);
   function resetTouchTrackingState() {
     ignoreTouchSwipeRef.current = false;
     touchScrollStateRef.current = null;
@@ -709,6 +707,7 @@ export const DrawerViewport = /*#__PURE__*/React.forwardRef(function DrawerViewp
   return /*#__PURE__*/_jsx(DialogViewport, {
     ref: forwardedRef,
     className: className,
+    style: style,
     render: render,
     ...mergeProps(elementProps, {
       onPointerDown(event) {

package/esm/field/control/FieldControl.js

@@ -85,12 +85,8 @@ export const FieldControl = /*#__PURE__*/React.forwardRef(function FieldControl(
   });
   const isControlled = valueProp !== undefined;
   const value = isControlled ? valueUnwrapped : undefined;
-  const getFieldValue = useStableCallback(() => validation.inputRef.current?.value);
-  useRegisterFieldControl(validation.inputRef, {
-    id,
-    value,
-    getValue: getFieldValue
-  });
+  const getValueFromInput = useStableCallback(() => validation.inputRef.current?.value);
+  useRegisterFieldControl(validation.inputRef, id, value, getValueFromInput);
   const element = useRenderElement('input', componentProps, {
     ref: [forwardedRef, inputRef],
     state,

package/esm/field/item/FieldItem.js

@@ -29,11 +29,8 @@ export const FieldItem = /*#__PURE__*/React.forwardRef(function FieldItem(compon
   } = useFieldRootContext(false);
   const disabled = rootDisabled || disabledProp;
   const checkboxGroupContext = useCheckboxGroupContext();
-  // checkboxGroupContext.parent is truthy even if no parent checkbox is involved
-  const parentId = checkboxGroupContext?.parent.id;
-  // this a more reliable check
   const hasParentCheckbox = checkboxGroupContext?.allValues !== undefined;
-  const controlId = hasParentCheckbox ? parentId : undefined;
+  const controlId = hasParentCheckbox ? checkboxGroupContext?.parent.id : undefined;
   const fieldItemContext = React.useMemo(() => ({
     disabled
   }), [disabled]);

package/esm/field/root/FieldRoot.js

@@ -48,6 +48,11 @@ const FieldRootInner = /*#__PURE__*/React.forwardRef(function FieldRootInner(com
   const dirty = dirtyProp ?? dirtyState;
   const touched = touchedProp ?? touchedState;
   const markedDirtyRef = React.useRef(false);
+  const registeredFieldIdRef = React.useRef(undefined);
+  const getRegisteredFieldId = React.useCallback(() => registeredFieldIdRef.current, []);
+  const setRegisteredFieldId = React.useCallback(id => {
+    registeredFieldIdRef.current = id;
+  }, []);
   const setDirty = useStableCallback(value => {
     if (dirtyProp !== undefined) {
       return;
@@ -91,17 +96,20 @@ const FieldRootInner = /*#__PURE__*/React.forwardRef(function FieldRootInner(com
     markedDirtyRef,
     state,
     name,
-    shouldValidateOnChange
+    shouldValidateOnChange,
+    getRegisteredFieldId
   });
+  const validityValue = validityData.value;
   const handleImperativeValidate = React.useCallback(() => {
     markedDirtyRef.current = true;
-    validation.commit(validityData.value);
-  }, [validation, validityData]);
+    validation.commit(validityValue);
+  }, [validation, validityValue]);
   const registerFieldControl = useFieldControlRegistration({
     commit: validation.commit,
     invalid,
     markedDirtyRef,
     name,
+    setRegisteredFieldId,
     setValidityData,
     validityData
   });

package/esm/field/root/useFieldValidation.d.ts

@@ -13,6 +13,7 @@ export interface UseFieldValidationParameters {
   state: FieldRootState;
   name: string | undefined;
   shouldValidateOnChange: () => boolean;
+  getRegisteredFieldId: () => string | undefined;
 }
 export interface UseFieldValidationReturnValue {
   getValidationProps: (props?: HTMLProps) => HTMLProps;

package/esm/field/root/useFieldValidation.js

@@ -42,7 +42,8 @@ export function useFieldValidation(params) {
     markedDirtyRef,
     state,
     name,
-    shouldValidateOnChange
+    shouldValidateOnChange,
+    getRegisteredFieldId
   } = params;
   const {
     controlId,
@@ -55,6 +56,21 @@ export function useFieldValidation(params) {
     if (!element) {
       return;
     }
+    function updateRegisteredFieldValidity(nextValidityData, externalInvalid = invalid) {
+      const fieldId = getRegisteredFieldId() ?? controlId;
+      if (fieldId == null) {
+        return;
+      }
+      const currentFieldData = formRef.current.fields.get(fieldId);
+      if (!currentFieldData) {
+        return;
+      }
+      const validityDataWithFormErrors = getCombinedFieldValidityData(nextValidityData, externalInvalid);
+      formRef.current.fields.set(fieldId, {
+        ...currentFieldData,
+        validityData: validityDataWithFormErrors
+      });
+    }
     if (revalidate) {
       if (state.valid !== false) {
         return;
@@ -75,15 +91,9 @@ export function useFieldValidation(params) {
           initialValue: validityData.initialValue
         };
         element.setCustomValidity('');
-        if (controlId) {
-          const currentFieldData = formRef.current.fields.get(controlId);
-          if (currentFieldData) {
-            formRef.current.fields.set(controlId, {
-              ...currentFieldData,
-              ...getCombinedFieldValidityData(nextValidityData, false) // invalid = false
-            });
-          }
-        }
+
+        // The required value is now present; ignore stale external invalid state for this pass.
+        updateRegisteredFieldValidity(nextValidityData, false);
         setValidityData(nextValidityData);
         return;
       }
@@ -186,16 +196,9 @@ export function useFieldValidation(params) {
       errors: validationErrors,
       initialValue: validityData.initialValue
     };
-    if (controlId) {
-      const currentFieldData = formRef.current.fields.get(controlId);
-      if (currentFieldData) {
-        formRef.current.fields.set(controlId, {
-          ...currentFieldData,
-          // Keep Form-level errors part of overall field validity for submit blocking/focus logic.
-          ...getCombinedFieldValidityData(nextValidityData, invalid)
-        });
-      }
-    }
+
+    // Keep Form-level errors part of overall field validity for submit blocking/focus logic.
+    updateRegisteredFieldValidity(nextValidityData);
     setValidityData(nextValidityData);
   });
   const getValidationProps = React.useCallback((externalProps = {}) => mergeProps(getDescriptionProps, state.valid === false ? {

package/esm/field/utils/getCombinedFieldValidityData.d.ts

@@ -1,4 +1,4 @@
-import { FieldValidityData } from "../root/FieldRoot.js";
+import type { FieldValidityData } from "../root/FieldRoot.js";
 /**
  * Combines the field's client-side, stateful validity data with the external invalid state to
  * determine the field's true validity.

package/esm/field/validity/FieldValidity.d.ts

@@ -1,5 +1,5 @@
 import * as React from 'react';
-import { FieldValidityData } from "../root/FieldRoot.js";
+import type { FieldValidityData } from "../root/FieldRoot.js";
 import { type TransitionStatus } from "../../internals/useTransitionStatus.js";
 /**
  * Used to display a custom message based on the field's validity.

package/esm/floating-ui-react/components/FloatingDelayGroup.js

@@ -68,11 +68,11 @@ export function FloatingDelayGroup(props) {
 export function useDelayGroup(context, options = {
   open: false
 }) {
-  const store = 'rootStore' in context ? context.rootStore : context;
-  const floatingId = store.useState('floatingId');
   const {
     open
   } = options;
+  const store = 'rootStore' in context ? context.rootStore : context;
+  const floatingId = store.useState('floatingId');
   const groupContext = React.useContext(FloatingDelayGroupContext);
   const {
     currentIdRef,
@@ -141,7 +141,7 @@ export function useDelayGroup(context, options = {
       setIsInstantPhase(false);
       prevContext?.setIsInstantPhase(false);
     }
-  }, [open, floatingId, store, currentIdRef, delayRef, timeoutMs, initialDelayRef, currentContextRef, timeout]);
+  }, [open, floatingId, store, currentIdRef, delayRef, initialDelayRef, currentContextRef, timeout]);
   useIsoLayoutEffect(() => {
     return () => {
       currentContextRef.current = null;

package/esm/floating-ui-react/components/FloatingFocusManager.d.ts

@@ -83,7 +83,7 @@ export interface FloatingFocusManagerProps {
    */
   beforeContentFocusGuardRef?: React.RefObject<HTMLSpanElement | null> | undefined;
   /**
-   * External FlatingTree to use when the one provided by context can't be used.
+   * External FloatingTree to use when the one provided by context can't be used.
    */
   externalTree?: FloatingTreeStore | undefined;
   /**

package/esm/floating-ui-react/components/FloatingFocusManager.js

@@ -180,7 +180,7 @@ export function FloatingFocusManager(props) {
     }
     const doc = ownerDocument(floatingFocusElement);
     return addEventListener(doc, 'keydown', onKeyDown);
-  }, [disabled, domReference, floatingFocusElement, modal, orderRef, isUntrappedTypeableCombobox, getTabbableContent]);
+  }, [disabled, floatingFocusElement, modal, isUntrappedTypeableCombobox, getTabbableContent]);
 
   // Track pointer/keyboard interactions to disambiguate focus and outside presses.
   React.useEffect(() => {
@@ -329,7 +329,7 @@ export function FloatingFocusManager(props) {
       markerCleanup();
       ariaHiddenCleanup();
     };
-  }, [open, disabled, domReference, floating, modal, orderRef, portalContext, isUntrappedTypeableCombobox, tree, getNodeId, nextFocusableElement, previousFocusableElement, getResolvedInsideElements]);
+  }, [open, disabled, domReference, floating, modal, portalContext, isUntrappedTypeableCombobox, tree, getNodeId, nextFocusableElement, previousFocusableElement, getResolvedInsideElements]);
 
   // Focus the initial element when the floating element opens.
   useIsoLayoutEffect(() => {
@@ -366,11 +366,20 @@ export function FloatingFocusManager(props) {
         elToFocus = resolveRef(resolvedInitialFocus);
       }
       elToFocus = elToFocus || getDefaultFocusElement();
+      const hadFocusInside = contains(floatingFocusElement, activeElement(doc));
       enqueueFocus(elToFocus, {
-        preventScroll: elToFocus === floatingFocusElement
+        preventScroll: elToFocus === floatingFocusElement,
+        shouldFocus() {
+          if (hadFocusInside) {
+            return true;
+          }
+          const currentActiveElement = activeElement(doc);
+          const focusMovedInside = currentActiveElement !== elToFocus && contains(floatingFocusElement, currentActiveElement);
+          return !focusMovedInside;
+        }
       });
     });
-  }, [disabled, open, floatingFocusElement, ignoreInitialFocus, getTabbableContent, initialFocusRef, openInteractionTypeRef]);
+  }, [disabled, open, floatingFocusElement, getTabbableContent, initialFocusRef, openInteractionTypeRef]);
 
   // Track return focus targets and restore focus on unmount/close.
   useIsoLayoutEffect(() => {
@@ -425,10 +434,12 @@ export function FloatingFocusManager(props) {
         resolvedReturnFocusValue = true;
       }
       if (typeof resolvedReturnFocusValue === 'boolean') {
-        const el = domReference || getPreviouslyFocusedElement();
-        return el && el.isConnected ? el : null;
+        if (domReference?.isConnected) {
+          return domReference;
+        }
+        return getPreviouslyFocusedElement() || null;
       }
-      const fallback = domReference || getPreviouslyFocusedElement();
+      const fallback = domReference?.isConnected ? domReference : getPreviouslyFocusedElement();
       return resolveRef(resolvedReturnFocusValue) || fallback || null;
     }
     return () => {
@@ -456,7 +467,7 @@ export function FloatingFocusManager(props) {
         preventReturnFocusRef.current = false;
       });
     };
-  }, [disabled, floating, floatingFocusElement, returnFocusRef, dataRef, events, tree, domReference, getNodeId, getResolvedInsideElements]);
+  }, [disabled, floating, floatingFocusElement, returnFocusRef, events, tree, domReference, getNodeId, getResolvedInsideElements]);
 
   // Safari may randomly scroll to the bottom of the page if an input inside a popup has focus
   // when the popup unmounts from the DOM.
@@ -473,6 +484,7 @@ export function FloatingFocusManager(props) {
       activeEl.blur();
     }
   }, [open, floating]);
+
   // Synchronize the `context` & `modal` value to the FloatingPortal context.
   // It will decide whether or not it needs to render its own guards.
   useIsoLayoutEffect(() => {

package/esm/floating-ui-react/components/FloatingPortal.js

@@ -100,12 +100,12 @@ export function useFloatingPortalNode(props = {}) {
  */
 export const FloatingPortal = /*#__PURE__*/React.forwardRef(function FloatingPortal(componentProps, forwardedRef) {
   const {
+    render,
+    className,
+    style,
     children,
     container,
-    className,
-    render,
     renderGuards,
-    style,
     ...elementProps
   } = componentProps;
   const {

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

@@ -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.js";
-import { isClickLikeEvent, isMouseLikePointerType } from "../utils/event.js";
+import { isMouseLikePointerType } from "../utils/event.js";
 import { createChangeEventDetails } from "../../internals/createBaseUIEventDetails.js";
 import { REASONS } from "../../internals/reasons.js";
 /**
@@ -13,8 +13,6 @@ import { REASONS } from "../../internals/reasons.js";
  * @see https://floating-ui.com/docs/useClick
  */
 export function useClick(context, props = {}) {
-  const store = 'rootStore' in context ? context.rootStore : context;
-  const dataRef = store.context.dataRef;
   const {
     enabled = true,
     event: eventOption = 'click',
@@ -24,89 +22,100 @@ export function useClick(context, props = {}) {
     touchOpenDelay = 0,
     reason = REASONS.triggerPress
   } = props;
+  const store = 'rootStore' in context ? context.rootStore : context;
+  const dataRef = store.context.dataRef;
   const pointerTypeRef = React.useRef(undefined);
   const frame = useAnimationFrame();
   const touchOpenTimeout = useTimeout();
-  const reference = React.useMemo(() => ({
-    onPointerDown(event) {
-      pointerTypeRef.current = event.pointerType;
-    },
-    onMouseDown(event) {
-      const pointerType = pointerTypeRef.current;
-      const nativeEvent = event.nativeEvent;
-      const open = store.select('open');
-
-      // Ignore all buttons except for the "main" button.
-      // https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/button
-      if (event.button !== 0 || eventOption === 'click' || isMouseLikePointerType(pointerType, true) && ignoreMouse) {
-        return;
+  const reference = React.useMemo(() => {
+    function setOpenWithTouchDelay(nextOpen, nativeEvent, target, pointerType) {
+      const details = createChangeEventDetails(reason, nativeEvent, target);
+      if (nextOpen && pointerType === 'touch' && touchOpenDelay > 0) {
+        touchOpenTimeout.start(touchOpenDelay, () => {
+          store.setOpen(true, details);
+        });
+      } else {
+        store.setOpen(nextOpen, details);
       }
+    }
+    function getNextOpen(open, currentTarget, isClickLikeOpenEvent) {
       const openEvent = dataRef.current.openEvent;
-      const openEventType = openEvent?.type;
-      const hasClickedOnInactiveTrigger = store.select('domReferenceElement') !== event.currentTarget;
-      const nextOpen = open && hasClickedOnInactiveTrigger || !(open && toggle && (openEvent && stickIfOpen ? openEventType === 'click' || openEventType === 'mousedown' : true));
+      const hasClickedOnInactiveTrigger = store.select('domReferenceElement') !== currentTarget;
+      if (open && hasClickedOnInactiveTrigger) {
+        // Moving between triggers should always open the newly active one.
+        return true;
+      }
+      if (!open) {
+        // A closed popup should open on the next press.
+        return true;
+      }
+      if (!toggle) {
+        // Non-toggle mode never closes on a repeated trigger press.
+        return true;
+      }
+      if (openEvent && stickIfOpen) {
+        // Preserve hover/focus-opened popups until the matching click-like event closes them.
+        return !isClickLikeOpenEvent(openEvent.type);
+      }
+
+      // Otherwise, a repeated click toggles the popup closed.
+      return false;
+    }
+    return {
+      onPointerDown(event) {
+        pointerTypeRef.current = event.pointerType;
+      },
+      onMouseDown(event) {
+        const pointerType = pointerTypeRef.current;
+        const nativeEvent = event.nativeEvent;
+        const open = store.select('open');
 
-      // Animations sometimes won't run on a typeable element if using a rAF.
-      // Focus is always set on these elements. For touch, we may delay opening.
-      const target = getTarget(nativeEvent);
-      if (isTypeableElement(target)) {
-        const details = createChangeEventDetails(reason, nativeEvent, target);
-        if (nextOpen && pointerType === 'touch' && touchOpenDelay > 0) {
-          touchOpenTimeout.start(touchOpenDelay, () => {
-            store.setOpen(true, details);
-          });
-        } else {
-          store.setOpen(nextOpen, details);
+        // Ignore all buttons except for the "main" button.
+        // https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/button
+        if (event.button !== 0 || eventOption === 'click' || isMouseLikePointerType(pointerType, true) && ignoreMouse) {
+          return;
+        }
+        const nextOpen = getNextOpen(open, event.currentTarget, openEventType => openEventType === 'click' || openEventType === 'mousedown');
+
+        // Animations sometimes won't run on a typeable element if using a rAF.
+        // Focus is always set on these elements. For touch, we may delay opening.
+        const target = getTarget(nativeEvent);
+        if (isTypeableElement(target)) {
+          setOpenWithTouchDelay(nextOpen, nativeEvent, target, pointerType);
+          return;
         }
-        return;
-      }
 
-      // Capture the currentTarget before the rAF.
-      // as React sets it to null after the event handler completes.
-      const eventCurrentTarget = event.currentTarget;
+        // Capture the currentTarget before the rAF.
+        // as React sets it to null after the event handler completes.
+        const eventCurrentTarget = event.currentTarget;
 
-      // Wait until focus is set on the element. This is an alternative to
-      // `event.preventDefault()` to avoid :focus-visible from appearing when using a pointer.
-      frame.request(() => {
-        const details = createChangeEventDetails(reason, nativeEvent, eventCurrentTarget);
-        if (nextOpen && pointerType === 'touch' && touchOpenDelay > 0) {
-          touchOpenTimeout.start(touchOpenDelay, () => {
-            store.setOpen(true, details);
-          });
-        } else {
-          store.setOpen(nextOpen, details);
+        // Wait until focus is set on the element. This is an alternative to
+        // `event.preventDefault()` to avoid :focus-visible from appearing when using a pointer.
+        frame.request(() => {
+          setOpenWithTouchDelay(nextOpen, nativeEvent, eventCurrentTarget, pointerType);
+        });
+      },
+      onClick(event) {
+        if (eventOption === 'mousedown-only') {
+          return;
         }
-      });
-    },
-    onClick(event) {
-      if (eventOption === 'mousedown-only') {
-        return;
-      }
-      const pointerType = pointerTypeRef.current;
-      if (eventOption === 'mousedown' && pointerType) {
+        const pointerType = pointerTypeRef.current;
+        if (eventOption === 'mousedown' && pointerType) {
+          pointerTypeRef.current = undefined;
+          return;
+        }
+        if (isMouseLikePointerType(pointerType, true) && ignoreMouse) {
+          return;
+        }
+        const open = store.select('open');
+        const nextOpen = getNextOpen(open, event.currentTarget, openEventType => openEventType === 'click' || openEventType === 'mousedown' || openEventType === 'keydown' || openEventType === 'keyup');
+        setOpenWithTouchDelay(nextOpen, event.nativeEvent, event.currentTarget, pointerType);
+      },
+      onKeyDown() {
         pointerTypeRef.current = undefined;
-        return;
       }
-      if (isMouseLikePointerType(pointerType, true) && ignoreMouse) {
-        return;
-      }
-      const open = store.select('open');
-      const openEvent = dataRef.current.openEvent;
-      const hasClickedOnInactiveTrigger = store.select('domReferenceElement') !== event.currentTarget;
-      const nextOpen = open && hasClickedOnInactiveTrigger || !(open && toggle && (openEvent && stickIfOpen ? isClickLikeEvent(openEvent) : true));
-      const details = createChangeEventDetails(reason, event.nativeEvent, event.currentTarget);
-      if (nextOpen && pointerType === 'touch' && touchOpenDelay > 0) {
-        touchOpenTimeout.start(touchOpenDelay, () => {
-          store.setOpen(true, details);
-        });
-      } else {
-        store.setOpen(nextOpen, details);
-      }
-    },
-    onKeyDown() {
-      pointerTypeRef.current = undefined;
-    }
-  }), [dataRef, eventOption, ignoreMouse, store, stickIfOpen, toggle, frame, touchOpenTimeout, touchOpenDelay, reason]);
+    };
+  }, [dataRef, eventOption, ignoreMouse, reason, store, stickIfOpen, toggle, frame, touchOpenTimeout, touchOpenDelay]);
   return React.useMemo(() => enabled ? {
     reference
   } : EMPTY_OBJECT, [enabled, reference]);