react-native-gesture-handler 2.6.0 → 2.6.2

package/lib/typescript/RNGestureHandlerModule.macos.d.ts

@@ -6,6 +6,7 @@ import PinchGestureHandler from './web/handlers/PinchGestureHandler';
 import RotationGestureHandler from './web/handlers/RotationGestureHandler';
 import FlingGestureHandler from './web/handlers/FlingGestureHandler';
 import NativeViewGestureHandler from './web/handlers/NativeViewGestureHandler';
+import ManualGestureHandler from './web/handlers/ManualGestureHandler';
 import HammerNativeViewGestureHandler from './web_hammer/NativeViewGestureHandler';
 import HammerPanGestureHandler from './web_hammer/PanGestureHandler';
 import HammerTapGestureHandler from './web_hammer/TapGestureHandler';
@@ -13,6 +14,7 @@ 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/interfaces';
 export declare const Gestures: {
     NativeViewGestureHandler: typeof NativeViewGestureHandler;
     PanGestureHandler: typeof PanGestureHandler;
@@ -21,6 +23,7 @@ export declare const Gestures: {
     PinchGestureHandler: typeof PinchGestureHandler;
     RotationGestureHandler: typeof RotationGestureHandler;
     FlingGestureHandler: typeof FlingGestureHandler;
+    ManualGestureHandler: typeof ManualGestureHandler;
 };
 export declare const HammerGestures: {
     NativeViewGestureHandler: typeof HammerNativeViewGestureHandler;
@@ -32,12 +35,12 @@ export declare const HammerGestures: {
     FlingGestureHandler: typeof HammerFlingGestureHandler;
 };
 declare const _default: {
-    handleSetJSResponder(tag: number, blockNativeResponder: boolean): void;
+    handleSetJSResponder(_tag: number, _blockNativeResponder: boolean): void;
     handleClearJSResponder(): void;
     createGestureHandler<T>(handlerName: keyof typeof Gestures, handlerTag: number, config: T): void;
     attachGestureHandler(handlerTag: number, newView: number, _actionType: ActionType, propsRef: React.RefObject<unknown>): void;
-    updateGestureHandler(handlerTag: number, newConfig: any): void;
-    getGestureHandlerNode(handlerTag: number): PanGestureHandler | TapGestureHandler | LongPressGestureHandler | PinchGestureHandler | RotationGestureHandler | FlingGestureHandler | NativeViewGestureHandler | HammerNativeViewGestureHandler | HammerPanGestureHandler | HammerTapGestureHandler | HammerLongPressGestureHandler | HammerPinchGestureHandler | HammerRotationGestureHandler | HammerFlingGestureHandler;
+    updateGestureHandler(handlerTag: number, newConfig: Config): void;
+    getGestureHandlerNode(handlerTag: number): PanGestureHandler | TapGestureHandler | LongPressGestureHandler | PinchGestureHandler | RotationGestureHandler | FlingGestureHandler | NativeViewGestureHandler | ManualGestureHandler | HammerNativeViewGestureHandler | HammerPanGestureHandler | HammerTapGestureHandler | HammerLongPressGestureHandler | HammerPinchGestureHandler | HammerRotationGestureHandler | HammerFlingGestureHandler;
     dropGestureHandler(handlerTag: number): void;
     flushOperations(): void;
 };

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

@@ -1,3 +1,4 @@
+import React from 'react';
 import { ActionType } from './ActionType';
 import PanGestureHandler from './web/handlers/PanGestureHandler';
 import TapGestureHandler from './web/handlers/TapGestureHandler';
@@ -6,6 +7,7 @@ import PinchGestureHandler from './web/handlers/PinchGestureHandler';
 import RotationGestureHandler from './web/handlers/RotationGestureHandler';
 import FlingGestureHandler from './web/handlers/FlingGestureHandler';
 import NativeViewGestureHandler from './web/handlers/NativeViewGestureHandler';
+import ManualGestureHandler from './web/handlers/ManualGestureHandler';
 import HammerNativeViewGestureHandler from './web_hammer/NativeViewGestureHandler';
 import HammerPanGestureHandler from './web_hammer/PanGestureHandler';
 import HammerTapGestureHandler from './web_hammer/TapGestureHandler';
@@ -22,6 +24,7 @@ export declare const Gestures: {
     PinchGestureHandler: typeof PinchGestureHandler;
     RotationGestureHandler: typeof RotationGestureHandler;
     FlingGestureHandler: typeof FlingGestureHandler;
+    ManualGestureHandler: typeof ManualGestureHandler;
 };
 export declare const HammerGestures: {
     NativeViewGestureHandler: typeof HammerNativeViewGestureHandler;
@@ -36,9 +39,9 @@ declare const _default: {
     handleSetJSResponder(tag: number, blockNativeResponder: boolean): void;
     handleClearJSResponder(): void;
     createGestureHandler<T>(handlerName: keyof typeof Gestures, handlerTag: number, config: T): void;
-    attachGestureHandler(handlerTag: number, newView: number, _actionType: ActionType, propsRef: React.RefObject<unknown>): void;
+    attachGestureHandler(handlerTag: number, newView: any, _actionType: ActionType, propsRef: React.RefObject<unknown>): void;
     updateGestureHandler(handlerTag: number, newConfig: Config): void;
-    getGestureHandlerNode(handlerTag: number): PanGestureHandler | TapGestureHandler | LongPressGestureHandler | PinchGestureHandler | RotationGestureHandler | FlingGestureHandler | NativeViewGestureHandler | HammerNativeViewGestureHandler | HammerPanGestureHandler | HammerTapGestureHandler | HammerLongPressGestureHandler | HammerPinchGestureHandler | HammerRotationGestureHandler | HammerFlingGestureHandler;
+    getGestureHandlerNode(handlerTag: number): PanGestureHandler | TapGestureHandler | LongPressGestureHandler | PinchGestureHandler | RotationGestureHandler | FlingGestureHandler | NativeViewGestureHandler | ManualGestureHandler | HammerNativeViewGestureHandler | HammerPanGestureHandler | HammerTapGestureHandler | HammerLongPressGestureHandler | HammerPinchGestureHandler | HammerRotationGestureHandler | HammerFlingGestureHandler;
     dropGestureHandler(handlerTag: number): void;
     flushOperations(): void;
 };

package/lib/typescript/components/Swipeable.d.ts

@@ -63,11 +63,11 @@ export interface SwipeableProps extends Pick<PanGestureHandlerProps, SwipeableEx
     /**
      * Called when action panel gets open (either right or left).
      */
-    onSwipeableOpen?: (direction: 'left' | 'right') => void;
+    onSwipeableOpen?: (direction: 'left' | 'right', swipeable: Swipeable) => void;
     /**
      * Called when action panel is closed.
      */
-    onSwipeableClose?: (direction: 'left' | 'right') => void;
+    onSwipeableClose?: (direction: 'left' | 'right', swipeable: Swipeable) => void;
     /**
      * @deprecated Use `direction` argument of onSwipeableWillOpen()
      *
@@ -107,7 +107,7 @@ export interface SwipeableProps extends Pick<PanGestureHandlerProps, SwipeableEx
      *
      * To support `rtl` flexbox layouts use `flexDirection` styling.
      * */
-    renderRightActions?: (progressAnimatedValue: Animated.AnimatedInterpolation, dragAnimatedValue: Animated.AnimatedInterpolation) => React.ReactNode;
+    renderRightActions?: (progressAnimatedValue: Animated.AnimatedInterpolation, dragAnimatedValue: Animated.AnimatedInterpolation, swipeable: Swipeable) => React.ReactNode;
     useNativeAnimations?: boolean;
     animationOptions?: Record<string, unknown>;
     /**

package/lib/typescript/components/touchables/TouchableNativeFeedback.android.d.ts

@@ -33,7 +33,7 @@ export default class TouchableNativeFeedback extends Component<TouchableNativeFe
     };
     static Ripple: (color: ColorValue, borderless: boolean, rippleRadius?: number | undefined) => {
         type: string;
-        color: string | symbol;
+        color: ColorValue;
         borderless: boolean;
         rippleRadius: number | undefined;
     };

package/lib/typescript/fabric/RNGestureHandlerButtonNativeComponent.d.ts

@@ -1,6 +1,6 @@
+/// <reference types="react-native/codegen" />
 import type { Int32, WithDefault } from 'react-native/Libraries/Types/CodegenTypes';
-import type { ViewProps, HostComponent } from 'react-native';
-import type { ColorValue } from 'react-native/Libraries/StyleSheet/StyleSheet';
+import type { ViewProps, ColorValue } from 'react-native';
 interface NativeProps extends ViewProps {
     exclusive?: WithDefault<boolean, true>;
     foreground?: boolean;
@@ -10,5 +10,5 @@ interface NativeProps extends ViewProps {
     rippleRadius?: Int32;
     touchSoundDisabled?: WithDefault<boolean, false>;
 }
-declare const _default: HostComponent<NativeProps>;
+declare const _default: import("react-native/Libraries/Utilities/codegenNativeComponent").NativeComponentType<NativeProps>;
 export default _default;

package/lib/typescript/fabric/RNGestureHandlerRootViewNativeComponent.d.ts

@@ -1,5 +1,6 @@
-import type { ViewProps, HostComponent } from 'react-native';
+/// <reference types="react-native/codegen" />
+import type { ViewProps } from 'react-native';
 interface NativeProps extends ViewProps {
 }
-declare const _default: HostComponent<NativeProps>;
+declare const _default: import("react-native/Libraries/Utilities/codegenNativeComponent").NativeComponentType<NativeProps>;
 export default _default;

package/lib/typescript/handlers/gestures/gestureStateManager.web.d.ts

@@ -0,0 +1,4 @@
+import { GestureStateManagerType } from './gestureStateManager';
+export declare const GestureStateManager: {
+    create(handlerTag: number): GestureStateManagerType;
+};

package/lib/typescript/utils.d.ts

@@ -1,3 +1,7 @@
+export declare const REACT_NATIVE_VERSION: {
+    major: number;
+    minor: number;
+};
 export declare function toArray<T>(object: T | T[]): T[];
 export declare type withPrevAndCurrentMapFn<T, Transformed> = (previous: Transformed | null, current: T) => Transformed;
 export declare function withPrevAndCurrent<T, Transformed>(array: T[], mapFn: withPrevAndCurrentMapFn<T, Transformed>): Transformed[];

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

@@ -1,14 +1,14 @@
-import { AdaptedPointerEvent } from '../interfaces';
+import { AdaptedEvent } 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;
+    onRotation: (detector: RotationGestureDetector) => boolean;
+    onRotationEnd: (detector: RotationGestureDetector) => void;
 }
 export default class RotationGestureDetector implements RotationGestureListener {
     onRotationBegin: (detector: RotationGestureDetector) => boolean;
-    onRotation: (detector: RotationGestureDetector, event: AdaptedPointerEvent) => boolean;
-    onRotationEnd: (detector: RotationGestureDetector, event: AdaptedPointerEvent) => void;
+    onRotation: (detector: RotationGestureDetector) => boolean;
+    onRotationEnd: (detector: RotationGestureDetector) => void;
     private currentTime;
     private previousTime;
     private previousAngle;
@@ -21,10 +21,10 @@ export default class RotationGestureDetector implements RotationGestureListener
     private updateCurrent;
     private finish;
     private setKeyPointers;
-    onTouchEvent(event: AdaptedPointerEvent, tracker: PointerTracker): boolean;
-    private adaptEvent;
+    onTouchEvent(event: AdaptedEvent, tracker: PointerTracker): boolean;
     getTimeDelta(): number;
     getAnchorX(): number;
     getAnchorY(): number;
     getRotation(): number;
+    reset(): void;
 }

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

@@ -1,14 +1,14 @@
-import { AdaptedPointerEvent } from '../interfaces';
+import { AdaptedEvent } 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;
+    onScale: (detector: ScaleGestureDetector) => boolean;
+    onScaleEnd: (detector: ScaleGestureDetector) => void;
 }
 export default class ScaleGestureDetector implements ScaleGestureListener {
     onScaleBegin: (detector: ScaleGestureDetector) => boolean;
-    onScale: (detector: ScaleGestureDetector, event: AdaptedPointerEvent) => boolean;
-    onScaleEnd: (detector: ScaleGestureDetector, event: AdaptedPointerEvent) => void;
+    onScale: (detector: ScaleGestureDetector) => boolean;
+    onScaleEnd: (detector: ScaleGestureDetector) => void;
     private focusX;
     private focusY;
     private currentSpan;
@@ -20,8 +20,7 @@ export default class ScaleGestureDetector implements ScaleGestureListener {
     private spanSlop;
     private minSpan;
     constructor(callbacks: ScaleGestureListener);
-    onTouchEvent(event: AdaptedPointerEvent, tracker: PointerTracker): boolean;
-    private adaptEvent;
+    onTouchEvent(event: AdaptedEvent, tracker: PointerTracker): boolean;
     getCurrentSpan(): number;
     getFocusX(): number;
     getFocusY(): number;

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

@@ -1,4 +1,4 @@
-import { AdaptedPointerEvent } from '../interfaces';
+import { AdaptedEvent, Config } from '../interfaces';
 import GestureHandler from './GestureHandler';
 export default class FlingGestureHandler extends GestureHandler {
     private numberOfPointersRequired;
@@ -10,11 +10,8 @@ export default class FlingGestureHandler extends GestureHandler {
     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): {
+    updateGestureConfig({ enabled, ...props }: Config): void;
+    protected transformNativeEvent(): {
         x: number;
         y: number;
         absoluteX: number;
@@ -23,9 +20,14 @@ export default class FlingGestureHandler extends GestureHandler {
     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 onPointerDown(event: AdaptedEvent): void;
+    protected onPointerAdd(event: AdaptedEvent): void;
+    private newPointerAction;
+    protected onPointerMove(event: AdaptedEvent): void;
+    protected onPointerUp(event: AdaptedEvent): void;
+    protected onPointerRemove(event: AdaptedEvent): void;
+    private onUp;
+    protected onPointerCancel(event: AdaptedEvent): void;
+    activate(force?: boolean): void;
     protected resetConfig(): void;
 }

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

@@ -1,7 +1,6 @@
 import { State } from '../../State';
-import { Config, AdaptedPointerEvent } from '../interfaces';
+import { Config, AdaptedEvent, PointerType } from '../interfaces';
 import EventManager from '../tools/EventManager';
-import InteractionManager from '../tools/InteractionManager';
 import PointerTracker from '../tools/PointerTracker';
 export default abstract class GestureHandler {
     private lastSentState;
@@ -11,32 +10,37 @@ export default abstract class GestureHandler {
     protected enabled: boolean;
     private ref;
     private propsRef;
-    protected config: Config;
     private handlerTag;
-    protected view: HTMLElement | null;
-    protected eventManager: EventManager;
+    protected config: Config;
+    protected view: HTMLElement;
+    protected eventManagers: EventManager[];
     protected tracker: PointerTracker;
-    protected interactionManager: InteractionManager;
     protected activationIndex: number;
     protected awaiting: boolean;
     protected active: boolean;
     protected shouldResetProgress: boolean;
+    protected pointerType: PointerType;
     constructor();
     protected init(ref: number, propsRef: React.RefObject<unknown>): void;
     private setView;
-    private setEventManager;
-    setInteractionManager(manager: InteractionManager): void;
+    private addEventManager;
     protected onCancel(): void;
     protected onReset(): void;
     protected resetProgress(): void;
     reset(): void;
-    moveToState(newState: State, event: AdaptedPointerEvent): void;
+    moveToState(newState: State, sendIfDisabled?: boolean): 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;
+    begin(): void;
+    /**
+     * @param {boolean} sendIfDisabled - Used when handler becomes disabled. With this flag orchestrator will be forced to send fail event
+     */
+    fail(sendIfDisabled?: boolean): void;
+    /**
+     * @param {boolean} sendIfDisabled - Used when handler becomes disabled. With this flag orchestrator will be forced to send cancel event
+     */
+    cancel(sendIfDisabled?: boolean): void;
+    activate(_force?: boolean): void;
+    end(): void;
     isAwaiting(): boolean;
     setAwaiting(value: boolean): void;
     isActive(): boolean;
@@ -49,36 +53,42 @@ export default abstract class GestureHandler {
     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;
+    protected onPointerDown(event: AdaptedEvent): void;
+    protected onPointerAdd(event: AdaptedEvent): void;
+    protected onPointerUp(event: AdaptedEvent): void;
+    protected onPointerRemove(event: AdaptedEvent): void;
+    protected onPointerMove(event: AdaptedEvent): void;
+    protected onPointerOut(event: AdaptedEvent): void;
+    protected onPointerEnter(event: AdaptedEvent): void;
+    protected onPointerCancel(event: AdaptedEvent): void;
+    protected onPointerOutOfBounds(event: AdaptedEvent): void;
     private tryToSendMoveEvent;
-    sendEvent: (event: AdaptedPointerEvent, newState: State, oldState: State) => void;
+    sendTouchEvent(event: AdaptedEvent): void;
+    sendEvent: (newState: State, oldState: State) => void;
     private transformEventData;
-    protected transformNativeEvent(_event: AdaptedPointerEvent): {};
-    updateGestureConfig({ enabled, ...props }: {
-        [x: string]: any;
-        enabled?: boolean | undefined;
-    }): void;
+    private transformTouchEvent;
+    private cancelTouches;
+    protected transformNativeEvent(): {};
+    updateGestureConfig({ enabled, ...props }: Config): void;
     protected checkCustomActivationCriteria(criterias: string[]): void;
     private validateHitSlops;
     private checkHitSlop;
+    isPointerInBounds({ x, y }: {
+        x: number;
+        y: number;
+    }): boolean;
     protected resetConfig(): void;
     getTag(): number;
     setTag(tag: number): void;
     protected getConfig(): Config;
     getShouldEnableGestureOnSetup(): boolean;
-    getView(): HTMLElement | null;
-    getEventManager(): EventManager;
+    getView(): HTMLElement;
+    getEventManagers(): EventManager[];
     getTracker(): PointerTracker;
     getTrackedPointersID(): number[];
     getState(): State;
-    protected setShouldCancelWhenOutside(flag: boolean): void;
+    isEnabled(): boolean;
+    protected setShouldCancelWhenOutside(shouldCancel: boolean): void;
     protected getShouldCancelWhenOutside(): boolean;
+    getPointerType(): PointerType;
 }

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

@@ -1,5 +1,5 @@
 import { State } from '../../State';
-import { AdaptedPointerEvent } from '../interfaces';
+import { AdaptedEvent, Config } from '../interfaces';
 import GestureHandler from './GestureHandler';
 export default class LongPressGestureHandler extends GestureHandler {
     private minDurationMs;
@@ -11,22 +11,19 @@ export default class LongPressGestureHandler extends GestureHandler {
     private previousTime;
     private activationTimeout;
     init(ref: number, propsRef: React.RefObject<unknown>): void;
-    protected transformNativeEvent(event: AdaptedPointerEvent): {
+    protected transformNativeEvent(): {
         x: number;
         y: number;
         absoluteX: number;
         absoluteY: number;
         duration: number;
     };
-    updateGestureConfig({ enabled, ...props }: {
-        [x: string]: any;
-        enabled?: boolean | undefined;
-    }): void;
+    updateGestureConfig({ enabled, ...props }: Config): 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;
+    protected onPointerDown(event: AdaptedEvent): void;
+    protected onPointerMove(event: AdaptedEvent): void;
+    protected onPointerUp(event: AdaptedEvent): void;
     private tryBegin;
     private tryActivate;
     private checkDistanceFail;

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

@@ -0,0 +1,11 @@
+import { AdaptedEvent } from '../interfaces';
+import GestureHandler from './GestureHandler';
+export default class ManualGestureHandler extends GestureHandler {
+    init(ref: number, propsRef: React.RefObject<unknown>): void;
+    protected onPointerDown(event: AdaptedEvent): void;
+    protected onPointerAdd(event: AdaptedEvent): void;
+    protected onPointerMove(event: AdaptedEvent): void;
+    protected onPointerUp(event: AdaptedEvent): void;
+    protected onPointerRemove(event: AdaptedEvent): void;
+    protected onPointerCancel(event: AdaptedEvent): void;
+}

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

@@ -1,15 +1,24 @@
-import { AdaptedPointerEvent } from '../interfaces';
+import { AdaptedEvent, Config } from '../interfaces';
 import GestureHandler from './GestureHandler';
 export default class NativeViewGestureHandler extends GestureHandler {
     private buttonRole;
+    private shouldActivateOnStart;
     private disallowInterruption;
+    private startX;
+    private startY;
+    private minDistSq;
     init(ref: number, propsRef: React.RefObject<unknown>): void;
+    updateGestureConfig({ enabled, ...props }: Config): 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;
+    protected onPointerDown(event: AdaptedEvent): void;
+    protected onPointerAdd(event: AdaptedEvent): void;
+    private newPointerAction;
+    protected onPointerMove(event: AdaptedEvent): void;
+    protected onPointerOut(): void;
+    protected onPointerUp(event: AdaptedEvent): void;
+    protected onPointerRemove(event: AdaptedEvent): void;
+    private onUp;
+    protected onPointerCancel(event: AdaptedEvent): void;
     shouldRecognizeSimultaneously(handler: GestureHandler): boolean;
     shouldBeCancelledByOther(_handler: GestureHandler): boolean;
     disallowsInterruption(): boolean;

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

@@ -1,4 +1,4 @@
-import { AdaptedPointerEvent } from '../interfaces';
+import { AdaptedEvent, Config } from '../interfaces';
 import GestureHandler from './GestureHandler';
 export default class PanGestureHandler extends GestureHandler {
     private readonly customActivationProperties;
@@ -25,22 +25,11 @@ export default class PanGestureHandler extends GestureHandler {
     private lastX;
     private lastY;
     private activateAfterLongPress;
+    private activationTimeout;
     init(ref: number, propsRef: React.RefObject<unknown>): void;
-    updateGestureConfig({ enabled, ...props }: {
-        [x: string]: any;
-        enabled?: boolean | undefined;
-    }): void;
+    updateGestureConfig({ enabled, ...props }: Config): void;
     protected resetConfig(): void;
-    protected transformNativeEvent(event: AdaptedPointerEvent): {
-        translationX?: undefined;
-        translationY?: undefined;
-        absoluteX?: undefined;
-        absoluteY?: undefined;
-        velocityX?: undefined;
-        velocityY?: undefined;
-        x?: undefined;
-        y?: undefined;
-    } | {
+    protected transformNativeEvent(): {
         translationX: number;
         translationY: number;
         absoluteX: number;
@@ -52,17 +41,20 @@ export default class PanGestureHandler extends GestureHandler {
     };
     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 clearActivationTimeout;
+    protected onPointerDown(event: AdaptedEvent): void;
+    protected onPointerAdd(event: AdaptedEvent): void;
+    protected onPointerUp(event: AdaptedEvent): void;
+    protected onPointerRemove(event: AdaptedEvent): void;
+    protected onPointerMove(event: AdaptedEvent): void;
+    protected onPointerCancel(event: AdaptedEvent): void;
+    protected onPointerOutOfBounds(event: AdaptedEvent): void;
     private shouldActivate;
     private shouldFail;
     private tryBegin;
     private checkBegan;
-    protected activate(event: AdaptedPointerEvent, force?: boolean): void;
+    activate(force?: boolean): void;
+    protected onCancel(): void;
+    protected onReset(): void;
     protected resetProgress(): void;
 }

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

@@ -1,4 +1,4 @@
-import { AdaptedPointerEvent } from '../interfaces';
+import { AdaptedEvent, Config } from '../interfaces';
 import GestureHandler from './GestureHandler';
 export default class PinchGestureHandler extends GestureHandler {
     private scale;
@@ -8,23 +8,22 @@ export default class PinchGestureHandler extends GestureHandler {
     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): {
+    updateGestureConfig({ enabled, ...props }: Config): void;
+    protected transformNativeEvent(): {
         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;
+    protected onPointerDown(event: AdaptedEvent): void;
+    protected onPointerAdd(event: AdaptedEvent): void;
+    protected onPointerUp(event: AdaptedEvent): void;
+    protected onPointerRemove(event: AdaptedEvent): void;
+    protected onPointerMove(event: AdaptedEvent): void;
+    protected onPointerOutOfBounds(event: AdaptedEvent): void;
+    protected onPointerCancel(event: AdaptedEvent): void;
     private tryBegin;
-    protected activate(event: AdaptedPointerEvent, force?: boolean): void;
+    activate(force?: boolean): void;
     protected onReset(): void;
     protected resetProgress(): void;
 }

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

@@ -1,4 +1,4 @@
-import { AdaptedPointerEvent } from '../interfaces';
+import { AdaptedEvent, Config } from '../interfaces';
 import GestureHandler from './GestureHandler';
 export default class RotationGestureHandler extends GestureHandler {
     private rotation;
@@ -8,11 +8,8 @@ export default class RotationGestureHandler extends GestureHandler {
     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): {
+    updateGestureConfig({ enabled, ...props }: Config): void;
+    protected transformNativeEvent(): {
         rotation: number;
         anchorX: number;
         anchorY: number;
@@ -20,11 +17,14 @@ export default class RotationGestureHandler extends GestureHandler {
     };
     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 onPointerDown(event: AdaptedEvent): void;
+    protected onPointerAdd(event: AdaptedEvent): void;
+    protected onPointerMove(event: AdaptedEvent): void;
+    protected onPointerOutOfBounds(event: AdaptedEvent): void;
+    protected onPointerUp(event: AdaptedEvent): void;
+    protected onPointerRemove(event: AdaptedEvent): void;
+    protected onPointerCancel(event: AdaptedEvent): void;
+    protected tryBegin(): void;
+    activate(_force?: boolean): void;
     protected onReset(): void;
 }

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

@@ -1,4 +1,4 @@
-import { AdaptedPointerEvent } from '../interfaces';
+import { AdaptedEvent, Config } from '../interfaces';
 import GestureHandler from './GestureHandler';
 export default class TapGestureHandler extends GestureHandler {
     private maxDeltaX;
@@ -19,12 +19,9 @@ export default class TapGestureHandler extends GestureHandler {
     private delayTimeout;
     private tapsSoFar;
     init(ref: number, propsRef: React.RefObject<unknown>): void;
-    updateGestureConfig({ enabled, ...props }: {
-        [x: string]: any;
-        enabled?: boolean | undefined;
-    }): void;
+    updateGestureConfig({ enabled, ...props }: Config): void;
     protected resetConfig(): void;
-    protected transformNativeEvent(event: AdaptedPointerEvent): {
+    protected transformNativeEvent(): {
         x: number;
         y: number;
         absoluteX: number;
@@ -33,17 +30,17 @@ export default class TapGestureHandler extends GestureHandler {
     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;
+    protected onPointerDown(event: AdaptedEvent): void;
+    protected onPointerAdd(event: AdaptedEvent): void;
+    protected onPointerUp(event: AdaptedEvent): void;
+    protected onPointerRemove(event: AdaptedEvent): void;
+    protected onPointerMove(event: AdaptedEvent): void;
+    protected onPointerOutOfBounds(event: AdaptedEvent): void;
+    protected onPointerCancel(event: AdaptedEvent): void;
     private updateState;
     private trySettingPosition;
     private shouldFail;
-    protected activate(event: AdaptedPointerEvent): void;
+    activate(): void;
     protected onCancel(): void;
     protected resetProgress(): void;
 }