react-native-gesture-handler 2.27.1 → 2.27.2

package/lib/typescript/utils.js

@@ -1,80 +0,0 @@
-import React from 'react';
-export function toArray(object) {
-    if (!Array.isArray(object)) {
-        return [object];
-    }
-    return object;
-}
-export function withPrevAndCurrent(array, mapFn) {
-    const previousArr = [null];
-    const currentArr = [...array];
-    const transformedArr = [];
-    currentArr.forEach((current, i) => {
-        // This type cast is fine and solves problem mentioned in https://github.com/software-mansion/react-native-gesture-handler/pull/2867 (namely that `previous` can be undefined).
-        // Unfortunately, linter on our CI does not allow this type of casting as it is unnecessary. To bypass that we use eslint-disable.
-        // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
-        const previous = previousArr[i];
-        const transformed = mapFn(previous, current);
-        previousArr.push(transformed);
-        transformedArr.push(transformed);
-    });
-    return transformedArr;
-}
-export function hasProperty(object, key) {
-    return Object.prototype.hasOwnProperty.call(object, key);
-}
-export function isTestEnv() {
-    // @ts-ignore Do not use `@types/node` because it will prioritise Node types over RN types which breaks the types (ex. setTimeout) in React Native projects.
-    return hasProperty(global, 'process') && process.env.NODE_ENV === 'test';
-}
-export function tagMessage(msg) {
-    return `[react-native-gesture-handler] ${msg}`;
-}
-// Helper method to check whether Fabric is enabled, however global.nativeFabricUIManager
-// may not be initialized before the first render
-export function isFabric() {
-    // @ts-expect-error nativeFabricUIManager is not yet included in the RN types
-    return !!global?.nativeFabricUIManager;
-}
-export function isReact19() {
-    return React.version.startsWith('19.');
-}
-export function isRemoteDebuggingEnabled() {
-    // react-native-reanimated checks if in remote debugging in the same way
-    // @ts-ignore global is available but node types are not included
-    const localGlobal = global;
-    return ((!localGlobal.nativeCallSyncHook || !!localGlobal.__REMOTEDEV__) &&
-        !localGlobal.RN$Bridgeless);
-}
-/**
- * Recursively compares two objects for deep equality.
- *
- * **Note:** This function does not support cyclic references.
- *
- * @param obj1 - The first object to compare.
- * @param obj2 - The second object to compare.
- * @returns `true` if the objects are deeply equal, `false` otherwise.
- */
-export function deepEqual(obj1, obj2) {
-    if (obj1 === obj2) {
-        return true;
-    }
-    if (typeof obj1 !== 'object' ||
-        typeof obj2 !== 'object' ||
-        obj1 === null ||
-        obj2 === null) {
-        return false;
-    }
-    const keys1 = Object.keys(obj1);
-    const keys2 = Object.keys(obj2);
-    if (keys1.length !== keys2.length) {
-        return false;
-    }
-    for (const key of keys1) {
-        if (!keys2.includes(key) || !deepEqual(obj1[key], obj2[key])) {
-            return false;
-        }
-    }
-    return true;
-}
-export const INT32_MAX = 2 ** 31 - 1;

package/lib/typescript/web/Gestures.js

@@ -1,38 +0,0 @@
-// Gesture Handlers
-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';
-// Hammer Handlers
-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 const Gestures = {
-    NativeViewGestureHandler,
-    PanGestureHandler,
-    TapGestureHandler,
-    LongPressGestureHandler,
-    PinchGestureHandler,
-    RotationGestureHandler,
-    FlingGestureHandler,
-    ManualGestureHandler,
-    HoverGestureHandler,
-};
-export const HammerGestures = {
-    NativeViewGestureHandler: HammerNativeViewGestureHandler,
-    PanGestureHandler: HammerPanGestureHandler,
-    TapGestureHandler: HammerTapGestureHandler,
-    LongPressGestureHandler: HammerLongPressGestureHandler,
-    PinchGestureHandler: HammerPinchGestureHandler,
-    RotationGestureHandler: HammerRotationGestureHandler,
-    FlingGestureHandler: HammerFlingGestureHandler,
-};

package/lib/typescript/web/constants.js

@@ -1,2 +0,0 @@
-export const DEFAULT_TOUCH_SLOP = 15;
-export const MINIMAL_RECOGNIZABLE_MAGNITUDE = 0.1;

package/lib/typescript/web/detectors/RotationGestureDetector.js

