@react-native-oh-tpl/react-native-gesture-handler 2.12.1-0.0.1

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

@@ -0,0 +1,27 @@
+import { AdaptedEvent, Config } 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;
+    private keyPointer;
+    init(ref: number, propsRef: React.RefObject<unknown>): void;
+    updateGestureConfig({ enabled, ...props }: Config): void;
+    private startFling;
+    private tryEndFling;
+    private endFling;
+    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;
+    activate(force?: boolean): void;
+    protected resetConfig(): void;
+}

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

@@ -0,0 +1,90 @@
+import { State } from '../../State';
+import { Config, AdaptedEvent, PointerType } from '../interfaces';
+import EventManager from '../tools/EventManager';
+import PointerTracker from '../tools/PointerTracker';
+import { GestureHandlerDelegate } from '../tools/GestureHandlerDelegate';
+export default abstract class GestureHandler {
+    private lastSentState;
+    protected currentState: State;
+    protected shouldCancellWhenOutside: boolean;
+    protected hasCustomActivationCriteria: boolean;
+    protected enabled: boolean;
+    private viewRef;
+    private propsRef;
+    private handlerTag;
+    protected config: Config;
+    protected tracker: PointerTracker;
+    protected activationIndex: number;
+    protected awaiting: boolean;
+    protected active: boolean;
+    protected shouldResetProgress: boolean;
+    protected pointerType: PointerType;
+    protected delegate: GestureHandlerDelegate<unknown>;
+    constructor(delegate: GestureHandlerDelegate<unknown>);
+    protected init(viewRef: number, propsRef: React.RefObject<unknown>): void;
+    attachEventManager(manager: EventManager<unknown>): void;
+    protected onCancel(): void;
+    protected onReset(): void;
+    protected resetProgress(): void;
+    reset(): void;
+    moveToState(newState: State, sendIfDisabled?: boolean): void;
+    protected onStateChange(_newState: State, _oldState: State): 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;
+    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: AdaptedEvent): void;
+    protected onPointerAdd(event: AdaptedEvent): void;
+    protected onPointerUp(event: AdaptedEvent): void;
+    protected onPointerRemove(event: AdaptedEvent): void;
+    protected onPointerMove(event: AdaptedEvent): void;
+    protected onPointerLeave(event: AdaptedEvent): void;
+    protected onPointerEnter(event: AdaptedEvent): void;
+    protected onPointerCancel(event: AdaptedEvent): void;
+    protected onPointerOutOfBounds(event: AdaptedEvent): void;
+    protected onPointerMoveOver(_event: AdaptedEvent): void;
+    protected onPointerMoveOut(_event: AdaptedEvent): void;
+    private tryToSendMoveEvent;
+    sendTouchEvent(event: AdaptedEvent): void;
+    sendEvent: (newState: State, oldState: State) => void;
+    private transformEventData;
+    private transformTouchEvent;
+    private cancelTouches;
+    protected transformNativeEvent(): Record<string, unknown>;
+    updateGestureConfig({ enabled, ...props }: Config): void;
+    protected checkCustomActivationCriteria(criterias: string[]): void;
+    private validateHitSlops;
+    private checkHitSlop;
+    protected resetConfig(): void;
+    getTag(): number;
+    setTag(tag: number): void;
+    getConfig(): Config;
+    getDelegate(): GestureHandlerDelegate<unknown>;
+    getTracker(): PointerTracker;
+    getTrackedPointersID(): number[];
+    getState(): State;
+    isEnabled(): boolean;
+    private isFinished;
+    protected setShouldCancelWhenOutside(shouldCancel: boolean): void;
+    protected getShouldCancelWhenOutside(): boolean;
+    getPointerType(): PointerType;
+}

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

@@ -0,0 +1,10 @@
+import { AdaptedEvent, Config } from '../interfaces';
+import GestureHandler from './GestureHandler';
+export default class HoverGestureHandler extends GestureHandler {
+    init(ref: number, propsRef: React.RefObject<unknown>): void;
+    updateGestureConfig({ enabled, ...props }: Config): void;
+    protected onPointerMoveOver(event: AdaptedEvent): void;
+    protected onPointerMoveOut(event: AdaptedEvent): void;
+    protected onPointerMove(event: AdaptedEvent): void;
+    protected onPointerCancel(event: AdaptedEvent): void;
+}

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

