react-native-gesture-handler 2.4.1 → 2.6.0

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

@@ -1,33 +1,44 @@
 import { ActionType } from './ActionType';
-import FlingGestureHandler from './web/FlingGestureHandler';
-import LongPressGestureHandler from './web/LongPressGestureHandler';
-import NativeViewGestureHandler from './web/NativeViewGestureHandler';
-import PanGestureHandler from './web/PanGestureHandler';
-import PinchGestureHandler from './web/PinchGestureHandler';
-import RotationGestureHandler from './web/RotationGestureHandler';
-import TapGestureHandler from './web/TapGestureHandler';
+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';
+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/interfaces';
 export declare const Gestures: {
+    NativeViewGestureHandler: typeof NativeViewGestureHandler;
     PanGestureHandler: typeof PanGestureHandler;
-    RotationGestureHandler: typeof RotationGestureHandler;
-    PinchGestureHandler: typeof PinchGestureHandler;
     TapGestureHandler: typeof TapGestureHandler;
-    NativeViewGestureHandler: typeof NativeViewGestureHandler;
     LongPressGestureHandler: typeof LongPressGestureHandler;
+    PinchGestureHandler: typeof PinchGestureHandler;
+    RotationGestureHandler: typeof RotationGestureHandler;
     FlingGestureHandler: typeof FlingGestureHandler;
 };
+export declare const HammerGestures: {
+    NativeViewGestureHandler: typeof HammerNativeViewGestureHandler;
+    PanGestureHandler: typeof HammerPanGestureHandler;
+    TapGestureHandler: typeof HammerTapGestureHandler;
+    LongPressGestureHandler: typeof HammerLongPressGestureHandler;
+    PinchGestureHandler: typeof HammerPinchGestureHandler;
+    RotationGestureHandler: typeof HammerRotationGestureHandler;
+    FlingGestureHandler: typeof HammerFlingGestureHandler;
+};
 declare const _default: {
-    Direction: {
-        RIGHT: number;
-        LEFT: number;
-        UP: number;
-        DOWN: number;
-    };
     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 | RotationGestureHandler | PinchGestureHandler | TapGestureHandler | NativeViewGestureHandler | LongPressGestureHandler | FlingGestureHandler;
+    updateGestureHandler(handlerTag: number, newConfig: Config): void;
+    getGestureHandlerNode(handlerTag: number): PanGestureHandler | TapGestureHandler | LongPressGestureHandler | PinchGestureHandler | RotationGestureHandler | FlingGestureHandler | NativeViewGestureHandler | HammerNativeViewGestureHandler | HammerPanGestureHandler | HammerTapGestureHandler | HammerLongPressGestureHandler | HammerPinchGestureHandler | HammerRotationGestureHandler | HammerFlingGestureHandler;
     dropGestureHandler(handlerTag: number): void;
     flushOperations(): void;
 };

package/lib/typescript/RNRenderer.d.ts

@@ -0,0 +1 @@
+export { default as RNRenderer } from 'react-native/Libraries/Renderer/shims/ReactNative';

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

@@ -0,0 +1,3 @@
+export declare const RNRenderer: {
+    findHostInstance_DEPRECATED: (_ref: any) => null;
+};

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

@@ -78,12 +78,15 @@ export interface DrawerLayoutProps {
     enableTrackpadTwoFingerGesture?: boolean;
     onDrawerSlide?: (position: number) => void;
     onGestureRef?: (ref: PanGestureHandler) => void;
+    children?: React.ReactNode | ((openValue?: Animated.AnimatedInterpolation) => React.ReactNode);
 }
 export declare type DrawerLayoutState = {
     dragX: Animated.Value;
     touchX: Animated.Value;
     drawerTranslation: Animated.Value;
     containerWidth: number;
+    drawerState: DrawerState;
+    drawerOpened: boolean;
 };
 export declare type DrawerMovementOption = {
     velocity?: number;
@@ -102,7 +105,7 @@ export default class DrawerLayout extends Component<DrawerLayoutProps, DrawerLay
         enableTrackpadTwoFingerGesture: boolean;
     };
     constructor(props: DrawerLayoutProps);
