react-native-gesture-handler 2.4.1 → 2.6.0

package/lib/typescript/web/handlers/PinchGestureHandler.d.ts

@@ -0,0 +1,30 @@
+import { AdaptedPointerEvent } from '../interfaces';
+import GestureHandler from './GestureHandler';
+export default class PinchGestureHandler extends GestureHandler {
+    private scale;
+    private velocity;
+    private startingSpan;
+    private spanSlop;
+    private scaleDetectorListener;
+    private scaleGestureDetector;
+    init(ref: number, propsRef: React.RefObject<unknown>): void;
+    updateGestureConfig({ enabled, ...props }: {
+        [x: string]: any;
+        enabled?: boolean | undefined;
+    }): void;
+    protected transformNativeEvent(_event: AdaptedPointerEvent): {
+        focalX: number;
+        focalY: number;
+        velocity: number;
+        scale: number;
+    };
+    protected onPointerDown(event: AdaptedPointerEvent): void;
+    protected onPointerUp(event: AdaptedPointerEvent): void;
+    protected onPointerMove(event: AdaptedPointerEvent): void;
+    protected onPointerOutOfBounds(_event: AdaptedPointerEvent): void;
+    protected onPointerCancel(_event: AdaptedPointerEvent): void;
+    private tryBegin;
+    protected activate(event: AdaptedPointerEvent, force?: boolean): void;
+    protected onReset(): void;
+    protected resetProgress(): void;
+}

package/lib/typescript/web/handlers/RotationGestureHandler.d.ts

@@ -0,0 +1,30 @@
+import { AdaptedPointerEvent } from '../interfaces';
+import GestureHandler from './GestureHandler';
+export default class RotationGestureHandler extends GestureHandler {
+    private rotation;
+    private velocity;
+    private cachedAnchorX;
+    private cachedAnchorY;
+    private rotationGestureListener;
+    private rotationGestureDetector;
+    init(ref: number, propsRef: React.RefObject<unknown>): void;
+    updateGestureConfig({ enabled, ...props }: {
+        [x: string]: any;
+        enabled?: boolean | undefined;
+    }): void;
+    protected transformNativeEvent(_event: AdaptedPointerEvent): {
+        rotation: number;
+        anchorX: number;
+        anchorY: number;
+        velocity: number;
+    };
+    getAnchorX(): number;
+    getAnchorY(): number;
+    protected onPointerDown(event: AdaptedPointerEvent): void;
+    protected onPointerMove(event: AdaptedPointerEvent): void;
+    protected onPointerUp(event: AdaptedPointerEvent): void;
+    protected onPointerCancel(event: AdaptedPointerEvent): void;
+    protected tryBegin(event: AdaptedPointerEvent): void;
+    protected activate(event: AdaptedPointerEvent, _force?: boolean): void;
+    protected onReset(): void;
+}

package/lib/typescript/web/handlers/TapGestureHandler.d.ts

@@ -0,0 +1,49 @@
+import { AdaptedPointerEvent } from '../interfaces';
+import GestureHandler from './GestureHandler';
+export default class TapGestureHandler extends GestureHandler {
+    private maxDeltaX;
+    private maxDeltaY;
+    private maxDistSq;
+    private maxDurationMs;
+    private maxDelayMs;
+    private numberOfTaps;
+    private minNumberOfPointers;
+    private currentMaxNumberOfPointers;
+    private startX;
+    private startY;
+    private offsetX;
+    private offsetY;
+    private lastX;
+    private lastY;
+    private waitTimeout;
+    private delayTimeout;
+    private tapsSoFar;
+    init(ref: number, propsRef: React.RefObject<unknown>): void;
+    updateGestureConfig({ enabled, ...props }: {
+        [x: string]: any;
+        enabled?: boolean | undefined;
+    }): void;
+    protected resetConfig(): void;
+    protected transformNativeEvent(event: AdaptedPointerEvent): {
+        x: number;
+        y: number;
+        absoluteX: number;
+        absoluteY: number;
+    };
+    private clearTimeouts;
+    private startTap;
+    private endTap;
+    protected onPointerDown(event: AdaptedPointerEvent): void;
+    protected onPointerAdd(_event: AdaptedPointerEvent): void;
+    protected onPointerUp(event: AdaptedPointerEvent): void;
+    protected onPointerRemove(_event: AdaptedPointerEvent): void;
+    protected onPointerMove(event: AdaptedPointerEvent): void;
+    protected onPointerOutOfBounds(event: AdaptedPointerEvent): void;
+    protected onPointerCancel(event: AdaptedPointerEvent): void;
+    private updateState;
+    private trySettingPosition;
+    private shouldFail;
+    protected activate(event: AdaptedPointerEvent): void;
+    protected onCancel(): void;
+    protected resetProgress(): void;
+}

