react-native-gesture-handler 2.27.0 → 2.27.1

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

@@ -0,0 +1,7 @@
+export declare const gestures: Record<number, any>;
+export declare function getHandler(tag: number): any;
+export declare function createGestureHandler(handlerTag: number, handler: any): void;
+export declare function dropGestureHandler(handlerTag: number): void;
+export declare function getNodes(): {
+    [x: number]: any;
+};

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

@@ -0,0 +1 @@
+{"version":3,"file":"NodeManager.d.ts","sourceRoot":"","sources":["../../../src/web_hammer/NodeManager.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAM,CAAC;AAEhD,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,OAMrC;AAED,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,QAOpE;AAED,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,MAAM,QASpD;AAED,wBAAgB,QAAQ;;EAEvB"}

package/lib/typescript/web_hammer/NodeManager.js

@@ -0,0 +1,28 @@
+export const gestures = {};
+export function getHandler(tag) {
+    if (tag in gestures) {
+        return gestures[tag];
+    }
+    throw new Error(`No handler for tag ${tag}`);
+}
+export function createGestureHandler(handlerTag, handler) {
+    if (handlerTag in gestures) {
+        throw new Error(`Handler with tag ${handlerTag} already exists`);
+    }
+    gestures[handlerTag] = handler;
+    // @ts-ignore no types for web handlers yet
+    gestures[handlerTag].handlerTag = handlerTag;
+}
+export function dropGestureHandler(handlerTag) {
+    // Since React 18, there are cases where componentWillUnmount gets called twice in a row
+    // so skip this if the tag was already removed.
+    if (!(handlerTag in gestures)) {
+        return;
+    }
+    getHandler(handlerTag).destroy();
+    // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+    delete gestures[handlerTag];
+}
+export function getNodes() {
+    return { ...gestures };
+}

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/PanGestureHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PanGestureHandler.d.ts","sourceRoot":"","sources":["../../../src/web_hammer/PanGestureHandler.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,QAAQ,EAGT,MAAM,aAAa,CAAC;AACrB,OAAO,sBAAsB,MAAM,0BAA0B,CAAC;AAE9D,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AAEjC,OAAO,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAC1D,cAAM,iBAAkB,SAAQ,sBAAsB;IACpD,IAAI,IAAI,WAEP;IAED,IAAI,kBAAkB,wBAErB;IAED,eAAe;;;;IAOf,QAAQ,CAAC,IAAI,EAAE,MAAM,OAAO,QAAQ;IAYpC,YAAY;IA0DZ,SAAS;;;;;;;;;;;;;;;;;;;;;IAWT,6BAA6B,CAC3B,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,cAAc,EAClC,QAAQ,EAAE,GAAG;IAYf,iCAAiC,CAC/B,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,EAAE,GAAG,EACjC,QAAQ,EAAE,GAAG;IAqBf,wBAAwB,CAAC,EACvB,aAAa,EACb,KAAK,EACL,aAAa,GACd,EAAE;QACD,aAAa,EAAE,MAAM,CAAC;QACtB,aAAa,EAAE,MAAM,CAAC;QACtB,KAAK,EAAE,MAAM,CAAC;KACf;IAsBD,iCAAiC,CAC/B,QAAQ,EAAE,MAAM,GAAG;QAAE,YAAY,CAAC,EAAE,MAAM,CAAC;QAAC,YAAY,CAAC,EAAE,MAAM,CAAA;KAAE;IAcrE,wBAAwB,CACtB,KAAK,EAAE,GAAG,EACV,WAAW,EAAE,GAAG,EAChB,SAAS,EAAE,cAAc,GAAG;QAAE,aAAa,EAAE,MAAM,CAAA;KAAE;;;;;;;CA6BxD;AAED,eAAe,iBAAiB,CAAC"}

package/lib/typescript/web_hammer/PanGestureHandler.js

@@ -0,0 +1,151 @@
+import Hammer from '@egjs/hammerjs';
+import { MULTI_FINGER_PAN_MAX_PINCH_THRESHOLD, MULTI_FINGER_PAN_MAX_ROTATION_THRESHOLD, } from './constants';
+import DraggingGestureHandler from './DraggingGestureHandler';
+import { isValidNumber, isnan, TEST_MIN_IF_NOT_NAN, VEC_LEN_SQ } from './utils';
+import { State } from '../State';
+class PanGestureHandler extends DraggingGestureHandler {
+    get name() {
+        return 'pan';
+    }
+    get NativeGestureClass() {
+        return Hammer.Pan;
+    }
+    getHammerConfig() {
+        return {
+            ...super.getHammerConfig(),
+            direction: this.getDirection(),
+        };
+    }
+    getState(type) {
+        const nextState = super.getState(type);
+        // Ensure that the first state sent is `BEGAN` and not `ACTIVE`
+        if (this.previousState === State.UNDETERMINED &&
+            nextState === State.ACTIVE) {
+            return State.BEGAN;
+        }
+        return nextState;
+    }
+    getDirection() {
+        const config = this.getConfig();
+        const { activeOffsetXStart, activeOffsetXEnd, activeOffsetYStart, activeOffsetYEnd, minDist, } = config;
+        let directions = [];
+        let horizontalDirections = [];
+        if (!isnan(minDist)) {
+            return Hammer.DIRECTION_ALL;
+        }
+        if (!isnan(activeOffsetXStart)) {
+            horizontalDirections.push(Hammer.DIRECTION_LEFT);
+        }
+        if (!isnan(activeOffsetXEnd)) {
+            horizontalDirections.push(Hammer.DIRECTION_RIGHT);
+        }
+        if (horizontalDirections.length === 2) {
+            horizontalDirections = [Hammer.DIRECTION_HORIZONTAL];
+        }
+        directions = directions.concat(horizontalDirections);
+        let verticalDirections = [];
+        if (!isnan(activeOffsetYStart)) {
+            verticalDirections.push(Hammer.DIRECTION_UP);
+        }
+        if (!isnan(activeOffsetYEnd)) {
+            verticalDirections.push(Hammer.DIRECTION_DOWN);
+        }
+        if (verticalDirections.length === 2) {
+            verticalDirections = [Hammer.DIRECTION_VERTICAL];
+        }
+        directions = directions.concat(verticalDirections);
+        if (!directions.length) {
+            return Hammer.DIRECTION_NONE;
+        }
+        if (directions[0] === Hammer.DIRECTION_HORIZONTAL &&
+            directions[1] === Hammer.DIRECTION_VERTICAL) {
+            return Hammer.DIRECTION_ALL;
+        }
+        if (horizontalDirections.length && verticalDirections.length) {
+            return Hammer.DIRECTION_ALL;
+        }
+        return directions[0];
+    }
+    getConfig() {
+        if (!this.hasCustomActivationCriteria) {
+            // Default config
+            // If no params have been defined then this config should emulate the native gesture as closely as possible.
+            return {
+                minDistSq: 10,
+            };
+        }
+        return this.config;
+    }
+    shouldFailUnderCustomCriteria({ deltaX, deltaY }, criteria) {
+        return ((!isnan(criteria.failOffsetXStart) &&
+            deltaX < criteria.failOffsetXStart) ||
+            (!isnan(criteria.failOffsetXEnd) && deltaX > criteria.failOffsetXEnd) ||
+            (!isnan(criteria.failOffsetYStart) &&
+                deltaY < criteria.failOffsetYStart) ||
+            (!isnan(criteria.failOffsetYEnd) && deltaY > criteria.failOffsetYEnd));
+    }
+    shouldActivateUnderCustomCriteria({ deltaX, deltaY, velocity }, criteria) {
+        return ((!isnan(criteria.activeOffsetXStart) &&
+            deltaX < criteria.activeOffsetXStart) ||
+            (!isnan(criteria.activeOffsetXEnd) &&
+                deltaX > criteria.activeOffsetXEnd) ||
+            (!isnan(criteria.activeOffsetYStart) &&
+                deltaY < criteria.activeOffsetYStart) ||
+            (!isnan(criteria.activeOffsetYEnd) &&
+                deltaY > criteria.activeOffsetYEnd) ||
+            TEST_MIN_IF_NOT_NAN(VEC_LEN_SQ({ x: deltaX, y: deltaY }), criteria.minDistSq) ||
+            TEST_MIN_IF_NOT_NAN(velocity.x, criteria.minVelocityX) ||
+            TEST_MIN_IF_NOT_NAN(velocity.y, criteria.minVelocityY) ||
+            TEST_MIN_IF_NOT_NAN(VEC_LEN_SQ(velocity), criteria.minVelocitySq));
+    }
+    shouldMultiFingerPanFail({ pointerLength, scale, deltaRotation, }) {
+        if (pointerLength <= 1) {
+            return false;
+        }
+        // Test if the pan had too much pinching or rotating.
+        const deltaScale = Math.abs(scale - 1);
+        const absDeltaRotation = Math.abs(deltaRotation);
+        if (deltaScale > MULTI_FINGER_PAN_MAX_PINCH_THRESHOLD) {
+            // > If the threshold doesn't seem right.
+            // You can log the value which it failed at here:
+            return true;
+        }
+        if (absDeltaRotation > MULTI_FINGER_PAN_MAX_ROTATION_THRESHOLD) {
+            // > If the threshold doesn't seem right.
+            // You can log the value which it failed at here:
+            return true;
+        }
+        return false;
+    }
+    updateHasCustomActivationCriteria(criteria) {
+        return (isValidNumber(criteria.minDistSq) ||
+            isValidNumber(criteria.minVelocityX) ||
+            isValidNumber(criteria.minVelocityY) ||
+            isValidNumber(criteria.minVelocitySq) ||
+            isValidNumber(criteria.activeOffsetXStart) ||
+            isValidNumber(criteria.activeOffsetXEnd) ||
+            isValidNumber(criteria.activeOffsetYStart) ||
+            isValidNumber(criteria.activeOffsetYEnd));
+    }
+    isGestureEnabledForEvent(props, _recognizer, inputData) {
+        if (this.shouldFailUnderCustomCriteria(inputData, props)) {
+            return { failed: true };
+        }
+        const velocity = { x: inputData.velocityX, y: inputData.velocityY };
+        if (this.hasCustomActivationCriteria &&
+            this.shouldActivateUnderCustomCriteria({ deltaX: inputData.deltaX, deltaY: inputData.deltaY, velocity }, props)) {
+            if (this.shouldMultiFingerPanFail({
+                pointerLength: inputData.maxPointers,
+                scale: inputData.scale,
+                deltaRotation: inputData.deltaRotation,
+            })) {
+                return {
+                    failed: true,
+                };
+            }
+            return { success: true };
+        }
+        return { success: false };
+    }
+}
+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/PinchGestureHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PinchGestureHandler.d.ts","sourceRoot":"","sources":["../../../src/web_hammer/PinchGestureHandler.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAElD,OAAO,wBAAwB,MAAM,4BAA4B,CAAC;AAElE,cAAM,mBAAoB,SAAQ,wBAAwB;IACxD,IAAI,IAAI,WAEP;IAED,IAAI,kBAAkB,0BAErB;IAED,oBAAoB,CAAC,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,cAAc;;;;;;CAQjE;AAED,eAAe,mBAAmB,CAAC"}

package/lib/typescript/web_hammer/PinchGestureHandler.js

@@ -0,0 +1,19 @@
+import Hammer from '@egjs/hammerjs';
+import IndiscreteGestureHandler from './IndiscreteGestureHandler';
+class PinchGestureHandler extends IndiscreteGestureHandler {
+    get name() {
+        return 'pinch';
+    }
+    get NativeGestureClass() {
+        return Hammer.Pinch;
+    }
+    transformNativeEvent({ scale, velocity, center }) {
+        return {
+            focalX: center.x,
+            focalY: center.y,
+            velocity,
+            scale,
+        };
+    }
+}
+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/PressGestureHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PressGestureHandler.d.ts","sourceRoot":"","sources":["../../../src/web_hammer/PressGestureHandler.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AACjC,OAAO,EAGL,gBAAgB,EACjB,MAAM,aAAa,CAAC;AACrB,OAAO,sBAAsB,MAAM,0BAA0B,CAAC;AAC9D,OAAO,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAG1D,cAAM,mBAAoB,SAAQ,sBAAsB;IACtD,OAAO,CAAC,mBAAmB,CAAM;IACjC,OAAO,CAAC,YAAY,CAA+B;IACnD,IAAI,IAAI,WAEP;IAED,IAAI,aAAa,QAGhB;IAED,IAAI,OAAO,uBAEV;IAED,IAAI,kBAAkB,0BAErB;IAED,kBAAkB,UAAQ;IAE1B,mBAAmB,CAAC,SAAS,EAAE,cAAc;IAM7C,iCAAiC,CAAC,EAChC,uBAAuB,EACvB,SAAS,GACV,EAAE,MAAM,GAAG;QAAE,uBAAuB,EAAE,OAAO,CAAA;KAAE;IAIhD,QAAQ,CAAC,IAAI,EAAE,MAAM,OAAO,gBAAgB,GAAG,KAAK;IASpD,SAAS;;;;;;;;;;;;;;;;;;;;;;;;IAYT,eAAe;;;;IAQf,kBAAkB,CAAC,EAAE,EAAE,cAAc;IAIrC,wBAAwB,CAAC,EAAE,WAAW,EAAE,EAAE,cAAc;IAKxD,cAAc,CAAC,EAAE,EAAE,cAAc;IAajC,uBAAuB,CAAC,EAAE,EAAE,cAAc;IAU1C,eAAe,CAAC,KAAK,EAAE,cAAc;IAOrC,UAAU,CAAC,EAAE,EAAE,cAAc;IAgC7B,mBAAmB,CAAC,EAClB,qBAA6B,EAC7B,oBAA4B,EAC5B,uBAA8B,EAC9B,aAA0B,EAC1B,OAAoB,EACpB,WAAe,EACf,WAAe,EACf,GAAG,KAAK,EACT;;;;;;;;;KAAA;;;;;;;;;;;;;;;;;;;;;CAYF;AACD,eAAe,mBAAmB,CAAC"}

package/lib/typescript/web_hammer/PressGestureHandler.js

@@ -0,0 +1,133 @@
+import Hammer from '@egjs/hammerjs';
+import { State } from '../State';
+import { CONTENT_TOUCHES_DELAY, CONTENT_TOUCHES_QUICK_TAP_END_DELAY, } from './constants';
+import DiscreteGestureHandler from './DiscreteGestureHandler';
+import { fireAfterInterval, isValidNumber, isnan } from './utils';
+class PressGestureHandler extends DiscreteGestureHandler {
+    visualFeedbackTimer;
+    initialEvent = null;
+    get name() {
+        return 'press';
+    }
+    get minDurationMs() {
+        // @ts-ignore FIXME(TS)
+        return isnan(this.config.minDurationMs) ? 5 : this.config.minDurationMs;
+    }
+    get maxDist() {
+        return isnan(this.config.maxDist) ? 9 : this.config.maxDist;
+    }
+    get NativeGestureClass() {
+        return Hammer.Press;
+    }
+    shouldDelayTouches = true;
+    simulateCancelEvent(inputData) {
+        // Long press never starts so we can't rely on the running event boolean.
+        this.hasGestureFailed = true;
+        this.cancelEvent(inputData);
+    }
+    updateHasCustomActivationCriteria({ shouldCancelWhenOutside, maxDistSq, }) {
+        return shouldCancelWhenOutside || !isValidNumber(maxDistSq);
+    }
+    getState(type) {
+        return {
+            [Hammer.INPUT_START]: State.BEGAN,
+            [Hammer.INPUT_MOVE]: State.ACTIVE,
+            [Hammer.INPUT_END]: State.END,
+            [Hammer.INPUT_CANCEL]: State.CANCELLED,
+        }[type];
+    }
+    getConfig() {
+        if (!this.hasCustomActivationCriteria) {
+            // Default config
+            // If no params have been defined then this config should emulate the native gesture as closely as possible.
+            return {
+                shouldCancelWhenOutside: true,
+                maxDistSq: 10,
+            };
+        }
+        return this.config;
+    }
+    getHammerConfig() {
+        return {
+            ...super.getHammerConfig(),
+            // threshold: this.maxDist,
+            time: this.minDurationMs,
+        };
+    }
+    onGestureActivated(ev) {
+        this.onGestureStart(ev);
+    }
+    shouldDelayTouchForEvent({ pointerType }) {
+        // Don't disable event for mouse input
+        return this.shouldDelayTouches && pointerType === 'touch';
+    }
+    onGestureStart(ev) {
+        this.isGestureRunning = true;
+        clearTimeout(this.visualFeedbackTimer);
+        this.initialEvent = ev;
+        this.visualFeedbackTimer = fireAfterInterval(() => {
+            this.sendGestureStartedEvent(this.initialEvent);
+            this.initialEvent = null;
+        }, this.shouldDelayTouchForEvent(ev) && CONTENT_TOUCHES_DELAY);
+    }
+    sendGestureStartedEvent(ev) {
+        clearTimeout(this.visualFeedbackTimer);
+        this.visualFeedbackTimer = null;
+        this.sendEvent({
+            ...ev,
+            eventType: Hammer.INPUT_MOVE,
+            isFirst: true,
+        });
+    }
+    forceInvalidate(event) {
+        super.forceInvalidate(event);
+        clearTimeout(this.visualFeedbackTimer);
+        this.visualFeedbackTimer = null;
+        this.initialEvent = null;
+    }
+    onRawEvent(ev) {
+        super.onRawEvent(ev);
+        if (this.isGestureRunning) {
+            if (ev.isFinal) {
+                let timeout;
+                if (this.visualFeedbackTimer) {
+                    // Aesthetic timing for a quick tap.
+                    // We haven't activated the tap right away to emulate iOS `delaysContentTouches`
+                    // Now we must send the initial activation event and wait a set amount of time before firing the end event.
+                    timeout = CONTENT_TOUCHES_QUICK_TAP_END_DELAY;
+                    this.sendGestureStartedEvent(this.initialEvent);
+                    this.initialEvent = null;
+                }
+                fireAfterInterval(() => {
+                    this.sendEvent({
+                        ...ev,
+                        eventType: Hammer.INPUT_END,
+                        isFinal: true,
+                    });
+                    // @ts-ignore -- this should explicitly support undefined
+                    this.onGestureEnded();
+                }, timeout);
+            }
+            else {
+                this.sendEvent({
+                    ...ev,
+                    eventType: Hammer.INPUT_MOVE,
+                    isFinal: false,
+                });
+            }
+        }
+    }
+    updateGestureConfig({ shouldActivateOnStart = false, disallowInterruption = false, shouldCancelWhenOutside = true, minDurationMs = Number.NaN, maxDist = Number.NaN, minPointers = 1, maxPointers = 1, ...props }) {
+        return super.updateGestureConfig({
+            shouldActivateOnStart,
+            disallowInterruption,
+            shouldCancelWhenOutside,
+            minDurationMs,
+            maxDist,
+            minPointers,
+            maxPointers,
+            ...props,
+        });
+    }
+}
+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/RotationGestureHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RotationGestureHandler.d.ts","sourceRoot":"","sources":["../../../src/web_hammer/RotationGestureHandler.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,wBAAwB,MAAM,4BAA4B,CAAC;AAElE,cAAM,sBAAuB,SAAQ,wBAAwB;IAC3D,IAAI,IAAI,WAEP;IAED,IAAI,kBAAkB,2BAErB;IAED,oBAAoB,CAAC,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,cAAc;;;;;;CAQpE;AACD,eAAe,sBAAsB,CAAC"}

package/lib/typescript/web_hammer/RotationGestureHandler.js

@@ -0,0 +1,20 @@
+import Hammer from '@egjs/hammerjs';
+import { DEG_RAD } from './constants';
+import IndiscreteGestureHandler from './IndiscreteGestureHandler';
+class RotationGestureHandler extends IndiscreteGestureHandler {
+    get name() {
+        return 'rotate';
+    }
+    get NativeGestureClass() {
+        return Hammer.Rotate;
+    }
+    transformNativeEvent({ rotation, velocity, center }) {
+        return {
+            rotation: (rotation - (this.initialRotation ?? 0)) * DEG_RAD,
+            anchorX: center.x,
+            anchorY: center.y,
+            velocity,
+        };
+    }
+}
+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/TapGestureHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TapGestureHandler.d.ts","sourceRoot":"","sources":["../../../src/web_hammer/TapGestureHandler.ts"],"names":[],"mappings":"AAEA,OAAO,sBAAsB,MAAM,0BAA0B,CAAC;AAC9D,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAGlD,cAAM,iBAAkB,SAAQ,sBAAsB;IACpD,OAAO,CAAC,mBAAmB,CAA+B;IAC1D,OAAO,CAAC,MAAM,CAAM;IACpB,OAAO,CAAC,cAAc,CAAM;IAC5B,IAAI,IAAI,WAEP;IAED,IAAI,kBAAkB,wBAErB;IAED,IAAI,UAAU,QAGb;IAED,mBAAmB,CAAC,SAAS,EAAE,cAAc;IAM7C,kBAAkB,CAAC,EAAE,EAAE,cAAc;IAMrC,eAAe,GAAI,IAAI,cAAc,UAWnC;IAEF,UAAU,CAAC,EAAE,EAAE,WAAW;IAkE1B,eAAe;;;;;;;IAgBf,mBAAmB,CAAC,EAClB,uBAA8B,EAC9B,SAAsB,EACtB,SAAsB,EACtB,YAAgB,EAChB,aAAmB,EACnB,UAAuB,EAEvB,aAA0B,EAC1B,OAAW,EACX,WAAe,EACf,WAAe,EACf,GAAG,KAAK,EACT;;;;;;;;;;;;KAAA;;;;;;;;;;;;;;;;;;;;;IAeD,cAAc,CAAC,GAAG,KAAK,EAAE,GAAG;IAM5B,cAAc,CAAC,QAAQ,EAAE,GAAG;CAM7B;AACD,eAAe,iBAAiB,CAAC"}