react-native-gesture-handler 2.15.0 → 2.16.0

package/lib/typescript/getShadowNodeFromRef.d.ts

@@ -1 +1 @@
-export declare function getShadowNodeFromRef(ref: any): any;
+export declare function getShadowNodeFromRef(ref: unknown): unknown;

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

@@ -22,7 +22,7 @@ export type NativeViewGestureHandlerPayload = {
      */
     pointerInside: boolean;
 };
-export declare const nativeViewProps: readonly ["id", "enabled", "shouldCancelWhenOutside", "hitSlop", "cancelsTouchesInView", "userSelect", "activeCursor", "mouseButton", "enableContextMenu", "waitFor", "simultaneousHandlers", "blocksHandlers", "onBegan", "onFailed", "onCancelled", "onActivated", "onEnded", "onGestureEvent", "onHandlerStateChange", "shouldActivateOnStart", "disallowInterruption"];
+export declare const nativeViewProps: readonly ["id", "enabled", "shouldCancelWhenOutside", "hitSlop", "cancelsTouchesInView", "userSelect", "activeCursor", "mouseButton", "enableContextMenu", "touchAction", "waitFor", "simultaneousHandlers", "blocksHandlers", "onBegan", "onFailed", "onCancelled", "onActivated", "onEnded", "onGestureEvent", "onHandlerStateChange", "shouldActivateOnStart", "disallowInterruption"];
 export declare const nativeViewHandlerName = "NativeViewGestureHandler";
 export type NativeViewGestureHandler = typeof NativeViewGestureHandler;
 export declare const NativeViewGestureHandler: import("react").ComponentType<NativeViewGestureHandlerProps & import("react").RefAttributes<any>>;

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

@@ -0,0 +1 @@
+export { customDirectEventTypes } from 'react-native/Libraries/Renderer/shims/ReactNativeViewConfigRegistry';

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

@@ -0,0 +1,2 @@
+declare const customDirectEventTypes: {};
+export { customDirectEventTypes };

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

@@ -2,13 +2,14 @@ import * as React from 'react';
 import { State } from '../State';
 import { TouchEventType } from '../TouchEventType';
 import { ValueOf } from '../typeUtils';