package/lib/typescript/web/interfaces.d.ts

@@ -0,0 +1,97 @@
+import { Directions } from '../Directions';
+import { State } from '../State';
+export interface HitSlop {
+    left?: number;
+    right?: number;
+    top?: number;
+    bottom?: number;
+    horizontal?: number;
+    vertical?: number;
+    width?: number;
+    height?: number;
+}
+export interface Handler {
+    handlerTag: number;
+}
+declare type ConfigArgs = number | boolean | HitSlop | Directions | Handler[] | null | undefined;
+export interface Config extends Record<string, ConfigArgs> {
+    enabled?: boolean;
+    simultaneousHandlers?: Handler[] | null;
+    waitFor?: Handler[] | null;
+    hitSlop?: HitSlop;
+    minPointers?: number;
+    maxPointers?: number;
+    minDist?: number;
+    minDistSq?: number;
+    minVelocity?: number;
+    minVelocityX?: number;
+    minVelocityY?: number;
+    minVelocitySq?: number;
+    maxDist?: number;
+    maxDistSq?: number;
+    failOffsetXStart?: number;
+    failOffsetYStart?: number;
+    failOffsetXEnd?: number;
+    failOffsetYEnd?: number;
+    activeOffsetXStart?: number;
+    activeOffsetXEnd?: number;
+    activeOffsetYStart?: number;
+    activeOffsetYEnd?: number;
+    numberOfPointers?: number;
+    minDurationMs?: number;
+    numberOfTaps?: number;
+    maxDurationMs?: number;
+    maxDelayMs?: number;
+    maxDeltaX?: number;
+    maxDeltaY?: number;
+    direction?: Directions;
+}
+declare type NativeEventArgs = number | State | boolean | undefined;
+interface NativeEvent extends Record<string, NativeEventArgs> {
+    numberOfPointers: number;
+    state: State;
+    pointerInside: boolean | undefined;
+    handlerTag: number;
+    target: number;
+    oldState?: State;
+}
+export interface ResultEvent extends Record<string, NativeEvent | number> {
+    nativeEvent: NativeEvent;
+    timeStamp: number;
+}
+export interface PropsRef {
+    onGestureHandlerEvent: () => void;
+    onGestureHandlerStateChange: () => void;
+}
+export interface AdaptedPointerEvent {
+    x: number;
+    y: number;
+    offsetX: number;
+    offsetY: number;
+    pointerId: number;
+    eventType: EventTypes;
+    pointerType: string;
+    buttons: number;
+    time: number;
+}
+export declare enum MouseButtons {
+    NONE = 0,
+    LEFT = 1,
+    RIGHT = 2,
+    LEFT_RIGHT = 3,
+    SCROLL = 4,
+    SCROLL_LEFT = 5,
+    SCROLL_RIGHT = 6,
+    SCROLL_LEFT_RIGHT = 7
+}
+export declare enum EventTypes {
+    DOWN = 0,
+    ADDITIONAL_POINTER_DOWN = 1,
+    UP = 2,
+    ADDITIONAL_POINTER_UP = 3,
+    MOVE = 4,
+    ENTER = 5,
+    OUT = 6,
+    CANCEL = 7
+}
+export {};