@@ -0,0 +1,26 @@
+import { State } from '../../State';
+import { AdaptedEvent, Config } 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(): {
+        duration: number;
+    };
+    updateGestureConfig({ enabled, ...props }: Config): void;
+    protected resetConfig(): void;
+    protected onStateChange(_newState: State, _oldState: State): 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,12 @@
+import { AdaptedEvent, Config } from '../interfaces';
+import GestureHandler from './GestureHandler';
+export default class ManualGestureHandler extends GestureHandler {
+    init(ref: number, propsRef: React.RefObject<unknown>): void;
+    updateGestureConfig({ enabled, ...props }: Config): 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;
+}

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

@@ -0,0 +1,24 @@
+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: AdaptedEvent): void;
+    protected onPointerAdd(event: AdaptedEvent): void;
+    private newPointerAction;
+    protected onPointerMove(event: AdaptedEvent): void;
+    protected onPointerLeave(): void;
+    protected onPointerUp(event: AdaptedEvent): void;
+    protected onPointerRemove(event: AdaptedEvent): void;
+    private onUp;
+    shouldRecognizeSimultaneously(handler: GestureHandler): boolean;
+    shouldBeCancelledByOther(_handler: GestureHandler): boolean;
+    disallowsInterruption(): boolean;
+}

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

@@ -0,0 +1,55 @@
+import { AdaptedEvent, Config } 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;
+    private activationTimeout;
+    init(ref: number, propsRef: React.RefObject<unknown>): void;
+    updateGestureConfig({ enabled, ...props }: Config): void;
+    protected resetConfig(): void;
+    protected transformNativeEvent(): {
+        translationX: number;
+        translationY: number;
+        velocityX: number;
+        velocityY: number;
+    };
+    private getTranslationX;
+    private getTranslationY;
+    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 onPointerOutOfBounds(event: AdaptedEvent): void;
+    private shouldActivate;
+    private shouldFail;
+    private tryBegin;
+    private checkBegan;
+    activate(force?: boolean): void;
+    protected onCancel(): void;
+    protected onReset(): void;
+    protected resetProgress(): void;
+}

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

@@ -0,0 +1,28 @@
+import { AdaptedEvent, Config } from '../interfaces';
+import GestureHandler from './GestureHandler';
+export default class PinchGestureHandler extends GestureHandler {
+    private scale;
+    private velocity;
+    private startingSpan;
+    private spanSlop;
+    private scaleDetectorListener;
+    private scaleGestureDetector;
+    init(ref: number, propsRef: React.RefObject<unknown>): void;
+    updateGestureConfig({ enabled, ...props }: Config): void;
+    protected transformNativeEvent(): {
+        focalX: number;
+        focalY: number;
+        velocity: number;
+        scale: number;
+    };
+    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;
+    private tryBegin;
+    activate(force?: boolean): void;
+    protected onReset(): void;
+    protected resetProgress(): void;
+}

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

@@ -0,0 +1,29 @@
+import { AdaptedEvent, Config } from '../interfaces';
+import GestureHandler from './GestureHandler';
+export default class RotationGestureHandler extends GestureHandler {
+    private rotation;
+    private velocity;
+    private cachedAnchorX;
+    private cachedAnchorY;
+    private rotationGestureListener;
+    private rotationGestureDetector;
+    init(ref: number, propsRef: React.RefObject<unknown>): void;
+    updateGestureConfig({ enabled, ...props }: Config): void;
+    protected transformNativeEvent(): {
+        rotation: number;
+        anchorX: number;
+        anchorY: number;
+        velocity: number;
+    };
+    getAnchorX(): number;
+    getAnchorY(): number;
+    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 tryBegin(): void;
+    activate(_force?: boolean): void;
+    protected onReset(): void;
+}

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

@@ -0,0 +1,39 @@
+import { AdaptedEvent, Config } from '../interfaces';
+import GestureHandler from './GestureHandler';
+export default class TapGestureHandler extends GestureHandler {
+    private maxDeltaX;
+    private maxDeltaY;
+    private maxDistSq;
+    private maxDurationMs;
+    private maxDelayMs;
+    private numberOfTaps;
+    private minNumberOfPointers;
+    private currentMaxNumberOfPointers;
+    private startX;
+    private startY;
+    private offsetX;
+    private offsetY;
+    private lastX;
+    private lastY;
+    private waitTimeout;
+    private delayTimeout;
+    private tapsSoFar;
+    init(ref: number, propsRef: React.RefObject<unknown>): void;
+    updateGestureConfig({ enabled, ...props }: Config): void;
+    protected resetConfig(): void;
+    private clearTimeouts;
+    private startTap;
+    private endTap;
+    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;
+    private updateState;
+    private trySettingPosition;
+    private shouldFail;
+    activate(): void;
+    protected onCancel(): void;
+    protected resetProgress(): void;
+}

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

