react-native-gesture-handler 2.27.0 → 2.27.1

package/lib/typescript/web/tools/PointerTracker.js

@@ -0,0 +1,161 @@
+import VelocityTracker from './VelocityTracker';
+const MAX_POINTERS = 20;
+export default class PointerTracker {
+    velocityTracker = new VelocityTracker();
+    _trackedPointers = new Map();
+    touchEventsIds = new Map();
+    lastMovedPointerId;
+    cachedAbsoluteAverages = { x: 0, y: 0 };
+    cachedRelativeAverages = { x: 0, y: 0 };
+    constructor() {
+        this.lastMovedPointerId = NaN;
+        for (let i = 0; i < MAX_POINTERS; ++i) {
+            this.touchEventsIds.set(i, NaN);
+        }
+    }
+    addToTracker(event) {
+        if (this.trackedPointers.has(event.pointerId)) {
+            return;
+        }
+        this.lastMovedPointerId = event.pointerId;
+        const newElement = {
+            abosoluteCoords: { x: event.x, y: event.y },
+            relativeCoords: { x: event.offsetX, y: event.offsetY },
+            timestamp: event.time,
+            velocityX: 0,
+            velocityY: 0,
+        };
+        this.trackedPointers.set(event.pointerId, newElement);
+        this.mapTouchEventId(event.pointerId);
+        this.cachedAbsoluteAverages = this.getAbsoluteCoordsAverage();
+        this.cachedRelativeAverages = this.getRelativeCoordsAverage();
+    }
+    removeFromTracker(pointerId) {
+        this.trackedPointers.delete(pointerId);
+        this.removeMappedTouchId(pointerId);
+    }
+    track(event) {
+        const pointerData = this.trackedPointers.get(event.pointerId);
+        if (!pointerData) {
+            return;
+        }
+        this.lastMovedPointerId = event.pointerId;
+        this.velocityTracker.add(event);
+        const [velocityX, velocityY] = this.velocityTracker.velocity;
+        pointerData.velocityX = velocityX;
+        pointerData.velocityY = velocityY;
+        pointerData.abosoluteCoords = { x: event.x, y: event.y };
+        pointerData.relativeCoords = { x: event.offsetX, y: event.offsetY };
+        this.trackedPointers.set(event.pointerId, pointerData);
+        this.cachedAbsoluteAverages = this.getAbsoluteCoordsAverage();
+        this.cachedRelativeAverages = this.getRelativeCoordsAverage();
+    }
+    // Mapping TouchEvents ID
+    mapTouchEventId(id) {
+        for (const [mappedId, touchId] of this.touchEventsIds) {
+            if (isNaN(touchId)) {
+                this.touchEventsIds.set(mappedId, id);
+                break;
+            }
+        }
+    }
+    removeMappedTouchId(id) {
+        const mappedId = this.getMappedTouchEventId(id);
+        if (!isNaN(mappedId)) {
+            this.touchEventsIds.set(mappedId, NaN);
+        }
+    }
+    getMappedTouchEventId(touchEventId) {
+        for (const [key, value] of this.touchEventsIds.entries()) {
+            if (value === touchEventId) {
+                return key;
+            }
+        }
+        return NaN;
+    }
+    getVelocity(pointerId) {
+        const pointerData = this.trackedPointers.get(pointerId);
+        return pointerData
+            ? {
+                x: pointerData.velocityX,
+                y: pointerData.velocityY,
+            }
+            : null;
+    }
+    getLastAbsoluteCoords(pointerId) {
+        return this.trackedPointers.get(pointerId ?? this.lastMovedPointerId)
+            ?.abosoluteCoords;
+    }
+    getLastRelativeCoords(pointerId) {
+        return this.trackedPointers.get(pointerId ?? this.lastMovedPointerId)
+            ?.relativeCoords;
+    }
+    // Some handlers use these methods to send average values in native event.
+    // This may happen when pointers have already been removed from tracker (i.e. pointerup event).
+    // In situation when NaN would be sent as a response, we return cached value.
+    // That prevents handlers from crashing
+    getAbsoluteCoordsAverage() {
+        const coordsSum = this.getAbsoluteCoordsSum();
+        const avgX = coordsSum.x / this.trackedPointers.size;
+        const avgY = coordsSum.y / this.trackedPointers.size;
+        const averages = {
+            x: isNaN(avgX) ? this.cachedAbsoluteAverages.x : avgX,
+            y: isNaN(avgY) ? this.cachedAbsoluteAverages.y : avgY,
+        };
+        return averages;
+    }
+    getRelativeCoordsAverage() {
+        const coordsSum = this.getRelativeCoordsSum();
+        const avgX = coordsSum.x / this.trackedPointers.size;
+        const avgY = coordsSum.y / this.trackedPointers.size;
+        const averages = {
+            x: isNaN(avgX) ? this.cachedRelativeAverages.x : avgX,
+            y: isNaN(avgY) ? this.cachedRelativeAverages.y : avgY,
+        };
+        return averages;
+    }
+    getAbsoluteCoordsSum(ignoredPointer) {
+        const sum = { x: 0, y: 0 };
+        this.trackedPointers.forEach((value, key) => {
+            if (key !== ignoredPointer) {
+                sum.x += value.abosoluteCoords.x;
+                sum.y += value.abosoluteCoords.y;
+            }
+        });
+        return sum;
+    }
+    getRelativeCoordsSum(ignoredPointer) {
+        const sum = { x: 0, y: 0 };
+        this.trackedPointers.forEach((value, key) => {
+            if (key !== ignoredPointer) {
+                sum.x += value.relativeCoords.x;
+                sum.y += value.relativeCoords.y;
+            }
+        });
+        return sum;
+    }
+    resetTracker() {
+        this.velocityTracker.reset();
+        this.trackedPointers.clear();
+        this.lastMovedPointerId = NaN;
+        for (let i = 0; i < MAX_POINTERS; ++i) {
+            this.touchEventsIds.set(i, NaN);
+        }
+    }
+    static shareCommonPointers(stPointers, ndPointers) {
+        return stPointers.some((pointerId) => ndPointers.includes(pointerId));
+    }
+    get trackedPointersCount() {
+        return this.trackedPointers.size;
+    }
+    get trackedPointersIDs() {
+        const keys = [];
+        this.trackedPointers.forEach((_value, key) => {
+            keys.push(key);
+        });
+        return keys;
+    }
+    get trackedPointers() {
+        return this._trackedPointers;
+    }
+}

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