-    UNSAFE_componentWillUpdate(props: DrawerLayoutProps, state: DrawerLayoutState): void;
+    shouldComponentUpdate(props: DrawerLayoutProps, state: DrawerLayoutState): boolean;
     private openValue?;
     private onGestureEvent?;
     private accessibilityIsModalView;

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

@@ -31,6 +31,12 @@ export interface RawButtonProps extends NativeViewGestureHandlerProps {
      * Defines whether the ripple animation should be drawn on the foreground of the view.
      */
     foreground?: boolean;
+    /**
+     * Android only.
+     *
+     * Set this to true if you don't want the system to play sound when the button is pressed.
+     */
+    touchSoundDisabled?: boolean;
 }
 export interface BaseButtonProps extends RawButtonProps {
     /**
@@ -38,6 +44,11 @@ export interface BaseButtonProps extends RawButtonProps {
      * `TouchableHighlight` from RN core).
      */
     onPress?: (pointerInside: boolean) => void;
+    /**
+     * Called when the button gets pressed and is held for `delayLongPress`
+     * milliseconds.
+     */
+    onLongPress?: () => void;
     /**
      * Called when button changes from inactive to active and vice versa. It
      * passes active state as a boolean variable as a first parameter for that
@@ -46,6 +57,11 @@ export interface BaseButtonProps extends RawButtonProps {
     onActiveStateChange?: (active: boolean) => void;
     style?: StyleProp<ViewStyle>;
     testID?: string;
+    /**
+     * Delay, in milliseconds, after which the `onLongPress` callback gets called.
+     * Defaults to 600.
+     */
+    delayLongPress?: number;
 }
 export interface RectButtonProps extends BaseButtonProps {
     /**
@@ -69,9 +85,15 @@ export interface BorderlessButtonProps extends BaseButtonProps {
 }
 export declare const RawButton: React.ForwardRefExoticComponent<RawButtonProps & NativeViewGestureHandlerProps & React.RefAttributes<React.ComponentType<any>>>;
 export declare class BaseButton extends React.Component<BaseButtonProps> {
+    static defaultProps: {
+        delayLongPress: number;
+    };
     private lastActive;
+    private longPressTimeout;
+    private longPressDetected;
     constructor(props: BaseButtonProps);
     private handleEvent;
+    private onLongPress;
     private onHandlerStateChange;
     private onGestureEvent;
     render(): JSX.Element;

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

@@ -1,11 +1,14 @@
 import * as React from 'react';
 import { PropsWithChildren, ForwardedRef, RefAttributes, ReactElement } from 'react';
-import { ScrollView as RNScrollView, ScrollViewProps as RNScrollViewProps, Switch as RNSwitch, SwitchProps as RNSwitchProps, TextInput as RNTextInput, TextInputProps as RNTextInputProps, DrawerLayoutAndroid as RNDrawerLayoutAndroid, DrawerLayoutAndroidProps as RNDrawerLayoutAndroidProps, FlatList as RNFlatList, FlatListProps as RNFlatListProps } from 'react-native';
+import { ScrollView as RNScrollView, ScrollViewProps as RNScrollViewProps, Switch as RNSwitch, SwitchProps as RNSwitchProps, TextInput as RNTextInput, TextInputProps as RNTextInputProps, DrawerLayoutAndroid as RNDrawerLayoutAndroid, DrawerLayoutAndroidProps as RNDrawerLayoutAndroidProps, FlatList as RNFlatList, FlatListProps as RNFlatListProps, RefreshControl as RNRefreshControl } from 'react-native';
 import { NativeViewGestureHandlerProps } from '../handlers/NativeViewGestureHandler';
-export declare const ScrollView: React.ForwardRefExoticComponent<RNScrollViewProps & {
+export declare const RefreshControl: React.ForwardRefExoticComponent<import("react-native").RefreshControlProps & NativeViewGestureHandlerProps & React.RefAttributes<React.ComponentType<any>>>;
+export declare type RefreshControl = typeof RefreshControl & RNRefreshControl;
+declare const GHScrollView: React.ForwardRefExoticComponent<RNScrollViewProps & {
     children?: React.ReactNode;
 } & NativeViewGestureHandlerProps & React.RefAttributes<React.ComponentType<any>>>;
-export declare type ScrollView = typeof ScrollView & RNScrollView;
+export declare const ScrollView: React.ForwardRefExoticComponent<RNScrollViewProps & NativeViewGestureHandlerProps & React.RefAttributes<RNScrollView>>;
+export declare type ScrollView = typeof GHScrollView & RNScrollView;
 export declare const Switch: React.ForwardRefExoticComponent<RNSwitchProps & NativeViewGestureHandlerProps & React.RefAttributes<React.ComponentType<any>>>;
 export declare type Switch = typeof Switch & RNSwitch;
 export declare const TextInput: React.ForwardRefExoticComponent<RNTextInputProps & NativeViewGestureHandlerProps & React.RefAttributes<React.ComponentType<any>>>;
@@ -16,3 +19,4 @@ export declare const DrawerLayoutAndroid: React.ForwardRefExoticComponent<RNDraw
 export declare type DrawerLayoutAndroid = typeof DrawerLayoutAndroid & RNDrawerLayoutAndroid;
 export declare const FlatList: <ItemT = any>(props: React.PropsWithChildren<RNFlatListProps<ItemT> & React.RefAttributes<FlatList<ItemT>> & NativeViewGestureHandlerProps>, ref: React.ForwardedRef<FlatList<ItemT>>) => ReactElement | null;
 export declare type FlatList<ItemT = any> = typeof FlatList & RNFlatList<ItemT>;
+export {};

package/lib/typescript/components/GestureComponents.web.d.ts

@@ -4,4 +4,5 @@ export declare const ScrollView: React.ForwardRefExoticComponent<import("react-n
 export declare const Switch: React.ForwardRefExoticComponent<import("react-native").SwitchProps & import("..").NativeViewGestureHandlerProps & React.RefAttributes<React.ComponentType<any>>>;
 export declare const TextInput: React.ForwardRefExoticComponent<import("react-native").TextInputProps & import("..").NativeViewGestureHandlerProps & React.RefAttributes<React.ComponentType<any>>>;
 export declare const DrawerLayoutAndroid: React.ForwardRefExoticComponent<import("react-native").DrawerLayoutAndroidProps & import("..").NativeViewGestureHandlerProps & React.RefAttributes<React.ComponentType<any>>>;
+export declare const RefreshControl: React.ForwardRefExoticComponent<import("react-native").ViewProps & import("..").NativeViewGestureHandlerProps & React.RefAttributes<React.ComponentType<any>>>;
 export declare const FlatList: React.ForwardRefExoticComponent<FlatListProps<unknown> & React.RefAttributes<unknown>>;

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

@@ -136,7 +136,7 @@ export default class Swipeable extends Component<SwipeableProps, SwipeableState>
         useNativeAnimations: boolean;
     };
     constructor(props: SwipeableProps);
-    UNSAFE_componentWillUpdate(props: SwipeableProps, state: SwipeableState): void;
+    shouldComponentUpdate(props: SwipeableProps, state: SwipeableState): boolean;
     private onGestureEvent?;
     private transX?;
     private showLeftAction?;

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

@@ -8,6 +8,7 @@ interface NativeProps extends ViewProps {
     enabled?: WithDefault<boolean, true>;
     rippleColor?: ColorValue;
     rippleRadius?: Int32;
+    touchSoundDisabled?: WithDefault<boolean, false>;
 }
 declare const _default: HostComponent<NativeProps>;
 export default _default;

package/lib/typescript/handlers/ForceTouchGestureHandler.d.ts

@@ -1,7 +1,7 @@
-import React from 'react';
+import React, { PropsWithChildren } from 'react';
 import { BaseGestureHandlerProps } from './gestureHandlerCommon';
 export declare const forceTouchGestureHandlerProps: readonly ["minForce", "maxForce", "feedbackOnActivation"];
-declare class ForceTouchFallback extends React.Component {
+declare class ForceTouchFallback extends React.Component<PropsWithChildren<unknown>> {
     static forceTouchAvailable: boolean;
     componentDidMount(): void;
     render(): React.ReactNode;

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

@@ -1,5 +1,5 @@
 import { BaseGestureHandlerProps } from './gestureHandlerCommon';
-export declare const panGestureHandlerProps: readonly ["activeOffsetY", "activeOffsetX", "failOffsetY", "failOffsetX", "minDist", "minVelocity", "minVelocityX", "minVelocityY", "minPointers", "maxPointers", "avgTouches", "enableTrackpadTwoFingerGesture"];
+export declare const panGestureHandlerProps: readonly ["activeOffsetY", "activeOffsetX", "failOffsetY", "failOffsetX", "minDist", "minVelocity", "minVelocityX", "minVelocityY", "minPointers", "maxPointers", "avgTouches", "enableTrackpadTwoFingerGesture", "activateAfterLongPress"];
 export declare const panGestureHandlerCustomNativeProps: readonly ["activeOffsetYStart", "activeOffsetYEnd", "activeOffsetXStart", "activeOffsetXEnd", "failOffsetYStart", "failOffsetYEnd", "failOffsetXStart", "failOffsetXEnd"];
 export declare type PanGestureHandlerEventPayload = {
     /**
@@ -82,6 +82,7 @@ interface CommonPanProperties {
     minVelocity?: number;
     minVelocityX?: number;
     minVelocityY?: number;
+    activateAfterLongPress?: number;
 }
 export interface PanGestureConfig extends CommonPanProperties {
     activeOffsetYStart?: number;

package/lib/typescript/handlers/PressabilityDebugView.d.ts

@@ -0,0 +1 @@
+export { PressabilityDebugView } from 'react-native/Libraries/Pressability/PressabilityDebug';

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

@@ -0,0 +1 @@
+export declare function PressabilityDebugView(): null;

package/lib/typescript/handlers/gestureHandlerCommon.d.ts

@@ -54,6 +54,7 @@ export declare type BaseGestureHandlerProps<ExtraEventPayloadT extends Record<st
     onEnded?: (event: HandlerStateChangeEvent) => void;
     onGestureEvent?: (event: GestureEvent<ExtraEventPayloadT>) => void;
     onHandlerStateChange?: (event: HandlerStateChangeEvent<ExtraEventPayloadT>) => void;
+    children?: React.ReactNode;
 };
 export declare function filterConfig(props: Record<string, unknown>, validProps: string[], defaults?: Record<string, unknown>): {
     [x: string]: unknown;

package/lib/typescript/handlers/gestures/GestureDetector.d.ts

@@ -11,6 +11,7 @@ export declare type GestureConfigReference = {
 };
 interface GestureDetectorProps {
     gesture?: ComposedGesture | GestureType;
+    children?: React.ReactNode;
 }
-export declare const GestureDetector: React.FunctionComponent<GestureDetectorProps>;
+export declare const GestureDetector: (props: GestureDetectorProps) => JSX.Element;
 export {};

package/lib/typescript/handlers/gestures/gesture.d.ts

@@ -22,6 +22,7 @@ export interface BaseGestureConfig extends CommonGestureConfig, Record<string, u
 }
 declare type TouchEventHandlerType = (event: GestureTouchEvent, stateManager: GestureStateManagerType) => void;
 export declare type HandlerCallbacks<EventPayloadT extends Record<string, unknown>> = {
+    gestureId: number;
     handlerTag: number;
     onBegin?: (event: GestureStateChangeEvent<EventPayloadT>) => void;
     onStart?: (event: GestureStateChangeEvent<EventPayloadT>) => void;
@@ -68,10 +69,12 @@ export declare abstract class Gesture {
     abstract prepare(): void;
 }
 export declare abstract class BaseGesture<EventPayloadT extends Record<string, unknown>> extends Gesture {
+    private gestureId;
     handlerTag: number;
     handlerName: string;
     config: BaseGestureConfig;
     handlers: HandlerCallbacks<EventPayloadT>;
+    constructor();
     private addDependency;
     withRef(ref: React.MutableRefObject<GestureType | undefined>): this;
     protected isWorklet(callback: Function): boolean;

package/lib/typescript/handlers/gestures/panGesture.d.ts

@@ -20,6 +20,7 @@ export declare class PanGesture extends ContinousBaseGesture<PanGestureHandlerEv
     minVelocityY(velocity: number): this;
     averageTouches(value: boolean): this;
     enableTrackpadTwoFingerGesture(value: boolean): this;
+    activateAfterLongPress(duration: number): this;
     onChange(callback: (event: GestureUpdateEvent<PanGestureHandlerEventPayload & PanGestureChangeEventPayload>) => void): this;
 }
 export declare type PanGestureType = InstanceType<typeof PanGesture>;

package/lib/typescript/index.d.ts

@@ -40,8 +40,9 @@ export { NativeViewGestureHandler } from './handlers/NativeViewGestureHandler';
 export type { RawButtonProps, BaseButtonProps, RectButtonProps, BorderlessButtonProps, } from './components/GestureButtons';
 export { RawButton, BaseButton, RectButton, BorderlessButton, } from './components/GestureButtons';
 export { TouchableHighlight, TouchableNativeFeedback, TouchableOpacity, TouchableWithoutFeedback, } from './components/touchables';
-export { ScrollView, Switch, TextInput, DrawerLayoutAndroid, FlatList, } from './components/GestureComponents';
+export { ScrollView, Switch, TextInput, DrawerLayoutAndroid, FlatList, RefreshControl, } from './components/GestureComponents';
 export type { GestureHandlerGestureEvent, GestureHandlerStateChangeEvent, GestureHandlerGestureEventNativeEvent, GestureHandlerStateChangeNativeEvent, NativeViewGestureHandlerGestureEvent, NativeViewGestureHandlerStateChangeEvent, TapGestureHandlerGestureEvent, TapGestureHandlerStateChangeEvent, ForceTouchGestureHandlerGestureEvent, ForceTouchGestureHandlerStateChangeEvent, LongPressGestureHandlerGestureEvent, LongPressGestureHandlerStateChangeEvent, PanGestureHandlerGestureEvent, PanGestureHandlerStateChangeEvent, PinchGestureHandlerGestureEvent, PinchGestureHandlerStateChangeEvent, RotationGestureHandlerGestureEvent, RotationGestureHandlerStateChangeEvent, FlingGestureHandlerGestureEvent, FlingGestureHandlerStateChangeEvent, NativeViewGestureHandlerProperties, TapGestureHandlerProperties, LongPressGestureHandlerProperties, PanGestureHandlerProperties, PinchGestureHandlerProperties, RotationGestureHandlerProperties, FlingGestureHandlerProperties, ForceTouchGestureHandlerProperties, RawButtonProperties, BaseButtonProperties, RectButtonProperties, BorderlessButtonProperties, } from './handlers/gestureHandlerTypesCompat';
 export { default as Swipeable } from './components/Swipeable';
 export type { DrawerLayoutProps, DrawerPosition, DrawerState, DrawerType, DrawerLockMode, DrawerKeyboardDismissMode, } from './components/DrawerLayout';
 export { default as DrawerLayout } from './components/DrawerLayout';
+export { enableExperimentalWebImplementation } from './EnableExperimentalWebImplementation';

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