@@ -1,122 +0,0 @@
-import { EventTypes } from '../interfaces';
-export default class RotationGestureDetector {
-    onRotationBegin;
-    onRotation;
-    onRotationEnd;
-    currentTime = 0;
-    previousTime = 0;
-    previousAngle = 0;
-    _rotation = 0;
-    _anchorX = 0;
-    _anchorY = 0;
-    isInProgress = false;
-    keyPointers = [NaN, NaN];
-    constructor(callbacks) {
-        this.onRotationBegin = callbacks.onRotationBegin;
-        this.onRotation = callbacks.onRotation;
-        this.onRotationEnd = callbacks.onRotationEnd;
-    }
-    updateCurrent(event, tracker) {
-        this.previousTime = this.currentTime;
-        this.currentTime = event.time;
-        const [firstPointerID, secondPointerID] = this.keyPointers;
-        const firstPointerCoords = tracker.getLastAbsoluteCoords(firstPointerID);
-        const secondPointerCoords = tracker.getLastAbsoluteCoords(secondPointerID);
-        if (!firstPointerCoords || !secondPointerCoords) {
-            return;
-        }
-        const vectorX = secondPointerCoords.x - firstPointerCoords.x;
-        const vectorY = secondPointerCoords.y - firstPointerCoords.y;
-        this._anchorX = (firstPointerCoords.x + secondPointerCoords.x) / 2;
-        this._anchorY = (firstPointerCoords.y + secondPointerCoords.y) / 2;
-        // Angle diff should be positive when rotating in clockwise direction
-        const angle = -Math.atan2(vectorY, vectorX);
-        this._rotation = Number.isNaN(this.previousAngle)
-            ? 0
-            : this.previousAngle - angle;
-        this.previousAngle = angle;
-        if (this.rotation > Math.PI) {
-            this._rotation -= Math.PI;
-        }
-        else if (this.rotation < -Math.PI) {
-            this._rotation += Math.PI;
-        }
-        if (this.rotation > Math.PI / 2) {
-            this._rotation -= Math.PI;
-        }
-        else if (this.rotation < -Math.PI / 2) {
-            this._rotation += Math.PI;
-        }
-    }
-    finish() {
-        if (!this.isInProgress) {
-            return;
-        }
-        this.isInProgress = false;
-        this.keyPointers = [NaN, NaN];
-        this.onRotationEnd(this);
-    }
-    setKeyPointers(tracker) {
-        if (this.keyPointers[0] && this.keyPointers[1]) {
-            return;
-        }
-        const pointerIDs = tracker.trackedPointers.keys();
-        this.keyPointers[0] = pointerIDs.next().value;
-        this.keyPointers[1] = pointerIDs.next().value;
-    }
-    onTouchEvent(event, tracker) {
-        switch (event.eventType) {
-            case EventTypes.DOWN:
-                this.isInProgress = false;
-                break;
-            case EventTypes.ADDITIONAL_POINTER_DOWN:
-                if (this.isInProgress) {
-                    break;
-                }
-                this.isInProgress = true;
-                this.previousTime = event.time;
-                this.previousAngle = NaN;
-                this.setKeyPointers(tracker);
-                this.updateCurrent(event, tracker);
-                this.onRotationBegin(this);
-                break;
-            case EventTypes.MOVE:
-                if (!this.isInProgress) {
-                    break;
-                }
-                this.updateCurrent(event, tracker);
-                this.onRotation(this);
-                break;
-            case EventTypes.ADDITIONAL_POINTER_UP:
-                if (!this.isInProgress) {
-                    break;
-                }
-                if (this.keyPointers.indexOf(event.pointerId) >= 0) {
-                    this.finish();
-                }
-                break;
-            case EventTypes.UP:
-                if (this.isInProgress) {
-                    this.finish();
-                }
-                break;
-        }
-        return true;
-    }
-    reset() {
-        this.keyPointers = [NaN, NaN];
-        this.isInProgress = false;
-    }
-    get anchorX() {
-        return this._anchorX;
-    }
-    get anchorY() {
-        return this._anchorY;
-    }
-    get rotation() {
-        return this._rotation;
-    }
-    get timeDelta() {
-        return this.currentTime + this.previousTime;
-    }
-}

package/lib/typescript/web/detectors/ScaleGestureDetector.js