@@ -0,0 +1,15 @@
+import { DiagonalDirections, Directions } from '../../Directions';
+import PointerTracker from './PointerTracker';
+export default class Vector {
+    private readonly x;
+    private readonly y;
+    private readonly unitX;
+    private readonly unitY;
+    private readonly _magnitude;
+    constructor(x: number, y: number);
+    static fromDirection(direction: Directions | DiagonalDirections): Vector;
+    static fromVelocity(tracker: PointerTracker, pointerId: number): Vector | null;
+    get magnitude(): number;
+    computeSimilarity(vector: Vector): number;
+    isSimilar(vector: Vector, threshold: number): boolean;
+}

package/lib/typescript/web/tools/Vector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Vector.d.ts","sourceRoot":"","sources":["../../../../src/web/tools/Vector.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAElE,OAAO,cAAc,MAAM,kBAAkB,CAAC;AAE9C,MAAM,CAAC,OAAO,OAAO,MAAM;IACzB,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC;IACnB,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC;IACnB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC;IACvB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC;IACvB,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAC;gBAEhB,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM;IAYhC,MAAM,CAAC,aAAa,CAAC,SAAS,EAAE,UAAU,GAAG,kBAAkB,GAAG,MAAM;IAIxE,MAAM,CAAC,YAAY,CAAC,OAAO,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM;IAK9D,IAAW,SAAS,WAEnB;IAED,iBAAiB,CAAC,MAAM,EAAE,MAAM;IAIhC,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;CAG5C"}

package/lib/typescript/web/tools/Vector.js