-import { MouseButton } from '../web/interfaces';
-export declare const baseGestureHandlerProps: readonly ["id", "enabled", "shouldCancelWhenOutside", "hitSlop", "cancelsTouchesInView", "userSelect", "activeCursor", "mouseButton", "enableContextMenu", "waitFor", "simultaneousHandlers", "blocksHandlers", "onBegan", "onFailed", "onCancelled", "onActivated", "onEnded", "onGestureEvent", "onHandlerStateChange"];
+import { PointerType } from '../PointerType';
+export declare const baseGestureHandlerProps: readonly ["id", "enabled", "shouldCancelWhenOutside", "hitSlop", "cancelsTouchesInView", "userSelect", "activeCursor", "mouseButton", "enableContextMenu", "touchAction", "waitFor", "simultaneousHandlers", "blocksHandlers", "onBegan", "onFailed", "onCancelled", "onActivated", "onEnded", "onGestureEvent", "onHandlerStateChange"];
 export declare const baseGestureHandlerWithMonitorProps: string[];
 export interface GestureEventPayload {
     handlerTag: number;
     numberOfPointers: number;
     state: ValueOf<typeof State>;
+    pointerType: PointerType;
 }
 export interface HandlerStateChangeEventPayload extends GestureEventPayload {
     oldState: ValueOf<typeof State>;
@@ -16,6 +17,15 @@ export interface HandlerStateChangeEventPayload extends GestureEventPayload {
 export type HitSlop = number | Partial<Record<'left' | 'right' | 'top' | 'bottom' | 'vertical' | 'horizontal', number>> | Record<'width' | 'left', number> | Record<'width' | 'right', number> | Record<'height' | 'top', number> | Record<'height' | 'bottom', number>;
 export type UserSelect = 'none' | 'auto' | 'text';
 export type ActiveCursor = 'auto' | 'default' | 'none' | 'context-menu' | 'help' | 'pointer' | 'progress' | 'wait' | 'cell' | 'crosshair' | 'text' | 'vertical-text' | 'alias' | 'copy' | 'move' | 'no-drop' | 'not-allowed' | 'grab' | 'grabbing' | 'e-resize' | 'n-resize' | 'ne-resize' | 'nw-resize' | 's-resize' | 'se-resize' | 'sw-resize' | 'w-resize' | 'ew-resize' | 'ns-resize' | 'nesw-resize' | 'nwse-resize' | 'col-resize' | 'row-resize' | 'all-scroll' | 'zoom-in' | 'zoom-out';
+export declare enum MouseButton {
+    LEFT = 1,
+    RIGHT = 2,
+    MIDDLE = 4,
+    BUTTON_4 = 8,
+    BUTTON_5 = 16,
+    ALL = 31
+}
+export type TouchAction = 'auto' | 'none' | 'pan-x' | 'pan-left' | 'pan-right' | 'pan-y' | 'pan-up' | 'pan-down' | 'pinch-zoom' | 'manipulation' | 'inherit' | 'initial' | 'revert' | 'revert-layer' | 'unset';
 export interface GestureEvent<ExtraEventPayloadT = Record<string, unknown>> {
     nativeEvent: Readonly<GestureEventPayload & ExtraEventPayloadT>;
 }
@@ -47,6 +57,7 @@ export type CommonGestureConfig = {
     activeCursor?: ActiveCursor;
     mouseButton?: MouseButton;
     enableContextMenu?: boolean;
+    touchAction?: TouchAction;
 };
 export type BaseGestureHandlerProps<ExtraEventPayloadT extends Record<string, unknown> = Record<string, unknown>> = CommonGestureConfig & {
     id?: string;

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

@@ -1,7 +1,7 @@
 import React from 'react';
 import { GestureType, HandlerCallbacks } from './gesture';
 import { SharedValue } from './reanimatedWrapper';
-import { UserSelect } from '../gestureHandlerCommon';
+import { UserSelect, TouchAction } from '../gestureHandlerCommon';
 import { ComposedGesture } from './gestureComposition';
 export type GestureConfigReference = {
     config: GestureType[];
@@ -15,6 +15,7 @@ interface GestureDetectorProps {
     children?: React.ReactNode;
     userSelect?: UserSelect;
     enableContextMenu?: boolean;
+    touchAction?: TouchAction;
 }
 export declare const GestureDetector: (props: GestureDetectorProps) => React.JSX.Element;
 export {};

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

@@ -1,6 +1,6 @@
 import { FlingGestureHandlerEventPayload } from '../FlingGestureHandler';
 import { ForceTouchGestureHandlerEventPayload } from '../ForceTouchGestureHandler';
-import { HitSlop, CommonGestureConfig, GestureTouchEvent, GestureStateChangeEvent, GestureUpdateEvent, ActiveCursor } from '../gestureHandlerCommon';
+import { HitSlop, CommonGestureConfig, GestureTouchEvent, GestureStateChangeEvent, GestureUpdateEvent, ActiveCursor, MouseButton } from '../gestureHandlerCommon';
 import { GestureStateManagerType } from './gestureStateManager';
 import { LongPressGestureHandlerEventPayload } from '../LongPressGestureHandler';
 import { PanGestureHandlerEventPayload } from '../PanGestureHandler';
@@ -8,7 +8,6 @@ import { PinchGestureHandlerEventPayload } from '../PinchGestureHandler';
 import { RotationGestureHandlerEventPayload } from '../RotationGestureHandler';
 import { TapGestureHandlerEventPayload } from '../TapGestureHandler';
 import { NativeViewGestureHandlerPayload } from '../NativeViewGestureHandler';
-import { MouseButton } from '../../web/interfaces';
 export type GestureType = BaseGesture<Record<string, unknown>> | BaseGesture<Record<string, never>> | BaseGesture<TapGestureHandlerEventPayload> | BaseGesture<PanGestureHandlerEventPayload> | BaseGesture<LongPressGestureHandlerEventPayload> | BaseGesture<RotationGestureHandlerEventPayload> | BaseGesture<PinchGestureHandlerEventPayload> | BaseGesture<FlingGestureHandlerEventPayload> | BaseGesture<ForceTouchGestureHandlerEventPayload> | BaseGesture<NativeViewGestureHandlerPayload>;
 export type GestureRef = number | GestureType | React.RefObject<GestureType | undefined> | React.RefObject<React.ComponentType | undefined>;
 export interface BaseGestureConfig extends CommonGestureConfig, Record<string, unknown> {

package/lib/typescript/index.d.ts

@@ -1,9 +1,10 @@
 export { Directions } from './Directions';
 export { State } from './State';
-export { MouseButton } from './web/interfaces';
+export { PointerType } from './PointerType';
 export { default as gestureHandlerRootHOC } from './components/gestureHandlerRootHOC';
 export { default as GestureHandlerRootView } from './components/GestureHandlerRootView';
 export type { GestureEvent, HandlerStateChangeEvent, GestureEventPayload, HandlerStateChangeEventPayload, GestureTouchEvent, TouchData, GestureUpdateEvent, GestureStateChangeEvent, } from './handlers/gestureHandlerCommon';
+export { MouseButton } from './handlers/gestureHandlerCommon';
 export type { GestureType } from './handlers/gestures/gesture';
 export type { TapGestureHandlerEventPayload, TapGestureHandlerProps, } from './handlers/TapGestureHandler';
 export type { ForceTouchGestureHandlerEventPayload, ForceTouchGestureHandlerProps, } from './handlers/ForceTouchGestureHandler';

package/lib/typescript/mocks.d.ts

@@ -26,6 +26,7 @@ declare const _default: {
     readonly dropGestureHandler: () => void;
     readonly updateGestureHandler: () => void;
     readonly flushOperations: () => void;
+    readonly install: () => void;
     readonly Directions: {
         readonly RIGHT: 1;
         readonly LEFT: 2;

package/lib/typescript/specs/NativeRNGestureHandlerModule.d.ts

@@ -1,12 +1,12 @@
 import { TurboModule } from 'react-native';
-import { Int32 } from 'react-native/Libraries/Types/CodegenTypes';
+import { Double } from 'react-native/Libraries/Types/CodegenTypes';
 export interface Spec extends TurboModule {
-    handleSetJSResponder: (tag: Int32, blockNativeResponder: boolean) => void;
+    handleSetJSResponder: (tag: Double, blockNativeResponder: boolean) => void;
     handleClearJSResponder: () => void;
-    createGestureHandler: (handlerName: string, handlerTag: Int32, config: Object) => void;
-    attachGestureHandler: (handlerTag: Int32, newView: Int32, actionType: Int32) => void;
-    updateGestureHandler: (handlerTag: Int32, newConfig: Object) => void;
-    dropGestureHandler: (handlerTag: Int32) => void;
+    createGestureHandler: (handlerName: string, handlerTag: Double, config: Object) => void;
+    attachGestureHandler: (handlerTag: Double, newView: Double, actionType: Double) => void;
+    updateGestureHandler: (handlerTag: Double, newConfig: Object) => void;
+    dropGestureHandler: (handlerTag: Double) => void;
     install: () => boolean;
     flushOperations: () => void;
 }

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

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

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

@@ -0,0 +1,36 @@
+import PanGestureHandler from './handlers/PanGestureHandler';
+import TapGestureHandler from './handlers/TapGestureHandler';
+import LongPressGestureHandler from './handlers/LongPressGestureHandler';
+import PinchGestureHandler from './handlers/PinchGestureHandler';
+import RotationGestureHandler from './handlers/RotationGestureHandler';
+import FlingGestureHandler from './handlers/FlingGestureHandler';
+import NativeViewGestureHandler from './handlers/NativeViewGestureHandler';
+import ManualGestureHandler from './handlers/ManualGestureHandler';
+import HoverGestureHandler from './handlers/HoverGestureHandler';
+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';
+export declare const Gestures: {
+    NativeViewGestureHandler: typeof NativeViewGestureHandler;
+    PanGestureHandler: typeof PanGestureHandler;
+    TapGestureHandler: typeof TapGestureHandler;
+    LongPressGestureHandler: typeof LongPressGestureHandler;
+    PinchGestureHandler: typeof PinchGestureHandler;
+    RotationGestureHandler: typeof RotationGestureHandler;
+    FlingGestureHandler: typeof FlingGestureHandler;
+    ManualGestureHandler: typeof ManualGestureHandler;
+    HoverGestureHandler: typeof HoverGestureHandler;
+};
+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;
+};

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

@@ -1,7 +1,2 @@
 export declare const DEFAULT_TOUCH_SLOP = 15;
-export declare const Direction: {
-    RIGHT: number;
-    LEFT: number;
-    UP: number;
-    DOWN: number;
-};
+export declare const MINIMAL_FLING_VELOCITY = 0.1;

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

@@ -4,10 +4,8 @@ export default class FlingGestureHandler extends GestureHandler {
     private numberOfPointersRequired;
     private direction;
     private maxDurationMs;
-    private minAcceptableDelta;
+    private minVelocity;
     private delayTimeout;
-    private startX;
-    private startY;
     private maxNumberOfPointersSimultaneously;
     private keyPointer;
     init(ref: number, propsRef: React.RefObject<unknown>): void;
@@ -18,7 +16,9 @@ export default class FlingGestureHandler extends GestureHandler {
     protected onPointerDown(event: AdaptedEvent): void;
     protected onPointerAdd(event: AdaptedEvent): void;
     private newPointerAction;
+    private pointerMoveAction;
     protected onPointerMove(event: AdaptedEvent): void;
+    protected onPointerOutOfBounds(event: AdaptedEvent): void;
     protected onPointerUp(event: AdaptedEvent): void;
     protected onPointerRemove(event: AdaptedEvent): void;
     private onUp;

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

@@ -1,9 +1,12 @@
 import { State } from '../../State';
-import { Config, AdaptedEvent, PointerType, MouseButton } from '../interfaces';
+import { Config, AdaptedEvent } from '../interfaces';
 import EventManager from '../tools/EventManager';
 import PointerTracker from '../tools/PointerTracker';
 import { GestureHandlerDelegate } from '../tools/GestureHandlerDelegate';
-export default abstract class GestureHandler {
+import IGestureHandler from './IGestureHandler';
+import { MouseButton } from '../../handlers/gestureHandlerCommon';
+import { PointerType } from '../../PointerType';
+export default abstract class GestureHandler implements IGestureHandler {
     private lastSentState;
     protected currentState: State;
     protected shouldCancellWhenOutside: boolean;
@@ -19,8 +22,8 @@ export default abstract class GestureHandler {
     protected active: boolean;
     protected shouldResetProgress: boolean;
     protected pointerType: PointerType;
-    protected delegate: GestureHandlerDelegate<unknown>;
-    constructor(delegate: GestureHandlerDelegate<unknown>);
+    protected delegate: GestureHandlerDelegate<unknown, IGestureHandler>;
+    constructor(delegate: GestureHandlerDelegate<unknown, IGestureHandler>);
     protected init(viewRef: number, propsRef: React.RefObject<unknown>): void;
     attachEventManager(manager: EventManager<unknown>): void;
     protected onCancel(): void;
@@ -48,10 +51,10 @@ export default abstract class GestureHandler {
     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;
+    shouldWaitForHandlerFailure(handler: IGestureHandler): boolean;
+    shouldRequireToWaitForFailure(handler: IGestureHandler): boolean;
+    shouldRecognizeSimultaneously(handler: IGestureHandler): boolean;
+    shouldBeCancelledByOther(handler: IGestureHandler): boolean;
     protected onPointerDown(event: AdaptedEvent): void;
     protected onPointerAdd(event: AdaptedEvent): void;
     protected onPointerUp(event: AdaptedEvent): void;
@@ -80,7 +83,7 @@ export default abstract class GestureHandler {
     getTag(): number;
     setTag(tag: number): void;
     getConfig(): Config;
-    getDelegate(): GestureHandlerDelegate<unknown>;
+    getDelegate(): GestureHandlerDelegate<unknown, IGestureHandler>;
     getTracker(): PointerTracker;
     getTrackedPointersID(): number[];
     getState(): State;

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

@@ -0,0 +1,38 @@
+import type { PointerType } from '../../PointerType';
+import type { MouseButton } from '../../handlers/gestureHandlerCommon';
+import type { State } from '../../State';
+import type { Config } from '../interfaces';
+import type EventManager from '../tools/EventManager';
+import type { GestureHandlerDelegate } from '../tools/GestureHandlerDelegate';
+import type PointerTracker from '../tools/PointerTracker';
+export default interface IGestureHandler {
+    getTag: () => number;
+    getState: () => State;
+    getConfig: () => Config;
+    getDelegate: () => GestureHandlerDelegate<unknown, this>;
+    attachEventManager: (manager: EventManager<unknown>) => void;
+    isButtonInConfig: (mouseButton: MouseButton | undefined) => boolean | number | undefined;
+    getPointerType: () => PointerType;
+    getTracker: () => PointerTracker;
+    getTrackedPointersID: () => number[];
+    begin: () => void;
+    activate: () => void;
+    end: () => void;
+    fail: () => void;
+    cancel: () => void;
+    reset: () => void;
+    isEnabled: () => boolean;
+    isActive: () => boolean;
+    setActive: (value: boolean) => void;
+    isAwaiting: () => boolean;
+    setAwaiting: (value: boolean) => void;
+    setActivationIndex: (value: number) => void;
+    setShouldResetProgress: (value: boolean) => void;
+    shouldWaitForHandlerFailure: (handler: IGestureHandler) => boolean;
+    shouldRequireToWaitForFailure: (handler: IGestureHandler) => boolean;
+    shouldRecognizeSimultaneously: (handler: IGestureHandler) => boolean;
+    shouldBeCancelledByOther: (handler: IGestureHandler) => boolean;
+    sendEvent: (newState: State, oldState: State) => void;
+    updateGestureConfig: (config: Config) => void;
+    isButton?: () => boolean;
+}

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

@@ -21,4 +21,5 @@ export default class NativeViewGestureHandler extends GestureHandler {
     shouldRecognizeSimultaneously(handler: GestureHandler): boolean;
     shouldBeCancelledByOther(_handler: GestureHandler): boolean;
     disallowsInterruption(): boolean;
+    isButton(): boolean;
 }

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

@@ -1,6 +1,7 @@
-import { UserSelect, ActiveCursor } from '../handlers/gestureHandlerCommon';
+import { UserSelect, ActiveCursor, MouseButton, TouchAction } from '../handlers/gestureHandlerCommon';
 import { Directions } from '../Directions';
 import { State } from '../State';
+import { PointerType } from '../PointerType';
 export interface HitSlop {
     left?: number;
     right?: number;
@@ -14,7 +15,7 @@ export interface HitSlop {
 export interface Handler {
     handlerTag: number;
 }
-type ConfigArgs = number | boolean | HitSlop | UserSelect | ActiveCursor | Directions | Handler[] | null | undefined;
+type ConfigArgs = number | boolean | HitSlop | UserSelect | TouchAction | ActiveCursor | Directions | Handler[] | null | undefined;
 export interface Config extends Record<string, ConfigArgs> {
     enabled?: boolean;
     simultaneousHandlers?: Handler[] | null;
@@ -26,6 +27,7 @@ export interface Config extends Record<string, ConfigArgs> {
     activeCursor?: ActiveCursor;
     mouseButton?: MouseButton;
     enableContextMenu?: boolean;
+    touchAction?: TouchAction;
     activateAfterLongPress?: number;
     failOffsetXStart?: number;
     failOffsetYStart?: number;
@@ -64,6 +66,11 @@ interface NativeEvent extends Record<string, NativeEventArgs> {
     handlerTag: number;
     target: number;
     oldState?: State;
+    pointerType: PointerType;
+}
+export interface Point {
+    x: number;
+    y: number;
 }
 export interface PointerData {
     id: number;
@@ -107,14 +114,6 @@ export interface AdaptedEvent {
     changedTouches?: TouchList;
     touchEventType?: TouchEventType;
 }
-export declare enum MouseButton {
-    LEFT = 1,
-    MIDDLE = 2,
-    RIGHT = 4,
-    BUTTON_4 = 8,
-    BUTTON_5 = 16,
-    ALL = 31
-}
 export declare enum EventTypes {
     DOWN = 0,
     ADDITIONAL_POINTER_DOWN = 1,
@@ -132,10 +131,4 @@ export declare enum TouchEventType {
     UP = 3,
     CANCELLED = 4
 }
-export declare enum PointerType {
-    NONE = "none",
-    MOUSE = "mouse",
-    TOUCH = "touch",
-    PEN = "pen"
-}
 export {};

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

@@ -1,10 +1,12 @@
 import { AdaptedEvent, EventTypes, TouchEventType } from '../interfaces';
+type PointerEventCallback = (event: AdaptedEvent) => void;
 export default abstract class EventManager<T> {
     protected readonly view: T;
     protected pointersInBounds: number[];
     protected activePointersCounter: number;
     constructor(view: T);
-    abstract setListeners(): void;
+    abstract registerListeners(): void;
+    abstract unregisterListeners(): void;
     protected abstract mapEvent(event: Event, eventType: EventTypes, index?: number, touchEventType?: TouchEventType): AdaptedEvent;
     protected onPointerDown(_event: AdaptedEvent): void;
     protected onPointerAdd(_event: AdaptedEvent): void;
@@ -17,18 +19,19 @@ export default abstract class EventManager<T> {
     protected onPointerOutOfBounds(_event: AdaptedEvent): void;
     protected onPointerMoveOver(_event: AdaptedEvent): void;
     protected onPointerMoveOut(_event: AdaptedEvent): void;
-    setOnPointerDown(callback: (event: AdaptedEvent) => void): void;
-    setOnPointerAdd(callback: (event: AdaptedEvent) => void): void;
-    setOnPointerUp(callback: (event: AdaptedEvent) => void): void;
-    setOnPointerRemove(callback: (event: AdaptedEvent) => void): void;
-    setOnPointerMove(callback: (event: AdaptedEvent) => void): void;
-    setOnPointerLeave(callback: (event: AdaptedEvent) => void): void;
-    setOnPointerEnter(callback: (event: AdaptedEvent) => void): void;
-    setOnPointerCancel(callback: (event: AdaptedEvent) => void): void;
-    setOnPointerOutOfBounds(callback: (event: AdaptedEvent) => void): void;
-    setOnPointerMoveOver(callback: (event: AdaptedEvent) => void): void;
-    setOnPointerMoveOut(callback: (event: AdaptedEvent) => void): void;
+    setOnPointerDown(callback: PointerEventCallback): void;
+    setOnPointerAdd(callback: PointerEventCallback): void;
+    setOnPointerUp(callback: PointerEventCallback): void;
+    setOnPointerRemove(callback: PointerEventCallback): void;
+    setOnPointerMove(callback: PointerEventCallback): void;
+    setOnPointerLeave(callback: PointerEventCallback): void;
+    setOnPointerEnter(callback: PointerEventCallback): void;
+    setOnPointerCancel(callback: PointerEventCallback): void;
+    setOnPointerOutOfBounds(callback: PointerEventCallback): void;
+    setOnPointerMoveOver(callback: PointerEventCallback): void;
+    setOnPointerMoveOut(callback: PointerEventCallback): void;
     protected markAsInBounds(pointerId: number): void;
     protected markAsOutOfBounds(pointerId: number): void;
     resetManager(): void;
 }
+export {};

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

@@ -1,4 +1,3 @@
-import type GestureHandler from '../handlers/GestureHandler';
 import { Config } from '../interfaces';
 export interface MeasureResult {
     pageX: number;
@@ -6,9 +5,9 @@ export interface MeasureResult {
     width: number;
     height: number;
 }
-export interface GestureHandlerDelegate<T> {
-    getView(): T;
-    init(viewRef: number, handler: GestureHandler): void;
+export interface GestureHandlerDelegate<TComponent, THandler> {
+    getView(): TComponent;
+    init(viewRef: number, handler: THandler): void;
     isPointerInBounds({ x, y }: {
         x: number;
         y: number;

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

@@ -1,29 +1,31 @@
 import { State } from '../../State';
-import GestureHandler from '../handlers/GestureHandler';
+import type IGestureHandler from '../handlers/IGestureHandler';
 export default class GestureHandlerOrchestrator {
     private static instance;
     private gestureHandlers;
     private awaitingHandlers;
+    private awaitingHandlersTags;
     private handlingChangeSemaphore;
     private activationIndex;
     private constructor();
     private scheduleFinishedHandlersCleanup;
     private cleanHandler;
-    removeHandlerFromOrchestrator(handler: GestureHandler): void;
+    removeHandlerFromOrchestrator(handler: IGestureHandler): void;
     private cleanupFinishedHandlers;
     private hasOtherHandlerToWaitFor;
+    private shouldBeCancelledByFinishedHandler;
     private tryActivate;
     private shouldActivate;
     private cleanupAwaitingHandlers;
-    onHandlerStateChange(handler: GestureHandler, newState: State, oldState: State, sendIfDisabled?: boolean): void;
+    onHandlerStateChange(handler: IGestureHandler, newState: State, oldState: State, sendIfDisabled?: boolean): void;
     private makeActive;
     private addAwaitingHandler;
-    recordHandlerIfNotPresent(handler: GestureHandler): void;
+    recordHandlerIfNotPresent(handler: IGestureHandler): void;
     private shouldHandlerWaitForOther;
     private canRunSimultaneously;
     private shouldHandlerBeCancelledBy;
     private checkOverlap;
     private isFinished;
-    cancelMouseAndPenGestures(currentHandler: GestureHandler): void;
+    cancelMouseAndPenGestures(currentHandler: IGestureHandler): void;
     static getInstance(): GestureHandlerOrchestrator;
 }

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

@@ -1,12 +1,12 @@
-import type GestureHandler from '../handlers/GestureHandler';
+import type IGestureHandler from '../handlers/IGestureHandler';
 import { GestureHandlerDelegate, MeasureResult } from './GestureHandlerDelegate';
 import { Config } from '../interfaces';
-export declare class GestureHandlerWebDelegate implements GestureHandlerDelegate<HTMLElement> {
+export declare class GestureHandlerWebDelegate implements GestureHandlerDelegate<HTMLElement, IGestureHandler> {
     private view;
     private gestureHandler;
     private eventManagers;
     getView(): HTMLElement;
-    init(viewRef: number, handler: GestureHandler): void;
+    init(viewRef: number, handler: IGestureHandler): void;
     isPointerInBounds({ x, y }: {
         x: number;
         y: number;

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

@@ -1,4 +1,4 @@
-import GestureHandler from '../handlers/GestureHandler';
+import type IGestureHandler from '../handlers/IGestureHandler';
 import { Config } from '../interfaces';
 export default class InteractionManager {
     private static instance;
@@ -6,11 +6,11 @@ export default class InteractionManager {
     private readonly simultaneousRelations;
     private readonly blocksHandlersRelations;
     private constructor();
-    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;
+    configureInteractions(handler: IGestureHandler, config: Config): void;
+    shouldWaitForHandlerFailure(handler: IGestureHandler, otherHandler: IGestureHandler): boolean;
+    shouldRecognizeSimultaneously(handler: IGestureHandler, otherHandler: IGestureHandler): boolean;
+    shouldRequireHandlerToWaitForFailure(handler: IGestureHandler, otherHandler: IGestureHandler): boolean;
+    shouldHandlerBeCancelledBy(_handler: IGestureHandler, otherHandler: IGestureHandler): boolean;
     dropRelationsForHandlerWithTag(handlerTag: number): void;
     reset(): void;
     static getInstance(): InteractionManager;

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

@@ -1,11 +1,12 @@
 import { ValueOf } from '../../typeUtils';
-import { Gestures } from '../../RNGestureHandlerModule.web';
+import { Gestures } from '../Gestures';
+import type IGestureHandler from '../handlers/IGestureHandler';
 export default abstract class NodeManager {
     private static gestures;
-    static getHandler(tag: number): import("../handlers/NativeViewGestureHandler").default | 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/ManualGestureHandler").default | import("../handlers/HoverGestureHandler").default;
+    static getHandler(tag: number): IGestureHandler;
     static createGestureHandler(handlerTag: number, handler: InstanceType<ValueOf<typeof Gestures>>): void;
     static dropGestureHandler(handlerTag: number): void;
     static getNodes(): {
-        [x: number]: import("../handlers/NativeViewGestureHandler").default | 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/ManualGestureHandler").default | import("../handlers/HoverGestureHandler").default;
+        [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 | import("../handlers/ManualGestureHandler").default | import("../handlers/HoverGestureHandler").default;
     };
 }

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

@@ -1,10 +1,19 @@
-import { AdaptedEvent, EventTypes } from '../interfaces';
 import EventManager from './EventManager';
+import { AdaptedEvent, EventTypes } from '../interfaces';
 export default class PointerEventManager extends EventManager<HTMLElement> {
     private trackedPointers;
     private readonly mouseButtonsMapper;
+    private lastPosition;
     constructor(view: HTMLElement);
-    setListeners(): void;
+    private pointerDownCallback;
+    private pointerUpCallback;
+    private pointerMoveCallback;
+    private pointerCancelCallback;
+    private pointerEnterCallback;
+    private pointerLeaveCallback;
+    private lostPointerCaptureCallback;
+    registerListeners(): void;
+    unregisterListeners(): void;
     protected mapEvent(event: PointerEvent, eventType: EventTypes): AdaptedEvent;
     resetManager(): void;
 }

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

@@ -1,6 +1,11 @@
 import { AdaptedEvent, EventTypes, TouchEventType } from '../interfaces';
 import EventManager from './EventManager';
 export default class TouchEventManager extends EventManager<HTMLElement> {
-    setListeners(): void;
+    private touchStartCallback;
+    private touchMoveCallback;
+    private touchEndCallback;
+    private touchCancelCallback;
+    registerListeners(): void;
+    unregisterListeners(): void;
     protected mapEvent(event: TouchEvent, eventType: EventTypes, index: number, touchEventType: TouchEventType): AdaptedEvent;
 }

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

@@ -0,0 +1,15 @@
+import { DiagonalDirections, Directions } from '../../Directions';
+import PointerTracker from './PointerTracker';
+export default class Vector {
+    private readonly x;
+    private readonly y;
+    private readonly unitX;
+    private readonly unitY;
+    private readonly _magnitude;
+    constructor(x: number, y: number);
+    static fromDirection(direction: Directions | DiagonalDirections): Vector;
+    static fromVelocity(tracker: PointerTracker, pointerId: number): Vector;
+    get magnitude(): number;
+    computeSimilarity(vector: Vector): number;
+    isSimilar(vector: Vector, threshold: number): boolean;
+}

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

@@ -1,4 +1,6 @@
-export declare function isPointerInBounds(view: HTMLElement, { x, y }: {
-    x: number;
-    y: number;
-}): boolean;
+import { PointerType } from '../PointerType';
+import { Point } from './interfaces';
+export declare function isPointerInBounds(view: HTMLElement, { x, y }: Point): boolean;
+export declare const PointerTypeMapping: Map<string, PointerType>;
+export declare const degToRad: (degrees: number) => number;
+export declare const coneToDeviation: (degrees: number) => number;

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

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