@amazon-devices/react-native-gesture-handler 2.0.1758683737 → 4.0.0

package/src/web/handlers/GestureHandler.ts

@@ -7,7 +7,6 @@ import {
   ResultEvent,
   PointerData,
   ResultTouchEvent,
-  PointerType,
   TouchEventType,
   EventTypes,
 } from '../interfaces';
@@ -15,34 +14,42 @@ import EventManager from '../tools/EventManager';
 import GestureHandlerOrchestrator from '../tools/GestureHandlerOrchestrator';
 import InteractionManager from '../tools/InteractionManager';
 import PointerTracker, { TrackerElement } from '../tools/PointerTracker';
+import IGestureHandler from './IGestureHandler';
+import { MouseButton } from '../../handlers/gestureHandlerCommon';
+import { PointerType } from '../../PointerType';
 import { GestureHandlerDelegate } from '../tools/GestureHandlerDelegate';
 
-export default abstract class GestureHandler {
+export default abstract class GestureHandler implements IGestureHandler {
   private lastSentState: State | null = null;
-  protected currentState: State = State.UNDETERMINED;
 
-  protected shouldCancellWhenOutside = false;
+  private _state: State = State.UNDETERMINED;
+
+  private _shouldCancelWhenOutside = false;
   protected hasCustomActivationCriteria = false;
-  protected enabled = false;
+  private _enabled = false;
 
   private viewRef!: number;
   private propsRef!: React.RefObject<unknown>;
-  private handlerTag!: number;
-  protected config: Config = { enabled: false };
+  private _handlerTag!: number;
+  private _config: Config = { enabled: false };
 
-  protected tracker: PointerTracker = new PointerTracker();
+  private _tracker: PointerTracker = new PointerTracker();
 
   // Orchestrator properties
-  protected activationIndex = 0;
-  protected awaiting = false;
-  protected active = false;
-  protected shouldResetProgress = false;
-  protected pointerType: PointerType = PointerType.NONE;
+  private _activationIndex = 0;
+
+  private _awaiting = false;
+  private _active = false;
 
-  protected delegate: GestureHandlerDelegate<unknown>;
+  private _shouldResetProgress = false;
+  private _pointerType: PointerType = PointerType.MOUSE;
 
-  public constructor(delegate: GestureHandlerDelegate<unknown>) {
-    this.delegate = delegate;
+  private _delegate: GestureHandlerDelegate<unknown, IGestureHandler>;
+
+  public constructor(
+    delegate: GestureHandlerDelegate<unknown, IGestureHandler>
+  ) {
+    this._delegate = delegate;
   }
 
   //
@@ -53,7 +60,7 @@ export default abstract class GestureHandler {
     this.propsRef = propsRef;
     this.viewRef = viewRef;
 
-    this.currentState = State.UNDETERMINED;
+    this.state = State.UNDETERMINED;
 
     this.delegate.init(viewRef, this);
   }
@@ -70,7 +77,9 @@ export default abstract 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();
   }
 
   //
@@ -86,7 +95,7 @@ export default abstract class GestureHandler {
     this.onReset();
     this.resetProgress();
     this.delegate.reset();
-    this.currentState = State.UNDETERMINED;
+    this.state = State.UNDETERMINED;
   }
 
   //
@@ -94,22 +103,22 @@ export default abstract class GestureHandler {
   //
 
   public moveToState(newState: State, sendIfDisabled?: boolean) {
-    if (this.currentState === newState) {
+    if (this.state === newState) {
       return;
     }
 
-    const oldState = this.currentState;
-    this.currentState = newState;
+    const oldState = this.state;
+    this.state = newState;
 
     if (
-      this.tracker.getTrackedPointersCount() > 0 &&
+      this.tracker.trackedPointersCount > 0 &&
       this.config.needsPointerData &&
       this.isFinished()
     ) {
       this.cancelTouches();
     }
 
-    GestureHandlerOrchestrator.getInstance().onHandlerStateChange(
+    GestureHandlerOrchestrator.instance.onHandlerStateChange(
       this,
       newState,
       oldState,
@@ -117,6 +126,10 @@ export default abstract class GestureHandler {
     );
 
     this.onStateChange(newState, oldState);
+
+    if (!this.enabled && this.isFinished()) {
+      this.state = State.UNDETERMINED;
+    }
   }
 
   protected onStateChange(_newState: State, _oldState: State): void {}
@@ -126,7 +139,7 @@ export default abstract class GestureHandler {
       return;
     }
 
-    if (this.currentState === State.UNDETERMINED) {
+    if (this.state === State.UNDETERMINED) {
       this.moveToState(State.BEGAN);
     }
   }
@@ -135,10 +148,7 @@ export default abstract class GestureHandler {
    * @param {boolean} sendIfDisabled - Used when handler becomes disabled. With this flag orchestrator will be forced to send fail event
    */
   public fail(sendIfDisabled?: boolean): void {
-    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();
@@ -154,9 +164,9 @@ export default abstract class GestureHandler {
    */
   public cancel(sendIfDisabled?: boolean): void {
     if (
-      this.currentState === State.ACTIVE ||
-      this.currentState === State.UNDETERMINED ||
-      this.currentState === State.BEGAN
+      this.state === State.ACTIVE ||
+      this.state === State.UNDETERMINED ||
+      this.state === State.BEGAN
     ) {
       this.onCancel();
 
@@ -167,22 +177,18 @@ export default abstract class GestureHandler {
     }
   }
 
-  public activate(_force = false) {
+  public activate(force = false) {
     if (
-      this.currentState === State.UNDETERMINED ||
-      this.currentState === State.BEGAN
+      (this.config.manualActivation !== true || force) &&
+      (this.state === State.UNDETERMINED || this.state === State.BEGAN)
     ) {
       this.delegate.onActivate();
-
       this.moveToState(State.ACTIVE);
     }
   }
 
   public 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();
 
@@ -196,20 +202,6 @@ export default abstract class GestureHandler {
   // Methods for orchestrator
   //
 
-  public isAwaiting(): boolean {
-    return this.awaiting;
-  }
-  public setAwaiting(value: boolean): void {
-    this.awaiting = value;
-  }
-
-  public isActive(): boolean {
-    return this.active;
-  }
-  public setActive(value: boolean): void {
-    this.active = value;
-  }
-
   public getShouldResetProgress(): boolean {
     return this.shouldResetProgress;
   }
@@ -217,52 +209,45 @@ export default abstract class GestureHandler {
     this.shouldResetProgress = value;
   }
 
-  public getActivationIndex(): number {
-    return this.activationIndex;
-  }
-  public setActivationIndex(value: number): void {
-    this.activationIndex = value;
-  }
-
-  public shouldWaitForHandlerFailure(handler: GestureHandler): boolean {
+  public shouldWaitForHandlerFailure(handler: IGestureHandler): boolean {
     if (handler === this) {
       return false;
     }
 
-    return InteractionManager.getInstance().shouldWaitForHandlerFailure(
+    return InteractionManager.instance.shouldWaitForHandlerFailure(
       this,
       handler
     );
   }
 
-  public shouldRequireToWaitForFailure(handler: GestureHandler): boolean {
+  public shouldRequireToWaitForFailure(handler: IGestureHandler): boolean {
     if (handler === this) {
       return false;
     }
 
-    return InteractionManager.getInstance().shouldRequireHandlerToWaitForFailure(
+    return InteractionManager.instance.shouldRequireHandlerToWaitForFailure(
       this,
       handler
     );
   }
 
-  public shouldRecognizeSimultaneously(handler: GestureHandler): boolean {
+  public shouldRecognizeSimultaneously(handler: IGestureHandler): boolean {
     if (handler === this) {
       return true;
     }
 
-    return InteractionManager.getInstance().shouldRecognizeSimultaneously(
+    return InteractionManager.instance.shouldRecognizeSimultaneously(
       this,
       handler
     );
   }
 
-  public shouldBeCancelledByOther(handler: GestureHandler): boolean {
+  public shouldBeCancelledByOther(handler: IGestureHandler): boolean {
     if (handler === this) {
       return false;
     }
 
-    return InteractionManager.getInstance().shouldHandlerBeCancelledBy(
+    return InteractionManager.instance.shouldHandlerBeCancelledBy(
       this,
       handler
     );
@@ -273,43 +258,32 @@ export default abstract class GestureHandler {
   //
 
   protected onPointerDown(event: AdaptedEvent): void {
-    GestureHandlerOrchestrator.getInstance().recordHandlerIfNotPresent(this);
+    GestureHandlerOrchestrator.instance.recordHandlerIfNotPresent(this);
     this.pointerType = event.pointerType;
 
     if (this.pointerType === PointerType.TOUCH) {
-      GestureHandlerOrchestrator.getInstance().cancelMouseAndPenGestures(this);
+      GestureHandlerOrchestrator.instance.cancelMouseAndPenGestures(this);
     }
 
-    if (this.config.needsPointerData) {
-      this.sendTouchEvent(event);
-    }
+    // TODO: Bring back touch events along with introducing `handleDown` method that will handle handler specific stuff
   }
   // Adding another pointer to existing ones
   protected onPointerAdd(event: AdaptedEvent): void {
-    if (this.config.needsPointerData) {
-      this.sendTouchEvent(event);
-    }
+    this.tryToSendTouchEvent(event);
   }
   protected onPointerUp(event: AdaptedEvent): void {
-    if (this.config.needsPointerData) {
-      this.sendTouchEvent(event);
-    }
+    this.tryToSendTouchEvent(event);
   }
   // Removing pointer, when there is more than one pointers
   protected onPointerRemove(event: AdaptedEvent): void {
-    if (this.config.needsPointerData) {
-      this.sendTouchEvent(event);
-    }
+    this.tryToSendTouchEvent(event);
   }
   protected onPointerMove(event: AdaptedEvent): void {
-    this.tryToSendMoveEvent(false);
-    if (this.config.needsPointerData) {
-      this.sendTouchEvent(event);
-    }
+    this.tryToSendMoveEvent(false, event);
   }
   protected onPointerLeave(event: AdaptedEvent): void {
-    if (this.shouldCancellWhenOutside) {
-      switch (this.currentState) {
+    if (this.shouldCancelWhenOutside) {
+      switch (this.state) {
         case State.ACTIVE:
           this.cancel();
           break;
@@ -320,42 +294,44 @@ export default abstract class GestureHandler {
       return;
     }
 
-    if (this.config.needsPointerData) {
-      this.sendTouchEvent(event);
-    }
+    this.tryToSendTouchEvent(event);
   }
   protected onPointerEnter(event: AdaptedEvent): void {
-    if (this.config.needsPointerData) {
-      this.sendTouchEvent(event);
-    }
+    this.tryToSendTouchEvent(event);
   }
   protected onPointerCancel(event: AdaptedEvent): void {
-    if (this.config.needsPointerData) {
-      this.sendTouchEvent(event);
-    }
+    this.tryToSendTouchEvent(event);
 
     this.cancel();
     this.reset();
   }
   protected onPointerOutOfBounds(event: AdaptedEvent): void {
-    this.tryToSendMoveEvent(true);
-    if (this.config.needsPointerData) {
-      this.sendTouchEvent(event);
-    }
+    this.tryToSendMoveEvent(true, event);
   }
   protected onPointerMoveOver(_event: AdaptedEvent): void {
-    // used only by hover gesture handler atm
+    // Used only by hover gesture handler atm
   }
   protected onPointerMoveOut(_event: AdaptedEvent): void {
-    // used only by hover gesture handler atm
+    // Used only by hover gesture handler atm
   }
-  private tryToSendMoveEvent(out: boolean): void {
-    if (
-      this.enabled &&
-      this.active &&
-      (!out || (out && !this.shouldCancellWhenOutside))
-    ) {
-      this.sendEvent(this.currentState, this.currentState);
+  protected onWheel(_event: AdaptedEvent): void {
+    // Used only by pan gesture handler
+  }
+  protected tryToSendMoveEvent(out: boolean, event: AdaptedEvent): void {
+    if ((out && this.shouldCancelWhenOutside) || !this.enabled) {
+      return;
+    }
+
+    if (this.active) {
+      this.sendEvent(this.state, this.state);
+    }
+
+    this.tryToSendTouchEvent(event);
+  }
+
+  protected tryToSendTouchEvent(event: AdaptedEvent): void {
+    if (this.config.needsPointerData) {
+      this.sendTouchEvent(event);
     }
   }
 
@@ -397,7 +373,7 @@ export default abstract class GestureHandler {
       this.lastSentState = newState;
       invokeNullableMethod(onGestureHandlerStateChange, resultEvent);
     }
-    if (this.currentState === State.ACTIVE) {
+    if (this.state === State.ACTIVE) {
       resultEvent.nativeEvent.oldState = undefined;
       invokeNullableMethod(onGestureHandlerEvent, resultEvent);
     }
@@ -406,16 +382,16 @@ export default abstract class GestureHandler {
   private transformEventData(newState: State, oldState: State): ResultEvent {
     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,
+        pointerType: this.pointerType,
       },
       timeStamp: Date.now(),
     };
@@ -429,7 +405,7 @@ export default abstract class GestureHandler {
     const all: PointerData[] = [];
     const changed: PointerData[] = [];
 
-    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
@@ -444,10 +420,10 @@ export default abstract class GestureHandler {
 
       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,
       });
     });
 
@@ -467,10 +443,10 @@ export default abstract class GestureHandler {
 
         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,
         });
       });
     }
@@ -509,11 +485,12 @@ export default abstract class GestureHandler {
     return {
       nativeEvent: {
         handlerTag: this.handlerTag,
-        state: this.currentState,
-        eventType: event.touchEventType ?? eventType,
+        state: this.state,
+        eventType: eventType,
         changedTouches: changed,
         allTouches: all,
         numberOfTouches: numberOfTouches,
+        pointerType: this.pointerType,
       },
       timeStamp: Date.now(),
     };
@@ -525,7 +502,7 @@ export default abstract class GestureHandler {
     const all: PointerData[] = [];
     const changed: PointerData[] = [];
 
-    const trackerData = this.tracker.getData();
+    const trackerData = this.tracker.trackedPointers;
 
     if (trackerData.size === 0) {
       return;
@@ -536,29 +513,30 @@ export default abstract class GestureHandler {
 
       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: ResultTouchEvent = {
       nativeEvent: {
         handlerTag: this.handlerTag,
-        state: this.currentState,
+        state: this.state,
         eventType: TouchEventType.CANCELLED,
         changedTouches: changed,
         allTouches: all,
         numberOfTouches: all.length,
+        pointerType: this.pointerType,
       },
       timeStamp: Date.now(),
     };
@@ -570,14 +548,15 @@ export default abstract class GestureHandler {
   }
 
   protected transformNativeEvent(): Record<string, unknown> {
-    // 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,
     };
   }
 
@@ -586,11 +565,16 @@ export default abstract class GestureHandler {
   //
 
   public updateGestureConfig({ enabled = true, ...props }: Config): void {
-    this.config = { enabled: enabled, ...props };
+    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();
@@ -599,14 +583,12 @@ export default abstract class GestureHandler {
       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);
@@ -703,8 +685,9 @@ export default abstract class GestureHandler {
     }
 
     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) {
         right = left + this.config.hitSlop.width;
@@ -722,76 +705,125 @@ export default abstract class GestureHandler {
     }
 
     const rect = this.delegate.measureView();
-    const offsetX: number = this.tracker.getLastX() - rect.pageX;
-    const offsetY: number = 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: number = lastCoords.x - rect.pageX;
+    const offsetY: number = lastCoords.y - rect.pageY;
+
+    return (
+      offsetX >= left && offsetX <= right && offsetY >= top && offsetY <= bottom
+    );
+  }
+
+  public isButtonInConfig(mouseButton: MouseButton | undefined) {
+    return (
+      !mouseButton ||
+      (!this.config.mouseButton && mouseButton === MouseButton.LEFT) ||
+      (this.config.mouseButton && mouseButton & this.config.mouseButton)
+    );
   }
 
   protected resetConfig(): void {}
 
+  public onDestroy(): void {
+    GestureHandlerOrchestrator.instance.removeHandlerFromOrchestrator(this);
+    this.delegate.destroy(this.config);
+  }
+
   //
   // Getters and setters
   //
 
-  public getTag(): number {
-    return this.handlerTag;
+  public get handlerTag() {
+    return this._handlerTag;
+  }
+  public set handlerTag(value: number) {
+    this._handlerTag = value;
   }
 
-  public setTag(tag: number): void {
-    this.handlerTag = tag;
+  public get config(): Config {
+    return this._config;
   }
 
-  public getConfig() {
-    return this.config;
+  public get delegate() {
+    return this._delegate;
   }
 
-  public getDelegate(): GestureHandlerDelegate<unknown> {
-    return this.delegate;
+  public get tracker() {
+    return this._tracker;
   }
 
-  public getTracker(): PointerTracker {
-    return this.tracker;
+  public get state(): State {
+    return this._state;
+  }
+  protected set state(value: State) {
+    this._state = value;
   }
 
-  public getTrackedPointersID(): number[] {
-    return this.tracker.getTrackedPointersID();
+  public get shouldCancelWhenOutside() {
+    return this._shouldCancelWhenOutside;
+  }
+  protected set shouldCancelWhenOutside(value) {
+    this._shouldCancelWhenOutside = value;
   }
 
-  public getState(): State {
-    return this.currentState;
+  public get enabled() {
+    return this._enabled;
+  }
+  protected set enabled(value) {
+    this._enabled = value;
   }
 
-  public isEnabled(): boolean {
-    return this.enabled;
+  public get pointerType(): PointerType {
+    return this._pointerType;
+  }
+  protected set pointerType(value: PointerType) {
+    this._pointerType = value;
   }
 
-  private isFinished(): boolean {
-    return (
-      this.currentState === State.END ||
-      this.currentState === State.FAILED ||
-      this.currentState === State.CANCELLED
-    );
+  public get active() {
+    return this._active;
+  }
+  protected set active(value) {
+    this._active = value;
+  }
+
+  public get awaiting() {
+    return this._awaiting;
+  }
+  protected set awaiting(value) {
+    this._awaiting = value;
+  }
+
+  public get activationIndex() {
+    return this._activationIndex;
+  }
+  protected set activationIndex(value) {
+    this._activationIndex = value;
   }
 
-  protected setShouldCancelWhenOutside(shouldCancel: boolean) {
-    this.shouldCancellWhenOutside = shouldCancel;
+  public get shouldResetProgress() {
+    return this._shouldResetProgress;
+  }
+  protected set shouldResetProgress(value) {
+    this._shouldResetProgress = value;
   }
 
-  protected getShouldCancelWhenOutside(): boolean {
-    return this.shouldCancellWhenOutside;
+  public getTrackedPointersID(): number[] {
+    return this.tracker.trackedPointersIDs;
   }
 
-  public getPointerType(): PointerType {
-    return this.pointerType;
+  private isFinished(): boolean {
+    return (
+      this.state === State.END ||
+      this.state === State.FAILED ||
+      this.state === State.CANCELLED
+    );
   }
 }
 
@@ -821,12 +853,11 @@ function invokeNullableMethod(
     return;
   }
 
-  const { argMapping } = method.__nodeConfig;
+  const { argMapping }: { argMapping: unknown } = method.__nodeConfig;
   if (!Array.isArray(argMapping)) {
     return;
   }
 
-  // @ts-ignore argMapping is unknown
   for (const [index, [key, value]] of argMapping.entries()) {
     if (!(key in event.nativeEvent)) {
       continue;
@@ -837,11 +868,11 @@ function invokeNullableMethod(
 
     // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
     if (value?.setValue) {
-      //Reanimated API
+      // 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];
     }
   }