@@ -0,0 +1,43 @@
+import { DiagonalDirections, Directions } from '../../Directions';
+import { MINIMAL_RECOGNIZABLE_MAGNITUDE } from '../constants';
+export default class Vector {
+    x;
+    y;
+    unitX;
+    unitY;
+    _magnitude;
+    constructor(x, y) {
+        this.x = x;
+        this.y = y;
+        this._magnitude = Math.hypot(this.x, this.y);
+        const isMagnitudeSufficient = this._magnitude > MINIMAL_RECOGNIZABLE_MAGNITUDE;
+        this.unitX = isMagnitudeSufficient ? this.x / this._magnitude : 0;
+        this.unitY = isMagnitudeSufficient ? this.y / this._magnitude : 0;
+    }
+    static fromDirection(direction) {
+        return DirectionToVectorMappings.get(direction) ?? new Vector(0, 0);
+    }
+    static fromVelocity(tracker, pointerId) {
+        const velocity = tracker.getVelocity(pointerId);
+        return velocity ? new Vector(velocity.x, velocity.y) : null;
+    }
+    get magnitude() {
+        return this._magnitude;
+    }
+    computeSimilarity(vector) {
+        return this.unitX * vector.unitX + this.unitY * vector.unitY;
+    }
+    isSimilar(vector, threshold) {
+        return this.computeSimilarity(vector) > threshold;
+    }
+}
+const DirectionToVectorMappings = new Map([
+    [Directions.LEFT, new Vector(-1, 0)],
+    [Directions.RIGHT, new Vector(1, 0)],
+    [Directions.UP, new Vector(0, -1)],
+    [Directions.DOWN, new Vector(0, 1)],
+    [DiagonalDirections.UP_RIGHT, new Vector(1, -1)],
+    [DiagonalDirections.DOWN_RIGHT, new Vector(1, 1)],
+    [DiagonalDirections.UP_LEFT, new Vector(-1, -1)],
+    [DiagonalDirections.DOWN_LEFT, new Vector(-1, 1)],
+]);

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;
+    get velocity(): [number, number];
+    reset(): void;
+}

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