@@ -0,0 +1,141 @@
+import { UserSelect, ActiveCursor } from '../handlers/gestureHandlerCommon';
+import { Directions } from '../Directions';
+import { State } from '../State';
+export interface HitSlop {
+    left?: number;
+    right?: number;
+    top?: number;
+    bottom?: number;
+    horizontal?: number;
+    vertical?: number;
+    width?: number;
+    height?: number;
+}
+export interface Handler {
+    handlerTag: number;
+}
+type ConfigArgs = number | boolean | HitSlop | UserSelect | ActiveCursor | Directions | Handler[] | null | undefined;
+export interface Config extends Record<string, ConfigArgs> {
+    enabled?: boolean;
+    simultaneousHandlers?: Handler[] | null;
+    waitFor?: Handler[] | null;
+    blocksHandlers?: Handler[] | null;
+    hitSlop?: HitSlop;
+    shouldCancelWhenOutside?: boolean;
+    userSelect?: UserSelect;
+    activeCursor?: ActiveCursor;
+    activateAfterLongPress?: number;
+    failOffsetXStart?: number;
+    failOffsetYStart?: number;
+    failOffsetXEnd?: number;
+    failOffsetYEnd?: number;
+    activeOffsetXStart?: number;
+    activeOffsetXEnd?: number;
+    activeOffsetYStart?: number;
+    activeOffsetYEnd?: number;
+    minPointers?: number;
+    maxPointers?: number;
+    minDist?: number;
+    minDistSq?: number;
+    minVelocity?: number;
+    minVelocityX?: number;
+    minVelocityY?: number;
+    minVelocitySq?: number;
+    maxDist?: number;
+    maxDistSq?: number;
+    numberOfPointers?: number;
+    minDurationMs?: number;
+    numberOfTaps?: number;
+    maxDurationMs?: number;
+    maxDelayMs?: number;
+    maxDeltaX?: number;
+    maxDeltaY?: number;
+    shouldActivateOnStart?: boolean;
+    disallowInterruption?: boolean;
+    direction?: Directions;
+}
+type NativeEventArgs = number | State | boolean | undefined;
+interface NativeEvent extends Record<string, NativeEventArgs> {
+    numberOfPointers: number;
+    state: State;
+    pointerInside: boolean | undefined;
+    handlerTag: number;
+    target: number;
+    oldState?: State;
+}
+export interface PointerData {
+    id: number;
+    x: number;
+    y: number;
+    absoluteX: number;
+    absoluteY: number;
+}
+type TouchNativeArgs = number | State | TouchEventType | PointerData[];
+interface NativeTouchEvent extends Record<string, TouchNativeArgs> {
+    handlerTag: number;
+    state: State;
+    eventType: TouchEventType;
+    changedTouches: PointerData[];
+    allTouches: PointerData[];
+    numberOfTouches: number;
+}
+export interface ResultEvent extends Record<string, NativeEvent | number> {
+    nativeEvent: NativeEvent;
+    timeStamp: number;
+}
+export interface ResultTouchEvent extends Record<string, NativeTouchEvent | number> {
+    nativeEvent: NativeTouchEvent;
+    timeStamp: number;
+}
+export interface PropsRef {
+    onGestureHandlerEvent: () => void;
+    onGestureHandlerStateChange: () => void;
+}
+export interface AdaptedEvent {
+    x: number;
+    y: number;
+    offsetX: number;
+    offsetY: number;
+    pointerId: number;
+    eventType: EventTypes;
+    pointerType: PointerType;
+    buttons: number;
+    time: number;
+    allTouches?: TouchList;
+    changedTouches?: TouchList;
+    touchEventType?: TouchEventType;
+}
+export declare enum MouseButtons {
+    NONE = 0,
+    LEFT = 1,
+    RIGHT = 2,
+    LEFT_RIGHT = 3,
+    SCROLL = 4,
+    SCROLL_LEFT = 5,
+    SCROLL_RIGHT = 6,
+    SCROLL_LEFT_RIGHT = 7
+}
+export declare enum EventTypes {
+    DOWN = 0,
+    ADDITIONAL_POINTER_DOWN = 1,
+    UP = 2,
+    ADDITIONAL_POINTER_UP = 3,
+    MOVE = 4,
+    ENTER = 5,
+    LEAVE = 6,
+    CANCEL = 7
+}
+export declare enum TouchEventType {
+    UNDETERMINED = 0,
+    DOWN = 1,
+    MOVE = 2,
+    UP = 3,
+    CANCELLED = 4
+}
+export declare enum PointerType {
+    NONE = "none",
+    MOUSE = "mouse",
+    TOUCH = "touch",
+    PEN = "pen"
+}
+export {};

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

