react-native-gesture-handler 2.5.0 → 2.6.0

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

@@ -1,39 +1,7 @@
-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 DEFAULT_TOUCH_SLOP = 15;
 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/lib/typescript/web/detectors/RotationGestureDetector.d.ts

@@ -0,0 +1,30 @@
+import { AdaptedPointerEvent } from '../interfaces';
+import PointerTracker from '../tools/PointerTracker';
+export interface RotationGestureListener {
+    onRotationBegin: (detector: RotationGestureDetector) => boolean;
+    onRotation: (detector: RotationGestureDetector, event: AdaptedPointerEvent) => boolean;
+    onRotationEnd: (detector: RotationGestureDetector, event: AdaptedPointerEvent) => void;
+}
+export default class RotationGestureDetector implements RotationGestureListener {
+    onRotationBegin: (detector: RotationGestureDetector) => boolean;
+    onRotation: (detector: RotationGestureDetector, event: AdaptedPointerEvent) => boolean;
+    onRotationEnd: (detector: RotationGestureDetector, event: AdaptedPointerEvent) => void;
+    private currentTime;
+    private previousTime;
+    private previousAngle;
+    private rotation;
+    private anchorX;
+    private anchorY;
+    private isInProgress;
+    private keyPointers;
+    constructor(callbacks: RotationGestureListener);
+    private updateCurrent;
+    private finish;
+    private setKeyPointers;
+    onTouchEvent(event: AdaptedPointerEvent, tracker: PointerTracker): boolean;
+    private adaptEvent;
+    getTimeDelta(): number;
+    getAnchorX(): number;
+    getAnchorY(): number;
+    getRotation(): number;
+}

package/lib/typescript/web/detectors/ScaleGestureDetector.d.ts

@@ -0,0 +1,30 @@
+import { AdaptedPointerEvent } from '../interfaces';
+import PointerTracker from '../tools/PointerTracker';
+export interface ScaleGestureListener {
+    onScaleBegin: (detector: ScaleGestureDetector) => boolean;
+    onScale: (detector: ScaleGestureDetector, event: AdaptedPointerEvent) => boolean;
+    onScaleEnd: (detector: ScaleGestureDetector, event: AdaptedPointerEvent) => void;
+}
+export default class ScaleGestureDetector implements ScaleGestureListener {
+    onScaleBegin: (detector: ScaleGestureDetector) => boolean;
+    onScale: (detector: ScaleGestureDetector, event: AdaptedPointerEvent) => boolean;
+    onScaleEnd: (detector: ScaleGestureDetector, event: AdaptedPointerEvent) => void;
+    private focusX;
+    private focusY;
+    private currentSpan;
+    private prevSpan;
+    private initialSpan;
+    private currentTime;
+    private prevTime;
+    private inProgress;
+    private spanSlop;
+    private minSpan;
+    constructor(callbacks: ScaleGestureListener);
+    onTouchEvent(event: AdaptedPointerEvent, tracker: PointerTracker): boolean;
+    private adaptEvent;
+    getCurrentSpan(): number;
+    getFocusX(): number;
+    getFocusY(): number;
+    getTimeDelta(): number;
+    getScaleFactor(numOfPointers: number): number;
+}

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

@@ -0,0 +1,31 @@
+import { AdaptedPointerEvent } from '../interfaces';
+import GestureHandler from './GestureHandler';
+export default class FlingGestureHandler extends GestureHandler {
+    private numberOfPointersRequired;
+    private direction;
+    private maxDurationMs;
+    private minAcceptableDelta;
+    private delayTimeout;
+    private startX;
+    private startY;
+    private maxNumberOfPointersSimultaneously;
+    init(ref: number, propsRef: React.RefObject<unknown>): void;
+    updateGestureConfig({ enabled, ...props }: {
+        [x: string]: any;
+        enabled?: boolean | undefined;
+    }): void;
+    protected transformNativeEvent(event: AdaptedPointerEvent): {
+        x: number;
+        y: number;
+        absoluteX: number;
+        absoluteY: number;
+    };
+    private startFling;
+    private tryEndFling;
+    private endFling;
+    protected onPointerDown(event: AdaptedPointerEvent): void;
+    protected onPointerMove(event: AdaptedPointerEvent): void;
+    protected onPointerUp(event: AdaptedPointerEvent): void;
+    protected activate(event: AdaptedPointerEvent, force?: boolean): void;
+    protected resetConfig(): void;
+}

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

