@redsift/design-system 11.6.0-muiv5-alpha.11 → 11.6.0-muiv5-alpha.12

package/packages/design-system/src/react-aria/react-aria/interactions/_internal/usePress.js

@@ -1,769 +0,0 @@
-import { objectWithoutProperties as _objectWithoutProperties, defineProperty as _defineProperty, classPrivateFieldInitSpec as _classPrivateFieldInitSpec, classPrivateFieldSet as _classPrivateFieldSet, classPrivateFieldGet as _classPrivateFieldGet } from '../../../../../../../_virtual/_internal/_rollupPluginBabelHelpers.js';
-import { disableTextSelection, restoreTextSelection } from './textSelection.js';
-import { PressResponderContext } from './context.js';
-import { useState, useRef, useMemo, useEffect, useContext } from 'react';
-import { useGlobalListeners } from '../../utils/_internal/useGlobalListeners.js';
-import { useEffectEvent } from '../../utils/_internal/useEffectEvent.js';
-import { isVirtualPointerEvent, isVirtualClick } from '../../utils/_internal/isVirtualEvent.js';
-import { focusWithoutScrolling } from '../../utils/_internal/focusWithoutScrolling.js';
-import { getOwnerDocument, getOwnerWindow } from '../../utils/_internal/domHelpers.js';
-import { mergeProps } from '../../utils/_internal/mergeProps.js';
-import { useSyncRef } from '../../utils/_internal/useSyncRef.js';
-import { chain } from '../../utils/_internal/chain.js';
-import { isMac } from '../../utils/_internal/platform.js';
-import { openLink } from '../../utils/_internal/openLink.js';
-
-const _excluded = ["register"],
-  _excluded2 = ["onPress", "onPressChange", "onPressStart", "onPressEnd", "onPressUp", "isDisabled", "isPressed", "preventFocusOnPress", "shouldCancelOnPointerExit", "allowTextSelectionOnPress", "ref"];
-function usePressResponderContext(props) {
-  // Consume context from <PressResponder> and merge with props.
-  let context = useContext(PressResponderContext);
-  if (context) {
-    let {
-        register
-      } = context,
-      contextProps = _objectWithoutProperties(context, _excluded);
-    props = mergeProps(contextProps, props);
-    register();
-  }
-  useSyncRef(context, props.ref);
-  return props;
-}
-var _shouldStopPropagation = /*#__PURE__*/new WeakMap();
-class PressEvent {
-  constructor(type, pointerType, originalEvent, state) {
-    var _state$target;
-    _defineProperty(this, "type", void 0);
-    _defineProperty(this, "pointerType", void 0);
-    _defineProperty(this, "target", void 0);
-    _defineProperty(this, "shiftKey", void 0);
-    _defineProperty(this, "ctrlKey", void 0);
-    _defineProperty(this, "metaKey", void 0);
-    _defineProperty(this, "altKey", void 0);
-    _defineProperty(this, "x", void 0);
-    _defineProperty(this, "y", void 0);
-    _classPrivateFieldInitSpec(this, _shouldStopPropagation, {
-      writable: true,
-      value: true
-    });
-    let currentTarget = (_state$target = state === null || state === void 0 ? void 0 : state.target) !== null && _state$target !== void 0 ? _state$target : originalEvent.currentTarget;
-    const rect = currentTarget === null || currentTarget === void 0 ? void 0 : currentTarget.getBoundingClientRect();
-    let x,
-      y = 0;
-    let clientX,
-      clientY = null;
-    if (originalEvent.clientX != null && originalEvent.clientY != null) {
-      clientX = originalEvent.clientX;
-      clientY = originalEvent.clientY;
-    }
-    if (rect) {
-      if (clientX != null && clientY != null) {
-        x = clientX - rect.left;
-        y = clientY - rect.top;
-      } else {
-        x = rect.width / 2;
-        y = rect.height / 2;
-      }
-    }
-    this.type = type;
-    this.pointerType = pointerType;
-    this.target = originalEvent.currentTarget;
-    this.shiftKey = originalEvent.shiftKey;
-    this.metaKey = originalEvent.metaKey;
-    this.ctrlKey = originalEvent.ctrlKey;
-    this.altKey = originalEvent.altKey;
-    this.x = x;
-    this.y = y;
-  }
-  continuePropagation() {
-    _classPrivateFieldSet(this, _shouldStopPropagation, false);
-  }
-  get shouldStopPropagation() {
-    return _classPrivateFieldGet(this, _shouldStopPropagation);
-  }
-}
-const LINK_CLICKED = Symbol('linkClicked');
-
-/**
- * Handles press interactions across mouse, touch, keyboard, and screen readers.
- * It normalizes behavior across browsers and platforms, and handles many nuances
- * of dealing with pointer and keyboard events.
- */
-function usePress(props) {
-  let _usePressResponderCon = usePressResponderContext(props),
-    {
-      onPress,
-      onPressChange,
-      onPressStart,
-      onPressEnd,
-      onPressUp,
-      isDisabled,
-      isPressed: isPressedProp,
-      preventFocusOnPress,
-      shouldCancelOnPointerExit,
-      allowTextSelectionOnPress,
-      // eslint-disable-next-line @typescript-eslint/no-unused-vars
-      ref: _ // Removing `ref` from `domProps` because TypeScript is dumb
-    } = _usePressResponderCon,
-    domProps = _objectWithoutProperties(_usePressResponderCon, _excluded2);
-  let [isPressed, setPressed] = useState(false);
-  let ref = useRef({
-    isPressed: false,
-    ignoreEmulatedMouseEvents: false,
-    ignoreClickAfterPress: false,
-    didFirePressStart: false,
-    isTriggeringEvent: false,
-    activePointerId: null,
-    target: null,
-    isOverTarget: false,
-    pointerType: null
-  });
-  let {
-    addGlobalListener,
-    removeAllGlobalListeners
-  } = useGlobalListeners();
-  let triggerPressStart = useEffectEvent((originalEvent, pointerType) => {
-    let state = ref.current;
-    if (isDisabled || state.didFirePressStart) {
-      return false;
-    }
-    let shouldStopPropagation = true;
-    state.isTriggeringEvent = true;
-    if (onPressStart) {
-      let event = new PressEvent('pressstart', pointerType, originalEvent);
-      onPressStart(event);
-      shouldStopPropagation = event.shouldStopPropagation;
-    }
-    if (onPressChange) {
-      onPressChange(true);
-    }
-    state.isTriggeringEvent = false;
-    state.didFirePressStart = true;
-    setPressed(true);
-    return shouldStopPropagation;
-  });
-  let triggerPressEnd = useEffectEvent(function (originalEvent, pointerType) {
-    let wasPressed = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
-    let state = ref.current;
-    if (!state.didFirePressStart) {
-      return false;
-    }
-    state.ignoreClickAfterPress = true;
-    state.didFirePressStart = false;
-    state.isTriggeringEvent = true;
-    let shouldStopPropagation = true;
-    if (onPressEnd) {
-      let event = new PressEvent('pressend', pointerType, originalEvent);
-      onPressEnd(event);
-      shouldStopPropagation = event.shouldStopPropagation;
-    }
-    if (onPressChange) {
-      onPressChange(false);
-    }
-    setPressed(false);
-    if (onPress && wasPressed && !isDisabled) {
-      let event = new PressEvent('press', pointerType, originalEvent);
-      onPress(event);
-      shouldStopPropagation &&= event.shouldStopPropagation;
-    }
-    state.isTriggeringEvent = false;
-    return shouldStopPropagation;
-  });
-  let triggerPressUp = useEffectEvent((originalEvent, pointerType) => {
-    let state = ref.current;
-    if (isDisabled) {
-      return false;
-    }
-    if (onPressUp) {
-      state.isTriggeringEvent = true;
-      let event = new PressEvent('pressup', pointerType, originalEvent);
-      onPressUp(event);
-      state.isTriggeringEvent = false;
-      return event.shouldStopPropagation;
-    }
-    return true;
-  });
-  let cancel = useEffectEvent(e => {
-    let state = ref.current;
-    if (state.isPressed && state.target) {
-      if (state.isOverTarget && state.pointerType != null) {
-        triggerPressEnd(createEvent(state.target, e), state.pointerType, false);
-      }
-      state.isPressed = false;
-      state.isOverTarget = false;
-      state.activePointerId = null;
-      state.pointerType = null;
-      removeAllGlobalListeners();
-      if (!allowTextSelectionOnPress) {
-        restoreTextSelection(state.target);
-      }
-    }
-  });
-  let cancelOnPointerExit = useEffectEvent(e => {
-    if (shouldCancelOnPointerExit) {
-      cancel(e);
-    }
-  });
-  let pressProps = useMemo(() => {
-    let state = ref.current;
-    let pressProps = {
-      onKeyDown(e) {
-        if (isValidKeyboardEvent(e.nativeEvent, e.currentTarget) && e.currentTarget.contains(e.target)) {
-          if (shouldPreventDefaultKeyboard(e.target, e.key)) {
-            e.preventDefault();
-          }
-
-          // 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
-          // only handle the first key down event.
-          let shouldStopPropagation = true;
-          if (!state.isPressed && !e.repeat) {
-            state.target = e.currentTarget;
-            state.isPressed = true;
-            shouldStopPropagation = triggerPressStart(e, 'keyboard');
-
-            // Focus may move before the key up event, so register the event on the document
-            // instead of the same element where the key down event occurred. Make it capturing so that it will trigger
-            // before stopPropagation from useKeyboard on a child element may happen and thus we can still call triggerPress for the parent element.
-            let originalTarget = e.currentTarget;
-            let pressUp = e => {
-              if (isValidKeyboardEvent(e, originalTarget) && !e.repeat && originalTarget.contains(e.target) && state.target) {
-                triggerPressUp(createEvent(state.target, e), 'keyboard');
-              }
-            };
-            addGlobalListener(getOwnerDocument(e.currentTarget), 'keyup', chain(pressUp, onKeyUp), true);
-          }
-          if (shouldStopPropagation) {
-            e.stopPropagation();
-          }
-
-          // Keep track of the keydown events that occur while the Meta (e.g. Command) key is held.
-          // macOS has a bug where keyup events are not fired while the Meta key is down.
-          // When the Meta key itself is released we will get an event for that, and we'll act as if
-          // all of these other keys were released as well.
-          // https://bugs.chromium.org/p/chromium/issues/detail?id=1393524
-          // https://bugs.webkit.org/show_bug.cgi?id=55291
-          // https://bugzilla.mozilla.org/show_bug.cgi?id=1299553
-          if (e.metaKey && isMac()) {
-            var _state$metaKeyEvents;
-            (_state$metaKeyEvents = state.metaKeyEvents) === null || _state$metaKeyEvents === void 0 ? void 0 : _state$metaKeyEvents.set(e.key, e.nativeEvent);
-          }
-        } else if (e.key === 'Meta') {
-          state.metaKeyEvents = new Map();
-        }
-      },
-      onClick(e) {
-        if (e && !e.currentTarget.contains(e.target)) {
-          return;
-        }
-        if (e && e.button === 0 && !state.isTriggeringEvent && !openLink.isOpening) {
-          let shouldStopPropagation = true;
-          if (isDisabled) {
-            e.preventDefault();
-          }
-
-          // If triggered from a screen reader or by using element.click(),
-          // trigger as if it were a keyboard click.
-          if (!state.ignoreClickAfterPress && !state.ignoreEmulatedMouseEvents && !state.isPressed && (state.pointerType === 'virtual' || isVirtualClick(e.nativeEvent))) {
-            // Ensure the element receives focus (VoiceOver on iOS does not do this)
-            if (!isDisabled && !preventFocusOnPress) {
-              focusWithoutScrolling(e.currentTarget);
-            }
-            let stopPressStart = triggerPressStart(e, 'virtual');
-            let stopPressUp = triggerPressUp(e, 'virtual');
-            let stopPressEnd = triggerPressEnd(e, 'virtual');
-            shouldStopPropagation = stopPressStart && stopPressUp && stopPressEnd;
-          }
-          state.ignoreEmulatedMouseEvents = false;
-          state.ignoreClickAfterPress = false;
-          if (shouldStopPropagation) {
-            e.stopPropagation();
-          }
-        }
-      }
-    };
-    let onKeyUp = e => {
-      var _state$metaKeyEvents3;
-      if (state.isPressed && state.target && isValidKeyboardEvent(e, state.target)) {
-        var _state$metaKeyEvents2;
-        if (shouldPreventDefaultKeyboard(e.target, e.key)) {
-          e.preventDefault();
-        }
-        let target = e.target;
-        triggerPressEnd(createEvent(state.target, e), 'keyboard', state.target.contains(target));
-        removeAllGlobalListeners();
-
-        // If a link was triggered with a key other than Enter, open the URL ourselves.
-        // This means the link has a role override, and the default browser behavior
-        // only applies when using the Enter key.
-        if (e.key !== 'Enter' && isHTMLAnchorLink(state.target) && state.target.contains(target) && !e[LINK_CLICKED]) {
-          // Store a hidden property on the event so we only trigger link click once,
-          // even if there are multiple usePress instances attached to the element.
-          e[LINK_CLICKED] = true;
-          openLink(state.target, e, false);
-        }
-        state.isPressed = false;
-        (_state$metaKeyEvents2 = state.metaKeyEvents) === null || _state$metaKeyEvents2 === void 0 ? void 0 : _state$metaKeyEvents2.delete(e.key);
-      } else if (e.key === 'Meta' && (_state$metaKeyEvents3 = state.metaKeyEvents) !== null && _state$metaKeyEvents3 !== void 0 && _state$metaKeyEvents3.size) {
-        // If we recorded keydown events that occurred while the Meta key was pressed,
-        // and those haven't received keyup events already, fire keyup events ourselves.
-        // See comment above for more info about the macOS bug causing this.
-        let events = state.metaKeyEvents;
-        state.metaKeyEvents = undefined;
-        for (let event of events.values()) {
-          var _state$target2;
-          (_state$target2 = state.target) === null || _state$target2 === void 0 ? void 0 : _state$target2.dispatchEvent(new KeyboardEvent('keyup', event));
-        }
-      }
-    };
-    if (typeof PointerEvent !== 'undefined') {
-      pressProps.onPointerDown = e => {
-        // 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 (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.
-        if (shouldPreventDefault(e.currentTarget)) {
-          e.preventDefault();
-        }
-        state.pointerType = e.pointerType;
-        let shouldStopPropagation = true;
-        if (!state.isPressed) {
-          state.isPressed = true;
-          state.isOverTarget = true;
-          state.activePointerId = e.pointerId;
-          state.target = e.currentTarget;
-          if (!isDisabled && !preventFocusOnPress) {
-            focusWithoutScrolling(e.currentTarget);
-          }
-          if (!allowTextSelectionOnPress) {
-            disableTextSelection(state.target);
-          }
-          shouldStopPropagation = triggerPressStart(e, state.pointerType);
-          addGlobalListener(getOwnerDocument(e.currentTarget), 'pointermove', onPointerMove, false);
-          addGlobalListener(getOwnerDocument(e.currentTarget), 'pointerup', onPointerUp, false);
-          addGlobalListener(getOwnerDocument(e.currentTarget), 'pointercancel', onPointerCancel, false);
-        }
-        if (shouldStopPropagation) {
-          e.stopPropagation();
-        }
-      };
-      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
-          // focus event will be fired.
-          if (shouldPreventDefault(e.currentTarget)) {
-            e.preventDefault();
-          }
-          e.stopPropagation();
-        }
-      };
-      pressProps.onPointerUp = e => {
-        // 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 && isOverTarget(e, e.currentTarget)) {
-          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.
-      // See https://bugs.webkit.org/show_bug.cgi?id=199803
-      let onPointerMove = e => {
-        if (e.pointerId !== state.activePointerId) {
-          return;
-        }
-        if (state.target && isOverTarget(e, state.target)) {
-          if (!state.isOverTarget && state.pointerType != null) {
-            state.isOverTarget = true;
-            triggerPressStart(createEvent(state.target, e), state.pointerType);
-          }
-        } else if (state.target && state.isOverTarget && state.pointerType != null) {
-          state.isOverTarget = false;
-          triggerPressEnd(createEvent(state.target, e), state.pointerType, false);
-          cancelOnPointerExit(e);
-        }
-      };
-      let onPointerUp = e => {
-        if (e.pointerId === state.activePointerId && state.isPressed && e.button === 0 && state.target) {
-          if (isOverTarget(e, state.target) && state.pointerType != null) {
-            triggerPressEnd(createEvent(state.target, e), state.pointerType);
-          } else if (state.isOverTarget && state.pointerType != null) {
-            triggerPressEnd(createEvent(state.target, e), state.pointerType, false);
-          }
-          state.isPressed = false;
-          state.isOverTarget = false;
-          state.activePointerId = null;
-          state.pointerType = null;
-          removeAllGlobalListeners();
-          if (!allowTextSelectionOnPress) {
-            restoreTextSelection(state.target);
-          }
-        }
-      };
-      let onPointerCancel = e => {
-        cancel(e);
-      };
-      pressProps.onDragStart = e => {
-        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 || !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.
-        if (shouldPreventDefault(e.currentTarget)) {
-          e.preventDefault();
-        }
-        if (state.ignoreEmulatedMouseEvents) {
-          e.stopPropagation();
-          return;
-        }
-        state.isPressed = true;
-        state.isOverTarget = true;
-        state.target = e.currentTarget;
-        state.pointerType = isVirtualClick(e.nativeEvent) ? 'virtual' : 'mouse';
-        if (!isDisabled && !preventFocusOnPress) {
-          focusWithoutScrolling(e.currentTarget);
-        }
-        let shouldStopPropagation = triggerPressStart(e, state.pointerType);
-        if (shouldStopPropagation) {
-          e.stopPropagation();
-        }
-        addGlobalListener(getOwnerDocument(e.currentTarget), 'mouseup', onMouseUp, false);
-      };
-      pressProps.onMouseEnter = e => {
-        if (!e.currentTarget.contains(e.target)) {
-          return;
-        }
-        let shouldStopPropagation = true;
-        if (state.isPressed && !state.ignoreEmulatedMouseEvents && state.pointerType != null) {
-          state.isOverTarget = true;
-          shouldStopPropagation = triggerPressStart(e, state.pointerType);
-        }
-        if (shouldStopPropagation) {
-          e.stopPropagation();
-        }
-      };
-      pressProps.onMouseLeave = e => {
-        if (!e.currentTarget.contains(e.target)) {
-          return;
-        }
-        let shouldStopPropagation = true;
-        if (state.isPressed && !state.ignoreEmulatedMouseEvents && state.pointerType != null) {
-          state.isOverTarget = false;
-          shouldStopPropagation = triggerPressEnd(e, state.pointerType, false);
-          cancelOnPointerExit(e);
-        }
-        if (shouldStopPropagation) {
-          e.stopPropagation();
-        }
-      };
-      pressProps.onMouseUp = e => {
-        if (!e.currentTarget.contains(e.target)) {
-          return;
-        }
-        if (!state.ignoreEmulatedMouseEvents && e.button === 0) {
-          triggerPressUp(e, state.pointerType || 'mouse');
-        }
-      };
-      let onMouseUp = e => {
-        // Only handle left clicks
-        if (e.button !== 0) {
-          return;
-        }
-        state.isPressed = false;
-        removeAllGlobalListeners();
-        if (state.ignoreEmulatedMouseEvents) {
-          state.ignoreEmulatedMouseEvents = false;
-          return;
-        }
-        if (state.target && isOverTarget(e, state.target) && state.pointerType != null) {
-          triggerPressEnd(createEvent(state.target, e), state.pointerType);
-        } else if (state.target && state.isOverTarget && state.pointerType != null) {
-          triggerPressEnd(createEvent(state.target, e), state.pointerType, false);
-        }
-        state.isOverTarget = false;
-      };
-      pressProps.onTouchStart = e => {
-        if (!e.currentTarget.contains(e.target)) {
-          return;
-        }
-        let touch = getTouchFromEvent(e.nativeEvent);
-        if (!touch) {
-          return;
-        }
-        state.activePointerId = touch.identifier;
-        state.ignoreEmulatedMouseEvents = true;
-        state.isOverTarget = true;
-        state.isPressed = true;
-        state.target = e.currentTarget;
-        state.pointerType = 'touch';
-
-        // Due to browser inconsistencies, especially on mobile browsers, we prevent default
-        // on the emulated mouse event and handle focusing the pressable element ourselves.
-        if (!isDisabled && !preventFocusOnPress) {
-          focusWithoutScrolling(e.currentTarget);
-        }
-        if (!allowTextSelectionOnPress) {
-          disableTextSelection(state.target);
-        }
-        let shouldStopPropagation = triggerPressStart(createTouchEvent(state.target, e), state.pointerType);
-        if (shouldStopPropagation) {
-          e.stopPropagation();
-        }
-        addGlobalListener(getOwnerWindow(e.currentTarget), 'scroll', onScroll, true);
-      };
-      pressProps.onTouchMove = e => {
-        if (!e.currentTarget.contains(e.target)) {
-          return;
-        }
-        if (!state.isPressed) {
-          e.stopPropagation();
-          return;
-        }
-        let touch = getTouchById(e.nativeEvent, state.activePointerId);
-        let shouldStopPropagation = true;
-        if (touch && isOverTarget(touch, e.currentTarget)) {
-          if (!state.isOverTarget && state.pointerType != null) {
-            state.isOverTarget = true;
-            shouldStopPropagation = triggerPressStart(createTouchEvent(state.target, e), state.pointerType);
-          }
-        } else if (state.isOverTarget && state.pointerType != null) {
-          state.isOverTarget = false;
-          shouldStopPropagation = triggerPressEnd(createTouchEvent(state.target, e), state.pointerType, false);
-          cancelOnPointerExit(createTouchEvent(state.target, e));
-        }
-        if (shouldStopPropagation) {
-          e.stopPropagation();
-        }
-      };
-      pressProps.onTouchEnd = e => {
-        if (!e.currentTarget.contains(e.target)) {
-          return;
-        }
-        if (!state.isPressed) {
-          e.stopPropagation();
-          return;
-        }
-        let touch = getTouchById(e.nativeEvent, state.activePointerId);
-        let shouldStopPropagation = true;
-        if (touch && isOverTarget(touch, e.currentTarget) && state.pointerType != null) {
-          triggerPressUp(createTouchEvent(state.target, e), state.pointerType);
-          shouldStopPropagation = triggerPressEnd(createTouchEvent(state.target, e), state.pointerType);
-        } else if (state.isOverTarget && state.pointerType != null) {
-          shouldStopPropagation = triggerPressEnd(createTouchEvent(state.target, e), state.pointerType, false);
-        }
-        if (shouldStopPropagation) {
-          e.stopPropagation();
-        }
-        state.isPressed = false;
-        state.activePointerId = null;
-        state.isOverTarget = false;
-        state.ignoreEmulatedMouseEvents = true;
-        if (state.target && !allowTextSelectionOnPress) {
-          restoreTextSelection(state.target);
-        }
-        removeAllGlobalListeners();
-      };
-      pressProps.onTouchCancel = e => {
-        if (!e.currentTarget.contains(e.target)) {
-          return;
-        }
-        e.stopPropagation();
-        if (state.isPressed) {
-          cancel(createTouchEvent(state.target, e));
-        }
-      };
-      let onScroll = e => {
-        if (state.isPressed && e.target.contains(state.target)) {
-          cancel({
-            currentTarget: state.target,
-            shiftKey: false,
-            ctrlKey: false,
-            metaKey: false,
-            altKey: false
-          });
-        }
-      };
-      pressProps.onDragStart = e => {
-        if (!e.currentTarget.contains(e.target)) {
-          return;
-        }
-        cancel(e);
-      };
-    }
-    return pressProps;
-  }, [addGlobalListener, isDisabled, preventFocusOnPress, removeAllGlobalListeners, allowTextSelectionOnPress, cancel, cancelOnPointerExit, triggerPressEnd, triggerPressStart, triggerPressUp]);
-
-  // Remove user-select: none in case component unmounts immediately after pressStart
-  // eslint-disable-next-line arrow-body-style
-  useEffect(() => {
-    return () => {
-      if (!allowTextSelectionOnPress) {
-        var _ref$current$target;
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-        restoreTextSelection((_ref$current$target = ref.current.target) !== null && _ref$current$target !== void 0 ? _ref$current$target : undefined);
-      }
-    };
-  }, [allowTextSelectionOnPress]);
-  return {
-    isPressed: isPressedProp || isPressed,
-    pressProps: mergeProps(domProps, pressProps)
-  };
-}
-function isHTMLAnchorLink(target) {
-  return target.tagName === 'A' && target.hasAttribute('href');
-}
-function isValidKeyboardEvent(event, currentTarget) {
-  const {
-    key,
-    code
-  } = event;
-  const element = currentTarget;
-  const role = element.getAttribute('role');
-  // Accessibility for keyboards. Space and Enter only.
-  // "Spacebar" is for IE 11
-  return (key === 'Enter' || key === ' ' || key === 'Spacebar' || code === 'Space') && !(element instanceof getOwnerWindow(element).HTMLInputElement && !isValidInputKey(element, key) || element instanceof getOwnerWindow(element).HTMLTextAreaElement || element.isContentEditable) &&
-  // Links should only trigger with Enter key
-  !((role === 'link' || !role && isHTMLAnchorLink(element)) && key !== 'Enter');
-}
-function getTouchFromEvent(event) {
-  const {
-    targetTouches
-  } = event;
-  if (targetTouches.length > 0) {
-    return targetTouches[0];
-  }
-  return null;
-}
-function getTouchById(event, pointerId) {
-  const changedTouches = event.changedTouches;
-  for (let i = 0; i < changedTouches.length; i++) {
-    const touch = changedTouches[i];
-    if (touch.identifier === pointerId) {
-      return touch;
-    }
-  }
-  return null;
-}
-function createTouchEvent(target, e) {
-  let clientX = 0;
-  let clientY = 0;
-  if (e.targetTouches && e.targetTouches.length === 1) {
-    clientX = e.targetTouches[0].clientX;
-    clientY = e.targetTouches[0].clientY;
-  }
-  return {
-    currentTarget: target,
-    shiftKey: e.shiftKey,
-    ctrlKey: e.ctrlKey,
-    metaKey: e.metaKey,
-    altKey: e.altKey,
-    clientX,
-    clientY
-  };
-}
-function createEvent(target, e) {
-  let clientX = e.clientX;
-  let clientY = e.clientY;
-  return {
-    currentTarget: target,
-    shiftKey: e.shiftKey,
-    ctrlKey: e.ctrlKey,
-    metaKey: e.metaKey,
-    altKey: e.altKey,
-    clientX,
-    clientY
-  };
-}
-function getPointClientRect(point) {
-  let offsetX = 0;
-  let offsetY = 0;
-  if (point.width !== undefined) {
-    offsetX = point.width / 2;
-  } else if (point.radiusX !== undefined) {
-    offsetX = point.radiusX;
-  }
-  if (point.height !== undefined) {
-    offsetY = point.height / 2;
-  } else if (point.radiusY !== undefined) {
-    offsetY = point.radiusY;
-  }
-  return {
-    top: point.clientY - offsetY,
-    right: point.clientX + offsetX,
-    bottom: point.clientY + offsetY,
-    left: point.clientX - offsetX
-  };
-}
-function 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 isOverTarget(point, target) {
-  let rect = target.getBoundingClientRect();
-  let pointRect = getPointClientRect(point);
-  return areRectanglesOverlapping(rect, pointRect);
-}
-function shouldPreventDefault(target) {
-  // We cannot prevent default if the target is a draggable element.
-  return !(target instanceof HTMLElement) || !target.hasAttribute('draggable');
-}
-function shouldPreventDefaultKeyboard(target, key) {
-  if (target instanceof HTMLInputElement) {
-    return !isValidInputKey(target, key);
-  }
-  if (target instanceof HTMLButtonElement) {
-    return target.type !== 'submit' && target.type !== 'reset';
-  }
-  if (isHTMLAnchorLink(target)) {
-    return false;
-  }
-  return true;
-}
-const nonTextInputTypes = new Set(['checkbox', 'radio', 'range', 'color', 'file', 'image', 'button', 'submit', 'reset']);
-function isValidInputKey(target, key) {
-  // Only space should toggle checkboxes and radios, not enter.
-  return target.type === 'checkbox' || target.type === 'radio' ? key === ' ' : nonTextInputTypes.has(target.type);
-}
-
-export { usePress };
-//# sourceMappingURL=usePress.js.map