react-native-gesture-handler 2.32.0 → 2.33.1

package/src/handlers/gestures/GestureDetector/Wrap.tsx

@@ -1,5 +1,15 @@
 import React from 'react';
-import { Reanimated } from '../reanimatedWrapper';
+import type { WrapRef } from '../../../hostInstance';
+import {
+  assignRef,
+  isHostInstance,
+  preferHostInstance,
+  resolveHostInstance,
+} from '../../../hostInstance';
+import {
+  Reanimated,
+  reanimatedRefreshesAnimatableRef,
+} from '../reanimatedWrapper';
 import { tagMessage } from '../../../utils';
 
 export class Wrap extends React.Component<{
@@ -7,20 +17,81 @@ export class Wrap extends React.Component<{
   // Implicit `children` prop has been removed in @types/react^18.0.0
   children?: React.ReactNode;
 }> {
-  render() {
+  private childInstance: unknown = null;
+  private hostInstance: unknown = null;
+  private childRef: WrapRef = undefined;
+  private attachedChildRef: WrapRef = undefined;
+  private childRefCleanup: (() => void) | undefined = undefined;
+
+  // eslint-disable-next-line @eslint-react/no-unused-class-component-members
+  public getHostInstance() {
+    return this.hostInstance;
+  }
+
+  // Used by Reanimated's `createAnimatedComponent` (`AnimatedWrap`). Without it,
+  // Reanimated calls `findHostInstance_DEPRECATED` on this class instance, which
+  // warns under StrictMode. Reanimated caches the result, so the child's host
+  // instance is only safe to hand out when it re-resolves the ref on update;
+  // otherwise return the instance itself, which keeps the deprecated lookup.
+  // eslint-disable-next-line @eslint-react/no-unused-class-component-members
+  public getAnimatableRef() {
+    return reanimatedRefreshesAnimatableRef()
+      ? resolveHostInstance(this)
+      : this;
+  }
+
+  private detachChildRef() {
+    if (this.childRefCleanup !== undefined) {
+      this.childRefCleanup();
+    } else if (this.attachedChildRef) {
+      assignRef(this.attachedChildRef, null);
+    }
+
+    this.childRefCleanup = undefined;
+    this.attachedChildRef = undefined;
+  }
+
+  private attachChildRef(instance: unknown) {
+    this.attachedChildRef = this.childRef;
+
+    this.childRefCleanup = assignRef(this.attachedChildRef, instance);
+  }
+
+  private handleChildRef = (instance: unknown) => {
+    this.childInstance = instance;
+
+    const resolved = preferHostInstance(instance);
+    this.hostInstance = isHostInstance(resolved) ? resolved : null;
+
+    this.detachChildRef();
+
+    if (instance !== null && instance !== undefined) {
+      this.attachChildRef(instance);
+    }
+  };
+
+  override componentDidUpdate() {
+    if (
+      this.childRef === this.attachedChildRef ||
+      this.childInstance === null
+    ) {
+      return;
+    }
+
+    this.detachChildRef();
+    this.attachChildRef(this.childInstance);
+  }
+
+  override render() {
+    // I don't think that fighting with types over such a simple function is worth it
+    // The only thing it does is add 'collapsable: false' to the child component
+    // to make sure it is in the native view hierarchy so the detector can find
+    // correct viewTag to attach to.
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let child: any;
+
     try {
-      // I don't think that fighting with types over such a simple function is worth it
-      // The only thing it does is add 'collapsable: false' to the child component
-      // to make sure it is in the native view hierarchy so the detector can find
-      // correct viewTag to attach to.
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      const child: any = React.Children.only(this.props.children);
-      return React.cloneElement(
-        child,
-        { collapsable: false },
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-        child.props.children
-      );
+      child = React.Children.only(this.props.children);
     } catch (e) {
       throw new Error(
         tagMessage(
@@ -28,6 +99,16 @@ export class Wrap extends React.Component<{
         )
       );
     }
+
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+    this.childRef = child.props.ref as WrapRef;
+
+    return React.cloneElement(
+      child,
+      { collapsable: false, ref: this.handleChildRef },
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+      child.props.children
+    );
   }
 }
 

package/src/handlers/gestures/GestureDetector/attachHandlers.ts

@@ -13,6 +13,7 @@ import {
   extractGestureRelations,
   checkGestureCallbacksForWorklets,
   ALLOWED_PROPS,
+  hasExternalRelations,
 } from './utils';
 import { MountRegistry } from '../../../mountRegistry';
 
@@ -53,6 +54,9 @@ export function attachHandlers({
     registerHandler(handler.handlerTag, handler, handler.config.testId);
   }
 
+  // React to every mount until the microtask below classifies the new gesture set
+  preparedGesture.hasExternalRelations = true;
+
   // Use queueMicrotask to extract handlerTags, because all refs should be initialized
   // when it's ran
   ghQueueMicrotask(() => {
@@ -70,9 +74,16 @@ export function attachHandlers({
       );
     }
 
+    preparedGesture.hasExternalRelations =
+      hasExternalRelations(gesturesToAttach);
+
     scheduleFlushOperations();
   });
 
+  // Set before the mount events below fire, so this detector's own mount
+  // listener can tell its gestures apart from external ones
+  preparedGesture.attachedGestures = gesturesToAttach;
+
   for (const gesture of gesturesToAttach) {
     const actionType = gesture.shouldUseReanimated
       ? ActionType.REANIMATED_WORKLET
@@ -98,8 +109,6 @@ export function attachHandlers({
     MountRegistry.gestureWillMount(gesture);
   }
 
-  preparedGesture.attachedGestures = gesturesToAttach;
-
   if (preparedGesture.animatedHandlers) {
     const isAnimatedGesture = (g: GestureType) => g.shouldUseReanimated;
 

package/src/handlers/gestures/GestureDetector/index.tsx

@@ -6,6 +6,7 @@ import { GestureType } from '../gesture';
 import { UserSelect, TouchAction } from '../../gestureHandlerCommon';
 import { ComposedGesture } from '../gestureComposition';
 import { isTestEnv } from '../../../utils';
+import { resolveHostInstance } from '../../../hostInstance';
 
 import GestureHandlerRootViewContext from '../../../GestureHandlerRootViewContext';
 import { AttachedGestureState, GestureDetectorState } from './types';
@@ -126,6 +127,10 @@ export const GestureDetector = (props: GestureDetectorProps) => {
     animatedHandlers: null,
     shouldUseReanimated: shouldUseReanimated,
     isMounted: false,
+    // The real value is computed in the attach microtask, which runs after
+    // this commit's effects. Until then react to every mount, so a relation
+    // to a gesture mounting in the same commit is never skipped.
+    hasExternalRelations: true,
   }).current;
 
   const updateAttachedGestures = useDetectorUpdater(
@@ -149,7 +154,9 @@ export const GestureDetector = (props: GestureDetectorProps) => {
   useAnimatedGesture(preparedGesture, needsToRebuildReanimatedEvent);
 
   useIsomorphicLayoutEffect(() => {
-    const viewTag = findNodeHandle(state.viewRef) as number;
+    const viewTag = findNodeHandle(
+      resolveHostInstance(state.viewRef)
+    ) as number;
     preparedGesture.isMounted = true;
 
     attachHandlers({

package/src/handlers/gestures/GestureDetector/types.ts

@@ -15,6 +15,9 @@ export interface AttachedGestureState {
   shouldUseReanimated: boolean;
   // Whether the GestureDetector is mounted
   isMounted: boolean;
+  // Whether any attached gesture has a relation to a gesture outside this
+  // detector (a ref or a gesture object), which may resolve on a later mount
+  hasExternalRelations: boolean;
 }
 
 export interface GestureDetectorState {

package/src/handlers/gestures/GestureDetector/updateHandlers.ts

@@ -9,6 +9,7 @@ import {
   extractGestureRelations,
   checkGestureCallbacksForWorklets,
   ALLOWED_PROPS,
+  hasExternalRelations,
 } from './utils';
 
 export function updateHandlers(
@@ -33,6 +34,9 @@ export function updateHandlers(
   // Store attached gestures to avoid crash when gestures changed after queueing micro task
   const attachedGestures = preparedGesture.attachedGestures;
 
+  // React to every mount until the microtask below classifies the new gesture set
+  preparedGesture.hasExternalRelations = true;
+
   // Use queueMicrotask to extract handlerTags, because when it's ran, all refs should be updated
   // and handlerTags in BaseGesture references should be updated in the loop above (we need to wait
   // in case of external relations)
@@ -77,6 +81,10 @@ export function updateHandlers(
       registerHandler(handler.handlerTag, handler, handler.config.testId);
     }
 
+    // Classify the new instances: their configs reference the new siblings,
+    // which the old attached objects would mistake for external gestures
+    preparedGesture.hasExternalRelations = hasExternalRelations(newGestures);
+
     if (preparedGesture.animatedHandlers && shouldUpdateSharedValueIfUsed) {
       const newHandlersValue = attachedGestures
         .filter((g) => g.shouldUseReanimated) // Ignore gestures that shouldn't run on UI

package/src/handlers/gestures/GestureDetector/useDetectorUpdater.ts

@@ -2,6 +2,7 @@ import React, { useCallback } from 'react';
 import { GestureType } from '../gesture';
 import { ComposedGesture } from '../gestureComposition';
 
+import { resolveHostInstance } from '../../../hostInstance';
 import {
   AttachedGestureState,
   GestureDetectorState,
@@ -29,7 +30,9 @@ export function useDetectorUpdater(
     // skipConfigUpdate is used to prevent unnecessary updates when only checking if the view has changed
     (skipConfigUpdate?: boolean) => {
       // If the underlying view has changed we need to reattach handlers to the new view
-      const viewTag = findNodeHandle(state.viewRef) as number;
+      const viewTag = findNodeHandle(
+        resolveHostInstance(state.viewRef)
+      ) as number;
       const didUnderlyingViewChange = viewTag !== state.previousViewTag;
 
       if (

package/src/handlers/gestures/GestureDetector/useMountReactions.ts

@@ -1,19 +1,33 @@
-import { transformIntoHandlerTags } from '../../utils';
+import type { GestureMountListener } from '../../../mountRegistry';
 import { MountRegistry } from '../../../mountRegistry';
 import { AttachedGestureState } from './types';
 import { useEffect } from 'react';
 import { GestureRef } from '../gesture';
 
+type MountedGesture = Parameters<GestureMountListener>[0];
+
 function shouldUpdateDetector(
   relation: GestureRef[] | undefined,
-  gesture: { handlerTag: number }
+  gesture: MountedGesture
 ) {
   if (relation === undefined) {
     return false;
   }
 
-  for (const tag of transformIntoHandlerTags(relation)) {
-    if (tag === gesture.handlerTag) {
+  for (const entry of relation) {
+    // A gesture object gets its tag in `initialize`, when its own detector
+    // attaches. The mount event carries that very object, so identity is enough.
+    if (entry === gesture) {
+      return true;
+    }
+
+    if (entry === null || typeof entry !== 'object' || !('current' in entry)) {
+      continue;
+    }
+
+    const current = entry.current as { handlerTag?: number } | null | undefined;
+
+    if (current?.handlerTag === gesture.handlerTag) {
       return true;
     }
   }
@@ -27,6 +41,23 @@ export function useMountReactions(
 ) {
   useEffect(() => {
     return MountRegistry.addMountListener((gesture) => {
+      // The detector may already be unmounted when this fires; bail out to avoid
+      // updating a detached detector.
+      if (!state.isMounted) {
+        return;
+      }
+
+      // Nothing here can resolve late, skip the scan (most detectors)
+      if (!state.hasExternalRelations) {
+        return;
+      }
+
+      // Own gestures are resolved by the attach microtask, and on a reattach
+      // they would match the sibling entries added by composition
+      if (state.attachedGestures.includes(gesture as never)) {
+        return;
+      }
+
       // At this point the ref in the gesture config should be updated, so we can check if one of the gestures
       // set in a relation with the gesture got mounted. If so, we need to update the detector to propagate
       // the changes to the native side.

package/src/handlers/gestures/GestureDetector/useViewRefHandler.ts

@@ -4,6 +4,7 @@ import { getShadowNodeFromRef } from '../../../getShadowNodeFromRef';
 import { GestureDetectorState } from './types';
 import React, { useCallback } from 'react';
 import findNodeHandle from '../../../findNodeHandle';
+import { resolveHostInstance } from '../../../hostInstance';
 
 declare const global: {
   isViewFlatteningDisabled: (node: unknown) => boolean | null; // JSI function
@@ -26,7 +27,9 @@ export function useViewRefHandler(
 
       // if it's the first render, also set the previousViewTag to prevent reattaching gestures when not needed
       if (state.previousViewTag === -1) {
-        state.previousViewTag = findNodeHandle(state.viewRef) as number;
+        state.previousViewTag = findNodeHandle(
+          resolveHostInstance(state.viewRef)
+        ) as number;
       }
 
       // Pass true as `skipConfigUpdate`. Here we only want to trigger the eventual reattaching of handlers
@@ -36,7 +39,7 @@ export function useViewRefHandler(
       }
 
       if (__DEV__ && isFabric() && global.isViewFlatteningDisabled) {
-        const node = getShadowNodeFromRef(ref);
+        const node = getShadowNodeFromRef(resolveHostInstance(ref));
         if (global.isViewFlatteningDisabled(node) === false) {
           console.error(
             tagMessage(

package/src/handlers/gestures/GestureDetector/utils.ts

@@ -64,21 +64,53 @@ function extractValidHandlerTags(interactionGroup: GestureRef[] | undefined) {
   );
 }
 
+// Relations that may resolve to a different handler after this detector attached:
+// refs (filled when the target mounts) and gesture objects attached by another
+// detector (they get a tag in `initialize`). Siblings added by composition are
+// attached together with the gesture, so they never resolve late.
+export function hasExternalRelations(gestures: GestureType[]) {
+  const ownGestures = new Set(gestures);
+
+  for (const gesture of gestures) {
+    const relations = [
+      gesture.config.blocksHandlers,
+      gesture.config.requireToFail,
+      gesture.config.simultaneousWith,
+    ];
+
+    for (const relation of relations) {
+      if (relation === undefined) {
+        continue;
+      }
+
+      for (const entry of relation) {
+        if (typeof entry === 'number') {
+          continue;
+        }
+
+        // Anything but our own gesture object is external: a ref, or a gesture
+        // attached by another detector
+        if (!(entry instanceof BaseGesture) || !ownGestures.has(entry)) {
+          return true;
+        }
+      }
+    }
+  }
+
+  return false;
+}
+
 export function extractGestureRelations(gesture: GestureType) {
-  gesture.config.requireToFail = extractValidHandlerTags(
-    gesture.config.requireToFail
-  );
-  gesture.config.simultaneousWith = extractValidHandlerTags(
+  const requireToFail = extractValidHandlerTags(gesture.config.requireToFail);
+  const simultaneousWith = extractValidHandlerTags(
     gesture.config.simultaneousWith
   );
-  gesture.config.blocksHandlers = extractValidHandlerTags(
-    gesture.config.blocksHandlers
-  );
+  const blocksHandlers = extractValidHandlerTags(gesture.config.blocksHandlers);
 
   return {
-    waitFor: gesture.config.requireToFail,
-    simultaneousHandlers: gesture.config.simultaneousWith,
-    blocksHandlers: gesture.config.blocksHandlers,
+    waitFor: requireToFail,
+    simultaneousHandlers: simultaneousWith,
+    blocksHandlers: blocksHandlers,
   };
 }
 

package/src/handlers/gestures/gesture.ts

@@ -131,6 +131,17 @@ export abstract class BaseGesture<
   public handlerTag = -1;
   public handlerName = '';
   public config: BaseGestureConfig = {};
+  // Snapshot of the relations defined directly on this gesture (e.g. via
+  // `simultaneousWithExternalGesture`), captured before any composition extends
+  // them. Composition rebuilds the relation config from this snapshot on every
+  // `prepare`, so repeated renders don't accumulate references to gestures from
+  // previous renders (memory leak, see #3763), while keeping the original
+  // references so relations stay re-resolvable after a remount, such as a
+  // `react-freeze` unfreeze (see #4238).
+  public relationsSnapshot?: {
+    simultaneousWith: GestureRef[] | undefined;
+    requireToFail: GestureRef[] | undefined;
+  };
   public handlers: HandlerCallbacks<EventPayloadT> = {
     gestureId: -1,
     handlerTag: -1,

package/src/handlers/gestures/gestureComposition.ts

@@ -27,16 +27,29 @@ export class ComposedGesture extends Gesture {
     requireGesturesToFail: GestureType[]
   ) {
     if (gesture instanceof BaseGesture) {
+      // Capture the relations defined directly on the gesture before composition
+      // extends them, then always rebuild from that snapshot. Otherwise, when the
+      // gesture is stable (e.g. wrapped in `useMemo`) but the composition is
+      // recreated on every render, the relations would keep accumulating
+      // references to gestures from previous renders, leaking memory (see #3763).
+      // We keep the original references (instead of collapsing them to handler
+      // tags) so relations can still be re-resolved after a remount, such as a
+      // `react-freeze` unfreeze (see #4238).
+      gesture.relationsSnapshot ??= {
+        simultaneousWith: gesture.config.simultaneousWith,
+        requireToFail: gesture.config.requireToFail,
+      };
+
       const newConfig = { ...gesture.config };
 
       // No need to extend `blocksHandlers` here, because it's not changed in composition.
       // The same effect is achieved by reversing the order of 2 gestures in `Exclusive`
       newConfig.simultaneousWith = extendRelation(
-        newConfig.simultaneousWith,
+        gesture.relationsSnapshot.simultaneousWith,
         simultaneousGestures
       );
       newConfig.requireToFail = extendRelation(
-        newConfig.requireToFail,
+        gesture.relationsSnapshot.requireToFail,
         requireGesturesToFail
       );
 

package/src/handlers/gestures/gestureStateManager.web.ts

@@ -1,5 +1,13 @@
 import NodeManager from '../../web/tools/NodeManager';
-import { GestureStateManagerType } from './gestureStateManager';
+
+export interface GestureStateManagerType {
+  begin: () => void;
+  activate: () => void;
+  fail: () => void;
+  end: () => void;
+  /** @internal */
+  handlerTag: number;
+}
 
 export const GestureStateManager = {
   create(handlerTag: number): GestureStateManagerType {

package/src/handlers/gestures/panGesture.ts

@@ -147,7 +147,8 @@ export class PanGesture extends ContinousBaseGesture<
   }
 
   /**
-   * Minimum velocity the finger has to reach in order to activate handler.
+   * Minimum speed the pointer has to reach in order to activate handler.
+   * Expressed in points per second.
    * @param velocity
    */
   minVelocity(velocity: number) {
@@ -156,7 +157,8 @@ export class PanGesture extends ContinousBaseGesture<
   }
 
   /**
-   * Minimum velocity along X axis the finger has to reach in order to activate handler.
+   * Minimum speed along X axis the pointer has to reach in order to activate handler.
+   * Expressed in points per second.
    * @param velocity
    */
   minVelocityX(velocity: number) {
@@ -165,7 +167,8 @@ export class PanGesture extends ContinousBaseGesture<
   }
 
   /**
-   * Minimum velocity along Y axis the finger has to reach in order to activate handler.
+   * Minimum speed along Y axis the pointer has to reach in order to activate handler.
+   * Expressed in points per second.
    * @param velocity
    */
   minVelocityY(velocity: number) {

package/src/handlers/gestures/reanimatedWrapper.ts

@@ -54,4 +54,27 @@ if (Reanimated !== undefined && !Reanimated.setGestureState) {
   };
 }
 
+// Reanimated resolves `getAnimatableRef()` once, when its ref to the wrapped
+// component attaches. Only versions that re-resolve it on update (their
+// `AnimatedComponent` has `_refreshComponentRef`) can be handed a child's host
+// instance that may change, as the legacy `Wrap` does. The class is not
+// exported, so probe it by subpath, as the v3 detector does for
+// `NativeEventsManager`.
+let refreshesAnimatableRef = false;
+try {
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+  const AnimatedComponent =
+    // eslint-disable-next-line @typescript-eslint/no-var-requires, @typescript-eslint/no-unsafe-member-access
+    require('react-native-reanimated/src/createAnimatedComponent/AnimatedComponent').default;
+  refreshesAnimatableRef =
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+    typeof AnimatedComponent?.prototype?._refreshComponentRef === 'function';
+} catch {
+  // Reanimated is missing or older; keep handing Reanimated the Wrap itself.
+}
+
+export function reanimatedRefreshesAnimatableRef() {
+  return refreshesAnimatableRef;
+}
+
 export { Reanimated };

package/src/hostInstance.ts

@@ -0,0 +1,57 @@
+import type { Ref } from 'react';
+
+export type WrapRef = Ref<unknown> | undefined;
+
+export function assignRef(
+  ref: WrapRef,
+  instance: unknown
+): (() => void) | undefined {
+  if (typeof ref === 'function') {
+    const cleanup = ref(instance as never);
+    return typeof cleanup === 'function' ? cleanup : undefined;
+  }
+
+  if (ref) {
+    ref.current = instance;
+  }
+
+  return undefined;
+}
+
+export function isHostInstance(instance: unknown) {
+  return (
+    (instance as { __internalInstanceHandle?: unknown } | null | undefined)
+      ?.__internalInstanceHandle !== undefined
+  );
+}
+
+export function preferHostInstance(instance: unknown) {
+  if (instance === null || instance === undefined || isHostInstance(instance)) {
+    return instance;
+  }
+
+  const nativeRef = (
+    instance as { getNativeScrollRef?: () => unknown }
+  ).getNativeScrollRef?.();
+
+  return isHostInstance(nativeRef) ? nativeRef : instance;
+}
+
+export interface HostInstanceProvider {
+  getHostInstance: () => unknown;
+}
+
+function providesHostInstance(ref: unknown): ref is HostInstanceProvider {
+  return (
+    typeof (ref as HostInstanceProvider | null | undefined)?.getHostInstance ===
+    'function'
+  );
+}
+
+export function resolveHostInstance<T>(ref: T): T {
+  if (!providesHostInstance(ref)) {
+    return ref;
+  }
+
+  return (ref.getHostInstance() ?? ref) as T;
+}

package/src/index.ts

@@ -146,6 +146,7 @@ export type {
 export type { SwipeableProps } from './components/Swipeable';
 export { default as Swipeable } from './components/Swipeable';
 export type {
+  PressableEvent,
   PressableProps,
   PressableStateCallbackType,
 } from './components/Pressable';

package/src/mocks/mocks.tsx

@@ -8,7 +8,9 @@ import {
   FlatList,
   Switch,
   TextInput,
+  TextInputProps,
   DrawerLayoutAndroid,
+  DrawerLayoutAndroidProps,
   View,
 } from 'react-native';
 import { State } from '../State';
@@ -48,8 +50,10 @@ export default {
   ScrollView,
   FlatList,
   Switch,
-  TextInput,
-  DrawerLayoutAndroid,
+  // Explicit types keep the emitted declaration portable under TS 6.
+  TextInput: TextInput as React.ComponentType<TextInputProps>,
+  DrawerLayoutAndroid:
+    DrawerLayoutAndroid as React.ComponentType<DrawerLayoutAndroidProps>,
   NativeViewGestureHandler,
   TapGestureHandler,
   ForceTouchGestureHandler,

package/src/specs/NativeRNGestureHandlerModule.ts

@@ -1,24 +1,30 @@
-import { TurboModuleRegistry, TurboModule } from 'react-native';
-import { Double } from 'react-native/Libraries/Types/CodegenTypes';
+import type { CodegenTypes, TurboModule } from 'react-native';
+import { TurboModuleRegistry } from 'react-native';
 
 export interface Spec extends TurboModule {
-  handleSetJSResponder: (tag: Double, blockNativeResponder: boolean) => void;
+  handleSetJSResponder: (
+    tag: CodegenTypes.Double,
+    blockNativeResponder: boolean
+  ) => void;
   handleClearJSResponder: () => void;
   createGestureHandler: (
     handlerName: string,
-    handlerTag: Double,
+    handlerTag: CodegenTypes.Double,
     // Record<> is not supported by codegen
     // eslint-disable-next-line @typescript-eslint/ban-types
     config: Object
   ) => void;
   attachGestureHandler: (
-    handlerTag: Double,
-    newView: Double,
-    actionType: Double
+    handlerTag: CodegenTypes.Double,
+    newView: CodegenTypes.Double,
+    actionType: CodegenTypes.Double
+  ) => void;
+  updateGestureHandler: (
+    handlerTag: CodegenTypes.Double,
+    // eslint-disable-next-line @typescript-eslint/ban-types
+    newConfig: Object
   ) => void;
-  // eslint-disable-next-line @typescript-eslint/ban-types
-  updateGestureHandler: (handlerTag: Double, newConfig: Object) => void;
-  dropGestureHandler: (handlerTag: Double) => void;
+  dropGestureHandler: (handlerTag: CodegenTypes.Double) => void;
   install: () => boolean;
   flushOperations: () => void;
 }