package/lib/typescript/web/tools/EventManager.d.ts

@@ -0,0 +1,28 @@
+import { AdaptedPointerEvent } from '../interfaces';
+export default class EventManager {
+    private activePointers;
+    private readonly view;
+    constructor(view: HTMLElement);
+    setListeners(): void;
+    private onPointerDown;
+    private onPointerUp;
+    private onPointerMove;
+    private onPointerOut;
+    private onPointerEnter;
+    private onPointerCancel;
+    private onPointerOutOfBounds;
+    setOnPointerDown(callback: (event: AdaptedPointerEvent) => void): void;
+    setOnPointerUp(callback: (event: AdaptedPointerEvent) => void): void;
+    setOnPointerMove(callback: (event: AdaptedPointerEvent) => void): void;
+    setOnPointerOut(callback: (event: AdaptedPointerEvent) => void): void;
+    setOnPointerEnter(callback: (event: AdaptedPointerEvent) => void): void;
+    setOnPointerCancel(callback: (event: AdaptedPointerEvent) => void): void;
+    setOnPointerOutOfBounds(callback: (event: AdaptedPointerEvent) => void): void;
+    private mapEvent;
+    isPointerInBounds({ x, y }: {
+        x: number;
+        y: number;
+    }): boolean;
+    private addActivePointer;
+    private removeActivePointer;
+}

package/lib/typescript/web/tools/GestureHandlerOrchestrator.d.ts

@@ -0,0 +1,28 @@
+import { State } from '../../State';
+import { AdaptedPointerEvent } from '../interfaces';
+import GestureHandler from '../handlers/GestureHandler';
+export default class GestureHandlerOrchestrator {
+    private static instance;
+    private gestureHandlers;
+    private awaitingHandlers;
+    private handlersToCancel;
+    private handlingChangeSemaphore;
+    private activationIndex;
+    private constructor();
+    private scheduleFinishedHandlersCleanup;
+    private cleanHandler;
+    private cleanupFinishedHandlers;
+    private hasOtherHandlerToWaitFor;
+    private tryActivate;
+    private cleanupAwaitingHandlers;
+    onHandlerStateChange(handler: GestureHandler, newState: State, oldState: State, event: AdaptedPointerEvent): void;
+    private makeActive;
+    private addAwaitingHandler;
+    recordHandlerIfNotPresent(handler: GestureHandler): void;
+    private shouldHandlerWaitForOther;
+    private canRunSimultaneously;
+    private shouldHandlerBeCancelledBy;
+    private checkOverlap;
+    private isFinished;
+    static getInstance(): GestureHandlerOrchestrator;
+}

package/lib/typescript/web/tools/InteractionManager.d.ts

@@ -0,0 +1,13 @@
+import GestureHandler from '../handlers/GestureHandler';
+import { Config } from '../interfaces';
+export default class InteractionManager {
+    private readonly waitForRelations;
+    private readonly simultaneousRelations;
+    configureInteractions(handler: GestureHandler, config: Config): void;
+    shouldWaitForHandlerFailure(handler: GestureHandler, otherHandler: GestureHandler): boolean;
+    shouldRecognizeSimultaneously(handler: GestureHandler, otherHandler: GestureHandler): boolean;
+    shouldRequireHandlerToWaitForFailure(_handler: GestureHandler, _otherHandler: GestureHandler): boolean;
+    shouldHandlerBeCancelledBy(_handler: GestureHandler, _otherHandler: GestureHandler): boolean;
+    dropRelationsForHandlerWithTag(handlerTag: number): void;
+    reset(): void;
+}

package/lib/typescript/web/tools/NodeManager.d.ts

