@tamagui/react-native-use-pressable 2.0.0-rc.4 → 2.0.0-rc.40

package/dist/cjs/PressResponder.cjs

@@ -3,91 +3,95 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
-    for (var name in all) __defProp(target, name, {
-      get: all[name],
-      enumerable: !0
-    });
-  },
-  __copyProps = (to, from, except, desc) => {
-    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
       get: () => from[key],
       enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
     });
-    return to;
-  };
+  }
+  return to;
+};
 var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
-  value: !0
+  value: true
 }), mod);
 var PressResponder_exports = {};
 __export(PressResponder_exports, {
   PressResponder: () => PressResponder
 });
 module.exports = __toCommonJS(PressResponder_exports);
-const DELAY = "DELAY",
-  ERROR = "ERROR",
-  LONG_PRESS_DETECTED = "LONG_PRESS_DETECTED",
-  NOT_RESPONDER = "NOT_RESPONDER",
-  RESPONDER_ACTIVE_LONG_PRESS_START = "RESPONDER_ACTIVE_LONG_PRESS_START",
-  RESPONDER_ACTIVE_PRESS_START = "RESPONDER_ACTIVE_PRESS_START",
-  RESPONDER_INACTIVE_PRESS_START = "RESPONDER_INACTIVE_PRESS_START",
-  RESPONDER_GRANT = "RESPONDER_GRANT",
-  RESPONDER_RELEASE = "RESPONDER_RELEASE",
-  RESPONDER_TERMINATED = "RESPONDER_TERMINATED",
-  Transitions = Object.freeze({
-    NOT_RESPONDER: {
-      DELAY: ERROR,
-      RESPONDER_GRANT: RESPONDER_INACTIVE_PRESS_START,
-      RESPONDER_RELEASE: ERROR,
-      RESPONDER_TERMINATED: ERROR,
-      LONG_PRESS_DETECTED: ERROR
-    },
-    RESPONDER_INACTIVE_PRESS_START: {
-      DELAY: RESPONDER_ACTIVE_PRESS_START,
-      RESPONDER_GRANT: ERROR,
-      RESPONDER_RELEASE: NOT_RESPONDER,
-      RESPONDER_TERMINATED: NOT_RESPONDER,
-      LONG_PRESS_DETECTED: ERROR
-    },
-    RESPONDER_ACTIVE_PRESS_START: {
-      DELAY: ERROR,
-      RESPONDER_GRANT: ERROR,
-      RESPONDER_RELEASE: NOT_RESPONDER,
-      RESPONDER_TERMINATED: NOT_RESPONDER,
-      LONG_PRESS_DETECTED: RESPONDER_ACTIVE_LONG_PRESS_START
-    },
-    RESPONDER_ACTIVE_LONG_PRESS_START: {
-      DELAY: ERROR,
-      RESPONDER_GRANT: ERROR,
-      RESPONDER_RELEASE: NOT_RESPONDER,
-      RESPONDER_TERMINATED: NOT_RESPONDER,
-      LONG_PRESS_DETECTED: RESPONDER_ACTIVE_LONG_PRESS_START
-    },
-    ERROR: {
-      DELAY: NOT_RESPONDER,
-      RESPONDER_GRANT: RESPONDER_INACTIVE_PRESS_START,
-      RESPONDER_RELEASE: NOT_RESPONDER,
-      RESPONDER_TERMINATED: NOT_RESPONDER,
-      LONG_PRESS_DETECTED: NOT_RESPONDER
-    }
-  }),
-  isActiveSignal = signal => signal === RESPONDER_ACTIVE_PRESS_START || signal === RESPONDER_ACTIVE_LONG_PRESS_START,
-  isButtonRole = element => element.getAttribute("role") === "button",
-  isPressStartSignal = signal => signal === RESPONDER_INACTIVE_PRESS_START || signal === RESPONDER_ACTIVE_PRESS_START || signal === RESPONDER_ACTIVE_LONG_PRESS_START,
-  isTerminalSignal = signal => signal === RESPONDER_TERMINATED || signal === RESPONDER_RELEASE,
-  isValidKeyPress = event => {
-    const key = event.key,
-      role = event.target.getAttribute("role");
-    return key === "Enter" || (key === " " || key === "Spacebar") && role === "button";
+const DELAY = "DELAY";
+const ERROR = "ERROR";
+const LONG_PRESS_DETECTED = "LONG_PRESS_DETECTED";
+const NOT_RESPONDER = "NOT_RESPONDER";
+const RESPONDER_ACTIVE_LONG_PRESS_START = "RESPONDER_ACTIVE_LONG_PRESS_START";
+const RESPONDER_ACTIVE_PRESS_START = "RESPONDER_ACTIVE_PRESS_START";
+const RESPONDER_INACTIVE_PRESS_START = "RESPONDER_INACTIVE_PRESS_START";
+const RESPONDER_GRANT = "RESPONDER_GRANT";
+const RESPONDER_RELEASE = "RESPONDER_RELEASE";
+const RESPONDER_TERMINATED = "RESPONDER_TERMINATED";
+const Transitions = Object.freeze({
+  NOT_RESPONDER: {
+    DELAY: ERROR,
+    RESPONDER_GRANT: RESPONDER_INACTIVE_PRESS_START,
+    RESPONDER_RELEASE: ERROR,
+    RESPONDER_TERMINATED: ERROR,
+    LONG_PRESS_DETECTED: ERROR
+  },
+  RESPONDER_INACTIVE_PRESS_START: {
+    DELAY: RESPONDER_ACTIVE_PRESS_START,
+    RESPONDER_GRANT: ERROR,
+    RESPONDER_RELEASE: NOT_RESPONDER,
+    RESPONDER_TERMINATED: NOT_RESPONDER,
+    LONG_PRESS_DETECTED: ERROR
+  },
+  RESPONDER_ACTIVE_PRESS_START: {
+    DELAY: ERROR,
+    RESPONDER_GRANT: ERROR,
+    RESPONDER_RELEASE: NOT_RESPONDER,
+    RESPONDER_TERMINATED: NOT_RESPONDER,
+    LONG_PRESS_DETECTED: RESPONDER_ACTIVE_LONG_PRESS_START
+  },
+  RESPONDER_ACTIVE_LONG_PRESS_START: {
+    DELAY: ERROR,
+    RESPONDER_GRANT: ERROR,
+    RESPONDER_RELEASE: NOT_RESPONDER,
+    RESPONDER_TERMINATED: NOT_RESPONDER,
+    LONG_PRESS_DETECTED: RESPONDER_ACTIVE_LONG_PRESS_START
   },
-  DEFAULT_LONG_PRESS_DELAY_MS = 450,
-  DEFAULT_PRESS_DELAY_MS = 50;
+  ERROR: {
+    DELAY: NOT_RESPONDER,
+    RESPONDER_GRANT: RESPONDER_INACTIVE_PRESS_START,
+    RESPONDER_RELEASE: NOT_RESPONDER,
+    RESPONDER_TERMINATED: NOT_RESPONDER,
+    LONG_PRESS_DETECTED: NOT_RESPONDER
+  }
+});
+const isActiveSignal = signal => signal === RESPONDER_ACTIVE_PRESS_START || signal === RESPONDER_ACTIVE_LONG_PRESS_START;
+const isButtonRole = element => element.getAttribute("role") === "button";
+const isPressStartSignal = signal => signal === RESPONDER_INACTIVE_PRESS_START || signal === RESPONDER_ACTIVE_PRESS_START || signal === RESPONDER_ACTIVE_LONG_PRESS_START;
+const isTerminalSignal = signal => signal === RESPONDER_TERMINATED || signal === RESPONDER_RELEASE;
+const isValidKeyPress = event => {
+  const key = event.key;
+  const target = event.target;
+  const role = target.getAttribute("role");
+  const isSpacebar = key === " " || key === "Spacebar";
+  return key === "Enter" || isSpacebar && role === "button";
+};
+const DEFAULT_LONG_PRESS_DELAY_MS = 450;
+const DEFAULT_PRESS_DELAY_MS = 50;
 class PressResponder {
   _touchActivatePosition = null;
   _pressDelayTimeout = 0;
-  _selectionTerminated = !1;
-  _isPointerTouch = !1;
+  _selectionTerminated = false;
+  _isPointerTouch = false;
   _longPressDelayTimeout = 0;
-  _longPressDispatched = !1;
+  _longPressDispatched = false;
   _pressOutDelayTimeout = 0;
   _touchState = NOT_RESPONDER;
   _config = null;
@@ -102,75 +106,120 @@ class PressResponder {
    * Resets any pending timers. This should be called on unmount.
    */
   reset() {
-    this._cancelLongPressDelayTimeout(), this._cancelPressDelayTimeout(), this._cancelPressOutDelayTimeout();
+    this._cancelLongPressDelayTimeout();
+    this._cancelPressDelayTimeout();
+    this._cancelPressOutDelayTimeout();
   }
   /**
    * Returns a set of props to spread into the interactive element.
    */
   getEventHandlers() {
-    return this._eventHandlers == null && (this._eventHandlers = this._createEventHandlers()), this._eventHandlers;
+    if (this._eventHandlers == null) {
+      this._eventHandlers = this._createEventHandlers();
+    }
+    return this._eventHandlers;
   }
   _createEventHandlers() {
     const start = (event, shouldDelay) => {
-        event.persist(), this._cancelPressOutDelayTimeout(), this._longPressDispatched = !1, this._selectionTerminated = !1, this._touchState = NOT_RESPONDER, this._isPointerTouch = event.nativeEvent.type === "touchstart", this._receiveSignal(RESPONDER_GRANT, event);
-        const delayPressStart = normalizeDelay(this._config.delayPressStart, 0, DEFAULT_PRESS_DELAY_MS);
-        shouldDelay !== !1 && delayPressStart > 0 ? this._pressDelayTimeout = setTimeout(() => {
+      event.persist();
+      this._cancelPressOutDelayTimeout();
+      this._longPressDispatched = false;
+      this._selectionTerminated = false;
+      this._touchState = NOT_RESPONDER;
+      this._isPointerTouch = event.nativeEvent.type === "touchstart";
+      this._receiveSignal(RESPONDER_GRANT, event);
+      const delayPressStart = normalizeDelay(this._config.delayPressStart, 0, DEFAULT_PRESS_DELAY_MS);
+      if (shouldDelay !== false && delayPressStart > 0) {
+        this._pressDelayTimeout = setTimeout(() => {
           this._receiveSignal(DELAY, event);
-        }, delayPressStart) : this._receiveSignal(DELAY, event);
-        const delayLongPress = normalizeDelay(this._config.delayLongPress, 10, DEFAULT_LONG_PRESS_DELAY_MS);
-        this._longPressDelayTimeout = setTimeout(() => {
-          this._handleLongPress(event);
-        }, delayLongPress + delayPressStart);
-      },
-      end = event => {
-        this._receiveSignal(RESPONDER_RELEASE, event);
-      },
-      keyupHandler = event => {
-        const onPress = this._config.onPress,
-          target = event.target;
-        if (this._touchState !== NOT_RESPONDER && isValidKeyPress(event)) {
-          end(event), document.removeEventListener("keyup", keyupHandler);
-          const role = target.getAttribute("role"),
-            elementType = target.tagName.toLowerCase(),
-            isNativeInteractiveElement = role === "link" || elementType === "a" || elementType === "button" || elementType === "input" || elementType === "select" || elementType === "textarea";
-          onPress != null && !isNativeInteractiveElement && onPress(event);
+        }, delayPressStart);
+      } else {
+        this._receiveSignal(DELAY, event);
+      }
+      const delayLongPress = normalizeDelay(this._config.delayLongPress, 10, DEFAULT_LONG_PRESS_DELAY_MS);
+      this._longPressDelayTimeout = setTimeout(() => {
+        this._handleLongPress(event);
+      }, delayLongPress + delayPressStart);
+    };
+    const end = event => {
+      this._receiveSignal(RESPONDER_RELEASE, event);
+    };
+    const keyupHandler = event => {
+      const onPress = this._config.onPress;
+      const target = event.target;
+      if (this._touchState !== NOT_RESPONDER && isValidKeyPress(event)) {
+        end(event);
+        document.removeEventListener("keyup", keyupHandler);
+        const role = target.getAttribute("role");
+        const elementType = target.tagName.toLowerCase();
+        const isNativeInteractiveElement = role === "link" || elementType === "a" || elementType === "button" || elementType === "input" || elementType === "select" || elementType === "textarea";
+        if (onPress != null && !isNativeInteractiveElement) {
+          onPress(event);
         }
-      };
+      }
+    };
     return {
       onStartShouldSetResponder: event => {
         const disabled = this._config.disabled;
-        return disabled && isButtonRole(event.currentTarget) && event.stopPropagation(), disabled == null ? !0 : !disabled;
+        if (disabled && isButtonRole(event.currentTarget)) {
+          event.stopPropagation();
+        }
+        if (disabled == null) {
+          return true;
+        }
+        return !disabled;
       },
       onKeyDown: event => {
-        const disabled = this._config.disabled,
-          key = event.key,
-          target = event.target;
+        const disabled = this._config.disabled;
+        const key = event.key;
+        const target = event.target;
         if (!disabled && isValidKeyPress(event)) {
-          this._touchState === NOT_RESPONDER && (start(event, !1), document.addEventListener("keyup", keyupHandler));
+          if (this._touchState === NOT_RESPONDER) {
+            start(event, false);
+            document.addEventListener("keyup", keyupHandler);
+          }
           const role = target.getAttribute("role");
-          (key === " " || key === "Spacebar") && (role === "button" || role === "menuitem") && event.preventDefault(), event.stopPropagation();
+          const isSpacebarKey = key === " " || key === "Spacebar";
+          const _isButtonRole = role === "button" || role === "menuitem";
+          if (isSpacebarKey && _isButtonRole) {
+            event.preventDefault();
+          }
+          event.stopPropagation();
         }
       },
       onResponderGrant: event => start(event),
       onResponderMove: event => {
-        this._config.onPressMove != null && this._config.onPressMove(event);
+        if (this._config.onPressMove != null) {
+          this._config.onPressMove(event);
+        }
         const touch = getTouchFromResponderEvent(event);
         if (this._touchActivatePosition != null) {
-          const deltaX = this._touchActivatePosition.pageX - touch.pageX,
-            deltaY = this._touchActivatePosition.pageY - touch.pageY;
-          Math.hypot(deltaX, deltaY) > 10 && this._cancelLongPressDelayTimeout();
+          const deltaX = this._touchActivatePosition.pageX - touch.pageX;
+          const deltaY = this._touchActivatePosition.pageY - touch.pageY;
+          if (Math.hypot(deltaX, deltaY) > 10) {
+            this._cancelLongPressDelayTimeout();
+          }
         }
       },
       onResponderRelease: event => end(event),
       onResponderTerminate: event => {
-        event.nativeEvent.type === "selectionchange" && (this._selectionTerminated = !0), this._receiveSignal(RESPONDER_TERMINATED, event);
+        if (event.nativeEvent.type === "selectionchange") {
+          this._selectionTerminated = true;
+        }
+        this._receiveSignal(RESPONDER_TERMINATED, event);
       },
       onResponderTerminationRequest: event => {
-        const _this$_config = this._config,
-          cancelable = _this$_config.cancelable,
-          disabled = _this$_config.disabled,
-          onLongPress = _this$_config.onLongPress;
-        return !disabled && onLongPress != null && this._isPointerTouch && event.nativeEvent.type === "contextmenu" ? !1 : cancelable ?? !0;
+        const _this$_config = this._config;
+        const cancelable = _this$_config.cancelable;
+        const disabled = _this$_config.disabled;
+        const onLongPress = _this$_config.onLongPress;
+        if (!disabled && onLongPress != null && this._isPointerTouch && event.nativeEvent.type === "contextmenu") {
+          return false;
+        }
+        if (cancelable == null) {
+          return true;
+        }
+        return cancelable;
       },
       // NOTE: this diverges from react-native in 3 significant ways:
       // * The `onPress` callback is not connected to the responder system (the native
@@ -181,18 +230,38 @@ class PressResponder {
       //   `click` target that is using the PressResponder.
       // * The event's `nativeEvent` is a `MouseEvent` not a `TouchEvent`.
       onClick: event => {
-        const _this$_config2 = this._config,
-          disabled = _this$_config2.disabled,
-          onPress = _this$_config2.onPress;
-        disabled ? isButtonRole(event.currentTarget) && event.stopPropagation() : (event.stopPropagation(), this._longPressDispatched || this._selectionTerminated ? event.preventDefault() : onPress != null && event.altKey === !1 && onPress(event));
+        const _this$_config2 = this._config;
+        const disabled = _this$_config2.disabled;
+        const onPress = _this$_config2.onPress;
+        if (!disabled) {
+          event.stopPropagation();
+          if (this._longPressDispatched || this._selectionTerminated) {
+            event.preventDefault();
+          } else if (onPress != null && event.altKey === false) {
+            onPress(event);
+          }
+        } else {
+          if (isButtonRole(event.currentTarget)) {
+            event.stopPropagation();
+          }
+        }
       },
       // If `onLongPress` is provided and a touch pointer is being used, prevent the
       // default context menu from opening.
       onContextMenu: event => {
-        const _this$_config3 = this._config,
-          disabled = _this$_config3.disabled,
-          onLongPress = _this$_config3.onLongPress;
-        disabled ? isButtonRole(event.currentTarget) && event.stopPropagation() : onLongPress != null && this._isPointerTouch && !event.defaultPrevented && (event.preventDefault(), event.stopPropagation());
+        const _this$_config3 = this._config;
+        const disabled = _this$_config3.disabled;
+        const onLongPress = _this$_config3.onLongPress;
+        if (!disabled) {
+          if (onLongPress != null && this._isPointerTouch && !event.defaultPrevented) {
+            event.preventDefault();
+            event.stopPropagation();
+          }
+        } else {
+          if (isButtonRole(event.currentTarget)) {
+            event.stopPropagation();
+          }
+        }
       }
     };
   }
@@ -203,69 +272,140 @@ class PressResponder {
   _receiveSignal(signal, event) {
     const prevState = this._touchState;
     let nextState = null;
-    Transitions[prevState] != null && (nextState = Transitions[prevState][signal]), !(this._touchState === NOT_RESPONDER && signal === RESPONDER_RELEASE) && (nextState == null || nextState === ERROR ? console.error(`PressResponder: Invalid signal ${signal} for state ${prevState} on responder`) : prevState !== nextState && (this._performTransitionSideEffects(prevState, nextState, signal, event), this._touchState = nextState));
+    if (Transitions[prevState] != null) {
+      nextState = Transitions[prevState][signal];
+    }
+    if (this._touchState === NOT_RESPONDER && signal === RESPONDER_RELEASE) {
+      return;
+    }
+    if (nextState == null || nextState === ERROR) {
+      console.error(`PressResponder: Invalid signal ${signal} for state ${prevState} on responder`);
+    } else if (prevState !== nextState) {
+      this._performTransitionSideEffects(prevState, nextState, signal, event);
+      this._touchState = nextState;
+    }
   }
   /**
    * Performs a transition between touchable states and identify any activations
    * or deactivations (and callback invocations).
    */
   _performTransitionSideEffects(prevState, nextState, signal, event) {
-    if (isTerminalSignal(signal) && (setTimeout(() => {
-      this._isPointerTouch = !1;
-    }, 0), this._touchActivatePosition = null, this._cancelLongPressDelayTimeout()), isPressStartSignal(prevState) && signal === LONG_PRESS_DETECTED) {
+    if (isTerminalSignal(signal)) {
+      setTimeout(() => {
+        this._isPointerTouch = false;
+      }, 0);
+      this._touchActivatePosition = null;
+      this._cancelLongPressDelayTimeout();
+    }
+    if (isPressStartSignal(prevState) && signal === LONG_PRESS_DETECTED) {
       const onLongPress = this._config.onLongPress;
-      onLongPress != null && event.nativeEvent.key == null && (onLongPress(event), this._longPressDispatched = !0);
+      if (onLongPress != null && event.nativeEvent.key == null) {
+        onLongPress(event);
+        this._longPressDispatched = true;
+      }
+    }
+    const isPrevActive = isActiveSignal(prevState);
+    const isNextActive = isActiveSignal(nextState);
+    if (!isPrevActive && isNextActive) {
+      this._activate(event);
+    } else if (isPrevActive && !isNextActive) {
+      this._deactivate(event);
     }
-    const isPrevActive = isActiveSignal(prevState),
-      isNextActive = isActiveSignal(nextState);
-    if (!isPrevActive && isNextActive ? this._activate(event) : isPrevActive && !isNextActive && this._deactivate(event), isPressStartSignal(prevState) && signal === RESPONDER_RELEASE) {
-      const _this$_config4 = this._config,
-        _onLongPress = _this$_config4.onLongPress;
-      _this$_config4.onPress != null && (_onLongPress != null && prevState === RESPONDER_ACTIVE_LONG_PRESS_START || isNextActive || isPrevActive || (this._activate(event), this._deactivate(event)));
+    if (isPressStartSignal(prevState) && signal === RESPONDER_RELEASE) {
+      const _this$_config4 = this._config;
+      const _onLongPress = _this$_config4.onLongPress;
+      const onPress = _this$_config4.onPress;
+      if (onPress != null) {
+        const isPressCanceledByLongPress = _onLongPress != null && prevState === RESPONDER_ACTIVE_LONG_PRESS_START;
+        if (!isPressCanceledByLongPress) {
+          if (!(isNextActive || isPrevActive)) {
+            this._activate(event);
+            this._deactivate(event);
+          }
+        }
+      }
     }
     this._cancelPressDelayTimeout();
   }
   _activate(event) {
-    const _this$_config5 = this._config,
-      onPressChange = _this$_config5.onPressChange,
-      onPressStart = _this$_config5.onPressStart,
-      touch = getTouchFromResponderEvent(event);
+    const _this$_config5 = this._config;
+    const onPressChange = _this$_config5.onPressChange;
+    const onPressStart = _this$_config5.onPressStart;
+    const touch = getTouchFromResponderEvent(event);
     this._touchActivatePosition = {
       pageX: touch.pageX,
       pageY: touch.pageY
-    }, onPressStart?.(event), onPressChange?.(!0);
+    };
+    if (onPressStart != null) {
+      onPressStart(event);
+    }
+    if (onPressChange != null) {
+      onPressChange(true);
+    }
   }
   _deactivate(event) {
-    const _this$_config6 = this._config,
-      onPressChange = _this$_config6.onPressChange,
-      onPressEnd = _this$_config6.onPressEnd;
+    const _this$_config6 = this._config;
+    const onPressChange = _this$_config6.onPressChange;
+    const onPressEnd = _this$_config6.onPressEnd;
     function end() {
-      onPressEnd?.(event), onPressChange?.(!1);
+      if (onPressEnd != null) {
+        onPressEnd(event);
+      }
+      if (onPressChange != null) {
+        onPressChange(false);
+      }
     }
     const delayPressEnd = normalizeDelay(this._config.delayPressEnd);
-    delayPressEnd > 0 ? this._pressOutDelayTimeout = setTimeout(() => {
+    if (delayPressEnd > 0) {
+      this._pressOutDelayTimeout = setTimeout(() => {
+        end();
+      }, delayPressEnd);
+    } else {
       end();
-    }, delayPressEnd) : end();
+    }
   }
   _handleLongPress(event) {
-    (this._touchState === RESPONDER_ACTIVE_PRESS_START || this._touchState === RESPONDER_ACTIVE_LONG_PRESS_START) && this._receiveSignal(LONG_PRESS_DETECTED, event);
+    if (this._touchState === RESPONDER_ACTIVE_PRESS_START || this._touchState === RESPONDER_ACTIVE_LONG_PRESS_START) {
+      this._receiveSignal(LONG_PRESS_DETECTED, event);
+    }
   }
   _cancelLongPressDelayTimeout() {
-    this._longPressDelayTimeout != null && (clearTimeout(this._longPressDelayTimeout), this._longPressDelayTimeout = null);
+    if (this._longPressDelayTimeout != null) {
+      clearTimeout(this._longPressDelayTimeout);
+      this._longPressDelayTimeout = null;
+    }
   }
   _cancelPressDelayTimeout() {
-    this._pressDelayTimeout != null && (clearTimeout(this._pressDelayTimeout), this._pressDelayTimeout = null);
+    if (this._pressDelayTimeout != null) {
+      clearTimeout(this._pressDelayTimeout);
+      this._pressDelayTimeout = null;
+    }
   }
   _cancelPressOutDelayTimeout() {
-    this._pressOutDelayTimeout != null && (clearTimeout(this._pressOutDelayTimeout), this._pressOutDelayTimeout = null);
+    if (this._pressOutDelayTimeout != null) {
+      clearTimeout(this._pressOutDelayTimeout);
+      this._pressOutDelayTimeout = null;
+    }
   }
 }
 function normalizeDelay(delay, min, fallback) {
-  return min === void 0 && (min = 0), fallback === void 0 && (fallback = 0), Math.max(min, delay ?? fallback);
+  if (min === void 0) {
+    min = 0;
+  }
+  if (fallback === void 0) {
+    fallback = 0;
+  }
+  return Math.max(min, delay !== null && delay !== void 0 ? delay : fallback);
 }
 function getTouchFromResponderEvent(event) {
-  const _event$nativeEvent = event.nativeEvent,
-    changedTouches = _event$nativeEvent.changedTouches,
-    touches = _event$nativeEvent.touches;
-  return touches != null && touches.length > 0 ? touches[0] : changedTouches != null && changedTouches.length > 0 ? changedTouches[0] : event.nativeEvent;
+  const _event$nativeEvent = event.nativeEvent;
+  const changedTouches = _event$nativeEvent.changedTouches;
+  const touches = _event$nativeEvent.touches;
+  if (touches != null && touches.length > 0) {
+    return touches[0];
+  }
+  if (changedTouches != null && changedTouches.length > 0) {
+    return changedTouches[0];
+  }
+  return event.nativeEvent;
 }