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

package/src/v3/types/EventTypes.ts

@@ -1,7 +1,8 @@
-import { Animated, NativeSyntheticEvent } from 'react-native';
-import { GestureTouchEvent } from '../../handlers/gestureHandlerCommon';
-import { PointerType } from '../../PointerType';
-import { State } from '../../State';
+import type { Animated, NativeSyntheticEvent } from 'react-native';
+
+import type { GestureTouchEvent } from '../../handlers/gestureHandlerCommon';
+import type { PointerType } from '../../PointerType';
+import type { State } from '../../State';
 
 type EventPayload = {
   handlerTag: number;
@@ -27,13 +28,19 @@ export type GestureStateChangeEventWithHandlerData<T> =
     handlerData: HandlerData<T>;
   };
 
-export type GestureHandlerEventWithHandlerData<THandlerData> =
-  | UpdateEventWithHandlerData<THandlerData>
+export type GestureHandlerEventWithHandlerData<
+  THandlerData,
+  TExtendedHandlerData extends THandlerData = THandlerData,
+> =
+  | UpdateEventWithHandlerData<TExtendedHandlerData>
   | StateChangeEventWithHandlerData<THandlerData>
   | TouchEvent;
 
-export type UnpackedGestureHandlerEventWithHandlerData<THandlerData> =
-  | GestureUpdateEventWithHandlerData<THandlerData>
+export type UnpackedGestureHandlerEventWithHandlerData<
+  THandlerData,
+  TExtendedHandlerData extends THandlerData = THandlerData,
+> =
+  | GestureUpdateEventWithHandlerData<TExtendedHandlerData>
   | GestureStateChangeEventWithHandlerData<THandlerData>
   | GestureTouchEvent;
 
@@ -53,6 +60,10 @@ export type GestureEvent<THandlerData> = {
   handlerTag: number;
 } & HandlerData<THandlerData>;
 
+export type GestureEndEvent<THandlerData> = {
+  canceled: boolean;
+} & GestureEvent<THandlerData>;
+
 export type UnpackedGestureHandlerEvent<THandlerData> =
   | GestureEvent<THandlerData>
   | GestureTouchEvent;
@@ -64,12 +75,12 @@ export type AnimatedEvent = {
   _argMapping: (Animated.Mapping | null)[];
 };
 
-export type ChangeCalculatorType<THandlerData> = (
-  current: GestureUpdateEventWithHandlerData<THandlerData>,
-  previous?: GestureUpdateEventWithHandlerData<THandlerData>
-) => GestureUpdateEventWithHandlerData<THandlerData>;
+export type ChangeCalculatorType<TExtendedHandlerData> = (
+  current: GestureUpdateEventWithHandlerData<TExtendedHandlerData>,
+  previous?: GestureUpdateEventWithHandlerData<TExtendedHandlerData>
+) => GestureUpdateEventWithHandlerData<TExtendedHandlerData>;
 
-export type DiffCalculatorType<THandlerData> = (
-  current: HandlerData<THandlerData>,
-  previous: HandlerData<THandlerData> | null
-) => Partial<HandlerData<THandlerData>>;
+export type DiffCalculatorType<TExtendedHandlerData> = (
+  current: HandlerData<TExtendedHandlerData>,
+  previous: HandlerData<TExtendedHandlerData> | null
+) => Partial<HandlerData<TExtendedHandlerData>>;

package/src/v3/types/GestureTypes.ts

