react-native-gesture-handler 2.27.0 → 2.27.1

package/lib/typescript/web_hammer/TapGestureHandler.js

@@ -0,0 +1,142 @@
+import Hammer from '@egjs/hammerjs';
+import DiscreteGestureHandler from './DiscreteGestureHandler';
+import { isnan } from './utils';
+class TapGestureHandler extends DiscreteGestureHandler {
+    _shouldFireEndEvent = null;
+    _timer;
+    _multiTapTimer; // TODO unused?
+    get name() {
+        return 'tap';
+    }
+    get NativeGestureClass() {
+        return Hammer.Tap;
+    }
+    get maxDelayMs() {
+        // @ts-ignore TODO(TS) trace down config
+        return isnan(this.config.maxDelayMs) ? 300 : this.config.maxDelayMs;
+    }
+    simulateCancelEvent(inputData) {
+        if (this.isGestureRunning) {
+            this.cancelEvent(inputData);
+        }
+    }
+    onGestureActivated(ev) {
+        if (this.isGestureRunning) {
+            this.onSuccessfulTap(ev);
+        }
+    }
+    onSuccessfulTap = (ev) => {
+        if (this._getPendingGestures().length) {
+            this._shouldFireEndEvent = ev;
+            return;
+        }
+        if (ev.eventType === Hammer.INPUT_END) {
+            this.sendEvent({ ...ev, eventType: Hammer.INPUT_MOVE });
+        }
+        // When handler gets activated it will turn into State.END immediately.
+        this.sendEvent({ ...ev, isFinal: true });
+        this.onGestureEnded(ev);
+    };
+    onRawEvent(ev) {
+        super.onRawEvent(ev);
+        // Attempt to create a touch-down event by checking if a valid tap hasn't started yet, then validating the input.
+        if (!this.hasGestureFailed &&
+            !this.isGestureRunning &&
+            // Prevent multi-pointer events from misfiring.
+            !ev.isFinal) {
+            // Tap Gesture start event
+            const gesture = this.hammer.get(this.name);
+            // @ts-ignore TODO(TS) trace down config
+            if (gesture.options.enable(gesture, ev)) {
+                clearTimeout(this._multiTapTimer);
+                this.onStart(ev);
+                this.sendEvent(ev);
+            }
+        }
+        if (ev.isFinal && ev.maxPointers > 1) {
+            setTimeout(() => {
+                // Handle case where one finger presses slightly
+                // after the first finger on a multi-tap event
+                if (this.isGestureRunning) {
+                    this.cancelEvent(ev);
+                }
+            });
+        }
+        if (this.hasGestureFailed) {
+            return;
+        }
+        // Hammer doesn't send a `cancel` event for taps.
+        // Manually fail the event.
+        if (ev.isFinal) {
+            // Handle case where one finger presses slightly
+            // after the first finger on a multi-tap event
+            if (ev.maxPointers > 1) {
+                setTimeout(() => {
+                    if (this.isGestureRunning) {
+                        this.cancelEvent(ev);
+                    }
+                });
+            }
+            // Clear last timer
+            clearTimeout(this._timer);
+            // Create time out for multi-taps.
+            this._timer = setTimeout(() => {
+                this.hasGestureFailed = true;
+                this.cancelEvent(ev);
+            }, this.maxDelayMs);
+        }
+        else if (!this.hasGestureFailed && !this.isGestureRunning) {
+            // Tap Gesture start event
+            const gesture = this.hammer.get(this.name);
+            // @ts-ignore TODO(TS) trace down config
+            if (gesture.options.enable(gesture, ev)) {
+                clearTimeout(this._multiTapTimer);
+                this.onStart(ev);
+                this.sendEvent(ev);
+            }
+        }
+    }
+    getHammerConfig() {
+        return {
+            ...super.getHammerConfig(),
+            event: this.name,
+            // @ts-ignore TODO(TS) trace down config
+            taps: isnan(this.config.numberOfTaps) ? 1 : this.config.numberOfTaps,
+            interval: this.maxDelayMs,
+            time: 
+            // @ts-ignore TODO(TS) trace down config
+            isnan(this.config.maxDurationMs) || this.config.maxDurationMs == null
+                ? 250
+                : // @ts-ignore TODO(TS) trace down config
+                    this.config.maxDurationMs,
+        };
+    }
+    updateGestureConfig({ shouldCancelWhenOutside = true, maxDeltaX = Number.NaN, maxDeltaY = Number.NaN, numberOfTaps = 1, minDurationMs = 525, maxDelayMs = Number.NaN, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars -- TODO possibly forgotten to use in updateGestureConfig?
+    maxDurationMs = Number.NaN, maxDist = 2, minPointers = 1, maxPointers = 1, ...props }) {
+        return super.updateGestureConfig({
+            shouldCancelWhenOutside,
+            numberOfTaps,
+            maxDeltaX,
+            maxDeltaY,
+            minDurationMs,
+            maxDelayMs,
+            maxDist,
+            minPointers,
+            maxPointers,
+            ...props,
+        });
+    }
+    onGestureEnded(...props) {
+        clearTimeout(this._timer);
+        // @ts-ignore TODO(TS) check how onGestureEnded works
+        super.onGestureEnded(...props);
+    }
+    onWaitingEnded(_gesture) {
+        if (this._shouldFireEndEvent) {
+            this.onSuccessfulTap(this._shouldFireEndEvent);
+            this._shouldFireEndEvent = null;
+        }
+    }
+}
+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;
+};

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

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/web_hammer/constants.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,qBAAqB,MAAM,CAAC;AACzC,eAAO,MAAM,mCAAmC,KAAK,CAAC;AACtD,eAAO,MAAM,oCAAoC,MAAM,CAAC;AACxD,eAAO,MAAM,uCAAuC,IAAI,CAAC;AACzD,eAAO,MAAM,OAAO,QAAgB,CAAC;AAGrC,eAAO,MAAM,QAAQ;;;;;CAKX,CAAC;AAEX,eAAO,MAAM,SAAS;;;;;CAKrB,CAAC;AAEF,eAAO,MAAM,YAAY;;;;;CAKxB,CAAC;AAEF,eAAO,MAAM,gBAAgB;;;;;CAK5B,CAAC;AACF,eAAO,MAAM,oBAAoB;;;;;;;;;CAShC,CAAC"}

