@amazon-devices/react-native-gesture-handler 2.0.1759135970 → 4.0.0-rn-83

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

@@ -1,58 +1,32 @@
-function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
-function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
-function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+"use strict";
+
 /* eslint-disable @typescript-eslint/no-empty-function */
 import { State } from '../../State';
-import { PointerType, TouchEventType, EventTypes } from '../interfaces';
+import { TouchEventType, EventTypes } from '../interfaces';
 import GestureHandlerOrchestrator from '../tools/GestureHandlerOrchestrator';
 import InteractionManager from '../tools/InteractionManager';
 import PointerTracker from '../tools/PointerTracker';
+import { MouseButton } from '../../handlers/gestureHandlerCommon';
+import { PointerType } from '../../PointerType';
 export default class GestureHandler {
-  constructor(delegate) {
-    _defineProperty(this, "lastSentState", null);
-    _defineProperty(this, "currentState", State.UNDETERMINED);
-    _defineProperty(this, "shouldCancellWhenOutside", false);
-    _defineProperty(this, "hasCustomActivationCriteria", false);
-    _defineProperty(this, "enabled", false);
-    _defineProperty(this, "viewRef", void 0);
-    _defineProperty(this, "propsRef", void 0);
-    _defineProperty(this, "handlerTag", void 0);
-    _defineProperty(this, "config", {
-      enabled: false
-    });
-    _defineProperty(this, "tracker", new PointerTracker());
-    // Orchestrator properties
-    _defineProperty(this, "activationIndex", 0);
-    _defineProperty(this, "awaiting", false);
-    _defineProperty(this, "active", false);
-    _defineProperty(this, "shouldResetProgress", false);
-    _defineProperty(this, "pointerType", PointerType.NONE);
-    _defineProperty(this, "delegate", void 0);
-    //
-    // Events Sending
-    //
-    _defineProperty(this, "sendEvent", (newState, oldState) => {
-      const {
-        onGestureHandlerEvent,
-        onGestureHandlerStateChange
-      } = this.propsRef.current;
-      const resultEvent = this.transformEventData(newState, oldState);
+  lastSentState = null;
+  _state = State.UNDETERMINED;
+  _shouldCancelWhenOutside = false;
+  hasCustomActivationCriteria = false;
+  _enabled = false;
+  _config = {
+    enabled: false
+  };
+  _tracker = new PointerTracker();
 
-      // In the new 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(onGestureHandlerStateChange, resultEvent);
-      }
-      if (this.currentState === State.ACTIVE) {
-        resultEvent.nativeEvent.oldState = undefined;
-        invokeNullableMethod(onGestureHandlerEvent, resultEvent);
-      }
-    });
-    this.delegate = delegate;
+  // Orchestrator properties
+  _activationIndex = 0;
+  _awaiting = false;
+  _active = false;
+  _shouldResetProgress = false;
+  _pointerType = PointerType.MOUSE;
+  constructor(delegate) {
+    this._delegate = delegate;
   }
 
   //
@@ -62,7 +36,7 @@ export default class GestureHandler {
   init(viewRef, propsRef) {
     this.propsRef = propsRef;
     this.viewRef = viewRef;
-    this.currentState = State.UNDETERMINED;
+    this.state = State.UNDETERMINED;
     this.delegate.init(viewRef, this);
   }
   attachEventManager(manager) {
@@ -77,7 +51,8 @@ export default class GestureHandler {
     manager.setOnPointerOutOfBounds(this.onPointerOutOfBounds.bind(this));
     manager.setOnPointerMoveOver(this.onPointerMoveOver.bind(this));
     manager.setOnPointerMoveOut(this.onPointerMoveOut.bind(this));
-    manager.setListeners();
+    manager.setOnWheel(this.onWheel.bind(this));
+    manager.registerListeners();
   }
 
   //
@@ -92,7 +67,7 @@ export default class GestureHandler {
     this.onReset();
     this.resetProgress();
     this.delegate.reset();
-    this.currentState = State.UNDETERMINED;
+    this.state = State.UNDETERMINED;
   }
 
   //
@@ -100,23 +75,26 @@ export default class GestureHandler {
   //
 
   moveToState(newState, sendIfDisabled) {
-    if (this.currentState === newState) {
+    if (this.state === newState) {
       return;
     }
-    const oldState = this.currentState;
-    this.currentState = newState;
-    if (this.tracker.getTrackedPointersCount() > 0 && this.config.needsPointerData && this.isFinished()) {
+    const oldState = this.state;
+    this.state = newState;
+    if (this.tracker.trackedPointersCount > 0 && this.config.needsPointerData && this.isFinished()) {
       this.cancelTouches();
     }
-    GestureHandlerOrchestrator.getInstance().onHandlerStateChange(this, newState, oldState, sendIfDisabled);
+    GestureHandlerOrchestrator.instance.onHandlerStateChange(this, newState, oldState, sendIfDisabled);
     this.onStateChange(newState, oldState);
+    if (!this.enabled && this.isFinished()) {
+      this.state = State.UNDETERMINED;
+    }
   }
   onStateChange(_newState, _oldState) {}
   begin() {
     if (!this.checkHitSlop()) {
       return;
     }
-    if (this.currentState === State.UNDETERMINED) {
+    if (this.state === State.UNDETERMINED) {
       this.moveToState(State.BEGAN);
     }
   }
@@ -125,7 +103,7 @@ export default class GestureHandler {
    * @param {boolean} sendIfDisabled - Used when handler becomes disabled. With this flag orchestrator will be forced to send fail event
    */
   fail(sendIfDisabled) {
-    if (this.currentState === State.ACTIVE || this.currentState === State.BEGAN) {
+    if (this.state === State.ACTIVE || this.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();
@@ -138,7 +116,7 @@ export default class GestureHandler {
    * @param {boolean} sendIfDisabled - Used when handler becomes disabled. With this flag orchestrator will be forced to send cancel event
    */
   cancel(sendIfDisabled) {
-    if (this.currentState === State.ACTIVE || this.currentState === State.UNDETERMINED || this.currentState === State.BEGAN) {
+    if (this.state === State.ACTIVE || this.state === State.UNDETERMINED || this.state === State.BEGAN) {
       this.onCancel();
 
       // Same as above - order matters
@@ -146,14 +124,14 @@ export default class GestureHandler {
       this.moveToState(State.CANCELLED, sendIfDisabled);
     }
   }
-  activate(_force = false) {
-    if (this.currentState === State.UNDETERMINED || this.currentState === State.BEGAN) {
+  activate(force = false) {
+    if ((this.config.manualActivation !== true || force) && (this.state === State.UNDETERMINED || this.state === State.BEGAN)) {
       this.delegate.onActivate();
       this.moveToState(State.ACTIVE);
     }
   }
   end() {
-    if (this.currentState === State.BEGAN || this.currentState === State.ACTIVE) {
+    if (this.state === State.BEGAN || this.state === State.ACTIVE) {
       // Same as above - order matters
       this.delegate.onEnd();
       this.moveToState(State.END);
@@ -165,53 +143,35 @@ export default class GestureHandler {
   // Methods for orchestrator
   //
 
-  isAwaiting() {
-    return this.awaiting;
-  }
-  setAwaiting(value) {
-    this.awaiting = value;
-  }
-  isActive() {
-    return this.active;
-  }
-  setActive(value) {
-    this.active = value;
-  }
   getShouldResetProgress() {
     return this.shouldResetProgress;
   }
   setShouldResetProgress(value) {
     this.shouldResetProgress = value;
   }
-  getActivationIndex() {
-    return this.activationIndex;
-  }
-  setActivationIndex(value) {
-    this.activationIndex = value;
-  }
   shouldWaitForHandlerFailure(handler) {
     if (handler === this) {
       return false;
     }
-    return InteractionManager.getInstance().shouldWaitForHandlerFailure(this, handler);
+    return InteractionManager.instance.shouldWaitForHandlerFailure(this, handler);
   }
   shouldRequireToWaitForFailure(handler) {
     if (handler === this) {
       return false;
     }
-    return InteractionManager.getInstance().shouldRequireHandlerToWaitForFailure(this, handler);
+    return InteractionManager.instance.shouldRequireHandlerToWaitForFailure(this, handler);
   }
   shouldRecognizeSimultaneously(handler) {
     if (handler === this) {
       return true;
     }
-    return InteractionManager.getInstance().shouldRecognizeSimultaneously(this, handler);
+    return InteractionManager.instance.shouldRecognizeSimultaneously(this, handler);
   }
   shouldBeCancelledByOther(handler) {
     if (handler === this) {
       return false;
     }
-    return InteractionManager.getInstance().shouldHandlerBeCancelledBy(this, handler);
+    return InteractionManager.instance.shouldHandlerBeCancelledBy(this, handler);
   }
 
   //
@@ -219,41 +179,31 @@ export default class GestureHandler {
   //
 
   onPointerDown(event) {
-    GestureHandlerOrchestrator.getInstance().recordHandlerIfNotPresent(this);
+    GestureHandlerOrchestrator.instance.recordHandlerIfNotPresent(this);
     this.pointerType = event.pointerType;
     if (this.pointerType === PointerType.TOUCH) {
-      GestureHandlerOrchestrator.getInstance().cancelMouseAndPenGestures(this);
-    }
-    if (this.config.needsPointerData) {
-      this.sendTouchEvent(event);
+      GestureHandlerOrchestrator.instance.cancelMouseAndPenGestures(this);
     }
+
+    // TODO: Bring back touch events along with introducing `handleDown` method that will handle handler specific stuff
   }
   // Adding another pointer to existing ones
   onPointerAdd(event) {
-    if (this.config.needsPointerData) {
-      this.sendTouchEvent(event);
-    }
+    this.tryToSendTouchEvent(event);
   }
   onPointerUp(event) {
-    if (this.config.needsPointerData) {
-      this.sendTouchEvent(event);
-    }
+    this.tryToSendTouchEvent(event);
   }
   // Removing pointer, when there is more than one pointers
   onPointerRemove(event) {
-    if (this.config.needsPointerData) {
-      this.sendTouchEvent(event);
-    }
+    this.tryToSendTouchEvent(event);
   }
   onPointerMove(event) {
-    this.tryToSendMoveEvent(false);
-    if (this.config.needsPointerData) {
-      this.sendTouchEvent(event);
-    }
+    this.tryToSendMoveEvent(false, event);
   }
   onPointerLeave(event) {
-    if (this.shouldCancellWhenOutside) {
-      switch (this.currentState) {
+    if (this.shouldCancelWhenOutside) {
+      switch (this.state) {
         case State.ACTIVE:
           this.cancel();
           break;
@@ -263,37 +213,40 @@ export default class GestureHandler {
       }
       return;
     }
-    if (this.config.needsPointerData) {
-      this.sendTouchEvent(event);
-    }
+    this.tryToSendTouchEvent(event);
   }
   onPointerEnter(event) {
-    if (this.config.needsPointerData) {
-      this.sendTouchEvent(event);
-    }
+    this.tryToSendTouchEvent(event);
   }
   onPointerCancel(event) {
-    if (this.config.needsPointerData) {
-      this.sendTouchEvent(event);
-    }
+    this.tryToSendTouchEvent(event);
     this.cancel();
     this.reset();
   }
   onPointerOutOfBounds(event) {
-    this.tryToSendMoveEvent(true);
-    if (this.config.needsPointerData) {
-      this.sendTouchEvent(event);
-    }
+    this.tryToSendMoveEvent(true, event);
   }
   onPointerMoveOver(_event) {
-    // used only by hover gesture handler atm
+    // Used only by hover gesture handler atm
   }
   onPointerMoveOut(_event) {
-    // used only by hover gesture handler atm
+    // Used only by hover gesture handler atm
+  }
+  onWheel(_event) {
+    // Used only by pan gesture handler
   }
-  tryToSendMoveEvent(out) {
-    if (this.enabled && this.active && (!out || out && !this.shouldCancellWhenOutside)) {
-      this.sendEvent(this.currentState, this.currentState);
+  tryToSendMoveEvent(out, event) {
+    if (out && this.shouldCancelWhenOutside || !this.enabled) {
+      return;
+    }
+    if (this.active) {
+      this.sendEvent(this.state, this.state);
+    }
+    this.tryToSendTouchEvent(event);
+  }
+  tryToSendTouchEvent(event) {
+    if (this.config.needsPointerData) {
+      this.sendTouchEvent(event);
     }
   }
   sendTouchEvent(event) {
@@ -308,29 +261,52 @@ export default class GestureHandler {
       invokeNullableMethod(onGestureHandlerEvent, touchEvent);
     }
   }
+
+  //
+  // Events Sending
+  //
+
+  sendEvent = (newState, oldState) => {
+    const {
+      onGestureHandlerEvent,
+      onGestureHandlerStateChange
+    } = this.propsRef.current;
+    const resultEvent = this.transformEventData(newState, oldState);
+
+    // In the new 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(onGestureHandlerStateChange, resultEvent);
+    }
+    if (this.state === State.ACTIVE) {
+      resultEvent.nativeEvent.oldState = undefined;
+      invokeNullableMethod(onGestureHandlerEvent, resultEvent);
+    }
+  };
   transformEventData(newState, oldState) {
     return {
       nativeEvent: {
-        numberOfPointers: this.tracker.getTrackedPointersCount(),
+        numberOfPointers: this.tracker.trackedPointersCount,
         state: newState,
-        pointerInside: this.delegate.isPointerInBounds({
-          x: this.tracker.getLastAvgX(),
-          y: this.tracker.getLastAvgY()
-        }),
+        pointerInside: this.delegate.isPointerInBounds(this.tracker.getAbsoluteCoordsAverage()),
         ...this.transformNativeEvent(),
         handlerTag: this.handlerTag,
         target: this.viewRef,
-        oldState: newState !== oldState ? oldState : undefined
+        oldState: newState !== oldState ? oldState : undefined,
+        pointerType: this.pointerType
       },
       timeStamp: Date.now()
     };
   }
   transformTouchEvent(event) {
-    var _event$touchEventType;
     const rect = this.delegate.measureView();
     const all = [];
     const changed = [];
-    const trackerData = this.tracker.getData();
+    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
@@ -343,10 +319,10 @@ export default class GestureHandler {
       const id = this.tracker.getMappedTouchEventId(key);
       all.push({
         id: id,
-        x: element.lastX - rect.pageX,
-        y: element.lastY - rect.pageY,
-        absoluteX: element.lastX,
-        absoluteY: element.lastY
+        x: element.abosoluteCoords.x - rect.pageX,
+        y: element.abosoluteCoords.y - rect.pageY,
+        absoluteX: element.abosoluteCoords.x,
+        absoluteY: element.abosoluteCoords.y
       });
     });
 
@@ -365,10 +341,10 @@ export default class GestureHandler {
         const id = this.tracker.getMappedTouchEventId(key);
         changed.push({
           id: id,
-          x: element.lastX - rect.pageX,
-          y: element.lastY - rect.pageY,
-          absoluteX: element.lastX,
-          absoluteY: element.lastY
+          x: element.abosoluteCoords.x - rect.pageX,
+          y: element.abosoluteCoords.y - rect.pageY,
+          absoluteX: element.abosoluteCoords.x,
+          absoluteY: element.abosoluteCoords.y
         });
       });
     }
@@ -400,11 +376,12 @@ export default class GestureHandler {
     return {
       nativeEvent: {
         handlerTag: this.handlerTag,
-        state: this.currentState,
-        eventType: (_event$touchEventType = event.touchEventType) !== null && _event$touchEventType !== void 0 ? _event$touchEventType : eventType,
+        state: this.state,
+        eventType: eventType,
         changedTouches: changed,
         allTouches: all,
-        numberOfTouches: numberOfTouches
+        numberOfTouches: numberOfTouches,
+        pointerType: this.pointerType
       },
       timeStamp: Date.now()
     };
@@ -413,7 +390,7 @@ export default class GestureHandler {
     const rect = this.delegate.measureView();
     const all = [];
     const changed = [];
-    const trackerData = this.tracker.getData();
+    const trackerData = this.tracker.trackedPointers;
     if (trackerData.size === 0) {
       return;
     }
@@ -421,27 +398,28 @@ export default class GestureHandler {
       const id = this.tracker.getMappedTouchEventId(key);
       all.push({
         id: id,
-        x: element.lastX - rect.pageX,
-        y: element.lastY - rect.pageY,
-        absoluteX: element.lastX,
-        absoluteY: element.lastY
+        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.lastX - rect.pageX,
-        y: element.lastY - rect.pageY,
-        absoluteX: element.lastX,
-        absoluteY: element.lastY
+        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.currentState,
+        state: this.state,
         eventType: TouchEventType.CANCELLED,
         changedTouches: changed,
         allTouches: all,
-        numberOfTouches: all.length
+        numberOfTouches: all.length,
+        pointerType: this.pointerType
       },
       timeStamp: Date.now()
     };
@@ -451,13 +429,14 @@ export default class GestureHandler {
     invokeNullableMethod(onGestureHandlerEvent, cancelEvent);
   }
   transformNativeEvent() {
-    // those properties are shared by most handlers and if not this method will be overriden
-    const rect = this.delegate.measureView();
+    // 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: this.tracker.getLastAvgX() - rect.pageX,
-      y: this.tracker.getLastAvgY() - rect.pageY,
-      absoluteX: this.tracker.getLastAvgX(),
-      absoluteY: this.tracker.getLastAvgY()
+      x: lastRelativeCoords.x,
+      y: lastRelativeCoords.y,
+      absoluteX: lastCoords.x,
+      absoluteY: lastCoords.y
     };
   }
 
@@ -469,24 +448,27 @@ export default class GestureHandler {
     enabled = true,
     ...props
   }) {
-    this.config = {
+    this._config = {
       enabled: enabled,
       ...props
     };
+    if (this.enabled !== enabled) {
+      this.delegate.onEnabledChange(enabled);
+    }
     this.enabled = enabled;
     if (this.config.shouldCancelWhenOutside !== undefined) {
-      this.setShouldCancelWhenOutside(this.config.shouldCancelWhenOutside);
+      this.shouldCancelWhenOutside = this.config.shouldCancelWhenOutside;
     }
     this.validateHitSlops();
     if (this.enabled) {
       return;
     }
-    switch (this.currentState) {
+    switch (this.state) {
       case State.ACTIVE:
         this.fail(true);
         break;
       case State.UNDETERMINED:
-        GestureHandlerOrchestrator.getInstance().removeHandlerFromOrchestrator(this);
+        GestureHandlerOrchestrator.instance.removeHandlerFromOrchestrator(this);
         break;
       default:
         this.cancel(true);
@@ -547,7 +529,7 @@ export default class GestureHandler {
       top = -this.config.hitSlop.top;
     }
     if (this.config.hitSlop.bottom !== undefined) {
-      bottom = width + this.config.hitSlop.bottom;
+      bottom = height + this.config.hitSlop.bottom;
     }
     if (this.config.hitSlop.width !== undefined) {
       if (this.config.hitSlop.left !== undefined) {
@@ -564,54 +546,95 @@ export default class GestureHandler {
       }
     }
     const rect = this.delegate.measureView();
-    const offsetX = this.tracker.getLastX() - rect.pageX;
-    const offsetY = this.tracker.getLastY() - rect.pageY;
-    if (offsetX >= left && offsetX <= right && offsetY >= top && offsetY <= bottom) {
-      return true;
+    const lastCoords = this.tracker.getLastAbsoluteCoords();
+    if (!lastCoords) {
+      return false;
     }
-    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.config.mouseButton && mouseButton === MouseButton.LEFT || this.config.mouseButton && mouseButton & this.config.mouseButton;
   }
   resetConfig() {}
+  onDestroy() {
+    GestureHandlerOrchestrator.instance.removeHandlerFromOrchestrator(this);
+    this.delegate.destroy(this.config);
+  }
 
   //
   // Getters and setters
   //
 
-  getTag() {
-    return this.handlerTag;
+  get handlerTag() {
+    return this._handlerTag;
   }
-  setTag(tag) {
-    this.handlerTag = tag;
+  set handlerTag(value) {
+    this._handlerTag = value;
   }
-  getConfig() {
-    return this.config;
+  get config() {
+    return this._config;
   }
-  getDelegate() {
-    return this.delegate;
+  get delegate() {
+    return this._delegate;
   }
-  getTracker() {
-    return this.tracker;
+  get tracker() {
+    return this._tracker;
   }
-  getTrackedPointersID() {
-    return this.tracker.getTrackedPointersID();
+  get state() {
+    return this._state;
   }
-  getState() {
-    return this.currentState;
+  set state(value) {
+    this._state = value;
   }
-  isEnabled() {
-    return this.enabled;
+  get shouldCancelWhenOutside() {
+    return this._shouldCancelWhenOutside;
   }
-  isFinished() {
-    return this.currentState === State.END || this.currentState === State.FAILED || this.currentState === State.CANCELLED;
+  set shouldCancelWhenOutside(value) {
+    this._shouldCancelWhenOutside = value;
+  }
+  get enabled() {
+    return this._enabled;
+  }
+  set enabled(value) {
+    this._enabled = value;
+  }
+  get pointerType() {
+    return this._pointerType;
+  }
+  set pointerType(value) {
+    this._pointerType = value;
   }
-  setShouldCancelWhenOutside(shouldCancel) {
-    this.shouldCancellWhenOutside = shouldCancel;
+  get active() {
+    return this._active;
   }
-  getShouldCancelWhenOutside() {
-    return this.shouldCancellWhenOutside;
+  set active(value) {
+    this._active = value;
   }
-  getPointerType() {
-    return this.pointerType;
+  get awaiting() {
+    return this._awaiting;
+  }
+  set awaiting(value) {
+    this._awaiting = value;
+  }
+  get activationIndex() {
+    return this._activationIndex;
+  }
+  set activationIndex(value) {
+    this._activationIndex = value;
+  }
+  get shouldResetProgress() {
+    return this._shouldResetProgress;
+  }
+  set shouldResetProgress(value) {
+    this._shouldResetProgress = value;
+  }
+  getTrackedPointersID() {
+    return this.tracker.trackedPointersIDs;
+  }
+  isFinished() {
+    return this.state === State.END || this.state === State.FAILED || this.state === State.CANCELLED;
   }
 }
 function invokeNullableMethod(method, event) {
@@ -636,8 +659,6 @@ function invokeNullableMethod(method, event) {
   if (!Array.isArray(argMapping)) {
     return;
   }
-
-  // @ts-ignore argMapping is unknown
   for (const [index, [key, value]] of argMapping.entries()) {
     if (!(key in event.nativeEvent)) {
       continue;
@@ -647,12 +668,12 @@ function invokeNullableMethod(method, event) {
     const nativeValue = event.nativeEvent[key];
 
     // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-    if (value !== null && value !== void 0 && value.setValue) {
-      //Reanimated API
+    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
+      // RN Animated API
       method.__nodeConfig.argMapping[index] = [key, nativeValue];
     }
   }