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

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

@@ -0,0 +1,53 @@
+import { AdaptedEvent } from '../interfaces';
+export interface TrackerElement {
+    lastX: number;
+    lastY: number;
+    timeStamp: number;
+    velocityX: number;
+    velocityY: number;
+}
+export default class PointerTracker {
+    private velocityTracker;
+    private trackedPointers;
+    private touchEventsIds;
+    private lastMovedPointerId;
+    private cachedAverages;
+    constructor();
+    addToTracker(event: AdaptedEvent): void;
+    removeFromTracker(pointerId: number): void;
+    track(event: AdaptedEvent): void;
+    private mapTouchEventId;
+    private removeMappedTouchId;
+    getMappedTouchEventId(touchEventId: number): number;
+    getVelocityX(pointerId: number): number;
+    getVelocityY(pointerId: number): number;
+    /**
+     * Returns X coordinate of last moved pointer
+     */
+    getLastX(): number;
+    /**
+     *
+     * @param pointerId
+     * Returns X coordinate of given pointer
+     */
+    getLastX(pointerId: number): number;
+    /**
+     * Returns Y coordinate of last moved pointer
+     */
+    getLastY(): number;
+    /**
+     *
+     * @param pointerId
+     * Returns Y coordinate of given pointer
+     */
+    getLastY(pointerId: number): number;
+    getLastAvgX(): number;
+    getLastAvgY(): number;
+    getSumX(ignoredPointer?: number): number;
+    getSumY(ignoredPointer?: number): number;
+    getTrackedPointersCount(): number;
+    getTrackedPointersID(): number[];
+    getData(): Map<number, TrackerElement>;
+    resetTracker(): void;
+    static shareCommonPointers(stPointers: number[], ndPointers: number[]): boolean;
+}

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

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

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

@@ -0,0 +1,13 @@
+import { AdaptedEvent } from '../interfaces';
+export default class VelocityTracker {
+    private assumePointerMoveStoppedMilliseconds;
+    private historySize;
+    private horizonMilliseconds;
+    private minSampleSize;
+    private samples;
+    constructor();
+    add(event: AdaptedEvent): void;
+    private getVelocityEstimate;
+    getVelocity(): [number, number];
+    reset(): void;
+}

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

@@ -0,0 +1,4 @@
+export declare function isPointerInBounds(view: HTMLElement, { x, y }: {
+    x: number;
+    y: number;
+}): boolean;

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

@@ -0,0 +1,20 @@
+import GestureHandler from './GestureHandler';
+declare abstract class DiscreteGestureHandler extends GestureHandler {
+    get isDiscrete(): boolean;
+    get shouldEnableGestureOnSetup(): boolean;
+    shouldFailUnderCustomCriteria({ x, y, deltaX, deltaY }: any, { maxDeltaX, maxDeltaY, maxDistSq, shouldCancelWhenOutside }: any): boolean;
+    transformNativeEvent({ center: { x, y } }: any): {
+        absoluteX: any;
+        absoluteY: any;
+        x: number;
+        y: number;
+    };
+    isGestureEnabledForEvent({ minPointers, maxPointers, maxDeltaX, maxDeltaY, maxDistSq, shouldCancelWhenOutside, }: any, _recognizer: any, { maxPointers: pointerLength, center, deltaX, deltaY }: any): {
+        failed: boolean;
+        success?: undefined;
+    } | {
+        success: boolean;
+        failed?: undefined;
+    };
+}
+export default DiscreteGestureHandler;

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

@@ -0,0 +1,15 @@
+import GestureHandler, { HammerInputExt } from './GestureHandler';
+declare abstract class DraggingGestureHandler extends GestureHandler {
+    get shouldEnableGestureOnSetup(): boolean;
+    transformNativeEvent({ deltaX, deltaY, velocityX, velocityY, center: { x, y }, }: HammerInputExt): {
+        translationX: number;
+        translationY: number;
+        absoluteX: number;
+        absoluteY: number;
+        velocityX: number;
+        velocityY: number;
+        x: number;
+        y: number;
+    };
+}
+export default DraggingGestureHandler;

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

