react-native-gesture-handler 3.0.0-beta.2 → 3.0.0-beta.3

package/lib/commonjs/web/handlers/GestureHandler.js

@@ -1,857 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-var _State = require("../../State");
-var _interfaces = require("../interfaces");
-var _GestureHandlerOrchestrator = _interopRequireDefault(require("../tools/GestureHandlerOrchestrator"));
-var _InteractionManager = _interopRequireDefault(require("../tools/InteractionManager"));
-var _PointerTracker = _interopRequireDefault(require("../tools/PointerTracker"));
-var _gestureHandlerCommon = require("../../handlers/gestureHandlerCommon");
-var _PointerType = require("../../PointerType");
-var _ActionType = require("../../ActionType");
-var _utils = require("../../utils");
-var _TouchEventType = require("../../TouchEventType");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-/* eslint-disable @typescript-eslint/no-empty-function */
-
-class GestureHandler {
-  lastSentState = null;
-  _state = _State.State.UNDETERMINED;
-  _shouldCancelWhenOutside = false;
-  _enabled = null;
-  viewRef = null;
-  propsRef = null;
-  actionType = null;
-  forAnimated = false;
-  forReanimated = false;
-  _testID = undefined;
-  hitSlop = undefined;
-  manualActivation = false;
-  mouseButton = undefined;
-  needsPointerData = false;
-  _tracker = new _PointerTracker.default();
-  _enableContextMenu = false;
-  _activeCursor = undefined;
-  _touchAction = undefined;
-  _userSelect = undefined;
-
-  // Orchestrator properties
-  _activationIndex = 0;
-  _awaiting = false;
-  _active = false;
-  _attached = false;
-  _shouldResetProgress = false;
-  _pointerType = _PointerType.PointerType.MOUSE;
-  constructor(delegate) {
-    this._delegate = delegate;
-  }
-
-  //
-  // Initializing handler
-  //
-
-  init(viewRef, propsRef, actionType) {
-    this.attached = true;
-    this.propsRef = propsRef;
-    this.viewRef = viewRef;
-    this.actionType = actionType;
-    this.state = _State.State.UNDETERMINED;
-    this.delegate.init(viewRef, this);
-  }
-  detach() {
-    if (this.state === _State.State.ACTIVE) {
-      this.cancel();
-    } else {
-      this.fail();
-    }
-    this.propsRef = null;
-    this.viewRef = null;
-    this.actionType = null;
-    this.state = _State.State.UNDETERMINED;
-    this.forAnimated = false;
-    this.forReanimated = false;
-    this.attached = false;
-    this.delegate.detach();
-  }
-  attachEventManager(manager) {
-    manager.setOnPointerDown(this.onPointerDown.bind(this));
-    manager.setOnPointerAdd(this.onPointerAdd.bind(this));
-    manager.setOnPointerUp(this.onPointerUp.bind(this));
-    manager.setOnPointerRemove(this.onPointerRemove.bind(this));
-    manager.setOnPointerMove(this.onPointerMove.bind(this));
-    manager.setOnPointerEnter(this.onPointerEnter.bind(this));
-    manager.setOnPointerLeave(this.onPointerLeave.bind(this));
-    manager.setOnPointerCancel(this.onPointerCancel.bind(this));
-    manager.setOnPointerOutOfBounds(this.onPointerOutOfBounds.bind(this));
-    manager.setOnPointerMoveOver(this.onPointerMoveOver.bind(this));
-    manager.setOnPointerMoveOut(this.onPointerMoveOut.bind(this));
-    manager.setOnWheel(this.onWheel.bind(this));
-    manager.registerListeners();
-  }
-
-  //
-  // Resetting handler
-  //
-
-  onCancel() {}
-  onReset() {}
-  resetProgress() {}
-  reset() {
-    this.tracker.resetTracker();
-    this.onReset();
-    this.resetProgress();
-    this.delegate.reset();
-    this.state = _State.State.UNDETERMINED;
-  }
-
-  //
-  // State logic
-  //
-
-  moveToState(newState, sendIfDisabled) {
-    if (this.state === newState) {
-      return;
-    }
-    const oldState = this.state;
-    this.state = newState;
-    if (this.tracker.trackedPointersCount > 0 && this.needsPointerData && this.isFinished()) {
-      this.cancelTouches();
-    }
-    _GestureHandlerOrchestrator.default.instance.onHandlerStateChange(this, newState, oldState, sendIfDisabled);
-    this.onStateChange(newState, oldState);
-    if (!this.enabled && this.isFinished()) {
-      this.state = _State.State.UNDETERMINED;
-    }
-  }
-  onStateChange(_newState, _oldState) {}
-  begin() {
-    if (!this.checkHitSlop()) {
-      return;
-    }
-    if (this.state === _State.State.UNDETERMINED) {
-      this.moveToState(_State.State.BEGAN);
-    }
-  }
-
-  /**
-   * @param {boolean} sendIfDisabled - Used when handler becomes disabled. With this flag orchestrator will be forced to send fail event
-   */
-  fail(sendIfDisabled) {
-    if (this.state === _State.State.ACTIVE || this.state === _State.State.BEGAN) {
-      // Here the order of calling the delegate and moveToState is important.
-      // At this point we can use currentState as previuos state, because immediately after changing cursor we call moveToState method.
-      this.delegate.onFail();
-      this.moveToState(_State.State.FAILED, sendIfDisabled);
-    }
-    this.resetProgress();
-  }
-
-  /**
-   * @param {boolean} sendIfDisabled - Used when handler becomes disabled. With this flag orchestrator will be forced to send cancel event
-   */
-  cancel(sendIfDisabled) {
-    if (this.state === _State.State.ACTIVE || this.state === _State.State.UNDETERMINED || this.state === _State.State.BEGAN) {
-      this.onCancel();
-
-      // Same as above - order matters
-      this.delegate.onCancel();
-      this.moveToState(_State.State.CANCELLED, sendIfDisabled);
-    }
-  }
-  activate(force = false) {
-    if ((this.manualActivation !== true || force) && (this.state === _State.State.UNDETERMINED || this.state === _State.State.BEGAN)) {
-      this.delegate.onActivate();
-      this.moveToState(_State.State.ACTIVE);
-    }
-  }
-  end() {
-    if (this.state === _State.State.BEGAN || this.state === _State.State.ACTIVE) {
-      // Same as above - order matters
-      this.delegate.onEnd();
-      this.moveToState(_State.State.END);
-    }
-    this.resetProgress();
-  }
-
-  //
-  // Methods for orchestrator
-  //
-
-  getShouldResetProgress() {
-    return this.shouldResetProgress;
-  }
-  setShouldResetProgress(value) {
-    this.shouldResetProgress = value;
-  }
-  shouldWaitForHandlerFailure(handler) {
-    if (handler === this) {
-      return false;
-    }
-    return _InteractionManager.default.instance.shouldWaitForHandlerFailure(this, handler);
-  }
-  shouldRequireToWaitForFailure(handler) {
-    if (handler === this) {
-      return false;
-    }
-    return _InteractionManager.default.instance.shouldRequireHandlerToWaitForFailure(this, handler);
-  }
-  shouldRecognizeSimultaneously(handler) {
-    if (handler === this) {
-      return true;
-    }
-    return _InteractionManager.default.instance.shouldRecognizeSimultaneously(this, handler);
-  }
-  shouldBeCancelledByOther(handler) {
-    if (handler === this) {
-      return false;
-    }
-    return _InteractionManager.default.instance.shouldHandlerBeCancelledBy(this, handler);
-  }
-  shouldAttachGestureToChildView() {
-    return false;
-  }
-
-  //
-  // Event actions
-  //
-
-  onPointerDown(event) {
-    _GestureHandlerOrchestrator.default.instance.recordHandlerIfNotPresent(this);
-    this._pointerType = event.pointerType;
-    if (this.pointerType === _PointerType.PointerType.TOUCH) {
-      _GestureHandlerOrchestrator.default.instance.cancelMouseAndPenGestures(this);
-    }
-    this.tryToSendTouchEvent(event);
-  }
-  // Adding another pointer to existing ones
-  onPointerAdd(event) {
-    this.tryToSendTouchEvent(event);
-  }
-  onPointerUp(event) {
-    this.tryToSendTouchEvent(event);
-  }
-  // Removing pointer, when there is more than one pointers
-  onPointerRemove(event) {
-    this.tryToSendTouchEvent(event);
-  }
-  onPointerMove(event) {
-    this.tryToSendMoveEvent(false, event);
-  }
-  onPointerLeave(event) {
-    if (this.shouldCancelWhenOutside) {
-      switch (this.state) {
-        case _State.State.ACTIVE:
-          this.cancel();
-          break;
-        case _State.State.BEGAN:
-          this.fail();
-          break;
-      }
-      return;
-    }
-    this.tryToSendTouchEvent(event);
-  }
-  onPointerEnter(event) {
-    this.tryToSendTouchEvent(event);
-  }
-  onPointerCancel(_event) {
-    // No need to send a cancel touch event explicitly here. `cancel` will
-    // handle cancelling all tracked touches if the handler expects pointer data.
-    this.cancel();
-    this.reset();
-  }
-  onPointerOutOfBounds(event) {
-    this.tryToSendMoveEvent(true, event);
-  }
-  onPointerMoveOver(_event) {
-    // Used only by hover gesture handler atm
-  }
-  onPointerMoveOut(_event) {
-    // Used only by hover gesture handler atm
-  }
-  onWheel(_event) {
-    // Used only by pan gesture handler
-  }
-  tryToSendMoveEvent(out, event) {
-    if (out && this.shouldCancelWhenOutside || !this.enabled) {
-      return;
-    }
-    this.tryToSendTouchEvent(event);
-    if (this.active) {
-      this.sendEvent(this.state, this.state);
-    }
-  }
-  tryToSendTouchEvent(event) {
-    if (this.needsPointerData) {
-      this.sendTouchEvent(event);
-    }
-  }
-  sendTouchEvent(event) {
-    if (!this.enabled) {
-      return;
-    }
-    this.ensurePropsRef();
-    const {
-      onGestureHandlerEvent,
-      onGestureHandlerTouchEvent,
-      onGestureHandlerReanimatedTouchEvent
-    } = this.propsRef.current;
-    const touchEvent = this.transformTouchEvent(event);
-    if (!touchEvent) {
-      return;
-    }
-    if ((0, _ActionType.usesNativeOrVirtualDetector)(this.actionType)) {
-      invokeNullableMethod(this.forReanimated ? onGestureHandlerReanimatedTouchEvent : onGestureHandlerTouchEvent, touchEvent);
-    } else {
-      invokeNullableMethod(onGestureHandlerEvent, touchEvent);
-    }
-  }
-
-  //
-  // Events Sending
-  //
-
-  sendEvent = (newState, oldState) => {
-    const {
-      onGestureHandlerEvent,
-      onGestureHandlerStateChange,
-      onGestureHandlerAnimatedEvent,
-      onGestureHandlerReanimatedEvent,
-      onGestureHandlerReanimatedStateChange
-    } = this.propsRef.current;
-    const resultEvent = !(0, _ActionType.usesNativeOrVirtualDetector)(this.actionType) ? this.transformEventData(newState, oldState) : this.lastSentState !== newState ? this.transformStateChangeEvent(newState, oldState) : this.transformUpdateEvent(newState);
-
-    // In the v2 API oldState field has to be undefined, unless we send event state changed
-    // Here the order is flipped to avoid workarounds such as making backup of the state and setting it to undefined first, then changing it back
-    // Flipping order with setting oldState to undefined solves issue, when events were being sent twice instead of once
-    // However, this may cause trouble in the future (but for now we don't know that)
-    if (this.lastSentState !== newState) {
-      this.lastSentState = newState;
-      invokeNullableMethod(this.forReanimated ? onGestureHandlerReanimatedStateChange : onGestureHandlerStateChange, resultEvent);
-    }
-    if (this.state === _State.State.ACTIVE) {
-      resultEvent.nativeEvent.oldState = undefined;
-      invokeNullableMethod(this.forReanimated ? onGestureHandlerReanimatedEvent : this.forAnimated ? onGestureHandlerAnimatedEvent : onGestureHandlerEvent, resultEvent);
-    }
-  };
-  transformEventData(newState, oldState) {
-    this.ensureViewRef(this.viewRef);
-    return {
-      nativeEvent: {
-        numberOfPointers: this.tracker.trackedPointersCount,
-        state: newState,
-        ...this.transformNativeEvent(),
-        handlerTag: this.handlerTag,
-        oldState: newState !== oldState ? oldState : undefined,
-        pointerType: this.pointerType
-      },
-      timeStamp: Date.now()
-    };
-  }
-  transformStateChangeEvent(newState, oldState) {
-    this.ensureViewRef(this.viewRef);
-    return {
-      nativeEvent: {
-        state: newState,
-        handlerTag: this.handlerTag,
-        oldState: oldState,
-        handlerData: {
-          numberOfPointers: this.tracker.trackedPointersCount,
-          pointerType: this.pointerType,
-          ...this.transformNativeEvent()
-        }
-      },
-      timeStamp: Date.now()
-    };
-  }
-  transformUpdateEvent(newState) {
-    this.ensureViewRef(this.viewRef);
-    return {
-      nativeEvent: {
-        state: newState,
-        handlerTag: this.handlerTag,
-        handlerData: {
-          pointerType: this.pointerType,
-          numberOfPointers: this.tracker.trackedPointersCount,
-          ...this.transformNativeEvent()
-        }
-      },
-      timeStamp: Date.now()
-    };
-  }
-  transformTouchEvent(event) {
-    const rect = this.delegate.measureView();
-    const all = [];
-    const changed = [];
-    const trackerData = this.tracker.trackedPointers;
-
-    // This if handles edge case where all pointers have been cancelled
-    // When pointercancel is triggered, reset method is called. This means that tracker will be reset after first pointer being cancelled
-    // The problem is, that handler will receive another pointercancel event from the rest of the pointers
-    // To avoid crashing, we don't send event if tracker tracks no pointers, i.e. has been reset
-    if (trackerData.size === 0 || !trackerData.has(event.pointerId)) {
-      return;
-    }
-    trackerData.forEach((element, key) => {
-      const id = this.tracker.getMappedTouchEventId(key);
-      all.push({
-        id: id,
-        x: element.abosoluteCoords.x - rect.pageX,
-        y: element.abosoluteCoords.y - rect.pageY,
-        absoluteX: element.abosoluteCoords.x,
-        absoluteY: element.abosoluteCoords.y
-      });
-    });
-
-    // Each pointer sends its own event, so we want changed touches to contain only the pointer that has changed.
-    // However, if the event is cancel, we want to cancel all pointers to avoid crashes
-    if (event.eventType !== _interfaces.EventTypes.CANCEL) {
-      changed.push({
-        id: this.tracker.getMappedTouchEventId(event.pointerId),
-        x: event.x - rect.pageX,
-        y: event.y - rect.pageY,
-        absoluteX: event.x,
-        absoluteY: event.y
-      });
-    } else {
-      trackerData.forEach((element, key) => {
-        const id = this.tracker.getMappedTouchEventId(key);
-        changed.push({
-          id: id,
-          x: element.abosoluteCoords.x - rect.pageX,
-          y: element.abosoluteCoords.y - rect.pageY,
-          absoluteX: element.abosoluteCoords.x,
-          absoluteY: element.abosoluteCoords.y
-        });
-      });
-    }
-    let eventType = _TouchEventType.TouchEventType.UNDETERMINED;
-    switch (event.eventType) {
-      case _interfaces.EventTypes.DOWN:
-      case _interfaces.EventTypes.ADDITIONAL_POINTER_DOWN:
-        eventType = _TouchEventType.TouchEventType.TOUCHES_DOWN;
-        break;
-      case _interfaces.EventTypes.UP:
-      case _interfaces.EventTypes.ADDITIONAL_POINTER_UP:
-        eventType = _TouchEventType.TouchEventType.TOUCHES_UP;
-        break;
-      case _interfaces.EventTypes.MOVE:
-        eventType = _TouchEventType.TouchEventType.TOUCHES_MOVE;
-        break;
-      case _interfaces.EventTypes.CANCEL:
-        eventType = _TouchEventType.TouchEventType.TOUCHES_CANCEL;
-        break;
-    }
-
-    // Here, when we receive up event, we want to decrease number of touches
-    // That's because we want handler to send information that there's one pointer less
-    // However, we still want this pointer to be present in allTouches array, so that its data can be accessed
-    let numberOfTouches = all.length;
-    if (event.eventType === _interfaces.EventTypes.UP || event.eventType === _interfaces.EventTypes.ADDITIONAL_POINTER_UP) {
-      --numberOfTouches;
-    }
-    return {
-      nativeEvent: {
-        handlerTag: this.handlerTag,
-        state: this.state,
-        eventType: eventType,
-        changedTouches: changed,
-        allTouches: all,
-        numberOfTouches: numberOfTouches,
-        pointerType: this.pointerType
-      },
-      timeStamp: Date.now()
-    };
-  }
-  cancelTouches() {
-    this.ensurePropsRef();
-    const rect = this.delegate.measureView();
-    const all = [];
-    const changed = [];
-    const trackerData = this.tracker.trackedPointers;
-    if (trackerData.size === 0) {
-      return;
-    }
-    trackerData.forEach((element, key) => {
-      const id = this.tracker.getMappedTouchEventId(key);
-      all.push({
-        id: id,
-        x: element.abosoluteCoords.x - rect.pageX,
-        y: element.abosoluteCoords.y - rect.pageY,
-        absoluteX: element.abosoluteCoords.x,
-        absoluteY: element.abosoluteCoords.y
-      });
-      changed.push({
-        id: id,
-        x: element.abosoluteCoords.x - rect.pageX,
-        y: element.abosoluteCoords.y - rect.pageY,
-        absoluteX: element.abosoluteCoords.x,
-        absoluteY: element.abosoluteCoords.y
-      });
-    });
-    const cancelEvent = {
-      nativeEvent: {
-        handlerTag: this.handlerTag,
-        state: this.state,
-        eventType: _TouchEventType.TouchEventType.TOUCHES_CANCEL,
-        changedTouches: changed,
-        allTouches: all,
-        numberOfTouches: all.length,
-        pointerType: this.pointerType
-      },
-      timeStamp: Date.now()
-    };
-    const {
-      onGestureHandlerEvent,
-      onGestureHandlerReanimatedTouchEvent,
-      onGestureHandlerTouchEvent
-    } = this.propsRef.current;
-    if (this.actionType === _ActionType.ActionType.NATIVE_DETECTOR) {
-      invokeNullableMethod(this.forReanimated ? onGestureHandlerReanimatedTouchEvent : onGestureHandlerTouchEvent, cancelEvent);
-    } else {
-      invokeNullableMethod(onGestureHandlerEvent, cancelEvent);
-    }
-  }
-  ensurePropsRef() {
-    if (!this.propsRef) {
-      throw new Error((0, _utils.tagMessage)('Cannot handle event when component props are null'));
-    }
-  }
-  ensureViewRef(viewRef) {
-    if (!viewRef) {
-      throw new Error((0, _utils.tagMessage)('Cannot handle event when target is null'));
-    }
-  }
-  transformNativeEvent() {
-    // Those properties are shared by most handlers and if not this method will be overriden
-    const lastCoords = this.tracker.getAbsoluteCoordsAverage();
-    const lastRelativeCoords = this.tracker.getRelativeCoordsAverage();
-    return {
-      x: lastRelativeCoords.x,
-      y: lastRelativeCoords.y,
-      absoluteX: lastCoords.x,
-      absoluteY: lastCoords.y
-    };
-  }
-
-  //
-  // Handling config
-  //
-
-  // Helper function to correctly set enabled property
-  maybeUpdateEnabled(enabled) {
-    if (enabled === undefined) {
-      if (this._enabled !== null) {
-        return false;
-      }
-      this._enabled = true;
-      return true;
-    }
-    const prevEnabled = this._enabled;
-    this._enabled = enabled;
-    return enabled !== prevEnabled;
-  }
-  setGestureConfig(config) {
-    this.resetConfig();
-    this.updateGestureConfig(config);
-  }
-  updateGestureConfig(config) {
-    const enabledChanged = this.maybeUpdateEnabled(config.enabled);
-    if (config.hitSlop !== undefined) {
-      this.hitSlop = config.hitSlop;
-      this.hitSlop = config.hitSlop;
-      this.validateHitSlops();
-    }
-    if (config.testID !== undefined) {
-      this._testID = config.testID;
-    }
-    if (config.dispatchesAnimatedEvents !== undefined) {
-      this.forAnimated = config.dispatchesAnimatedEvents;
-    }
-    if (config.dispatchesReanimatedEvents !== undefined) {
-      this.forReanimated = config.dispatchesReanimatedEvents;
-    }
-    if (config.manualActivation !== undefined) {
-      this.manualActivation = config.manualActivation;
-    }
-    if (config.mouseButton !== undefined) {
-      this.mouseButton = config.mouseButton;
-    }
-    if (config.needsPointerData !== undefined) {
-      this.needsPointerData = config.needsPointerData;
-    }
-    if (config.shouldCancelWhenOutside !== undefined) {
-      this.shouldCancelWhenOutside = config.shouldCancelWhenOutside;
-    }
-    if (config.activeCursor !== undefined) {
-      this._activeCursor = config.activeCursor;
-    }
-    let shouldUpdateDOM = false;
-    if (config.enableContextMenu !== undefined) {
-      this.enableContextMenu = config.enableContextMenu;
-      shouldUpdateDOM = true;
-    }
-    if (config.touchAction !== undefined) {
-      this._touchAction = config.touchAction;
-      shouldUpdateDOM = true;
-    }
-    if (config.userSelect !== undefined) {
-      this._userSelect = config.userSelect;
-      shouldUpdateDOM = true;
-    }
-    if (enabledChanged) {
-      this.delegate.onEnabledChange();
-    } else if (shouldUpdateDOM) {
-      this.delegate.updateDOM();
-    }
-    if (this.enabled) {
-      return;
-    }
-    switch (this.state) {
-      case _State.State.ACTIVE:
-        this.fail(true);
-        break;
-      case _State.State.UNDETERMINED:
-        _GestureHandlerOrchestrator.default.instance.removeHandlerFromOrchestrator(this);
-        break;
-      default:
-        this.cancel(true);
-        break;
-    }
-  }
-  validateHitSlops() {
-    if (!this.hitSlop) {
-      return;
-    }
-    if (this.hitSlop.left !== undefined && this.hitSlop.right !== undefined && this.hitSlop.width !== undefined) {
-      throw new Error('HitSlop Error: Cannot define left, right and width at the same time');
-    }
-    if (this.hitSlop.width !== undefined && this.hitSlop.left === undefined && this.hitSlop.right === undefined) {
-      throw new Error('HitSlop Error: When width is defined, either left or right has to be defined');
-    }
-    if (this.hitSlop.height !== undefined && this.hitSlop.top !== undefined && this.hitSlop.bottom !== undefined) {
-      throw new Error('HitSlop Error: Cannot define top, bottom and height at the same time');
-    }
-    if (this.hitSlop.height !== undefined && this.hitSlop.top === undefined && this.hitSlop.bottom === undefined) {
-      throw new Error('HitSlop Error: When height is defined, either top or bottom has to be defined');
-    }
-  }
-  checkHitSlop() {
-    if (!this.hitSlop) {
-      return true;
-    }
-    const {
-      width,
-      height
-    } = this.delegate.measureView();
-    let left = 0;
-    let top = 0;
-    let right = width;
-    let bottom = height;
-    if (this.hitSlop.horizontal !== undefined) {
-      left -= this.hitSlop.horizontal;
-      right += this.hitSlop.horizontal;
-    }
-    if (this.hitSlop.vertical !== undefined) {
-      top -= this.hitSlop.vertical;
-      bottom += this.hitSlop.vertical;
-    }
-    if (this.hitSlop.left !== undefined) {
-      left = -this.hitSlop.left;
-    }
-    if (this.hitSlop.right !== undefined) {
-      right = width + this.hitSlop.right;
-    }
-    if (this.hitSlop.top !== undefined) {
-      top = -this.hitSlop.top;
-    }
-    if (this.hitSlop.bottom !== undefined) {
-      bottom = height + this.hitSlop.bottom;
-    }
-    if (this.hitSlop.width !== undefined) {
-      if (this.hitSlop.left !== undefined) {
-        right = left + this.hitSlop.width;
-      } else if (this.hitSlop.right !== undefined) {
-        left = right - this.hitSlop.width;
-      }
-    }
-    if (this.hitSlop.height !== undefined) {
-      if (this.hitSlop.top !== undefined) {
-        bottom = top + this.hitSlop.height;
-      } else if (this.hitSlop.bottom !== undefined) {
-        top = bottom - this.hitSlop.height;
-      }
-    }
-    const rect = this.delegate.measureView();
-    const lastCoords = this.tracker.getLastAbsoluteCoords();
-    if (!lastCoords) {
-      return false;
-    }
-    const offsetX = lastCoords.x - rect.pageX;
-    const offsetY = lastCoords.y - rect.pageY;
-    return offsetX >= left && offsetX <= right && offsetY >= top && offsetY <= bottom;
-  }
-  isButtonInConfig(mouseButton) {
-    return !mouseButton || !this.mouseButton && mouseButton === _gestureHandlerCommon.MouseButton.LEFT || this.mouseButton && mouseButton & this.mouseButton;
-  }
-  resetConfig() {
-    this._testID = undefined;
-    this.manualActivation = false;
-    this.shouldCancelWhenOutside = false;
-    this.mouseButton = undefined;
-    this.hitSlop = undefined;
-    this.needsPointerData = false;
-    this.forAnimated = false;
-    this.forReanimated = false;
-    this.enableContextMenu = false;
-    this._activeCursor = undefined;
-    this._touchAction = undefined;
-    this._userSelect = undefined;
-  }
-  onDestroy() {
-    _GestureHandlerOrchestrator.default.instance.removeHandlerFromOrchestrator(this);
-    this.delegate.destroy();
-  }
-
-  //
-  // Getters and setters
-  //
-
-  get handlerTag() {
-    return this._handlerTag;
-  }
-  set handlerTag(value) {
-    this._handlerTag = value;
-  }
-  get testID() {
-    return this._testID;
-  }
-  get delegate() {
-    return this._delegate;
-  }
-  get tracker() {
-    return this._tracker;
-  }
-  get state() {
-    return this._state;
-  }
-  set state(value) {
-    this._state = value;
-  }
-  get shouldCancelWhenOutside() {
-    return this._shouldCancelWhenOutside;
-  }
-  set shouldCancelWhenOutside(value) {
-    this._shouldCancelWhenOutside = value;
-  }
-  get enabled() {
-    return this._enabled;
-  }
-  get pointerType() {
-    return this._pointerType;
-  }
-  get active() {
-    return this._active;
-  }
-  set active(value) {
-    this._active = value;
-  }
-  get awaiting() {
-    return this._awaiting;
-  }
-  set awaiting(value) {
-    this._awaiting = value;
-  }
-  get attached() {
-    return this._attached;
-  }
-  set attached(value) {
-    this._attached = value;
-  }
-  get activationIndex() {
-    return this._activationIndex;
-  }
-  set activationIndex(value) {
-    this._activationIndex = value;
-  }
-  get shouldResetProgress() {
-    return this._shouldResetProgress;
-  }
-  set shouldResetProgress(value) {
-    this._shouldResetProgress = value;
-  }
-  get enableContextMenu() {
-    return this._enableContextMenu;
-  }
-  set enableContextMenu(value) {
-    this._enableContextMenu = value;
-  }
-  get activeCursor() {
-    return this._activeCursor;
-  }
-  get touchAction() {
-    return this._touchAction;
-  }
-  get userSelect() {
-    return this._userSelect;
-  }
-  get name() {
-    return this._name;
-  }
-  set name(value) {
-    this._name = value;
-  }
-  getTrackedPointersID() {
-    return this.tracker.trackedPointersIDs;
-  }
-  isFinished() {
-    return this.state === _State.State.END || this.state === _State.State.FAILED || this.state === _State.State.CANCELLED;
-  }
-}
-exports.default = GestureHandler;
-function invokeNullableMethod(method, event) {
-  if (!method) {
-    return;
-  }
-  if (typeof method === 'function') {
-    method(event);
-    return;
-  }
-  if ('__getHandler' in method && typeof method.__getHandler === 'function') {
-    const handler = method.__getHandler();
-    invokeNullableMethod(handler, event);
-    return;
-  }
-  if (!('__nodeConfig' in method)) {
-    return;
-  }
-  const {
-    argMapping
-  } = method.__nodeConfig;
-  if (!Array.isArray(argMapping)) {
-    return;
-  }
-  for (const [index, [key, value]] of argMapping.entries()) {
-    if (!(key in event.nativeEvent)) {
-      continue;
-    }
-
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-    const nativeValue = event.nativeEvent[key];
-
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-    if (value?.setValue) {
-      // Reanimated API
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
-      value.setValue(nativeValue);
-    } else {
-      // RN Animated API
-      method.__nodeConfig.argMapping[index] = [key, nativeValue];
-    }
-  }
-  return;
-}
-//# sourceMappingURL=GestureHandler.js.map