@@ -1,61 +1,88 @@
-import { DetectorCallbacks } from './DetectorTypes';
-import {
+import type {
   CommonGestureConfig,
   ComposedGestureConfig,
   GestureCallbacks,
   GestureRelations,
   InternalConfigProps,
 } from './ConfigTypes';
-import { FilterNeverProperties } from './UtilityTypes';
+import type { DetectorCallbacks } from './DetectorTypes';
+import type { FilterNeverProperties } from './UtilityTypes';
 
 // Unfortunately, this type cannot be moved into ConfigTypes.ts because of circular dependency
 export type ExternalRelations = {
-  simultaneousWith?: AnyGesture | AnyGesture[];
-  requireToFail?: AnyGesture | AnyGesture[];
-  block?: AnyGesture | AnyGesture[];
+  simultaneousWith?: AnyGesture | AnyGesture[] | undefined;
+  requireToFail?: AnyGesture | AnyGesture[] | undefined;
+  block?: AnyGesture | AnyGesture[] | undefined;
 };
 
 // Similarly, this type cannot be moved into ConfigTypes.ts because it depends on `ExternalRelations`
-export type BaseGestureConfig<THandlerData, TConfig> = ExternalRelations &
-  GestureCallbacks<THandlerData> &
+export type BaseGestureConfig<
+  TConfig,
+  THandlerData,
+  TExtendedHandlerData extends THandlerData = THandlerData,
+> = ExternalRelations &
+  GestureCallbacks<THandlerData, TExtendedHandlerData> &
   FilterNeverProperties<TConfig> &
-  InternalConfigProps<THandlerData> &
+  InternalConfigProps<TExtendedHandlerData> &
   CommonGestureConfig;
 
-export type BaseDiscreteGestureConfig<THandlerData, TConfig> = Omit<
-  BaseGestureConfig<THandlerData, TConfig>,
+export type BaseDiscreteGestureConfig<
+  TConfig,
+  THandlerData,
+  TExtendedHandlerData extends THandlerData = THandlerData,
+> = Omit<
+  BaseGestureConfig<TConfig, THandlerData, TExtendedHandlerData>,
   'onUpdate'
 >;
 
-export type SingleGesture<THandlerData, TConfig> = {
+export type SingleGesture<
+  TConfig,
+  THandlerData,
+  TExtendedHandlerData extends THandlerData = THandlerData,
+> = {
   handlerTag: number;
   type: SingleGestureName;
-  config: BaseGestureConfig<THandlerData, TConfig>;
-  detectorCallbacks: DetectorCallbacks<THandlerData>;
+  config: BaseGestureConfig<TConfig, THandlerData, TExtendedHandlerData>;
+  detectorCallbacks: DetectorCallbacks<THandlerData, TExtendedHandlerData>;
   gestureRelations: GestureRelations;
 };
 
-export type DiscreteSingleGesture<THandlerData, TConfig> = {
-  [K in keyof SingleGesture<THandlerData, TConfig>]: K extends 'config'
-    ? Omit<SingleGesture<THandlerData, TConfig>[K], 'onUpdate'>
-    : SingleGesture<THandlerData, TConfig>[K];
+export type DiscreteSingleGesture<
+  TConfig,
+  THandlerData,
+  TExtendedHandlerData extends THandlerData = THandlerData,
+> = {
+  [K in keyof SingleGesture<
+    TConfig,
+    THandlerData,
+    TExtendedHandlerData
+  >]: K extends 'config'
+    ? Omit<
+        SingleGesture<TConfig, THandlerData, TExtendedHandlerData>[K],
+        'onUpdate'
+      >
+    : SingleGesture<TConfig, THandlerData, TExtendedHandlerData>[K];
 };
 
 export type ComposedGesture = {
   handlerTags: number[];
   type: ComposedGestureName;
   config: ComposedGestureConfig;
-  detectorCallbacks: DetectorCallbacks<unknown>;
+  detectorCallbacks: DetectorCallbacks<unknown, unknown>;
   externalSimultaneousHandlers: number[];
   gestures: Gesture[];
 };
 
-export type Gesture<THandlerData = unknown, TConfig = unknown> =
-  | SingleGesture<THandlerData, TConfig>
+export type Gesture<
+  TConfig = unknown,
+  THandlerData = unknown,
+  TExtendedHandlerData extends THandlerData = THandlerData,
+> =
+  | SingleGesture<TConfig, THandlerData, TExtendedHandlerData>
   | ComposedGesture;
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-export type AnyGesture = Gesture<any, unknown>;
+export type AnyGesture = Gesture<unknown, any>;
 
 export enum SingleGestureName {
   Tap = 'TapGestureHandler',

package/src/v3/types/NativeWrapperType.ts

@@ -1,8 +1,23 @@
-import { CommonGestureConfig, ExternalRelations, GestureCallbacks } from '.';
-import { NativeGestureNativeProperties } from '../hooks/gestures/native/NativeProperties';
-import { NativeViewHandlerData } from '../hooks/gestures/native/useNativeGesture';
+import type {
+  NativeGesture,
+  NativeGestureNativeProperties,
+  NativeHandlerData,
+} from '../hooks/gestures/native/NativeTypes';
+import type {
+  CommonGestureConfig,
+  ExternalRelations,
+  GestureCallbacks,
+} from '.';
 
-export type NativeWrapperProperties = CommonGestureConfig &
-  GestureCallbacks<NativeViewHandlerData> &
+export type WrapperSpecificProperties<T = unknown> = {
+  ref?: React.Ref<T> | undefined;
+  onGestureUpdate_CAN_CAUSE_INFINITE_RERENDER?: (
+    gesture: NativeGesture
+  ) => void;
+};
+
+export type NativeWrapperProperties<T = unknown> = CommonGestureConfig &
+  GestureCallbacks<NativeHandlerData> &
   NativeGestureNativeProperties &
-  ExternalRelations;
+  ExternalRelations &
+  WrapperSpecificProperties<T>;

package/src/v3/types/ReanimatedTypes.ts

@@ -37,7 +37,7 @@ type WithSharedValueRecursive<T extends object, P> = {
     ? Simplify<SharedValueOrT<T[K], P>>
     : // Special case for boolean as passing `boolean` as P doesn't look ok.
       boolean extends T[K]
-      ? boolean | SharedValue<boolean>
+      ? boolean | SharedValue<boolean> | Extract<T[K], undefined>
       : // Special handling for tuples [number, number].
         T[K] extends [number, number]
         ? [WithSharedValue<number, P>, WithSharedValue<number, P>]

package/src/v3/types/UtilityTypes.ts

@@ -1,10 +1,10 @@
-import { PanGestureNativeProperties } from '../hooks/gestures/pan/PanProperties';
-import { FlingGestureNativeProperties } from '../hooks/gestures/fling/FlingProperties';
-import { HoverGestureNativeProperties } from '../hooks/gestures/hover/HoverProperties';
-import { LongPressGestureNativeProperties } from '../hooks/gestures/longPress/LongPressProperties';
-import { NativeGestureNativeProperties } from '../hooks/gestures/native/NativeProperties';
-import { TapGestureNativeConfig } from '../hooks/gestures/tap/TapProperties';
-import { InternalConfigProps } from './ConfigTypes';
+import type { FlingGestureNativeProperties } from '../hooks/gestures/fling/FlingTypes';
+import type { HoverGestureNativeProperties } from '../hooks/gestures/hover/HoverTypes';
+import type { LongPressGestureNativeProperties } from '../hooks/gestures/longPress/LongPressTypes';
+import type { NativeGestureNativeProperties } from '../hooks/gestures/native/NativeTypes';
+import type { PanGestureNativeProperties } from '../hooks/gestures/pan/PanTypes';
+import type { TapGestureNativeConfig } from '../hooks/gestures/tap/TapTypes';
+import type { InternalConfigProps } from './ConfigTypes';
 
 export type HandlersPropsWhiteList =
   | Set<keyof PanGestureNativeProperties>

package/src/v3/types/index.ts

@@ -1,52 +1,48 @@
 export type {
-  SharedValue,
-  SharedValueOrT,
-  WithSharedValue,
-} from './ReanimatedTypes';
-
-export type {
-  HandlerData,
-  GestureUpdateEventWithHandlerData,
-  GestureStateChangeEventWithHandlerData,
-  GestureHandlerEventWithHandlerData,
-  UnpackedGestureHandlerEventWithHandlerData,
-  UnpackedGestureHandlerEvent,
-  UpdateEventWithHandlerData,
-  StateChangeEventWithHandlerData,
-  TouchEvent,
-  GestureEvent,
-  AnimatedEvent,
-  ChangeCalculatorType,
-  DiffCalculatorType,
-} from './EventTypes';
-
-export type {
+  CommonGestureConfig,
+  ComposedGestureConfig,
   GestureCallbacks,
+  GestureEndEventCallback,
   GestureEventCallback,
-  GestureEventCallbackWithDidSucceed,
-  GestureTouchEventCallback,
   GestureRelations,
+  GestureTouchEventCallback,
   InternalConfigProps,
-  CommonGestureConfig,
-  ComposedGestureConfig,
 } from './ConfigTypes';
-
 export type { DetectorCallbacks, VirtualChild } from './DetectorTypes';
-
-export { SingleGestureName, ComposedGestureName } from './GestureTypes';
 export type {
-  ExternalRelations,
+  AnimatedEvent,
+  ChangeCalculatorType,
+  DiffCalculatorType,
+  GestureEndEvent,
+  GestureEvent,
+  GestureHandlerEventWithHandlerData,
+  GestureStateChangeEventWithHandlerData,
+  GestureUpdateEventWithHandlerData,
+  HandlerData,
+  StateChangeEventWithHandlerData,
+  TouchEvent,
+  UnpackedGestureHandlerEvent,
+  UnpackedGestureHandlerEventWithHandlerData,
+  UpdateEventWithHandlerData,
+} from './EventTypes';
+export type {
+  AnyGesture,
   BaseDiscreteGestureConfig,
   BaseGestureConfig,
-  SingleGesture,
-  DiscreteSingleGesture,
   ComposedGesture,
+  DiscreteSingleGesture,
+  ExternalRelations,
   Gesture,
-  AnyGesture,
+  SingleGesture,
 } from './GestureTypes';
-
+export { ComposedGestureName, SingleGestureName } from './GestureTypes';
+export type {
+  SharedValue,
+  SharedValueOrT,
+  WithSharedValue,
+} from './ReanimatedTypes';
 export type {
-  HandlersPropsWhiteList,
-  FilterNeverProperties,
   ExcludeInternalConfigProps,
+  FilterNeverProperties,
+  HandlersPropsWhiteList,
 } from './UtilityTypes';

package/src/web/Gestures.ts

@@ -1,13 +1,13 @@
 // Gesture Handlers
-import PanGestureHandler from './handlers/PanGestureHandler';
-import TapGestureHandler from './handlers/TapGestureHandler';
+import FlingGestureHandler from './handlers/FlingGestureHandler';
+import HoverGestureHandler from './handlers/HoverGestureHandler';
 import LongPressGestureHandler from './handlers/LongPressGestureHandler';
+import ManualGestureHandler from './handlers/ManualGestureHandler';
+import NativeViewGestureHandler from './handlers/NativeViewGestureHandler';
+import PanGestureHandler from './handlers/PanGestureHandler';
 import PinchGestureHandler from './handlers/PinchGestureHandler';
 import RotationGestureHandler from './handlers/RotationGestureHandler';
-import FlingGestureHandler from './handlers/FlingGestureHandler';
-import NativeViewGestureHandler from './handlers/NativeViewGestureHandler';
-import ManualGestureHandler from './handlers/ManualGestureHandler';
-import HoverGestureHandler from './handlers/HoverGestureHandler';
+import TapGestureHandler from './handlers/TapGestureHandler';
 
 export const Gestures = {
   NativeViewGestureHandler,

package/src/web/detectors/RotationGestureDetector.ts

@@ -1,5 +1,6 @@
-import { AdaptedEvent, EventTypes } from '../interfaces';
-import PointerTracker from '../tools/PointerTracker';
+import type { AdaptedEvent } from '../interfaces';
+import { EventTypes } from '../interfaces';
+import type PointerTracker from '../tools/PointerTracker';
 
 export interface RotationGestureListener {
   onRotationBegin: (detector: RotationGestureDetector) => boolean;
@@ -75,12 +76,11 @@ export default class RotationGestureDetector
   }
 
   private finish(): void {
-    if (!this.isInProgress) {
-      return;
+    if (this.isInProgress) {
+      this.isInProgress = false;
+      this.keyPointers = [NaN, NaN];
     }
 
-    this.isInProgress = false;
-    this.keyPointers = [NaN, NaN];
     this.onRotationEnd(this);
   }
 
@@ -138,9 +138,8 @@ export default class RotationGestureDetector
         break;
 
       case EventTypes.UP:
-        if (this.isInProgress) {
-          this.finish();
-        }
+        this.finish();
+
         break;
     }
 

package/src/web/detectors/ScaleGestureDetector.ts

@@ -1,7 +1,7 @@
 import { DEFAULT_TOUCH_SLOP } from '../constants';
-import { AdaptedEvent, EventTypes } from '../interfaces';
-
-import PointerTracker from '../tools/PointerTracker';
+import type { AdaptedEvent } from '../interfaces';
+import { EventTypes } from '../interfaces';
+import type PointerTracker from '../tools/PointerTracker';
 
 export interface ScaleGestureListener {
   onScaleBegin: (detector: ScaleGestureDetector) => boolean;
@@ -76,7 +76,7 @@ export default class ScaleGestureDetector implements ScaleGestureListener {
 
     const div: number = pointerUp ? numOfPointers - 1 : numOfPointers;
 
-    const coordsSum = tracker.getAbsoluteCoordsSum();
+    const coordsSum = tracker.getAbsoluteCoordsSum(ignoredPointer);
 
     const focusX = coordsSum.x / div;
     const focusY = coordsSum.y / div;

package/src/web/handlers/FlingGestureHandler.ts

@@ -1,13 +1,12 @@
-import { State } from '../../State';
 import { DiagonalDirections, Directions } from '../../Directions';
-import { AdaptedEvent, Config } from '../interfaces';
-
-import GestureHandler from './GestureHandler';
+import { State } from '../../State';
+import { SingleGestureName } from '../../v3/types';
+import type { AdaptedEvent, Config } from '../interfaces';
+import type { GestureHandlerDelegate } from '../tools/GestureHandlerDelegate';
 import Vector from '../tools/Vector';
 import { coneToDeviation } from '../utils';
-import { GestureHandlerDelegate } from '../tools/GestureHandlerDelegate';
-import IGestureHandler from './IGestureHandler';
-import { SingleGestureName } from '../../v3/types';
+import GestureHandler from './GestureHandler';
+import type IGestureHandler from './IGestureHandler';
 
 const DEFAULT_MAX_DURATION_MS = 800;
 const DEFAULT_MIN_VELOCITY = 700;

package/src/web/handlers/GestureHandler.ts

@@ -1,37 +1,38 @@
 /* eslint-disable @typescript-eslint/no-empty-function */
-import { State } from '../../State';
-import {
-  Config,
-  AdaptedEvent,
-  PropsRef,
-  ResultEvent,
-  PointerData,
-  EventTypes,
-  HitSlop,
-  GestureHandlerNativeEvent,
-} from '../interfaces';
-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 {
+import { ActionType, usesNativeOrVirtualDetector } from '../../ActionType';
+import type {
   ActiveCursor,
+  GestureTouchEvent,
   TouchAction,
   UserSelect,
-  GestureTouchEvent,
-  MouseButton,
 } from '../../handlers/gestureHandlerCommon';
+import { MouseButton } from '../../handlers/gestureHandlerCommon';
 import { PointerType } from '../../PointerType';
-import { GestureHandlerDelegate } from '../tools/GestureHandlerDelegate';
-import { ActionType, usesNativeOrVirtualDetector } from '../../ActionType';
+import { State } from '../../State';
+import { TouchEventType } from '../../TouchEventType';
 import { tagMessage } from '../../utils';
-import {
+import type {
   GestureStateChangeEventWithHandlerData,
   GestureUpdateEventWithHandlerData,
   SingleGestureName,
 } from '../../v3/types';
-import { TouchEventType } from '../../TouchEventType';
+import type {
+  AdaptedEvent,
+  Config,
+  GestureHandlerNativeEvent,
+  HitSlop,
+  PointerData,
+  PropsRef,
+  ResultEvent,
+} from '../interfaces';
+import { EventTypes } from '../interfaces';
+import type EventManager from '../tools/EventManager';
+import type { GestureHandlerDelegate } from '../tools/GestureHandlerDelegate';
+import GestureHandlerOrchestrator from '../tools/GestureHandlerOrchestrator';
+import InteractionManager from '../tools/InteractionManager';
+import type { TrackerElement } from '../tools/PointerTracker';
+import PointerTracker from '../tools/PointerTracker';
+import type IGestureHandler from './IGestureHandler';
 
 export default abstract class GestureHandler implements IGestureHandler {
   private _name!: SingleGestureName;
@@ -48,18 +49,18 @@ export default abstract class GestureHandler implements IGestureHandler {
   private forAnimated: boolean = false;
   private forReanimated: boolean = false;
   private _handlerTag!: number;
-  private _testID?: string = undefined;
+  private _testID?: string | undefined = undefined;
 
-  private hitSlop?: HitSlop = undefined;
+  private hitSlop?: HitSlop | undefined = undefined;
   private manualActivation: boolean = false;
-  private mouseButton?: MouseButton = undefined;
+  private mouseButton?: MouseButton | undefined = undefined;
   private needsPointerData: boolean = false;
   private _tracker: PointerTracker = new PointerTracker();
 
   private _enableContextMenu: boolean = false;
-  private _activeCursor?: ActiveCursor = undefined;
-  private _touchAction?: TouchAction = undefined;
-  private _userSelect?: UserSelect = undefined;
+  private _activeCursor?: ActiveCursor | undefined = undefined;
+  private _touchAction?: TouchAction | undefined = undefined;
+  private _userSelect?: UserSelect | undefined = undefined;
 
   // Orchestrator properties
   private _activationIndex = 0;
@@ -228,7 +229,7 @@ export default abstract class GestureHandler implements IGestureHandler {
   public activate(force = false) {
     if (
       (this.manualActivation !== true || force) &&
-      (this.state === State.UNDETERMINED || this.state === State.BEGAN)
+      this.state === State.BEGAN
     ) {
       this.delegate.onActivate();
       this.moveToState(State.ACTIVE);
@@ -404,15 +405,15 @@ export default abstract class GestureHandler implements IGestureHandler {
       return;
     }
 
-    if (usesNativeOrVirtualDetector(this.actionType)) {
-      invokeNullableMethod(
-        this.forReanimated
-          ? onGestureHandlerReanimatedTouchEvent
-          : onGestureHandlerTouchEvent,
-        touchEvent
-      );
+    if (!usesNativeOrVirtualDetector(this.actionType)) {
+      onGestureHandlerEvent?.(touchEvent);
+      return;
+    }
+
+    if (this.forReanimated) {
+      onGestureHandlerReanimatedTouchEvent?.(touchEvent);
     } else {
-      invokeNullableMethod(onGestureHandlerEvent, touchEvent);
+      onGestureHandlerTouchEvent?.(touchEvent);
     }
   }
 
@@ -443,25 +444,26 @@ export default abstract class GestureHandler implements IGestureHandler {
     // 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.forReanimated) {
+        onGestureHandlerReanimatedStateChange?.(resultEvent);
+      } else {
+        onGestureHandlerStateChange?.(resultEvent);
+      }
     }
-    if (this.state === State.ACTIVE) {
-      (resultEvent.nativeEvent as GestureHandlerNativeEvent).oldState =
-        undefined;
-
-      invokeNullableMethod(
-        this.forReanimated
-          ? onGestureHandlerReanimatedEvent
-          : this.forAnimated
-            ? onGestureHandlerAnimatedEvent
-            : onGestureHandlerEvent,
-        resultEvent
-      );
+
+    if (this.state !== State.ACTIVE) {
+      return;
+    }
+
+    (resultEvent.nativeEvent as GestureHandlerNativeEvent).oldState = undefined;
+
+    if (this.forReanimated) {
+      onGestureHandlerReanimatedEvent?.(resultEvent);
+    } else if (this.forAnimated) {
+      onGestureHandlerAnimatedEvent?.(resultEvent);
+    } else {
+      onGestureHandlerEvent?.(resultEvent);
     }
   };
 
@@ -672,15 +674,15 @@ export default abstract class GestureHandler implements IGestureHandler {
       onGestureHandlerTouchEvent,
     }: PropsRef = this.propsRef!.current;
 
-    if (this.actionType === ActionType.NATIVE_DETECTOR) {
-      invokeNullableMethod(
-        this.forReanimated
-          ? onGestureHandlerReanimatedTouchEvent
-          : onGestureHandlerTouchEvent,
-        cancelEvent
-      );
+    if (this.actionType !== ActionType.NATIVE_DETECTOR) {
+      onGestureHandlerEvent?.(cancelEvent);
+      return;
+    }
+
+    if (this.forReanimated) {
+      onGestureHandlerReanimatedTouchEvent?.(cancelEvent);
     } else {
-      invokeNullableMethod(onGestureHandlerEvent, cancelEvent);
+      onGestureHandlerTouchEvent?.(cancelEvent);
     }
   }
 
@@ -1082,58 +1084,3 @@ export default abstract class GestureHandler implements IGestureHandler {
     );
   }
 }
-
-function invokeNullableMethod(
-  method:
-    | ((event: ResultEvent) => void)
-    | { __getHandler: () => (event: ResultEvent) => void }
-    | { __nodeConfig: { argMapping: unknown[] } }
-    | null
-    | undefined,
-  event: ResultEvent
-): void {
-  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 }: { argMapping: unknown } = 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 as any)[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;
-}