package/lib/typescript/web_hammer/constants.js

@@ -0,0 +1,42 @@
+import Hammer from '@egjs/hammerjs';
+import { State } from '../State';
+export const CONTENT_TOUCHES_DELAY = 240;
+export const CONTENT_TOUCHES_QUICK_TAP_END_DELAY = 50;
+export const MULTI_FINGER_PAN_MAX_PINCH_THRESHOLD = 0.1;
+export const MULTI_FINGER_PAN_MAX_ROTATION_THRESHOLD = 7;
+export const DEG_RAD = Math.PI / 180;
+// Map Hammer values to RNGH
+export const EventMap = {
+    [Hammer.INPUT_START]: State.BEGAN,
+    [Hammer.INPUT_MOVE]: State.ACTIVE,
+    [Hammer.INPUT_END]: State.END,
+    [Hammer.INPUT_CANCEL]: State.FAILED,
+};
+export const Direction = {
+    RIGHT: 1,
+    LEFT: 2,
+    UP: 4,
+    DOWN: 8,
+};
+export const DirectionMap = {
+    [Hammer.DIRECTION_RIGHT]: Direction.RIGHT,
+    [Hammer.DIRECTION_LEFT]: Direction.LEFT,
+    [Hammer.DIRECTION_UP]: Direction.UP,
+    [Hammer.DIRECTION_DOWN]: Direction.DOWN,
+};
+export const HammerInputNames = {
+    [Hammer.INPUT_START]: 'START',
+    [Hammer.INPUT_MOVE]: 'MOVE',
+    [Hammer.INPUT_END]: 'END',
+    [Hammer.INPUT_CANCEL]: 'CANCEL',
+};
+export const HammerDirectionNames = {
+    [Hammer.DIRECTION_HORIZONTAL]: 'HORIZONTAL',
+    [Hammer.DIRECTION_UP]: 'UP',
+    [Hammer.DIRECTION_DOWN]: 'DOWN',
+    [Hammer.DIRECTION_VERTICAL]: 'VERTICAL',
+    [Hammer.DIRECTION_NONE]: 'NONE',
+    [Hammer.DIRECTION_ALL]: 'ALL',
+    [Hammer.DIRECTION_RIGHT]: 'RIGHT',
+    [Hammer.DIRECTION_LEFT]: 'LEFT',
+};

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

@@ -0,0 +1,9 @@
+export declare const isnan: (v: unknown) => boolean;
+export declare const isValidNumber: (v: unknown) => boolean;
+export declare const TEST_MIN_IF_NOT_NAN: (value: number, limit: number) => boolean;
+export declare const VEC_LEN_SQ: ({ x, y }?: {
+    x?: number | undefined;
+    y?: number | undefined;
+}) => number;
+export declare const TEST_MAX_IF_NOT_NAN: (value: number, max: number) => boolean;
+export declare function fireAfterInterval(method: () => void, interval?: number | boolean): number | null;

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/web_hammer/utils.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,KAAK,GAAI,GAAG,OAAO,YAAoB,CAAC;AAGrD,eAAO,MAAM,aAAa,GAAI,GAAG,OAAO,YACG,CAAC;AAE5C,eAAO,MAAM,mBAAmB,GAAI,OAAO,MAAM,EAAE,OAAO,MAAM,KAAG,OAEA,CAAC;AACpE,eAAO,MAAM,UAAU,GAAI;;;CAAqB,WAAkB,CAAC;AACnE,eAAO,MAAM,mBAAmB,GAAI,OAAO,MAAM,EAAE,KAAK,MAAM,YACU,CAAC;AAEzE,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,MAAM,IAAI,EAClB,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,iBAO5B"}

package/lib/typescript/web_hammer/utils.js

@@ -0,0 +1,15 @@
+// TODO(TS) remove if not necessary after rewrite
+export const isnan = (v) => Number.isNaN(v);
+// TODO(TS) remove if not necessary after rewrite
+export const isValidNumber = (v) => typeof v === 'number' && !Number.isNaN(v);
+export const TEST_MIN_IF_NOT_NAN = (value, limit) => !isnan(limit) &&
+    ((limit < 0 && value <= limit) || (limit >= 0 && value >= limit));
+export const VEC_LEN_SQ = ({ x = 0, y = 0 } = {}) => x * x + y * y;
+export const TEST_MAX_IF_NOT_NAN = (value, max) => !isnan(max) && ((max < 0 && value < max) || (max >= 0 && value > max));
+export function fireAfterInterval(method, interval) {
+    if (!interval) {
+        method();
+        return null;
+    }
+    return setTimeout(() => method(), interval);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-gesture-handler",
-  "version": "2.27.0",
+  "version": "2.27.1",
   "description": "Declarative API exposing native platform touch and gesture system to React Native",
   "scripts": {
     "test": "jest",