@react-aria/interactions 3.4.0 → 3.7.0

package/dist/module.js

@@ -1,44 +1,72 @@
 import _react, { useContext, useEffect, useMemo, useRef, useState, useCallback } from "react";
-import { mergeProps, runAfterTransition, focusWithoutScrolling, useGlobalListeners, useSyncRef, isMac } from "@react-aria/utils";
+import { mergeProps, isIOS, runAfterTransition, focusWithoutScrolling, useGlobalListeners, useSyncRef, isMac, useEvent, useDescription } from "@react-aria/utils";
 import _babelRuntimeHelpersEsmObjectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
 import _babelRuntimeHelpersEsmExtends from "@babel/runtime/helpers/esm/extends";
+// Note that state only matters here for iOS. Non-iOS gets user-select: none applied to the target element
+// rather than at the document level so we just need to apply/remove user-select: none for each pressed element individually
 let $e17c9db826984f8ab8e5d837bf0b8$var$state = 'default';
 let $e17c9db826984f8ab8e5d837bf0b8$var$savedUserSelect = '';
+let $e17c9db826984f8ab8e5d837bf0b8$var$modifiedElementMap = new WeakMap();
 
-function $e17c9db826984f8ab8e5d837bf0b8$export$disableTextSelection() {
-  if ($e17c9db826984f8ab8e5d837bf0b8$var$state === 'default') {
-    $e17c9db826984f8ab8e5d837bf0b8$var$savedUserSelect = document.documentElement.style.webkitUserSelect;
-    document.documentElement.style.webkitUserSelect = 'none';
-  }
+function $e17c9db826984f8ab8e5d837bf0b8$export$disableTextSelection(target) {
+  if (isIOS()) {
+    if ($e17c9db826984f8ab8e5d837bf0b8$var$state === 'default') {
+      $e17c9db826984f8ab8e5d837bf0b8$var$savedUserSelect = document.documentElement.style.webkitUserSelect;
+      document.documentElement.style.webkitUserSelect = 'none';
+    }
 
-  $e17c9db826984f8ab8e5d837bf0b8$var$state = 'disabled';
+    $e17c9db826984f8ab8e5d837bf0b8$var$state = 'disabled';
+  } else if (target) {
+    // If not iOS, store the target's original user-select and change to user-select: none
+    // Ignore state since it doesn't apply for non iOS
+    $e17c9db826984f8ab8e5d837bf0b8$var$modifiedElementMap.set(target, target.style.userSelect);
+    target.style.userSelect = 'none';
+  }
 }
 
-function $e17c9db826984f8ab8e5d837bf0b8$export$restoreTextSelection() {
-  // If the state is already default, there's nothing to do.
-  // If it is restoring, then there's no need to queue a second restore.
-  if ($e17c9db826984f8ab8e5d837bf0b8$var$state !== 'disabled') {
-    return;
-  }
+function $e17c9db826984f8ab8e5d837bf0b8$export$restoreTextSelection(target) {
+  if (isIOS()) {
+    // If the state is already default, there's nothing to do.
+    // If it is restoring, then there's no need to queue a second restore.
+    if ($e17c9db826984f8ab8e5d837bf0b8$var$state !== 'disabled') {
+      return;
+    }
 
-  $e17c9db826984f8ab8e5d837bf0b8$var$state = 'restoring'; // There appears to be a delay on iOS where selection still might occur
-  // after pointer up, so wait a bit before removing user-select.
+    $e17c9db826984f8ab8e5d837bf0b8$var$state = 'restoring'; // There appears to be a delay on iOS where selection still might occur
+    // after pointer up, so wait a bit before removing user-select.
+
+    setTimeout(() => {
+      // Wait for any CSS transitions to complete so we don't recompute style
+      // for the whole page in the middle of the animation and cause jank.
+      runAfterTransition(() => {
+        // Avoid race conditions
+        if ($e17c9db826984f8ab8e5d837bf0b8$var$state === 'restoring') {
+          if (document.documentElement.style.webkitUserSelect === 'none') {
+            document.documentElement.style.webkitUserSelect = $e17c9db826984f8ab8e5d837bf0b8$var$savedUserSelect || '';
+          }
 
-  setTimeout(() => {
-    // Wait for any CSS transitions to complete so we don't recompute style
-    // for the whole page in the middle of the animation and cause jank.
-    runAfterTransition(() => {
-      // Avoid race conditions
-      if ($e17c9db826984f8ab8e5d837bf0b8$var$state === 'restoring') {
-        if (document.documentElement.style.webkitUserSelect === 'none') {
-          document.documentElement.style.webkitUserSelect = $e17c9db826984f8ab8e5d837bf0b8$var$savedUserSelect || '';
+          $e17c9db826984f8ab8e5d837bf0b8$var$savedUserSelect = '';
+          $e17c9db826984f8ab8e5d837bf0b8$var$state = 'default';
         }
+      });
+    }, 300);
+  } else {
+    // If not iOS, restore the target's original user-select if any
+    // Ignore state since it doesn't apply for non iOS
+    if (target && $e17c9db826984f8ab8e5d837bf0b8$var$modifiedElementMap.has(target)) {
+      let targetOldUserSelect = $e17c9db826984f8ab8e5d837bf0b8$var$modifiedElementMap.get(target);
 
-        $e17c9db826984f8ab8e5d837bf0b8$var$savedUserSelect = '';
-        $e17c9db826984f8ab8e5d837bf0b8$var$state = 'default';
+      if (target.style.userSelect === 'none') {
+        target.style.userSelect = targetOldUserSelect;
       }
-    });
-  }, 300);
+
+      if (target.getAttribute('style') === '') {
+        target.removeAttribute('style');
+      }
+
+      $e17c9db826984f8ab8e5d837bf0b8$var$modifiedElementMap.delete(target);
+    }
+  }
 }
 
 /*
@@ -108,9 +136,11 @@ export function usePress(props) {
     onPressUp,
     isDisabled,
     isPressed: isPressedProp,
-    preventFocusOnPress
+    preventFocusOnPress,
+    shouldCancelOnPointerExit,
+    allowTextSelectionOnPress
   } = _usePressResponderCon,
-      domProps = _babelRuntimeHelpersEsmObjectWithoutPropertiesLoose(_usePressResponderCon, ["onPress", "onPressChange", "onPressStart", "onPressEnd", "onPressUp", "isDisabled", "isPressed", "preventFocusOnPress", "ref"]);
+      domProps = _babelRuntimeHelpersEsmObjectWithoutPropertiesLoose(_usePressResponderCon, ["onPress", "onPressChange", "onPressStart", "onPressEnd", "onPressUp", "isDisabled", "isPressed", "preventFocusOnPress", "shouldCancelOnPointerExit", "allowTextSelectionOnPress", "ref"]);
 
   let propsRef = useRef(null);
   propsRef.current = {
@@ -119,7 +149,8 @@ export function usePress(props) {
     onPressStart,
     onPressEnd,
     onPressUp,
-    isDisabled
+    isDisabled,
+    shouldCancelOnPointerExit
   };
   let [isPressed, setPressed] = useState(false);
   let ref = useRef({
@@ -157,7 +188,8 @@ export function usePress(props) {
           target: originalEvent.currentTarget,
           shiftKey: originalEvent.shiftKey,
           metaKey: originalEvent.metaKey,
-          ctrlKey: originalEvent.ctrlKey
+          ctrlKey: originalEvent.ctrlKey,
+          altKey: originalEvent.altKey
         });
       }
 
@@ -195,7 +227,8 @@ export function usePress(props) {
           target: originalEvent.currentTarget,
           shiftKey: originalEvent.shiftKey,
           metaKey: originalEvent.metaKey,
-          ctrlKey: originalEvent.ctrlKey
+          ctrlKey: originalEvent.ctrlKey,
+          altKey: originalEvent.altKey
         });
       }
 
@@ -212,7 +245,8 @@ export function usePress(props) {
           target: originalEvent.currentTarget,
           shiftKey: originalEvent.shiftKey,
           metaKey: originalEvent.metaKey,
-          ctrlKey: originalEvent.ctrlKey
+          ctrlKey: originalEvent.ctrlKey,
+          altKey: originalEvent.altKey
         });
       }
     };
@@ -234,7 +268,8 @@ export function usePress(props) {
           target: originalEvent.currentTarget,
           shiftKey: originalEvent.shiftKey,
           metaKey: originalEvent.metaKey,
-          ctrlKey: originalEvent.ctrlKey
+          ctrlKey: originalEvent.ctrlKey,
+          altKey: originalEvent.altKey
         });
       }
     };
@@ -250,13 +285,16 @@ export function usePress(props) {
         state.activePointerId = null;
         state.pointerType = null;
         removeAllGlobalListeners();
-        $e17c9db826984f8ab8e5d837bf0b8$export$restoreTextSelection();
+
+        if (!allowTextSelectionOnPress) {
+          $e17c9db826984f8ab8e5d837bf0b8$export$restoreTextSelection(state.target);
+        }
       }
     };
 
     let pressProps = {
       onKeyDown(e) {
-        if ($ffc54430b1dbeee65879852feaaff07d$var$isValidKeyboardEvent(e.nativeEvent)) {
+        if ($ffc54430b1dbeee65879852feaaff07d$var$isValidKeyboardEvent(e.nativeEvent) && e.currentTarget.contains(e.target)) {
           e.preventDefault();
           e.stopPropagation(); // If the event is repeating, it may have started on a different element
           // after which focus moved to the current element. Ignore these events and
@@ -274,12 +312,16 @@ export function usePress(props) {
       },
 
       onKeyUp(e) {
-        if ($ffc54430b1dbeee65879852feaaff07d$var$isValidKeyboardEvent(e.nativeEvent) && !e.repeat) {
+        if ($ffc54430b1dbeee65879852feaaff07d$var$isValidKeyboardEvent(e.nativeEvent) && !e.repeat && e.currentTarget.contains(e.target)) {
           triggerPressUp($ffc54430b1dbeee65879852feaaff07d$var$createEvent(state.target, e), 'keyboard');
         }
       },
 
       onClick(e) {
+        if (e && !e.currentTarget.contains(e.target)) {
+          return;
+        }
+
         if (e && e.button === 0) {
           e.stopPropagation();
 
@@ -289,7 +331,7 @@ export function usePress(props) {
           // trigger as if it were a keyboard click.
 
 
-          if (!state.ignoreClickAfterPress && !state.ignoreEmulatedMouseEvents && $f67ef9f1b8ed09b4b00fd0840cd8b94b$export$isVirtualClick(e.nativeEvent)) {
+          if (!state.ignoreClickAfterPress && !state.ignoreEmulatedMouseEvents && (state.pointerType === 'virtual' || $f67ef9f1b8ed09b4b00fd0840cd8b94b$export$isVirtualClick(e.nativeEvent))) {
             // Ensure the element receives focus (VoiceOver on iOS does not do this)
             if (!isDisabled && !preventFocusOnPress) {
               focusWithoutScrolling(e.currentTarget);
@@ -312,11 +354,12 @@ export function usePress(props) {
         e.preventDefault();
         e.stopPropagation();
         state.isPressed = false;
-        triggerPressEnd($ffc54430b1dbeee65879852feaaff07d$var$createEvent(state.target, e), 'keyboard', e.target === state.target);
+        let target = e.target;
+        triggerPressEnd($ffc54430b1dbeee65879852feaaff07d$var$createEvent(state.target, e), 'keyboard', state.target.contains(target));
         removeAllGlobalListeners(); // If the target is a link, trigger the click method to open the URL,
         // but defer triggering pressEnd until onClick event handler.
 
-        if (e.target === state.target && $ffc54430b1dbeee65879852feaaff07d$var$isHTMLAnchorLink(state.target) || state.target.getAttribute('role') === 'link') {
+        if (state.target.contains(target) && $ffc54430b1dbeee65879852feaaff07d$var$isHTMLAnchorLink(state.target) || state.target.getAttribute('role') === 'link') {
           state.target.click();
         }
       }
@@ -324,8 +367,17 @@ export function usePress(props) {
 
     if (typeof PointerEvent !== 'undefined') {
       pressProps.onPointerDown = e => {
-        // Only handle left clicks
-        if (e.button !== 0) {
+        // Only handle left clicks, and ignore events that bubbled through portals.
+        if (e.button !== 0 || !e.currentTarget.contains(e.target)) {
+          return;
+        } // iOS safari fires pointer events from VoiceOver with incorrect coordinates/target.
+        // Ignore and let the onClick handler take care of it instead.
+        // https://bugs.webkit.org/show_bug.cgi?id=222627
+        // https://bugs.webkit.org/show_bug.cgi?id=223202
+
+
+        if ($ffc54430b1dbeee65879852feaaff07d$var$isVirtualPointerEvent(e.nativeEvent)) {
+          state.pointerType = 'virtual';
           return;
         } // Due to browser inconsistencies, especially on mobile browsers, we prevent
         // default on pointer down and handle focusing the pressable element ourselves.
@@ -333,11 +385,9 @@ export function usePress(props) {
 
         if ($ffc54430b1dbeee65879852feaaff07d$var$shouldPreventDefault(e.target)) {
           e.preventDefault();
-        } // iOS safari fires pointer events from VoiceOver (but only when outside an iframe...)
-        // https://bugs.webkit.org/show_bug.cgi?id=222627
-
+        }
 
-        state.pointerType = $ffc54430b1dbeee65879852feaaff07d$var$isVirtualPointerEvent(e.nativeEvent) ? 'virtual' : e.pointerType;
+        state.pointerType = e.pointerType;
         e.stopPropagation();
 
         if (!state.isPressed) {
@@ -350,7 +400,10 @@ export function usePress(props) {
             focusWithoutScrolling(e.currentTarget);
           }
 
-          $e17c9db826984f8ab8e5d837bf0b8$export$disableTextSelection();
+          if (!allowTextSelectionOnPress) {
+            $e17c9db826984f8ab8e5d837bf0b8$export$disableTextSelection(state.target);
+          }
+
           triggerPressStart(e, state.pointerType);
           addGlobalListener(document, 'pointermove', onPointerMove, false);
           addGlobalListener(document, 'pointerup', onPointerUp, false);
@@ -359,6 +412,10 @@ export function usePress(props) {
       };
 
       pressProps.onMouseDown = e => {
+        if (!e.currentTarget.contains(e.target)) {
+          return;
+        }
+
         if (e.button === 0) {
           // Chrome and Firefox on touch Windows devices require mouse down events
           // to be canceled in addition to pointer events, or an extra asynchronous
@@ -372,11 +429,16 @@ export function usePress(props) {
       };
 
       pressProps.onPointerUp = e => {
-        // Only handle left clicks
+        // iOS fires pointerup with zero width and height, so check the pointerType recorded during pointerdown.
+        if (!e.currentTarget.contains(e.target) || state.pointerType === 'virtual') {
+          return;
+        } // Only handle left clicks
         // Safari on iOS sometimes fires pointerup events, even
         // when the touch isn't over the target, so double check.
+
+
         if (e.button === 0 && $ffc54430b1dbeee65879852feaaff07d$var$isOverTarget(e, e.currentTarget)) {
-          triggerPressUp(e, state.pointerType);
+          triggerPressUp(e, state.pointerType || e.pointerType);
         }
       }; // Safari on iOS < 13.2 does not implement pointerenter/pointerleave events correctly.
       // Use pointer move events instead to implement our own hit testing.
@@ -396,6 +458,10 @@ export function usePress(props) {
         } else if (state.isOverTarget) {
           state.isOverTarget = false;
           triggerPressEnd($ffc54430b1dbeee65879852feaaff07d$var$createEvent(state.target, e), state.pointerType, false);
+
+          if (propsRef.current.shouldCancelOnPointerExit) {
+            cancel(e);
+          }
         }
       };
 
@@ -412,7 +478,10 @@ export function usePress(props) {
           state.activePointerId = null;
           state.pointerType = null;
           removeAllGlobalListeners();
-          $e17c9db826984f8ab8e5d837bf0b8$export$restoreTextSelection();
+
+          if (!allowTextSelectionOnPress) {
+            $e17c9db826984f8ab8e5d837bf0b8$export$restoreTextSelection(state.target);
+          }
         }
       };
 
@@ -421,13 +490,17 @@ export function usePress(props) {
       };
 
       pressProps.onDragStart = e => {
-        // Safari does not call onPointerCancel when a drag starts, whereas Chrome and Firefox do.
+        if (!e.currentTarget.contains(e.target)) {
+          return;
+        } // Safari does not call onPointerCancel when a drag starts, whereas Chrome and Firefox do.
+
+
         cancel(e);
       };
     } else {
       pressProps.onMouseDown = e => {
         // Only handle left clicks
-        if (e.button !== 0) {
+        if (e.button !== 0 || !e.currentTarget.contains(e.target)) {
           return;
         } // Due to browser inconsistencies, especially on mobile browsers, we prevent
         // default on mouse down and handle focusing the pressable element ourselves.
@@ -457,6 +530,10 @@ export function usePress(props) {
       };
 
       pressProps.onMouseEnter = e => {
+        if (!e.currentTarget.contains(e.target)) {
+          return;
+        }
+
         e.stopPropagation();
 
         if (state.isPressed && !state.ignoreEmulatedMouseEvents) {
@@ -466,15 +543,27 @@ export function usePress(props) {
       };
 
       pressProps.onMouseLeave = e => {
+        if (!e.currentTarget.contains(e.target)) {
+          return;
+        }
+
         e.stopPropagation();
 
         if (state.isPressed && !state.ignoreEmulatedMouseEvents) {
           state.isOverTarget = false;
           triggerPressEnd(e, state.pointerType, false);
+
+          if (propsRef.current.shouldCancelOnPointerExit) {
+            cancel(e);
+          }
         }
       };
 
       pressProps.onMouseUp = e => {
+        if (!e.currentTarget.contains(e.target)) {
+          return;
+        }
+
         if (!state.ignoreEmulatedMouseEvents && e.button === 0) {
           triggerPressUp(e, state.pointerType);
         }
@@ -504,6 +593,10 @@ export function usePress(props) {
       };
 
       pressProps.onTouchStart = e => {
+        if (!e.currentTarget.contains(e.target)) {
+          return;
+        }
+
         e.stopPropagation();
         let touch = $ffc54430b1dbeee65879852feaaff07d$var$getTouchFromEvent(e.nativeEvent);
 
@@ -523,12 +616,19 @@ export function usePress(props) {
           focusWithoutScrolling(e.currentTarget);
         }
 
-        $e17c9db826984f8ab8e5d837bf0b8$export$disableTextSelection();
+        if (!allowTextSelectionOnPress) {
+          $e17c9db826984f8ab8e5d837bf0b8$export$disableTextSelection(state.target);
+        }
+
         triggerPressStart(e, state.pointerType);
         addGlobalListener(window, 'scroll', onScroll, true);
       };
 
       pressProps.onTouchMove = e => {
+        if (!e.currentTarget.contains(e.target)) {
+          return;
+        }
+
         e.stopPropagation();
 
         if (!state.isPressed) {
@@ -545,10 +645,18 @@ export function usePress(props) {
         } else if (state.isOverTarget) {
           state.isOverTarget = false;
           triggerPressEnd(e, state.pointerType, false);
+
+          if (propsRef.current.shouldCancelOnPointerExit) {
+            cancel(e);
+          }
         }
       };
 
       pressProps.onTouchEnd = e => {
+        if (!e.currentTarget.contains(e.target)) {
+          return;
+        }
+
         e.stopPropagation();
 
         if (!state.isPressed) {
@@ -568,11 +676,19 @@ export function usePress(props) {
         state.activePointerId = null;
         state.isOverTarget = false;
         state.ignoreEmulatedMouseEvents = true;
-        $e17c9db826984f8ab8e5d837bf0b8$export$restoreTextSelection();
+
+        if (!allowTextSelectionOnPress) {
+          $e17c9db826984f8ab8e5d837bf0b8$export$restoreTextSelection(state.target);
+        }
+
         removeAllGlobalListeners();
       };
 
       pressProps.onTouchCancel = e => {
+        if (!e.currentTarget.contains(e.target)) {
+          return;
+        }
+
         e.stopPropagation();
 
         if (state.isPressed) {
@@ -586,23 +702,32 @@ export function usePress(props) {
             currentTarget: state.target,
             shiftKey: false,
             ctrlKey: false,
-            metaKey: false
+            metaKey: false,
+            altKey: false
           });
         }
       };
 
       pressProps.onDragStart = e => {
+        if (!e.currentTarget.contains(e.target)) {
+          return;
+        }
+
         cancel(e);
       };
     }
 
     return pressProps;
-  }, [addGlobalListener, isDisabled, preventFocusOnPress, removeAllGlobalListeners]); // Remove user-select: none in case component unmounts immediately after pressStart
+  }, [addGlobalListener, isDisabled, preventFocusOnPress, removeAllGlobalListeners, allowTextSelectionOnPress]); // Remove user-select: none in case component unmounts immediately after pressStart
   // eslint-disable-next-line arrow-body-style
 
   useEffect(() => {
-    return () => $e17c9db826984f8ab8e5d837bf0b8$export$restoreTextSelection();
-  }, []);
+    return () => {
+      if (!allowTextSelectionOnPress) {
+        $e17c9db826984f8ab8e5d837bf0b8$export$restoreTextSelection(ref.current.target);
+      }
+    };
+  }, [allowTextSelectionOnPress]);
   return {
     isPressed: isPressedProp || isPressed,
     pressProps: mergeProps(domProps, pressProps)
@@ -616,6 +741,7 @@ function $ffc54430b1dbeee65879852feaaff07d$var$isHTMLAnchorLink(target) {
 function $ffc54430b1dbeee65879852feaaff07d$var$isValidKeyboardEvent(event) {
   const {
     key,
+    code,
     target
   } = event;
   const element = target;
@@ -626,7 +752,7 @@ function $ffc54430b1dbeee65879852feaaff07d$var$isValidKeyboardEvent(event) {
   const role = element.getAttribute('role'); // Accessibility for keyboards. Space and Enter only.
   // "Spacebar" is for IE 11
 
-  return (key === 'Enter' || key === ' ' || key === 'Spacebar') && tagName !== 'INPUT' && tagName !== 'TEXTAREA' && isContentEditable !== true && ( // A link with a valid href should be handled natively,
+  return (key === 'Enter' || key === ' ' || key === 'Spacebar' || code === 'Space') && tagName !== 'INPUT' && tagName !== 'TEXTAREA' && isContentEditable !== true && ( // A link with a valid href should be handled natively,
   // unless it also has role='button' and was triggered using Space.
   !$ffc54430b1dbeee65879852feaaff07d$var$isHTMLAnchorLink(element) || role === 'button' && key !== 'Enter') && // An element with role='link' should only trigger with Enter key
   !(role === 'link' && key !== 'Enter');
@@ -663,13 +789,40 @@ function $ffc54430b1dbeee65879852feaaff07d$var$createEvent(target, e) {
     currentTarget: target,
     shiftKey: e.shiftKey,
     ctrlKey: e.ctrlKey,
-    metaKey: e.metaKey
+    metaKey: e.metaKey,
+    altKey: e.altKey
+  };
+}
+
+function $ffc54430b1dbeee65879852feaaff07d$var$getPointClientRect(point) {
+  let offsetX = point.width / 2 || point.radiusX || 0;
+  let offsetY = point.height / 2 || point.radiusY || 0;
+  return {
+    top: point.clientY - offsetY,
+    right: point.clientX + offsetX,
+    bottom: point.clientY + offsetY,
+    left: point.clientX - offsetX
   };
 }
 
+function $ffc54430b1dbeee65879852feaaff07d$var$areRectanglesOverlapping(a, b) {
+  // check if they cannot overlap on x axis
+  if (a.left > b.right || b.left > a.right) {
+    return false;
+  } // check if they cannot overlap on y axis
+
+
+  if (a.top > b.bottom || b.top > a.bottom) {
+    return false;
+  }
+
+  return true;
+}
+
 function $ffc54430b1dbeee65879852feaaff07d$var$isOverTarget(point, target) {
   let rect = target.getBoundingClientRect();
-  return (point.clientX || 0) >= (rect.left || 0) && (point.clientX || 0) <= (rect.right || 0) && (point.clientY || 0) >= (rect.top || 0) && (point.clientY || 0) <= (rect.bottom || 0);
+  let pointRect = $ffc54430b1dbeee65879852feaaff07d$var$getPointClientRect(point);
+  return $ffc54430b1dbeee65879852feaaff07d$var$areRectanglesOverlapping(rect, pointRect);
 }
 
 function $ffc54430b1dbeee65879852feaaff07d$var$shouldPreventDefault(target) {
@@ -679,7 +832,11 @@ function $ffc54430b1dbeee65879852feaaff07d$var$shouldPreventDefault(target) {
 
 function $ffc54430b1dbeee65879852feaaff07d$var$isVirtualPointerEvent(event) {
   // If the pointer size is zero, then we assume it's from a screen reader.
-  return event.width === 0 && event.height === 0;
+  // Android TalkBack double tap will sometimes return a event with width and height of 1
+  // and pointerType === 'mouse' so we need to check for a specific combination of event attributes.
+  // Cannot use "event.pressure === 0" as the sole check due to Safari pointer events always returning pressure === 0
+  // instead of .5, see https://bugs.webkit.org/show_bug.cgi?id=206216
+  return event.width === 0 && event.height === 0 || event.width === 1 && event.height === 1 && event.pressure === 0 && event.detail === 0;
 }
 
 export const Pressable = /*#__PURE__*/_react.forwardRef((_ref, ref) => {
@@ -714,7 +871,7 @@ export const PressResponder = /*#__PURE__*/_react.forwardRef((_ref, ref) => {
   let isRegistered = useRef(false);
   let prevContext = useContext($a3ff51240de6f955c79cf17a88e349$export$PressResponderContext);
   let context = mergeProps(prevContext || {}, _babelRuntimeHelpersEsmExtends({}, props, {
-    ref,
+    ref: ref || (prevContext == null ? void 0 : prevContext.ref),
 
     register() {
       isRegistered.current = true;
@@ -725,6 +882,7 @@ export const PressResponder = /*#__PURE__*/_react.forwardRef((_ref, ref) => {
     }
 
   }));
+  useSyncRef(prevContext, ref);
   useEffect(() => {
     if (!isRegistered.current) {
       console.warn('A PressResponder was rendered without a pressable child. ' + 'Either call the usePress hook, or wrap your DOM node with <Pressable> component.');
@@ -788,7 +946,8 @@ export function useFocus(props) {
 let $d01f69bb2ab5f70dfd0005370a2a2cbc$var$currentModality = null;
 let $d01f69bb2ab5f70dfd0005370a2a2cbc$var$changeHandlers = new Set();
 let $d01f69bb2ab5f70dfd0005370a2a2cbc$var$hasSetupGlobalListeners = false;
-let $d01f69bb2ab5f70dfd0005370a2a2cbc$var$hasEventBeforeFocus = false; // Only Tab or Esc keys will make focus visible on text input elements
+let $d01f69bb2ab5f70dfd0005370a2a2cbc$var$hasEventBeforeFocus = false;
+let $d01f69bb2ab5f70dfd0005370a2a2cbc$var$hasBlurredWindowRecently = false; // Only Tab or Esc keys will make focus visible on text input elements
 
 const $d01f69bb2ab5f70dfd0005370a2a2cbc$var$FOCUS_VISIBLE_INPUT_KEYS = {
   Tab: true,
@@ -806,7 +965,8 @@ function $d01f69bb2ab5f70dfd0005370a2a2cbc$var$triggerChangeHandlers(modality, e
 
 
 function $d01f69bb2ab5f70dfd0005370a2a2cbc$var$isValidKey(e) {
-  return !(e.metaKey || !isMac() && e.altKey || e.ctrlKey);
+  // Control and Shift keys trigger when navigating back to the tab with keyboard.
+  return !(e.metaKey || !isMac() && e.altKey || e.ctrlKey || e.key === 'Control' || e.key === 'Shift' || e.key === 'Meta');
 }
 
 function $d01f69bb2ab5f70dfd0005370a2a2cbc$var$handleKeyboardEvent(e) {
@@ -844,18 +1004,20 @@ function $d01f69bb2ab5f70dfd0005370a2a2cbc$var$handleFocusEvent(e) {
   // This occurs, for example, when navigating a form with the next/previous buttons on iOS.
 
 
-  if (!$d01f69bb2ab5f70dfd0005370a2a2cbc$var$hasEventBeforeFocus) {
+  if (!$d01f69bb2ab5f70dfd0005370a2a2cbc$var$hasEventBeforeFocus && !$d01f69bb2ab5f70dfd0005370a2a2cbc$var$hasBlurredWindowRecently) {
     $d01f69bb2ab5f70dfd0005370a2a2cbc$var$currentModality = 'virtual';
     $d01f69bb2ab5f70dfd0005370a2a2cbc$var$triggerChangeHandlers('virtual', e);
   }
 
   $d01f69bb2ab5f70dfd0005370a2a2cbc$var$hasEventBeforeFocus = false;
+  $d01f69bb2ab5f70dfd0005370a2a2cbc$var$hasBlurredWindowRecently = false;
 }
 
 function $d01f69bb2ab5f70dfd0005370a2a2cbc$var$handleWindowBlur() {
   // When the window is blurred, reset state. This is necessary when tabbing out of the window,
   // for example, since a subsequent focus event won't be fired.
   $d01f69bb2ab5f70dfd0005370a2a2cbc$var$hasEventBeforeFocus = false;
+  $d01f69bb2ab5f70dfd0005370a2a2cbc$var$hasBlurredWindowRecently = true;
 }
 /**
  * Setup global event listeners to control when keyboard focus style should be visible.
@@ -940,40 +1102,56 @@ export function useInteractionModality() {
   }, []);
   return modality;
 }
+/**
+ * If this is attached to text input component, return if the event is a focus event (Tab/Escape keys pressed) so that
+ * focus visible style can be properly set.
+ */
+
+function $d01f69bb2ab5f70dfd0005370a2a2cbc$var$isKeyboardFocusEvent(isTextInput, modality, e) {
+  return !(isTextInput && modality === 'keyboard' && e instanceof KeyboardEvent && !$d01f69bb2ab5f70dfd0005370a2a2cbc$var$FOCUS_VISIBLE_INPUT_KEYS[e.key]);
+}
 /**
  * Manages focus visible state for the page, and subscribes individual components for updates.
  */
 
+
 export function useFocusVisible(props) {
   if (props === void 0) {
     props = {};
   }
 
-  $d01f69bb2ab5f70dfd0005370a2a2cbc$var$setupGlobalFocusEvents();
   let {
     isTextInput,
     autoFocus
   } = props;
   let [isFocusVisibleState, setFocusVisible] = useState(autoFocus || isFocusVisible());
+  useFocusVisibleListener(isFocusVisible => {
+    setFocusVisible(isFocusVisible);
+  }, [isTextInput], {
+    isTextInput
+  });
+  return {
+    isFocusVisible: isFocusVisibleState
+  };
+}
+/**
+ * Listens for trigger change and reports if focus is visible (i.e., modality is not pointer).
+ */
+
+export function useFocusVisibleListener(fn, deps, opts) {
+  $d01f69bb2ab5f70dfd0005370a2a2cbc$var$setupGlobalFocusEvents();
   useEffect(() => {
     let handler = (modality, e) => {
-      // If this is a text input component, don't update the focus visible style when
-      // typing except for when the Tab and Escape keys are pressed.
-      if (isTextInput && modality === 'keyboard' && e instanceof KeyboardEvent && !$d01f69bb2ab5f70dfd0005370a2a2cbc$var$FOCUS_VISIBLE_INPUT_KEYS[e.key]) {
+      if (!$d01f69bb2ab5f70dfd0005370a2a2cbc$var$isKeyboardFocusEvent(opts == null ? void 0 : opts.isTextInput, modality, e)) {
         return;
       }
 
-      setFocusVisible(isFocusVisible());
+      fn(isFocusVisible());
     };
 
     $d01f69bb2ab5f70dfd0005370a2a2cbc$var$changeHandlers.add(handler);
-    return () => {
-      $d01f69bb2ab5f70dfd0005370a2a2cbc$var$changeHandlers.delete(handler);
-    };
-  }, [isTextInput]);
-  return {
-    isFocusVisible: isFocusVisibleState
-  };
+    return () => $d01f69bb2ab5f70dfd0005370a2a2cbc$var$changeHandlers.delete(handler);
+  }, deps);
 }
 
 /**
@@ -1093,17 +1271,25 @@ export function useHover(props) {
   let [isHovered, setHovered] = useState(false);
   let state = useRef({
     isHovered: false,
-    ignoreEmulatedMouseEvents: false
+    ignoreEmulatedMouseEvents: false,
+    pointerType: '',
+    target: null
   }).current;
   useEffect($b1a784c66b81d90efa4f74e05b$var$setupGlobalTouchEvents, []);
-  let hoverProps = useMemo(() => {
+  let {
+    hoverProps,
+    triggerHoverEnd
+  } = useMemo(() => {
     let triggerHoverStart = (event, pointerType) => {
-      if (isDisabled || pointerType === 'touch' || state.isHovered) {
+      state.pointerType = pointerType;
+
+      if (isDisabled || pointerType === 'touch' || state.isHovered || !event.currentTarget.contains(event.target)) {
         return;
       }
 
       state.isHovered = true;
-      let target = event.target;
+      let target = event.currentTarget;
+      state.target = target;
 
       if (onHoverStart) {
         onHoverStart({
@@ -1121,12 +1307,15 @@ export function useHover(props) {
     };
 
     let triggerHoverEnd = (event, pointerType) => {
+      state.pointerType = '';
+      state.target = null;
+
       if (pointerType === 'touch' || !state.isHovered) {
         return;
       }
 
       state.isHovered = false;
-      let target = event.target;
+      let target = event.currentTarget;
 
       if (onHoverEnd) {
         onHoverEnd({
@@ -1155,7 +1344,9 @@ export function useHover(props) {
       };
 
       hoverProps.onPointerLeave = e => {
-        triggerHoverEnd(e, e.pointerType);
+        if (!isDisabled && e.currentTarget.contains(e.target)) {
+          triggerHoverEnd(e, e.pointerType);
+        }
       };
     } else {
       hoverProps.onTouchStart = () => {
@@ -1171,12 +1362,26 @@ export function useHover(props) {
       };
 
       hoverProps.onMouseLeave = e => {
-        triggerHoverEnd(e, 'mouse');
+        if (!isDisabled && e.currentTarget.contains(e.target)) {
+          triggerHoverEnd(e, 'mouse');
+        }
       };
     }
 
-    return hoverProps;
+    return {
+      hoverProps,
+      triggerHoverEnd
+    };
   }, [onHoverStart, onHoverChange, onHoverEnd, isDisabled, state]);
+  useEffect(() => {
+    // Call the triggerHoverEnd as soon as isDisabled changes to true
+    // Safe to call triggerHoverEnd, it will early return if we aren't currently hovering
+    if (isDisabled) {
+      triggerHoverEnd({
+        currentTarget: state.target
+      }, state.pointerType);
+    }
+  }, [isDisabled]);
   return {
     hoverProps,
     isHovered
@@ -1191,81 +1396,80 @@ export function useInteractOutside(props) {
   let {
     ref,
     onInteractOutside,
-    isDisabled
+    isDisabled,
+    onInteractOutsideStart
   } = props;
   let stateRef = useRef({
     isPointerDown: false,
-    ignoreEmulatedMouseEvents: false
+    ignoreEmulatedMouseEvents: false,
+    onInteractOutside,
+    onInteractOutsideStart
   });
   let state = stateRef.current;
+  state.onInteractOutside = onInteractOutside;
+  state.onInteractOutsideStart = onInteractOutsideStart;
   useEffect(() => {
+    if (isDisabled) {
+      return;
+    }
+
     let onPointerDown = e => {
-      if (isDisabled) {
-        return;
-      }
+      if ($e415bb64ab27cb8fbfac2f417412022f$var$isValidEvent(e, ref) && state.onInteractOutside) {
+        if (state.onInteractOutsideStart) {
+          state.onInteractOutsideStart(e);
+        }
 
-      if ($e415bb64ab27cb8fbfac2f417412022f$var$isValidEvent(e, ref)) {
         state.isPointerDown = true;
       }
-    };
-    /*
-    // FF bug https://bugzilla.mozilla.org/show_bug.cgi?id=1675846 prevents us from using this pointerevent
-    // once it's fixed we can uncomment
-    // Use pointer events if available. Otherwise, fall back to mouse and touch events.
+    }; // Use pointer events if available. Otherwise, fall back to mouse and touch events.
+
+
     if (typeof PointerEvent !== 'undefined') {
-      let onPointerUp = (e) => {
-        if (state.isPointerDown && onInteractOutside && isValidEvent(e, ref)) {
+      let onPointerUp = e => {
+        if (state.isPointerDown && state.onInteractOutside && $e415bb64ab27cb8fbfac2f417412022f$var$isValidEvent(e, ref)) {
           state.isPointerDown = false;
-          onInteractOutside(e);
+          state.onInteractOutside(e);
         }
-      };
-       // changing these to capture phase fixed combobox
+      }; // changing these to capture phase fixed combobox
+
+
       document.addEventListener('pointerdown', onPointerDown, true);
       document.addEventListener('pointerup', onPointerUp, true);
-       return () => {
+      return () => {
         document.removeEventListener('pointerdown', onPointerDown, true);
         document.removeEventListener('pointerup', onPointerUp, true);
       };
-    } else {*/
-
-
-    let onMouseUp = e => {
-      if (isDisabled) {
-        return;
-      }
-
-      if (state.ignoreEmulatedMouseEvents) {
-        state.ignoreEmulatedMouseEvents = false;
-      } else if (state.isPointerDown && onInteractOutside && $e415bb64ab27cb8fbfac2f417412022f$var$isValidEvent(e, ref)) {
-        state.isPointerDown = false;
-        onInteractOutside(e);
-      }
-    };
-
-    let onTouchEnd = e => {
-      if (isDisabled) {
-        return;
-      }
+    } else {
+      let onMouseUp = e => {
+        if (state.ignoreEmulatedMouseEvents) {
+          state.ignoreEmulatedMouseEvents = false;
+        } else if (state.isPointerDown && state.onInteractOutside && $e415bb64ab27cb8fbfac2f417412022f$var$isValidEvent(e, ref)) {
+          state.isPointerDown = false;
+          state.onInteractOutside(e);
+        }
+      };
 
-      state.ignoreEmulatedMouseEvents = true;
+      let onTouchEnd = e => {
+        state.ignoreEmulatedMouseEvents = true;
 
-      if (onInteractOutside && state.isPointerDown && $e415bb64ab27cb8fbfac2f417412022f$var$isValidEvent(e, ref)) {
-        state.isPointerDown = false;
-        onInteractOutside(e);
-      }
-    };
+        if (state.onInteractOutside && state.isPointerDown && $e415bb64ab27cb8fbfac2f417412022f$var$isValidEvent(e, ref)) {
+          state.isPointerDown = false;
+          state.onInteractOutside(e);
+        }
+      };
 
-    document.addEventListener('mousedown', onPointerDown, true);
-    document.addEventListener('mouseup', onMouseUp, true);
-    document.addEventListener('touchstart', onPointerDown, true);
-    document.addEventListener('touchend', onTouchEnd, true);
-    return () => {
-      document.removeEventListener('mousedown', onPointerDown, true);
-      document.removeEventListener('mouseup', onMouseUp, true);
-      document.removeEventListener('touchstart', onPointerDown, true);
-      document.removeEventListener('touchend', onTouchEnd, true);
-    };
-  }, [onInteractOutside, ref, state.ignoreEmulatedMouseEvents, state.isPointerDown, isDisabled]);
+      document.addEventListener('mousedown', onPointerDown, true);
+      document.addEventListener('mouseup', onMouseUp, true);
+      document.addEventListener('touchstart', onPointerDown, true);
+      document.addEventListener('touchend', onTouchEnd, true);
+      return () => {
+        document.removeEventListener('mousedown', onPointerDown, true);
+        document.removeEventListener('mouseup', onMouseUp, true);
+        document.removeEventListener('touchstart', onPointerDown, true);
+        document.removeEventListener('touchend', onTouchEnd, true);
+      };
+    }
+  }, [ref, state, isDisabled]);
 }
 
 function $e415bb64ab27cb8fbfac2f417412022f$var$isValidEvent(event, ref) {
@@ -1601,17 +1805,93 @@ export function useScrollWheel(props, ref) {
       });
     }
   }, [onScroll]);
-  useEffect(() => {
-    let elem = ref.current;
+  useEvent(ref, 'wheel', isDisabled ? null : onScrollHandler);
+}
+const $cd8e0096d064b4c36af8a188dfbda75c$var$DEFAULT_THRESHOLD = 500;
+/**
+ * Handles long press interactions across mouse and touch devices. Supports a customizable time threshold,
+ * accessibility description, and normalizes behavior across browsers and devices.
+ */
 
-    if (isDisabled) {
-      return;
+export function useLongPress(props) {
+  let {
+    isDisabled,
+    onLongPressStart,
+    onLongPressEnd,
+    onLongPress,
+    threshold = $cd8e0096d064b4c36af8a188dfbda75c$var$DEFAULT_THRESHOLD,
+    accessibilityDescription
+  } = props;
+  const timeRef = useRef(null);
+  let {
+    addGlobalListener,
+    removeGlobalListener
+  } = useGlobalListeners();
+  let {
+    pressProps
+  } = usePress({
+    isDisabled,
+
+    onPressStart(e) {
+      if (e.pointerType === 'mouse' || e.pointerType === 'touch') {
+        if (onLongPressStart) {
+          onLongPressStart(_babelRuntimeHelpersEsmExtends({}, e, {
+            type: 'longpressstart'
+          }));
+        }
+
+        timeRef.current = setTimeout(() => {
+          // Prevent other usePress handlers from also handling this event.
+          e.target.dispatchEvent(new PointerEvent('pointercancel', {
+            bubbles: true
+          }));
+
+          if (onLongPress) {
+            onLongPress(_babelRuntimeHelpersEsmExtends({}, e, {
+              type: 'longpress'
+            }));
+          }
+
+          timeRef.current = null;
+        }, threshold); // Prevent context menu, which may be opened on long press on touch devices
+
+        if (e.pointerType === 'touch') {
+          let onContextMenu = e => {
+            e.preventDefault();
+          };
+
+          addGlobalListener(e.target, 'contextmenu', onContextMenu, {
+            once: true
+          });
+          addGlobalListener(window, 'pointerup', () => {
+            // If no contextmenu event is fired quickly after pointerup, remove the handler
+            // so future context menu events outside a long press are not prevented.
+            setTimeout(() => {
+              removeGlobalListener(e.target, 'contextmenu', onContextMenu);
+            }, 30);
+          }, {
+            once: true
+          });
+        }
+      }
+    },
+
+    onPressEnd(e) {
+      if (timeRef.current) {
+        clearTimeout(timeRef.current);
+      }
+
+      if (onLongPressEnd && (e.pointerType === 'mouse' || e.pointerType === 'touch')) {
+        onLongPressEnd(_babelRuntimeHelpersEsmExtends({}, e, {
+          type: 'longpressend'
+        }));
+      }
     }
 
-    elem.addEventListener('wheel', onScrollHandler);
-    return () => {
-      elem.removeEventListener('wheel', onScrollHandler);
-    };
-  }, [onScrollHandler, ref, isDisabled]);
+  });
+  let descriptionProps = useDescription(onLongPress && !isDisabled ? accessibilityDescription : null);
+  return {
+    longPressProps: mergeProps(pressProps, descriptionProps)
+  };
 }
 //# sourceMappingURL=module.js.map