@@ -0,0 +1,11 @@
+import { ValueOf } from '../../typeUtils';
+import { Gestures } from '../../RNGestureHandlerModule.web';
+export default class NodeManager {
+    private static gestures;
+    static getHandler(tag: number): import("../handlers/PanGestureHandler").default | import("../handlers/TapGestureHandler").default | import("../handlers/LongPressGestureHandler").default | import("../handlers/PinchGestureHandler").default | import("../handlers/RotationGestureHandler").default | import("../handlers/FlingGestureHandler").default | import("../handlers/NativeViewGestureHandler").default;
+    static createGestureHandler(handlerTag: number, handler: InstanceType<ValueOf<typeof Gestures>>): void;
+    static dropGestureHandler(handlerTag: number): void;
+    static getNodes(): {
+        [x: number]: import("../handlers/PanGestureHandler").default | import("../handlers/TapGestureHandler").default | import("../handlers/LongPressGestureHandler").default | import("../handlers/PinchGestureHandler").default | import("../handlers/RotationGestureHandler").default | import("../handlers/FlingGestureHandler").default | import("../handlers/NativeViewGestureHandler").default;
+    };
+}

package/lib/typescript/web/tools/PointerTracker.d.ts

@@ -0,0 +1,28 @@
+import { AdaptedPointerEvent } from '../interfaces';
+interface TrackerElement {
+    lastX: number;
+    lastY: number;
+    timeStamp: number;
+    velocityX: number;
+    velocityY: number;
+}
+export default class PointerTracker {
+    private trackedPointers;
+    addToTracker(event: AdaptedPointerEvent): void;
+    removeFromTracker(pointerId: number): void;
+    track(event: AdaptedPointerEvent): void;
+    getVelocityX(pointerId: number): number;
+    getVelocityY(pointerId: number): number;
+    getLastX(pointerId: number): number;
+    getLastY(pointerId: number): number;
+    getLastAvgX(): number;
+    getLastAvgY(): number;
+    getSumX(ignoredPointer?: number): number;
+    getSumY(ignoredPointer?: number): number;
+    getTrackedPointersCount(): number;
+    getTrackedPointersID(): number[];
+    getData(): Map<number, TrackerElement>;
+    resetTracker(): void;
+    static shareCommonPointers(stPointers: number[], ndPointers: number[]): boolean;
+}
+export {};

package/lib/typescript/{web → web_hammer}/FlingGestureHandler.d.ts

@@ -37,6 +37,7 @@ declare class FlingGestureHandler extends DraggingGestureHandler {
         activeOffsetYStart: number;
         activeOffsetYEnd: number;
         waitFor: any[] | null;
+        simultaneousHandlers: any[] | null;
     }>;
 }
 export default FlingGestureHandler;

package/lib/typescript/{web → web_hammer}/GestureHandler.d.ts