@@ -0,0 +1,11 @@
+export default class CircularBuffer<T> {
+    private bufferSize;
+    private buffer;
+    private index;
+    private actualSize;
+    constructor(size: number);
+    get size(): number;
+    push(element: T): void;
+    get(at: number): T;
+    clear(): void;
+}

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

@@ -0,0 +1,34 @@
+import { AdaptedEvent, EventTypes, TouchEventType } from '../interfaces';
+export default abstract class EventManager<T> {
+    protected readonly view: T;
+    protected pointersInBounds: number[];
+    protected activePointersCounter: number;
+    constructor(view: T);
+    abstract setListeners(): void;
+    protected abstract mapEvent(event: Event, eventType: EventTypes, index?: number, touchEventType?: TouchEventType): AdaptedEvent;
+    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 onPointerLeave(_event: AdaptedEvent): void;
+    protected onPointerEnter(_event: AdaptedEvent): void;
+    protected onPointerCancel(_event: AdaptedEvent): void;
+    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;
+    protected markAsInBounds(pointerId: number): void;
+    protected markAsOutOfBounds(pointerId: number): void;
+    resetManager(): void;
+}

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

@@ -0,0 +1,22 @@
+import type GestureHandler from '../handlers/GestureHandler';
+export interface MeasureResult {
+    pageX: number;
+    pageY: number;
+    width: number;
+    height: number;
+}
+export interface GestureHandlerDelegate<T> {
+    getView(): T;
+    init(viewRef: number, handler: GestureHandler): void;
+    isPointerInBounds({ x, y }: {
+        x: number;
+        y: number;
+    }): boolean;
+    measureView(): MeasureResult;
+    reset(): void;
+    onBegin(): void;
+    onActivate(): void;
+    onEnd(): void;
+    onCancel(): void;
+    onFail(): void;
+}

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

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

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

@@ -0,0 +1,21 @@
+import type GestureHandler from '../handlers/GestureHandler';
+import { GestureHandlerDelegate, MeasureResult } from './GestureHandlerDelegate';
+export declare class GestureHandlerWebDelegate implements GestureHandlerDelegate<HTMLElement> {
+    private view;
+    private gestureHandler;
+    private eventManagers;
+    getView(): HTMLElement;
+    init(viewRef: number, handler: GestureHandler): void;
+    isPointerInBounds({ x, y }: {
+        x: number;
+        y: number;
+    }): boolean;
+    measureView(): MeasureResult;
+    reset(): void;
+    tryResetCursor(): void;
+    onBegin(): void;
+    onActivate(): void;
+    onEnd(): void;
+    onCancel(): void;
+    onFail(): void;
+}

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

@@ -0,0 +1,17 @@
+import GestureHandler from '../handlers/GestureHandler';
+import { Config } from '../interfaces';
+export default class InteractionManager {
+    private static instance;
+    private readonly waitForRelations;
+    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;
+    dropRelationsForHandlerWithTag(handlerTag: number): void;
+    reset(): void;
+    static getInstance(): InteractionManager;
+}

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

@@ -0,0 +1,12 @@
+declare class PolynomialFit {
+    coefficients: number[];
+    constructor(degree: number);
+}
+export default class LeastSquareSolver {
+    private x;
+    private y;
+    private w;
+    constructor(x: number[], y: number[], w: number[]);
+    solve(degree: number): PolynomialFit | null;
+}
+export {};

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

@@ -0,0 +1,11 @@
+import { ValueOf } from '../../typeUtils';
+import { Gestures } from '../../RNGestureHandlerModule.web';
+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 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;
+    };
+}

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

@@ -0,0 +1,8 @@
+import { AdaptedEvent, EventTypes } from '../interfaces';
+import EventManager from './EventManager';
+export default class PointerEventManager extends EventManager<HTMLElement> {
+    private trackedPointers;
+    setListeners(): void;
+    protected mapEvent(event: PointerEvent, eventType: EventTypes): AdaptedEvent;
+    resetManager(): void;
+}