@@ -0,0 +1 @@
+{"version":3,"file":"VelocityTracker.d.ts","sourceRoot":"","sources":["../../../../src/web/tools/VelocityTracker.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAI7C,MAAM,CAAC,OAAO,OAAO,eAAe;IAClC,OAAO,CAAC,oCAAoC,CAAM;IAClD,OAAO,CAAC,WAAW,CAAM;IACzB,OAAO,CAAC,mBAAmB,CAAO;IAClC,OAAO,CAAC,aAAa,CAAK;IAE1B,OAAO,CAAC,OAAO,CAA+B;;IAMvC,GAAG,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI;IAUrC,OAAO,CAAC,mBAAmB;IA4D3B,IAAW,QAAQ,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC,CAMtC;IAEM,KAAK,IAAI,IAAI;CAGrB"}

package/lib/typescript/web/tools/VelocityTracker.js

@@ -0,0 +1,76 @@
+import CircularBuffer from './CircularBuffer';
+import LeastSquareSolver from './LeastSquareSolver';
+export default class VelocityTracker {
+    assumePointerMoveStoppedMilliseconds = 40;
+    historySize = 20;
+    horizonMilliseconds = 300;
+    minSampleSize = 3;
+    samples;
+    constructor() {
+        this.samples = new CircularBuffer(this.historySize);
+    }
+    add(event) {
+        this.samples.push(event);
+    }
+    // Returns an estimate of the velocity of the object being tracked by the
+    // tracker given the current information available to the tracker.
+    //
+    // Information is added using [addPosition].
+    //
+    // Returns null if there is no data on which to base an estimate.
+    getVelocityEstimate() {
+        const x = [];
+        const y = [];
+        const w = [];
+        const time = [];
+        let sampleCount = 0;
+        let index = this.samples.size - 1;
+        const newestSample = this.samples.get(index);
+        if (!newestSample) {
+            return null;
+        }
+        let previousSample = newestSample;
+        // Starting with the most recent PointAtTime sample, iterate backwards while
+        // the samples represent continuous motion.
+        while (sampleCount < this.samples.size) {
+            const sample = this.samples.get(index);
+            const age = newestSample.time - sample.time;
+            const delta = Math.abs(sample.time - previousSample.time);
+            previousSample = sample;
+            if (age > this.horizonMilliseconds ||
+                delta > this.assumePointerMoveStoppedMilliseconds) {
+                break;
+            }
+            x.push(sample.x);
+            y.push(sample.y);
+            w.push(1);
+            time.push(-age);
+            sampleCount++;
+            index--;
+        }
+        if (sampleCount >= this.minSampleSize) {
+            const xSolver = new LeastSquareSolver(time, x, w);
+            const xFit = xSolver.solve(2);
+            if (xFit !== null) {
+                const ySolver = new LeastSquareSolver(time, y, w);
+                const yFit = ySolver.solve(2);
+                if (yFit !== null) {
+                    const xVelocity = xFit.coefficients[1] * 1000;
+                    const yVelocity = yFit.coefficients[1] * 1000;
+                    return [xVelocity, yVelocity];
+                }
+            }
+        }
+        return null;
+    }
+    get velocity() {
+        const estimate = this.getVelocityEstimate();
+        if (estimate !== null) {
+            return estimate;
+        }
+        return [0, 0];
+    }
+    reset() {
+        this.samples.clear();
+    }
+}

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

@@ -0,0 +1,11 @@
+import EventManager from './EventManager';
+import { AdaptedEvent } from '../interfaces';
+export default class WheelEventManager extends EventManager<HTMLElement> {
+    private wheelDelta;
+    private resetDelta;
+    private wheelCallback;
+    registerListeners(): void;
+    unregisterListeners(): void;
+    protected mapEvent(event: WheelEvent): AdaptedEvent;
+    resetManager(): void;
+}

package/lib/typescript/web/tools/WheelEventManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WheelEventManager.d.ts","sourceRoot":"","sources":["../../../../src/web/tools/WheelEventManager.ts"],"names":[],"mappings":"AAAA,OAAO,YAAY,MAAM,gBAAgB,CAAC;AAC1C,OAAO,EAAE,YAAY,EAAc,MAAM,eAAe,CAAC;AAGzD,MAAM,CAAC,OAAO,OAAO,iBAAkB,SAAQ,YAAY,CAAC,WAAW,CAAC;IACtE,OAAO,CAAC,UAAU,CAAkB;IAEpC,OAAO,CAAC,UAAU,CAEhB;IAEF,OAAO,CAAC,aAAa,CAMnB;IAEK,iBAAiB,IAAI,IAAI;IAKzB,mBAAmB,IAAI,IAAI;IAKlC,SAAS,CAAC,QAAQ,CAAC,KAAK,EAAE,UAAU,GAAG,YAAY;IAe5C,YAAY,IAAI,IAAI;CAG5B"}

package/lib/typescript/web/tools/WheelEventManager.js

@@ -0,0 +1,40 @@
+import EventManager from './EventManager';
+import { EventTypes } from '../interfaces';
+import { PointerType } from '../../PointerType';
+export default class WheelEventManager extends EventManager {
+    wheelDelta = { x: 0, y: 0 };
+    resetDelta = (_event) => {
+        this.wheelDelta = { x: 0, y: 0 };
+    };
+    wheelCallback = (event) => {
+        this.wheelDelta.x += event.deltaX;
+        this.wheelDelta.y += event.deltaY;
+        const adaptedEvent = this.mapEvent(event);
+        this.onWheel(adaptedEvent);
+    };
+    registerListeners() {
+        this.view.addEventListener('pointermove', this.resetDelta);
+        this.view.addEventListener('wheel', this.wheelCallback);
+    }
+    unregisterListeners() {
+        this.view.removeEventListener('pointermove', this.resetDelta);
+        this.view.removeEventListener('wheel', this.wheelCallback);
+    }
+    mapEvent(event) {
+        return {
+            x: event.clientX + this.wheelDelta.x,
+            y: event.clientY + this.wheelDelta.y,
+            offsetX: event.offsetX - event.deltaX,
+            offsetY: event.offsetY - event.deltaY,
+            pointerId: -1,
+            eventType: EventTypes.MOVE,
+            pointerType: PointerType.OTHER,
+            time: event.timeStamp,
+            // @ts-ignore It does exist, but it's deprecated
+            wheelDeltaY: event.wheelDeltaY,
+        };
+    }
+    resetManager() {
+        super.resetManager();
+    }
+}

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

@@ -0,0 +1,14 @@
+import { PointerType } from '../PointerType';
+import type { GestureHandlerRef, Point, StylusData, SVGRef } from './interfaces';
+export declare function isPointerInBounds(view: HTMLElement, { x, y }: Point): boolean;
+export declare const PointerTypeMapping: Map<string, PointerType>;
+export declare const degToRad: (degrees: number) => number;
+export declare const coneToDeviation: (degrees: number) => number;
+export declare function calculateViewScale(view: HTMLElement): {
+    scaleX: number;
+    scaleY: number;
+};
+export declare function tryExtractStylusData(event: PointerEvent): StylusData | undefined;
+export declare const RNSVGElements: Set<string>;
+export declare function isRNSVGElement(viewRef: SVGRef | GestureHandlerRef): boolean;
+export declare function isRNSVGNode(node: any): boolean;

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/web/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,KAAK,EACV,iBAAiB,EACjB,KAAK,EACL,UAAU,EACV,MAAM,EACP,MAAM,cAAc,CAAC;AAEtB,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,WAAW,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,KAAK,GAAG,OAAO,CAI7E;AAED,eAAO,MAAM,kBAAkB,0BAK7B,CAAC;AAEH,eAAO,MAAM,QAAQ,GAAI,SAAS,MAAM,WAA8B,CAAC;AAEvE,eAAO,MAAM,eAAe,GAAI,SAAS,MAAM,WACd,CAAC;AAElC,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,WAAW;;;EAkCnD;AAED,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,YAAY,GAClB,UAAU,GAAG,SAAS,CAsDxB;AAqHD,eAAO,MAAM,aAAa,aAqBxB,CAAC;AAWH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,iBAAiB,WAOjE;AAOD,wBAAgB,WAAW,CAAC,IAAI,EAAE,GAAG,WAWpC"}

package/lib/typescript/web/utils.js

@@ -0,0 +1,233 @@
+import { PointerType } from '../PointerType';
+export function isPointerInBounds(view, { x, y }) {
+    const rect = view.getBoundingClientRect();
+    return x >= rect.left && x <= rect.right && y >= rect.top && y <= rect.bottom;
+}
+export const PointerTypeMapping = new Map([
+    ['mouse', PointerType.MOUSE],
+    ['touch', PointerType.TOUCH],
+    ['pen', PointerType.STYLUS],
+    ['none', PointerType.OTHER],
+]);
+export const degToRad = (degrees) => (degrees * Math.PI) / 180;
+export const coneToDeviation = (degrees) => Math.cos(degToRad(degrees / 2));
+export function calculateViewScale(view) {
+    const styles = getComputedStyle(view);
+    const resultScales = {
+        scaleX: 1,
+        scaleY: 1,
+    };
+    // Get scales from scale property
+    if (styles.scale !== undefined && styles.scale !== 'none') {
+        const scales = styles.scale.split(' ');
+        if (scales[0]) {
+            resultScales.scaleX = parseFloat(scales[0]);
+        }
+        resultScales.scaleY = scales[1]
+            ? parseFloat(scales[1])
+            : parseFloat(scales[0]);
+    }
+    // Get scales from transform property
+    const matrixElements = new RegExp(/matrix\((.+)\)/).exec(styles.transform)?.[1];
+    if (matrixElements) {
+        const matrixElementsArray = matrixElements.split(', ');
+        resultScales.scaleX *= parseFloat(matrixElementsArray[0]);
+        resultScales.scaleY *= parseFloat(matrixElementsArray[3]);
+    }
+    return resultScales;
+}
+export function tryExtractStylusData(event) {
+    const pointerType = PointerTypeMapping.get(event.pointerType);
+    if (pointerType !== PointerType.STYLUS) {
+        return;
+    }
+    // @ts-ignore This property exists (https://developer.mozilla.org/en-US/docs/Web/API/PointerEvent#instance_properties)
+    const eventAzimuthAngle = event.azimuthAngle;
+    // @ts-ignore This property exists (https://developer.mozilla.org/en-US/docs/Web/API/PointerEvent#instance_properties)
+    const eventAltitudeAngle = event.altitudeAngle;
+    if (event.tiltX === 0 && event.tiltY === 0) {
+        // If we are in this branch, it means that either tilt properties are not supported and we have to calculate them from altitude and azimuth angles,
+        // or stylus is perpendicular to the screen and we can use altitude / azimuth instead of tilt
+        // If azimuth and altitude are undefined in this branch, it means that we are either perpendicular to the screen,
+        // or that none of the position sets is supported. In that case, we can treat stylus as perpendicular
+        if (eventAzimuthAngle === undefined || eventAltitudeAngle === undefined) {
+            return {
+                tiltX: 0,
+                tiltY: 0,
+                azimuthAngle: Math.PI / 2,
+                altitudeAngle: Math.PI / 2,
+                pressure: event.pressure,
+            };
+        }
+        const { tiltX, tiltY } = spherical2tilt(eventAltitudeAngle, eventAzimuthAngle);
+        return {
+            tiltX,
+            tiltY,
+            azimuthAngle: eventAzimuthAngle,
+            altitudeAngle: eventAltitudeAngle,
+            pressure: event.pressure,
+        };
+    }
+    const { altitudeAngle, azimuthAngle } = tilt2spherical(event.tiltX, event.tiltY);
+    return {
+        tiltX: event.tiltX,
+        tiltY: event.tiltY,
+        azimuthAngle,
+        altitudeAngle,
+        pressure: event.pressure,
+    };
+}
+// `altitudeAngle` and `azimuthAngle` are experimental properties, which are not supported on Firefox and Safari.
+// Given that, we use `tilt` properties and algorithm that converts one value to another.
+//
+// Source: https://w3c.github.io/pointerevents/#converting-between-tiltx-tilty-and-altitudeangle-azimuthangle
+function tilt2spherical(tiltX, tiltY) {
+    const tiltXrad = (tiltX * Math.PI) / 180;
+    const tiltYrad = (tiltY * Math.PI) / 180;
+    // calculate azimuth angle
+    let azimuthAngle = 0;
+    if (tiltX === 0) {
+        if (tiltY > 0) {
+            azimuthAngle = Math.PI / 2;
+        }
+        else if (tiltY < 0) {
+            azimuthAngle = (3 * Math.PI) / 2;
+        }
+    }
+    else if (tiltY === 0) {
+        if (tiltX < 0) {
+            azimuthAngle = Math.PI;
+        }
+    }
+    else if (Math.abs(tiltX) === 90 || Math.abs(tiltY) === 90) {
+        // not enough information to calculate azimuth
+        azimuthAngle = 0;
+    }
+    else {
+        // Non-boundary case: neither tiltX nor tiltY is equal to 0 or +-90
+        const tanX = Math.tan(tiltXrad);
+        const tanY = Math.tan(tiltYrad);
+        azimuthAngle = Math.atan2(tanY, tanX);
+        if (azimuthAngle < 0) {
+            azimuthAngle += 2 * Math.PI;
+        }
+    }
+    // calculate altitude angle
+    let altitudeAngle = 0;
+    if (Math.abs(tiltX) === 90 || Math.abs(tiltY) === 90) {
+        altitudeAngle = 0;
+    }
+    else if (tiltX === 0) {
+        altitudeAngle = Math.PI / 2 - Math.abs(tiltYrad);
+    }
+    else if (tiltY === 0) {
+        altitudeAngle = Math.PI / 2 - Math.abs(tiltXrad);
+    }
+    else {
+        // Non-boundary case: neither tiltX nor tiltY is equal to 0 or +-90
+        altitudeAngle = Math.atan(1.0 /
+            Math.sqrt(Math.pow(Math.tan(tiltXrad), 2) + Math.pow(Math.tan(tiltYrad), 2)));
+    }
+    return { altitudeAngle: altitudeAngle, azimuthAngle: azimuthAngle };
+}
+// If we are on a platform that doesn't support `tiltX` and `tiltY`, we have to calculate them from `altitude` and `azimuth` angles.
+//
+// Source: https://w3c.github.io/pointerevents/#converting-between-tiltx-tilty-and-altitudeangle-azimuthangle
+function spherical2tilt(altitudeAngle, azimuthAngle) {
+    const radToDeg = 180 / Math.PI;
+    let tiltXrad = 0;
+    let tiltYrad = 0;
+    if (altitudeAngle === 0) {
+        // the pen is in the X-Y plane
+        if (azimuthAngle === 0 || azimuthAngle === 2 * Math.PI) {
+            // pen is on positive X axis
+            tiltXrad = Math.PI / 2;
+        }
+        if (azimuthAngle === Math.PI / 2) {
+            // pen is on positive Y axis
+            tiltYrad = Math.PI / 2;
+        }
+        if (azimuthAngle === Math.PI) {
+            // pen is on negative X axis
+            tiltXrad = -Math.PI / 2;
+        }
+        if (azimuthAngle === (3 * Math.PI) / 2) {
+            // pen is on negative Y axis
+            tiltYrad = -Math.PI / 2;
+        }
+        if (azimuthAngle > 0 && azimuthAngle < Math.PI / 2) {
+            tiltXrad = Math.PI / 2;
+            tiltYrad = Math.PI / 2;
+        }
+        if (azimuthAngle > Math.PI / 2 && azimuthAngle < Math.PI) {
+            tiltXrad = -Math.PI / 2;
+            tiltYrad = Math.PI / 2;
+        }
+        if (azimuthAngle > Math.PI && azimuthAngle < (3 * Math.PI) / 2) {
+            tiltXrad = -Math.PI / 2;
+            tiltYrad = -Math.PI / 2;
+        }
+        if (azimuthAngle > (3 * Math.PI) / 2 && azimuthAngle < 2 * Math.PI) {
+            tiltXrad = Math.PI / 2;
+            tiltYrad = -Math.PI / 2;
+        }
+    }
+    if (altitudeAngle !== 0) {
+        const tanAlt = Math.tan(altitudeAngle);
+        tiltXrad = Math.atan(Math.cos(azimuthAngle) / tanAlt);
+        tiltYrad = Math.atan(Math.sin(azimuthAngle) / tanAlt);
+    }
+    const tiltX = Math.round(tiltXrad * radToDeg);
+    const tiltY = Math.round(tiltYrad * radToDeg);
+    return { tiltX, tiltY };
+}
+export const RNSVGElements = new Set([
+    'Circle',
+    'ClipPath',
+    'Ellipse',
+    'ForeignObject',
+    'G',
+    'Image',
+    'Line',
+    'Marker',
+    'Mask',
+    'Path',
+    'Pattern',
+    'Polygon',
+    'Polyline',
+    'Rect',
+    'Svg',
+    'Symbol',
+    'TSpan',
+    'Text',
+    'TextPath',
+    'Use',
+]);
+// This function helps us determine whether given node is SVGElement or not. In our implementation of
+// findNodeHandle, we can encounter such element in 2 forms - SVG tag or ref to SVG Element. Since Gesture Handler
+// does not depend on SVG, we use our simplified SVGRef type that has `elementRef` field. This is something that is present
+// in actual SVG ref object.
+//
+// In order to make sure that node passed into this function is in fact SVG element, first we check if its constructor name
+// corresponds to one of the possible SVG elements. Then we also check if `elementRef` field exists.
+// By doing both steps we decrease probability of detecting situations where, for example, user makes custom `Circle` and
+// we treat it as SVG.
+export function isRNSVGElement(viewRef) {
+    const componentClassName = Object.getPrototypeOf(viewRef).constructor.name;
+    return (RNSVGElements.has(componentClassName) &&
+        Object.hasOwn(viewRef, 'elementRef'));
+}
+// This function checks if given node is SVGElement. Unlike the function above, this one
+// operates on React Nodes, not DOM nodes.
+//
+// Second condition was introduced to handle case where SVG element was wrapped with
+// `createAnimatedComponent` from Reanimated.
+export function isRNSVGNode(node) {
+    // If `ref` has `rngh` field, it means that component comes from Gesture Handler. This is a special case for
+    // `Text` component, which is present in `RNSVGElements` set, yet we don't want to treat it as SVG.
+    if (node.ref?.rngh) {
+        return false;
+    }
+    return (Object.getPrototypeOf(node?.type)?.name === 'WebShape' ||
+        RNSVGElements.has(node?.type?.displayName));
+}

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

@@ -0,0 +1 @@
+{"version":3,"file":"DiscreteGestureHandler.d.ts","sourceRoot":"","sources":["../../../src/web_hammer/DiscreteGestureHandler.ts"],"names":[],"mappings":"AAEA,OAAO,cAAc,MAAM,kBAAkB,CAAC;AAG9C,uBAAe,sBAAuB,SAAQ,cAAc;IAC1D,IAAI,UAAU,YAEb;IAED,IAAI,0BAA0B,YAE7B;IAED,6BAA6B,CAC3B,EAAE,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,GAAG,EAC7B,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,uBAAuB,EAAE,EAAE,GAAG;IAiBnE,oBAAoB,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,GAAG;;;;;;IAY9C,wBAAwB,CACtB,EACE,WAAW,EACX,WAAW,EACX,SAAS,EACT,SAAS,EACT,SAAS,EACT,uBAAuB,GACxB,EAAE,GAAG,EACN,WAAW,EAAE,GAAG,EAChB,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,GAAG;;;;;;;CAwB9D;AAED,eAAe,sBAAsB,CAAC"}