@@ -0,0 +1,3 @@
+export declare class GesturePropError extends Error {
+    constructor(name: string, value: unknown, expectedType: string);
+}

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

@@ -0,0 +1,43 @@
+import DraggingGestureHandler from './DraggingGestureHandler';
+import { HammerInputExt } from './GestureHandler';
+declare class FlingGestureHandler extends DraggingGestureHandler {
+    get name(): string;
+    get NativeGestureClass(): SwipeRecognizerStatic;
+    onGestureActivated(event: HammerInputExt): void;
+    onRawEvent(ev: HammerInputExt): void;
+    getHammerConfig(): {
+        pointers: any;
+        direction: number;
+    };
+    getTargetDirections(direction: number): number[];
+    getDirection(): number;
+    isGestureEnabledForEvent({ numberOfPointers }: any, _recognizer: any, { maxPointers: pointerLength }: any): {
+        failed: boolean;
+        success?: undefined;
+    } | {
+        success: boolean;
+        failed?: undefined;
+    };
+    updateGestureConfig({ numberOfPointers, direction, ...props }: any): Partial<{
+        enabled: boolean;
+        minPointers: number;
+        maxPointers: number;
+        minDist: number;
+        minDistSq: number;
+        minVelocity: number;
+        minVelocitySq: number;
+        maxDist: number;
+        maxDistSq: number;
+        failOffsetXStart: number;
+        failOffsetYStart: number;
+        failOffsetXEnd: number;
+        failOffsetYEnd: number;
+        activeOffsetXStart: number;
+        activeOffsetXEnd: number;
+        activeOffsetYStart: number;
+        activeOffsetYEnd: number;
+        waitFor: any[] | null;
+        simultaneousHandlers: any[] | null;
+    }>;
+}
+export default FlingGestureHandler;

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