@@ -0,0 +1,84 @@
+import { State } from '../../State';
+import { Config, AdaptedPointerEvent } from '../interfaces';
+import EventManager from '../tools/EventManager';
+import InteractionManager from '../tools/InteractionManager';
+import PointerTracker from '../tools/PointerTracker';
+export default abstract class GestureHandler {
+    private lastSentState;
+    protected currentState: State;
+    protected shouldCancellWhenOutside: boolean;
+    protected hasCustomActivationCriteria: boolean;
+    protected enabled: boolean;
+    private ref;
+    private propsRef;
+    protected config: Config;
+    private handlerTag;
+    protected view: HTMLElement | null;
+    protected eventManager: EventManager;
+    protected tracker: PointerTracker;
+    protected interactionManager: InteractionManager;
+    protected activationIndex: number;
+    protected awaiting: boolean;
+    protected active: boolean;
+    protected shouldResetProgress: boolean;
+    constructor();
+    protected init(ref: number, propsRef: React.RefObject<unknown>): void;
+    private setView;
+    private setEventManager;
+    setInteractionManager(manager: InteractionManager): void;
+    protected onCancel(): void;
+    protected onReset(): void;
+    protected resetProgress(): void;
+    reset(): void;
+    moveToState(newState: State, event: AdaptedPointerEvent): void;
+    protected onStateChange(_newState: State, _oldState: State): void;
+    begin(event: AdaptedPointerEvent): void;
+    fail(event: AdaptedPointerEvent): void;
+    cancel(event: AdaptedPointerEvent): void;
+    protected activate(event: AdaptedPointerEvent, _force?: boolean): void;
+    end(event: AdaptedPointerEvent): void;
+    isAwaiting(): boolean;
+    setAwaiting(value: boolean): void;
+    isActive(): boolean;
+    setActive(value: boolean): void;
+    getShouldResetProgress(): boolean;
+    setShouldResetProgress(value: boolean): void;
+    getActivationIndex(): number;
+    setActivationIndex(value: number): void;
+    shouldWaitForHandlerFailure(handler: GestureHandler): boolean;
+    shouldRequireToWaitForFailure(handler: GestureHandler): boolean;
+    shouldRecognizeSimultaneously(handler: GestureHandler): boolean;
+    shouldBeCancelledByOther(handler: GestureHandler): boolean;
+    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 onPointerOut(_event: AdaptedPointerEvent): void;
+    protected onPointerEnter(_event: AdaptedPointerEvent): void;
+    protected onPointerCancel(_event: AdaptedPointerEvent): void;
+    protected onPointerOutOfBounds(event: AdaptedPointerEvent): void;
+    private tryToSendMoveEvent;
+    sendEvent: (event: AdaptedPointerEvent, newState: State, oldState: State) => void;
+    private transformEventData;
+    protected transformNativeEvent(_event: AdaptedPointerEvent): {};
+    updateGestureConfig({ enabled, ...props }: {
+        [x: string]: any;
+        enabled?: boolean | undefined;
+    }): void;
+    protected checkCustomActivationCriteria(criterias: string[]): void;
+    private validateHitSlops;
+    private checkHitSlop;
+    protected resetConfig(): void;
+    getTag(): number;
+    setTag(tag: number): void;
+    protected getConfig(): Config;
+    getShouldEnableGestureOnSetup(): boolean;
+    getView(): HTMLElement | null;
+    getEventManager(): EventManager;
+    getTracker(): PointerTracker;
+    getTrackedPointersID(): number[];
+    getState(): State;
+    protected setShouldCancelWhenOutside(flag: boolean): void;
+    protected getShouldCancelWhenOutside(): boolean;
+}

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