@@ -21,6 +21,7 @@ export declare type Config = Partial<{
     activeOffsetYStart: number;
     activeOffsetYEnd: number;
     waitFor: any[] | null;
+    simultaneousHandlers: any[] | null;
 }>;
 declare abstract class GestureHandler {
     handlerTag: any;
@@ -43,6 +44,7 @@ declare abstract class GestureHandler {
     private ref;
     abstract get name(): string;
     get id(): string;
+    get isNative(): boolean;
     get isDiscrete(): boolean;
     get shouldEnableGestureOnSetup(): boolean;
     constructor();
@@ -65,6 +67,7 @@ declare abstract class GestureHandler {
         activeOffsetYStart: number;
         activeOffsetYEnd: number;
         waitFor: any[] | null;
+        simultaneousHandlers: any[] | null;
     }>;
     onWaitingEnded(_gesture: this): void;
     removePendingGesture(id: string): void;
@@ -98,6 +101,7 @@ declare abstract class GestureHandler {
         activeOffsetYStart: number;
         activeOffsetYEnd: number;
         waitFor: any[] | null;
+        simultaneousHandlers: any[] | null;
     }>;
     destroy: () => void;
     isPointInView: ({ x, y }: {
@@ -124,6 +128,7 @@ declare abstract class GestureHandler {
     forceInvalidate(event: HammerInputExt): void;
     cancelEvent(event: HammerInputExt): void;
     onRawEvent({ isFirst }: HammerInputExt): void;
+    shouldUseTouchEvents(config: Config): boolean;
     setView(ref: Parameters<typeof findNodeHandle>['0'], propsRef: any): void;
     setupEvents(): void;
     onStart({ deltaX, deltaY, rotation }: HammerInputExt): void;
@@ -135,5 +140,6 @@ declare abstract class GestureHandler {
     };
     sync: () => void;
     simulateCancelEvent(_inputData: any): void;
+    ensureConfig(config: Config): Required<Config>;
 }
 export default GestureHandler;

package/lib/typescript/{web → web_hammer}/IndiscreteGestureHandler.d.ts

@@ -27,6 +27,7 @@ declare abstract class IndiscreteGestureHandler extends GestureHandler {
         activeOffsetYStart: number;
         activeOffsetYEnd: number;
         waitFor: any[] | null;
+        simultaneousHandlers: any[] | null;
     }>;
     isGestureEnabledForEvent({ minPointers, maxPointers }: any, _recognizer: any, { maxPointers: pointerLength }: any): {
         failed: boolean;

package/lib/typescript/{web → web_hammer}/LongPressGestureHandler.d.ts

@@ -24,6 +24,7 @@ declare class LongPressGestureHandler extends PressGestureHandler {
         activeOffsetYStart: number;
         activeOffsetYEnd: number;
         waitFor: any[] | null;
+        simultaneousHandlers: any[] | null;
     }> | {
         shouldCancelWhenOutside: boolean;
         maxDistSq: number;

package/lib/typescript/{web → web_hammer}/NativeViewGestureHandler.d.ts

@@ -1,6 +1,7 @@
 import { HammerInputExt } from './GestureHandler';
 import PressGestureHandler from './PressGestureHandler';
 declare class NativeViewGestureHandler extends PressGestureHandler {
+    get isNative(): boolean;
     onRawEvent(ev: HammerInputExt): void;
 }
 export default NativeViewGestureHandler;

package/lib/typescript/web_hammer/NodeManager.d.ts

@@ -0,0 +1,8 @@
+import { ValueOf } from '../typeUtils';
+import { HammerGestures } from '../RNGestureHandlerModule.web';
+export declare function getHandler(tag: number): import("./NativeViewGestureHandler").default | import("./PanGestureHandler").default | import("./TapGestureHandler").default | import("./LongPressGestureHandler").default | import("./PinchGestureHandler").default | import("./RotationGestureHandler").default | import("./FlingGestureHandler").default;
+export declare function createGestureHandler(handlerTag: number, handler: InstanceType<ValueOf<typeof HammerGestures>>): void;
+export declare function dropGestureHandler(handlerTag: number): void;
+export declare function getNodes(): {
+    [x: number]: import("./NativeViewGestureHandler").default | import("./PanGestureHandler").default | import("./TapGestureHandler").default | import("./LongPressGestureHandler").default | import("./PinchGestureHandler").default | import("./RotationGestureHandler").default | import("./FlingGestureHandler").default;
+};

package/lib/typescript/{web → web_hammer}/PanGestureHandler.d.ts

@@ -30,6 +30,7 @@ declare class PanGestureHandler extends DraggingGestureHandler {
         activeOffsetYStart: number;
         activeOffsetYEnd: number;
         waitFor: any[] | null;
+        simultaneousHandlers: any[] | null;
     }>;
     shouldFailUnderCustomCriteria({ deltaX, deltaY }: HammerInputExt, criteria: any): boolean;
     shouldActivateUnderCustomCriteria({ deltaX, deltaY, velocity }: any, criteria: any): boolean;

package/lib/typescript/{web → web_hammer}/PressGestureHandler.d.ts

@@ -34,6 +34,7 @@ declare class PressGestureHandler extends DiscreteGestureHandler {
         activeOffsetYStart: number;
         activeOffsetYEnd: number;
         waitFor: any[] | null;
+        simultaneousHandlers: any[] | null;
     }> | {
         shouldCancelWhenOutside: boolean;
         maxDistSq: number;
@@ -76,6 +77,7 @@ declare class PressGestureHandler extends DiscreteGestureHandler {
         activeOffsetYStart: number;
         activeOffsetYEnd: number;
         waitFor: any[] | null;
+        simultaneousHandlers: any[] | null;
     }>;
 }
 export default PressGestureHandler;

package/lib/typescript/{web → web_hammer}/TapGestureHandler.d.ts

@@ -49,6 +49,7 @@ declare class TapGestureHandler extends DiscreteGestureHandler {
         activeOffsetYStart: number;
         activeOffsetYEnd: number;
         waitFor: any[] | null;
+        simultaneousHandlers: any[] | null;
     }>;
     onGestureEnded(...props: any): void;
     onWaitingEnded(_gesture: any): void;

package/lib/typescript/web_hammer/constants.d.ts

@@ -0,0 +1,39 @@
+export declare const CONTENT_TOUCHES_DELAY = 240;
+export declare const CONTENT_TOUCHES_QUICK_TAP_END_DELAY = 50;
+export declare const MULTI_FINGER_PAN_MAX_PINCH_THRESHOLD = 0.1;
+export declare const MULTI_FINGER_PAN_MAX_ROTATION_THRESHOLD = 7;
+export declare const DEG_RAD: number;
+export declare const EventMap: {
+    readonly 1: 2;
+    readonly 2: 4;
+    readonly 4: 5;
+    readonly 8: 1;
+};
+export declare const Direction: {
+    RIGHT: number;
+    LEFT: number;
+    UP: number;
+    DOWN: number;
+};
+export declare const DirectionMap: {
+    4: number;
+    2: number;
+    8: number;
+    16: number;
+};
+export declare const HammerInputNames: {
+    1: string;
+    2: string;
+    4: string;
+    8: string;
+};
+export declare const HammerDirectionNames: {
+    6: string;
+    8: string;
+    16: string;
+    24: string;
+    1: string;
+    30: string;
+    4: string;
+    2: string;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-gesture-handler",
-  "version": "2.4.1",
+  "version": "2.6.0",
   "description": "Experimental implementation of a new declarative API for gesture handling in react-native",
   "scripts": {
     "prepare": "bob build",

package/src/EnableExperimentalWebImplementation.ts

@@ -0,0 +1,18 @@
+let EXPERIMENTAL_WEB_IMPLEMENTATION = false;
+let getWasCalled = false;
+
+export function enableExperimentalWebImplementation(shouldEnable = true): void {
+  if (getWasCalled) {
+    console.error(
+      'Some parts of this application have already started using old gesture handler implementation. No changes will be applied. You can try enabling new implementation earlier.'
+    );
+    return;
+  }
+
+  EXPERIMENTAL_WEB_IMPLEMENTATION = shouldEnable;
+}
+
+export function isExperimentalWebImplementationEnabled(): boolean {
+  getWasCalled = true;
+  return EXPERIMENTAL_WEB_IMPLEMENTATION;
+}

package/src/RNGestureHandlerModule.macos.ts

@@ -0,0 +1,114 @@
+import { ActionType } from './ActionType';
+import { isExperimentalWebImplementationEnabled } from './EnableExperimentalWebImplementation';
+
+//GestureHandlers
+import InteractionManager from './web/tools/InteractionManager';
+import NodeManager from './web/tools/NodeManager';
+import PanGestureHandler from './web/handlers/PanGestureHandler';
+import TapGestureHandler from './web/handlers/TapGestureHandler';
+import LongPressGestureHandler from './web/handlers/LongPressGestureHandler';
+import PinchGestureHandler from './web/handlers/PinchGestureHandler';
+import RotationGestureHandler from './web/handlers/RotationGestureHandler';
+import FlingGestureHandler from './web/handlers/FlingGestureHandler';
+import NativeViewGestureHandler from './web/handlers/NativeViewGestureHandler';
+
+//Hammer Handlers
+import * as HammerNodeManager from './web_hammer/NodeManager';
+import HammerNativeViewGestureHandler from './web_hammer/NativeViewGestureHandler';
+import HammerPanGestureHandler from './web_hammer/PanGestureHandler';
+import HammerTapGestureHandler from './web_hammer/TapGestureHandler';
+import HammerLongPressGestureHandler from './web_hammer/LongPressGestureHandler';
+import HammerPinchGestureHandler from './web_hammer/PinchGestureHandler';
+import HammerRotationGestureHandler from './web_hammer/RotationGestureHandler';
+import HammerFlingGestureHandler from './web_hammer/FlingGestureHandler';
+import { Config } from './web_hammer/GestureHandler';
+
+export const Gestures = {
+  NativeViewGestureHandler,
+  PanGestureHandler,
+  TapGestureHandler,
+  LongPressGestureHandler,
+  PinchGestureHandler,
+  RotationGestureHandler,
+  FlingGestureHandler,
+};
+
+export const HammerGestures = {
+  NativeViewGestureHandler: HammerNativeViewGestureHandler,
+  PanGestureHandler: HammerPanGestureHandler,
+  TapGestureHandler: HammerTapGestureHandler,
+  LongPressGestureHandler: HammerLongPressGestureHandler,
+  PinchGestureHandler: HammerPinchGestureHandler,
+  RotationGestureHandler: HammerRotationGestureHandler,
+  FlingGestureHandler: HammerFlingGestureHandler,
+};
+
+export default {
+  // Direction,
+  handleSetJSResponder(tag: number, blockNativeResponder: boolean) {
+    console.warn('handleSetJSResponder: ', tag, blockNativeResponder);
+  },
+  handleClearJSResponder() {
+    console.warn('handleClearJSResponder: ');
+  },
+  createGestureHandler<T>(
+    handlerName: keyof typeof Gestures,
+    handlerTag: number,
+    config: T
+  ) {
+    if (isExperimentalWebImplementationEnabled()) {
+      if (!(handlerName in Gestures)) return;
+
+      const interactionManager = new InteractionManager();
+
+      const GestureClass = Gestures[handlerName];
+      NodeManager.createGestureHandler(handlerTag, new GestureClass());
+      interactionManager.configureInteractions(
+        NodeManager.getHandler(handlerTag),
+        (config as unknown) as Config
+      );
+    } else {
+      if (!(handlerName in HammerGestures)) return;
+
+      const GestureClass = HammerGestures[handlerName];
+      HammerNodeManager.createGestureHandler(handlerTag, new GestureClass());
+    }
+
+    this.updateGestureHandler(handlerTag, config);
+  },
+  attachGestureHandler(
+    handlerTag: number,
+    newView: number, //ref
+    _actionType: ActionType,
+    propsRef: React.RefObject<unknown>
+  ) {
+    if (isExperimentalWebImplementationEnabled()) {
+      NodeManager.getHandler(handlerTag).init(newView, propsRef);
+    } else {
+      HammerNodeManager.getHandler(handlerTag).setView(newView, propsRef);
+    }
+  },
+  updateGestureHandler(handlerTag: number, newConfig: any) {
+    if (isExperimentalWebImplementationEnabled()) {
+      NodeManager.getHandler(handlerTag).updateGestureConfig(newConfig);
+    } else {
+      HammerNodeManager.getHandler(handlerTag).updateGestureConfig(newConfig);
+    }
+  },
+  getGestureHandlerNode(handlerTag: number) {
+    if (isExperimentalWebImplementationEnabled()) {
+      return NodeManager.getHandler(handlerTag);
+    } else {
+      return HammerNodeManager.getHandler(handlerTag);
+    }
+  },
+  dropGestureHandler(handlerTag: number) {
+    if (isExperimentalWebImplementationEnabled()) {
+      NodeManager.dropGestureHandler(handlerTag);
+    } else {
+      HammerNodeManager.dropGestureHandler(handlerTag);
+    }
+  },
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  flushOperations() {},
+};