@@ -0,0 +1,145 @@
+import { findNodeHandle } from 'react-native';
+import { State } from '../State';
+import { EventMap } from './constants';
+export type HammerInputExt = Omit<HammerInput, 'destroy' | 'handler' | 'init'>;
+export type Config = Partial<{
+    enabled: boolean;
+    minPointers: number;
+    maxPointers: number;
+    minDist: number;
+    minDistSq: number;
+    minVelocity: number;
+    minVelocitySq: number;
+    maxDist: number;
+    maxDistSq: number;
+    failOffsetXStart: number;
+    failOffsetYStart: number;
+    failOffsetXEnd: number;
+    failOffsetYEnd: number;
+    activeOffsetXStart: number;
+    activeOffsetXEnd: number;
+    activeOffsetYStart: number;
+    activeOffsetYEnd: number;
+    waitFor: any[] | null;
+    simultaneousHandlers: any[] | null;
+}>;
+declare abstract class GestureHandler {
+    handlerTag: any;
+    isGestureRunning: boolean;
+    view: number | null;
+    protected hasCustomActivationCriteria: boolean;
+    protected hasGestureFailed: boolean;
+    protected hammer: HammerManager | null;
+    protected initialRotation: number | null;
+    protected __initialX: any;
+    protected __initialY: any;
+    protected config: Config;
+    protected previousState: State;
+    private pendingGestures;
+    private oldState;
+    private lastSentState;
+    private gestureInstance;
+    private _stillWaiting;
+    private propsRef;
+    private ref;
+    abstract get name(): string;
+    get id(): string;
+    get isNative(): boolean;
+    get isDiscrete(): boolean;
+    get shouldEnableGestureOnSetup(): boolean;
+    constructor();
+    getConfig(): Partial<{
+        enabled: boolean;
+        minPointers: number;
+        maxPointers: number;
+        minDist: number;
+        minDistSq: number;
+        minVelocity: number;
+        minVelocitySq: number;
+        maxDist: number;
+        maxDistSq: number;
+        failOffsetXStart: number;
+        failOffsetYStart: number;
+        failOffsetXEnd: number;
+        failOffsetYEnd: number;
+        activeOffsetXStart: number;
+        activeOffsetXEnd: number;
+        activeOffsetYStart: number;
+        activeOffsetYEnd: number;
+        waitFor: any[] | null;
+        simultaneousHandlers: any[] | null;
+    }>;
+    onWaitingEnded(_gesture: this): void;
+    removePendingGesture(id: string): void;
+    addPendingGesture(gesture: this): void;
+    isGestureEnabledForEvent(_config: any, _recognizer: any, _event: any): {
+        failed?: boolean;
+        success?: boolean;
+    };
+    get NativeGestureClass(): RecognizerStatic;
+    updateHasCustomActivationCriteria(_config: Config): boolean;
+    clearSelfAsPending: () => void;
+    updateGestureConfig({ enabled, ...props }: {
+        [x: string]: any;
+        enabled?: boolean | undefined;
+    }): Partial<{
+        enabled: boolean;
+        minPointers: number;
+        maxPointers: number;
+        minDist: number;
+        minDistSq: number;
+        minVelocity: number;
+        minVelocitySq: number;
+        maxDist: number;
+        maxDistSq: number;
+        failOffsetXStart: number;
+        failOffsetYStart: number;
+        failOffsetXEnd: number;
+        failOffsetYEnd: number;
+        activeOffsetXStart: number;
+        activeOffsetXEnd: number;
+        activeOffsetYStart: number;
+        activeOffsetYEnd: number;
+        waitFor: any[] | null;
+        simultaneousHandlers: any[] | null;
+    }>;
+    destroy: () => void;
+    isPointInView: ({ x, y }: {
+        x: number;
+        y: number;
+    }) => boolean;
+    getState(type: keyof typeof EventMap): State;
+    transformEventData(event: HammerInputExt): {
+        nativeEvent: {
+            handlerTag: any;
+            target: any;
+            oldState: State | undefined;
+            numberOfPointers: number;
+            state: State;
+            pointerInside: boolean;
+        };
+        timeStamp: number;
+    };
+    transformNativeEvent(_event: HammerInputExt): {};
+    sendEvent: (nativeEvent: HammerInputExt) => void;
+    cancelPendingGestures(event: HammerInputExt): void;
+    notifyPendingGestures(): void;
+    onGestureEnded(event: HammerInputExt): void;
+    forceInvalidate(event: HammerInputExt): void;
+    cancelEvent(event: HammerInputExt): void;
+    onRawEvent({ isFirst }: HammerInputExt): void;
+    shouldUseTouchEvents(config: Config): boolean;
+    setView(ref: Parameters<typeof findNodeHandle>['0'], propsRef: any): void;
+    setupEvents(): void;
+    onStart({ deltaX, deltaY, rotation }: HammerInputExt): void;
+    onGestureActivated(ev: HammerInputExt): void;
+    onSuccess(): void;
+    _getPendingGestures(): any[];
+    getHammerConfig(): {
+        pointers: number | undefined;
+    };
+    sync: () => void;
+    simulateCancelEvent(_inputData: any): void;
+    ensureConfig(config: Config): Required<Config>;
+}
+export default GestureHandler;

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

@@ -0,0 +1,40 @@
+import GestureHandler from './GestureHandler';
+/**
+ * The base class for **Rotation** and **Pinch** gesture handlers.
+ */
+declare abstract class IndiscreteGestureHandler extends GestureHandler {
+    get shouldEnableGestureOnSetup(): boolean;
+    updateGestureConfig({ minPointers, maxPointers, ...props }: {
+        [x: string]: any;
+        minPointers?: number | undefined;
+        maxPointers?: number | undefined;
+    }): Partial<{
+        enabled: boolean;
+        minPointers: number;
+        maxPointers: number;
+        minDist: number;
+        minDistSq: number;
+        minVelocity: number;
+        minVelocitySq: number;
+        maxDist: number;
+        maxDistSq: number;
+        failOffsetXStart: number;
+        failOffsetYStart: number;
+        failOffsetXEnd: number;
+        failOffsetYEnd: number;
+        activeOffsetXStart: number;
+        activeOffsetXEnd: number;
+        activeOffsetYStart: number;
+        activeOffsetYEnd: number;
+        waitFor: any[] | null;
+        simultaneousHandlers: any[] | null;
+    }>;
+    isGestureEnabledForEvent({ minPointers, maxPointers }: any, _recognizer: any, { maxPointers: pointerLength }: any): {
+        failed: boolean;
+        success?: undefined;
+    } | {
+        success: boolean;
+        failed?: undefined;
+    };
+}
+export default IndiscreteGestureHandler;

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