@@ -0,0 +1,33 @@
+import { State } from '../../State';
+import { AdaptedPointerEvent } from '../interfaces';
+import GestureHandler from './GestureHandler';
+export default class LongPressGestureHandler extends GestureHandler {
+    private minDurationMs;
+    private defaultMaxDistSq;
+    private maxDistSq;
+    private startX;
+    private startY;
+    private startTime;
+    private previousTime;
+    private activationTimeout;
+    init(ref: number, propsRef: React.RefObject<unknown>): void;
+    protected transformNativeEvent(event: AdaptedPointerEvent): {
+        x: number;
+        y: number;
+        absoluteX: number;
+        absoluteY: number;
+        duration: number;
+    };
+    updateGestureConfig({ enabled, ...props }: {
+        [x: string]: any;
+        enabled?: boolean | undefined;
+    }): void;
+    protected resetConfig(): void;
+    protected onStateChange(_newState: State, _oldState: State): void;
+    protected onPointerDown(event: AdaptedPointerEvent): void;
+    protected onPointerUp(event: AdaptedPointerEvent): void;
+    protected onPointerMove(event: AdaptedPointerEvent): void;
+    private tryBegin;
+    private tryActivate;
+    private checkDistanceFail;
+}

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

@@ -0,0 +1,16 @@
+import { AdaptedPointerEvent } from '../interfaces';
+import GestureHandler from './GestureHandler';
+export default class NativeViewGestureHandler extends GestureHandler {
+    private buttonRole;
+    private disallowInterruption;
+    init(ref: number, propsRef: React.RefObject<unknown>): void;
+    protected resetConfig(): void;
+    protected onPointerDown(event: AdaptedPointerEvent): void;
+    protected onPointerMove(_event: AdaptedPointerEvent): void;
+    protected onPointerOut(event: AdaptedPointerEvent): void;
+    protected onPointerUp(event: AdaptedPointerEvent): void;
+    protected onPointerCancel(event: AdaptedPointerEvent): void;
+    shouldRecognizeSimultaneously(handler: GestureHandler): boolean;
+    shouldBeCancelledByOther(_handler: GestureHandler): boolean;
+    disallowsInterruption(): boolean;
+}

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

@@ -0,0 +1,68 @@
+import { AdaptedPointerEvent } from '../interfaces';
+import GestureHandler from './GestureHandler';
+export default class PanGestureHandler extends GestureHandler {
+    private readonly customActivationProperties;
+    velocityX: number;
+    velocityY: number;
+    private minDistSq;
+    private activeOffsetXStart;
+    private activeOffsetXEnd;
+    private failOffsetXStart;
+    private failOffsetXEnd;
+    private activeOffsetYStart;
+    private activeOffsetYEnd;
+    private failOffsetYStart;
+    private failOffsetYEnd;
+    private minVelocityX;
+    private minVelocityY;
+    private minVelocitySq;
+    private minPointers;
+    private maxPointers;
+    private startX;
+    private startY;
+    private offsetX;
+    private offsetY;
+    private lastX;
+    private lastY;
+    private activateAfterLongPress;
+    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): {
+        translationX?: undefined;
+        translationY?: undefined;
+        absoluteX?: undefined;
+        absoluteY?: undefined;
+        velocityX?: undefined;
+        velocityY?: undefined;
+        x?: undefined;
+        y?: undefined;
+    } | {
+        translationX: number;
+        translationY: number;
+        absoluteX: number;
+        absoluteY: number;
+        velocityX: number;
+        velocityY: number;
+        x: number;
+        y: number;
+    };
+    private getTranslationX;
+    private getTranslationY;
+    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 onPointerCancel(event: AdaptedPointerEvent): void;
+    protected onPointerOutOfBounds(event: AdaptedPointerEvent): void;
+    private shouldActivate;
+    private shouldFail;
+    private tryBegin;
+    private checkBegan;
+    protected activate(event: AdaptedPointerEvent, force?: boolean): void;
+    protected resetProgress(): void;
+}

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 {};