@@ -1,117 +0,0 @@
-import { DEFAULT_TOUCH_SLOP } from '../constants';
-import { EventTypes } from '../interfaces';
-export default class ScaleGestureDetector {
-    onScaleBegin;
-    onScale;
-    onScaleEnd;
-    _focusX;
-    _focusY;
-    _currentSpan;
-    prevSpan;
-    initialSpan;
-    currentTime;
-    prevTime;
-    inProgress = false;
-    spanSlop;
-    minSpan;
-    constructor(callbacks) {
-        this.onScaleBegin = callbacks.onScaleBegin;
-        this.onScale = callbacks.onScale;
-        this.onScaleEnd = callbacks.onScaleEnd;
-        this.spanSlop = DEFAULT_TOUCH_SLOP * 2;
-        this.minSpan = 0;
-    }
-    onTouchEvent(event, tracker) {
-        this.currentTime = event.time;
-        const action = event.eventType;
-        const numOfPointers = tracker.trackedPointersCount;
-        const streamComplete = action === EventTypes.UP ||
-            action === EventTypes.ADDITIONAL_POINTER_UP ||
-            action === EventTypes.CANCEL;
-        if (action === EventTypes.DOWN || streamComplete) {
-            if (this.inProgress) {
-                this.onScaleEnd(this);
-                this.inProgress = false;
-                this.initialSpan = 0;
-            }
-            if (streamComplete) {
-                return true;
-            }
-        }
-        const configChanged = action === EventTypes.DOWN ||
-            action === EventTypes.ADDITIONAL_POINTER_UP ||
-            action === EventTypes.ADDITIONAL_POINTER_DOWN;
-        const pointerUp = action === EventTypes.ADDITIONAL_POINTER_UP;
-        const ignoredPointer = pointerUp
-            ? event.pointerId
-            : undefined;
-        // Determine focal point
-        const div = pointerUp ? numOfPointers - 1 : numOfPointers;
-        const coordsSum = tracker.getAbsoluteCoordsSum();
-        const focusX = coordsSum.x / div;
-        const focusY = coordsSum.y / div;
-        // Determine average deviation from focal point
-        let devSumX = 0;
-        let devSumY = 0;
-        tracker.trackedPointers.forEach((value, key) => {
-            if (key === ignoredPointer) {
-                return;
-            }
-            devSumX += Math.abs(value.abosoluteCoords.x - focusX);
-            devSumY += Math.abs(value.abosoluteCoords.y - focusY);
-        });
-        const devX = devSumX / div;
-        const devY = devSumY / div;
-        const spanX = devX * 2;
-        const spanY = devY * 2;
-        const span = Math.hypot(spanX, spanY);
-        // Begin/end events
-        const wasInProgress = this.inProgress;
-        this._focusX = focusX;
-        this._focusY = focusY;
-        if (this.inProgress && (span < this.minSpan || configChanged)) {
-            this.onScaleEnd(this);
-            this.inProgress = false;
-            this.initialSpan = span;
-        }
-        if (configChanged) {
-            this.initialSpan = this.prevSpan = this._currentSpan = span;
-        }
-        if (!this.inProgress &&
-            span >= this.minSpan &&
-            (wasInProgress || Math.abs(span - this.initialSpan) > this.spanSlop)) {
-            this.prevSpan = this._currentSpan = span;
-            this.prevTime = this.currentTime;
-            this.inProgress = this.onScaleBegin(this);
-        }
-        // Handle motion
-        if (action !== EventTypes.MOVE) {
-            return true;
-        }
-        this._currentSpan = span;
-        if (this.inProgress && !this.onScale(this)) {
-            return true;
-        }
-        this.prevSpan = this.currentSpan;
-        this.prevTime = this.currentTime;
-        return true;
-    }
-    calculateScaleFactor(numOfPointers) {
-        if (numOfPointers < 2) {
-            return 1;
-        }
-        return this.prevSpan > 0 ? this.currentSpan / this.prevSpan : 1;
-    }
-    get currentSpan() {
-        return this._currentSpan;
-    }
-    get focusX() {
-        return this._focusX;
-    }
-    get focusY() {
-        return this._focusY;
-    }
-    get timeDelta() {
-        return this.currentTime - this.prevTime;
-    }
-}

package/lib/typescript/web/handlers/FlingGestureHandler.js