@@ -0,0 +1,38 @@
+import PressGestureHandler from './PressGestureHandler';
+import { Config } from './GestureHandler';
+import { HammerInputNames } from './constants';
+declare class LongPressGestureHandler extends PressGestureHandler {
+    get minDurationMs(): number;
+    get maxDist(): number | undefined;
+    updateHasCustomActivationCriteria({ maxDistSq }: Config): boolean;
+    getConfig(): Partial<{
+        enabled: boolean;
+        minPointers: number;
+        maxPointers: number;
+        minDist: number;
+        minDistSq: number;
+        minVelocity: number;
+        minVelocitySq: number;
+        maxDist: number;
+        maxDistSq: number;
+        failOffsetXStart: number;
+        failOffsetYStart: number;
+        failOffsetXEnd: number;
+        failOffsetYEnd: number;
+        activeOffsetXStart: number;
+        activeOffsetXEnd: number;
+        activeOffsetYStart: number;
+        activeOffsetYEnd: number;
+        waitFor: any[] | null;
+        simultaneousHandlers: any[] | null;
+    }> | {
+        shouldCancelWhenOutside: boolean;
+        maxDistSq: number;
+    };
+    getHammerConfig(): {
+        time: number;
+        pointers: number | undefined;
+    };
+    getState(type: keyof typeof HammerInputNames): 1 | 4 | 5;
+}
+export default LongPressGestureHandler;

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

@@ -0,0 +1,7 @@
+import { HammerInputExt } from './GestureHandler';
+import PressGestureHandler from './PressGestureHandler';
+declare class NativeViewGestureHandler extends PressGestureHandler {
+    get isNative(): boolean;
+    onRawEvent(ev: HammerInputExt): void;
+}
+export default NativeViewGestureHandler;

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

@@ -0,0 +1,8 @@
+import { ValueOf } from '../typeUtils';
+import { HammerGestures } from '../RNGestureHandlerModule.web';
+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;
+export declare function getNodes(): {
+    [x: number]: import("./NativeViewGestureHandler").default | import("./PanGestureHandler").default | import("./TapGestureHandler").default | import("./LongPressGestureHandler").default | import("./PinchGestureHandler").default | import("./RotationGestureHandler").default | import("./FlingGestureHandler").default;
+};

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

@@ -0,0 +1,56 @@
+import { EventMap } from './constants';
+import DraggingGestureHandler from './DraggingGestureHandler';
+import { State } from '../State';
+import { Config, HammerInputExt } from './GestureHandler';
+declare class PanGestureHandler extends DraggingGestureHandler {
+    get name(): string;
+    get NativeGestureClass(): PanRecognizerStatic;
+    getHammerConfig(): {
+        direction: number;
+        pointers: number | undefined;
+    };
+    getState(type: keyof typeof EventMap): State;
+    getDirection(): number;
+    getConfig(): Partial<{
+        enabled: boolean;
+        minPointers: number;
+        maxPointers: number;
+        minDist: number;
+        minDistSq: number;
+        minVelocity: number;
+        minVelocitySq: number;
+        maxDist: number;
+        maxDistSq: number;
+        failOffsetXStart: number;
+        failOffsetYStart: number;
+        failOffsetXEnd: number;
+        failOffsetYEnd: number;
+        activeOffsetXStart: number;
+        activeOffsetXEnd: number;
+        activeOffsetYStart: number;
+        activeOffsetYEnd: number;
+        waitFor: any[] | null;
+        simultaneousHandlers: any[] | null;
+    }>;
+    shouldFailUnderCustomCriteria({ deltaX, deltaY }: HammerInputExt, criteria: any): boolean;
+    shouldActivateUnderCustomCriteria({ deltaX, deltaY, velocity }: any, criteria: any): boolean;
+    shouldMultiFingerPanFail({ pointerLength, scale, deltaRotation, }: {
+        deltaRotation: number;
+        pointerLength: number;
+        scale: number;
+    }): boolean;
+    updateHasCustomActivationCriteria(criteria: Config & {
+        minVelocityX?: number;
+        minVelocityY?: number;
+    }): boolean;
+    isGestureEnabledForEvent(props: any, _recognizer: any, inputData: HammerInputExt & {
+        deltaRotation: number;
+    }): {
+        failed: boolean;
+        success?: undefined;
+    } | {
+        success: boolean;
+        failed?: undefined;
+    };
+}
+export default PanGestureHandler;

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

@@ -0,0 +1,13 @@
+import { HammerInputExt } from './GestureHandler';
+import IndiscreteGestureHandler from './IndiscreteGestureHandler';
+declare class PinchGestureHandler extends IndiscreteGestureHandler {
+    get name(): string;
+    get NativeGestureClass(): PinchRecognizerStatic;
+    transformNativeEvent({ scale, velocity, center }: HammerInputExt): {
+        focalX: number;
+        focalY: number;
+        velocity: number;
+        scale: number;
+    };
+}
+export default PinchGestureHandler;

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

@@ -0,0 +1,83 @@
+import { State } from '../State';
+import { HammerInputNames } from './constants';
+import DiscreteGestureHandler from './DiscreteGestureHandler';
+import { Config, HammerInputExt } from './GestureHandler';
+declare class PressGestureHandler extends DiscreteGestureHandler {
+    private visualFeedbackTimer;
+    private initialEvent;
+    get name(): string;
+    get minDurationMs(): any;
+    get maxDist(): number | undefined;
+    get NativeGestureClass(): PressRecognizerStatic;
+    shouldDelayTouches: boolean;
+    simulateCancelEvent(inputData: HammerInputExt): void;
+    updateHasCustomActivationCriteria({ shouldCancelWhenOutside, maxDistSq, }: Config & {
+        shouldCancelWhenOutside: boolean;
+    }): boolean;
+    getState(type: keyof typeof HammerInputNames): State;
+    getConfig(): Partial<{
+        enabled: boolean;
+        minPointers: number;
+        maxPointers: number;
+        minDist: number;
+        minDistSq: number;
+        minVelocity: number;
+        minVelocitySq: number;
+        maxDist: number;
+        maxDistSq: number;
+        failOffsetXStart: number;
+        failOffsetYStart: number;
+        failOffsetXEnd: number;
+        failOffsetYEnd: number;
+        activeOffsetXStart: number;
+        activeOffsetXEnd: number;
+        activeOffsetYStart: number;
+        activeOffsetYEnd: number;
+        waitFor: any[] | null;
+        simultaneousHandlers: any[] | null;
+    }> | {
+        shouldCancelWhenOutside: boolean;
+        maxDistSq: number;
+    };
+    getHammerConfig(): {
+        time: any;
+        pointers: number | undefined;
+    };
+    onGestureActivated(ev: HammerInputExt): void;
+    shouldDelayTouchForEvent({ pointerType }: HammerInputExt): boolean;
+    onGestureStart(ev: HammerInputExt): void;
+    sendGestureStartedEvent(ev: HammerInputExt): void;
+    forceInvalidate(event: HammerInputExt): void;
+    onRawEvent(ev: HammerInputExt): void;
+    updateGestureConfig({ shouldActivateOnStart, disallowInterruption, shouldCancelWhenOutside, minDurationMs, maxDist, minPointers, maxPointers, ...props }: {
+        [x: string]: any;
+        shouldActivateOnStart?: boolean | undefined;
+        disallowInterruption?: boolean | undefined;
+        shouldCancelWhenOutside?: boolean | undefined;
+        minDurationMs?: number | undefined;
+        maxDist?: number | undefined;
+        minPointers?: number | undefined;
+        maxPointers?: number | undefined;
+    }): Partial<{
+        enabled: boolean;
+        minPointers: number;
+        maxPointers: number;
+        minDist: number;
+        minDistSq: number;
+        minVelocity: number;
+        minVelocitySq: number;
+        maxDist: number;
+        maxDistSq: number;
+        failOffsetXStart: number;
+        failOffsetYStart: number;
+        failOffsetXEnd: number;
+        failOffsetYEnd: number;
+        activeOffsetXStart: number;
+        activeOffsetXEnd: number;
+        activeOffsetYStart: number;
+        activeOffsetYEnd: number;
+        waitFor: any[] | null;
+        simultaneousHandlers: any[] | null;
+    }>;
+}
+export default PressGestureHandler;

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