@@ -1,133 +0,0 @@
-import { State } from '../../State';
-import { DiagonalDirections, Directions } from '../../Directions';
-import GestureHandler from './GestureHandler';
-import Vector from '../tools/Vector';
-import { coneToDeviation } from '../utils';
-const DEFAULT_MAX_DURATION_MS = 800;
-const DEFAULT_MIN_VELOCITY = 700;
-const DEFAULT_ALIGNMENT_CONE = 30;
-const DEFAULT_DIRECTION = Directions.RIGHT;
-const DEFAULT_NUMBER_OF_TOUCHES_REQUIRED = 1;
-const AXIAL_DEVIATION_COSINE = coneToDeviation(DEFAULT_ALIGNMENT_CONE);
-const DIAGONAL_DEVIATION_COSINE = coneToDeviation(90 - DEFAULT_ALIGNMENT_CONE);
-export default class FlingGestureHandler extends GestureHandler {
-    numberOfPointersRequired = DEFAULT_NUMBER_OF_TOUCHES_REQUIRED;
-    direction = DEFAULT_DIRECTION;
-    maxDurationMs = DEFAULT_MAX_DURATION_MS;
-    minVelocity = DEFAULT_MIN_VELOCITY;
-    delayTimeout;
-    maxNumberOfPointersSimultaneously = 0;
-    keyPointer = NaN;
-    updateGestureConfig({ enabled = true, ...props }) {
-        super.updateGestureConfig({ enabled: enabled, ...props });
-        if (this.config.direction) {
-            this.direction = this.config.direction;
-        }
-        if (this.config.numberOfPointers) {
-            this.numberOfPointersRequired = this.config.numberOfPointers;
-        }
-    }
-    startFling() {
-        this.begin();
-        this.maxNumberOfPointersSimultaneously = 1;
-        this.delayTimeout = setTimeout(() => this.fail(), this.maxDurationMs);
-    }
-    tryEndFling() {
-        const velocityVector = Vector.fromVelocity(this.tracker, this.keyPointer);
-        if (!velocityVector) {
-            return false;
-        }
-        const getAlignment = (direction, minimalAlignmentCosine) => {
-            return ((direction & this.direction) === direction &&
-                velocityVector.isSimilar(Vector.fromDirection(direction), minimalAlignmentCosine));
-        };
-        const axialDirectionsList = Object.values(Directions);
-        const diagonalDirectionsList = Object.values(DiagonalDirections);
-        // List of alignments to all activated directions
-        const axialAlignmentList = axialDirectionsList.map((direction) => getAlignment(direction, AXIAL_DEVIATION_COSINE));
-        const diagonalAlignmentList = diagonalDirectionsList.map((direction) => getAlignment(direction, DIAGONAL_DEVIATION_COSINE));
-        const isAligned = axialAlignmentList.some(Boolean) || diagonalAlignmentList.some(Boolean);
-        const isFast = velocityVector.magnitude > this.minVelocity;
-        if (this.maxNumberOfPointersSimultaneously ===
-            this.numberOfPointersRequired &&
-            isAligned &&
-            isFast) {
-            clearTimeout(this.delayTimeout);
-            this.activate();
-            return true;
-        }
-        return false;
-    }
-    endFling() {
-        if (!this.tryEndFling()) {
-            this.fail();
-        }
-    }
-    onPointerDown(event) {
-        if (!this.isButtonInConfig(event.button)) {
-            return;
-        }
-        this.tracker.addToTracker(event);
-        this.keyPointer = event.pointerId;
-        super.onPointerDown(event);
-        this.newPointerAction();
-        this.tryToSendTouchEvent(event);
-    }
-    onPointerAdd(event) {
-        this.tracker.addToTracker(event);
-        super.onPointerAdd(event);
-        this.newPointerAction();
-    }
-    newPointerAction() {
-        if (this.state === State.UNDETERMINED) {
-            this.startFling();
-        }
-        if (this.state !== State.BEGAN) {
-            return;
-        }
-        this.tryEndFling();
-        if (this.tracker.trackedPointersCount > this.maxNumberOfPointersSimultaneously) {
-            this.maxNumberOfPointersSimultaneously =
-                this.tracker.trackedPointersCount;
-        }
-    }
-    pointerMoveAction(event) {
-        this.tracker.track(event);
-        if (this.state !== State.BEGAN) {
-            return;
-        }
-        this.tryEndFling();
-    }
-    onPointerMove(event) {
-        this.pointerMoveAction(event);
-        super.onPointerMove(event);
-    }
-    onPointerOutOfBounds(event) {
-        this.pointerMoveAction(event);
-        super.onPointerOutOfBounds(event);
-    }
-    onPointerUp(event) {
-        super.onPointerUp(event);
-        this.onUp(event);
-        this.keyPointer = NaN;
-    }
-    onPointerRemove(event) {
-        super.onPointerRemove(event);
-        this.onUp(event);
-    }
-    onUp(event) {
-        if (this.state === State.BEGAN) {
-            this.endFling();
-        }
-        this.tracker.removeFromTracker(event.pointerId);
-    }
-    activate(force) {
-        super.activate(force);
-        this.end();
-    }
-    resetConfig() {
-        super.resetConfig();
-        this.numberOfPointersRequired = DEFAULT_NUMBER_OF_TOUCHES_REQUIRED;
-        this.direction = DEFAULT_DIRECTION;
-    }
-}