@@ -0,0 +1,13 @@
+import { HammerInputExt } from './GestureHandler';
+import IndiscreteGestureHandler from './IndiscreteGestureHandler';
+declare class RotationGestureHandler extends IndiscreteGestureHandler {
+    get name(): string;
+    get NativeGestureClass(): RotateRecognizerStatic;
+    transformNativeEvent({ rotation, velocity, center }: HammerInputExt): {
+        rotation: number;
+        anchorX: number;
+        anchorY: number;
+        velocity: number;
+    };
+}
+export default RotationGestureHandler;

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

@@ -0,0 +1,57 @@
+import DiscreteGestureHandler from './DiscreteGestureHandler';
+import { HammerInputExt } from './GestureHandler';
+declare class TapGestureHandler extends DiscreteGestureHandler {
+    private _shouldFireEndEvent;
+    private _timer;
+    private _multiTapTimer;
+    get name(): string;
+    get NativeGestureClass(): TapRecognizerStatic;
+    get maxDelayMs(): any;
+    simulateCancelEvent(inputData: HammerInputExt): void;
+    onGestureActivated(ev: HammerInputExt): void;
+    onSuccessfulTap: (ev: HammerInputExt) => void;
+    onRawEvent(ev: HammerInput): void;
+    getHammerConfig(): {
+        event: string;
+        taps: any;
+        interval: any;
+        time: any;
+        pointers: number | undefined;
+    };
+    updateGestureConfig({ shouldCancelWhenOutside, maxDeltaX, maxDeltaY, numberOfTaps, minDurationMs, maxDelayMs, maxDurationMs, maxDist, minPointers, maxPointers, ...props }: {
+        [x: string]: any;
+        shouldCancelWhenOutside?: boolean | undefined;
+        maxDeltaX?: number | undefined;
+        maxDeltaY?: number | undefined;
+        numberOfTaps?: number | undefined;
+        minDurationMs?: number | undefined;
+        maxDelayMs?: number | undefined;
+        maxDurationMs?: number | undefined;
+        maxDist?: number | undefined;
+        minPointers?: number | undefined;
+        maxPointers?: number | undefined;
+    }): Partial<{
+        enabled: boolean;
+        minPointers: number;
+        maxPointers: number;
+        minDist: number;
+        minDistSq: number;
+        minVelocity: number;
+        minVelocitySq: number;
+        maxDist: number;
+        maxDistSq: number;
+        failOffsetXStart: number;
+        failOffsetYStart: number;
+        failOffsetXEnd: number;
+        failOffsetYEnd: number;
+        activeOffsetXStart: number;
+        activeOffsetXEnd: number;
+        activeOffsetYStart: number;
+        activeOffsetYEnd: number;
+        waitFor: any[] | null;
+        simultaneousHandlers: any[] | null;
+    }>;
+    onGestureEnded(...props: any): void;
+    onWaitingEnded(_gesture: any): void;
+}
+export default TapGestureHandler;

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

@@ -0,0 +1,39 @@
+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 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;
+};