react-native-gesture-handler 2.27.1 → 2.27.2

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

@@ -1,161 +0,0 @@
-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.js

@@ -1,43 +0,0 @@
-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.js

@@ -1,76 +0,0 @@
-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.js

@@ -1,40 +0,0 @@
-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.js

@@ -1,233 +0,0 @@
-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.js

@@ -1,48 +0,0 @@
-/* eslint-disable @eslint-community/eslint-comments/no-unlimited-disable */
-/* eslint-disable */
-import GestureHandler from './GestureHandler';
-import { TEST_MAX_IF_NOT_NAN } from './utils';
-class DiscreteGestureHandler extends GestureHandler {
-    get isDiscrete() {
-        return true;
-    }
-    get shouldEnableGestureOnSetup() {
-        return true;
-    }
-    shouldFailUnderCustomCriteria({ x, y, deltaX, deltaY }, { maxDeltaX, maxDeltaY, maxDistSq, shouldCancelWhenOutside }) {
-        if (shouldCancelWhenOutside) {
-            if (!this.isPointInView({ x, y })) {
-                return true;
-            }
-        }
-        return (TEST_MAX_IF_NOT_NAN(Math.abs(deltaX), maxDeltaX) ||
-            TEST_MAX_IF_NOT_NAN(Math.abs(deltaY), maxDeltaY) ||
-            TEST_MAX_IF_NOT_NAN(Math.abs(deltaY * deltaY + deltaX * deltaX), maxDistSq));
-    }
-    transformNativeEvent({ center: { x, y } }) {
-        // @ts-ignore FIXME(TS)
-        const rect = this.view.getBoundingClientRect();
-        return {
-            absoluteX: x,
-            absoluteY: y,
-            x: x - rect.left,
-            y: y - rect.top,
-        };
-    }
-    isGestureEnabledForEvent({ minPointers, maxPointers, maxDeltaX, maxDeltaY, maxDistSq, shouldCancelWhenOutside, }, _recognizer, { maxPointers: pointerLength, center, deltaX, deltaY }) {
-        const validPointerCount = pointerLength >= minPointers && pointerLength <= maxPointers;
-        if (this.shouldFailUnderCustomCriteria({ ...center, deltaX, deltaY }, {
-            maxDeltaX,
-            maxDeltaY,
-            maxDistSq,
-            shouldCancelWhenOutside,
-        }) ||
-            // A user probably won't land a multi-pointer tap on the first tick (so we cannot just cancel each time)
-            // but if the gesture is running and the user adds or subtracts another pointer then it should fail.
-            (!validPointerCount && this.isGestureRunning)) {
-            return { failed: true };
-        }
-        return { success: validPointerCount };
-    }
-}
-export default DiscreteGestureHandler;

package/lib/typescript/web_hammer/DraggingGestureHandler.js

@@ -1,25 +0,0 @@
-/* eslint-disable @eslint-community/eslint-comments/no-unlimited-disable */
-/* eslint-disable */
-import GestureHandler from './GestureHandler';
-import { PixelRatio } from 'react-native';
-class DraggingGestureHandler extends GestureHandler {
-    get shouldEnableGestureOnSetup() {
-        return true;
-    }
-    transformNativeEvent({ deltaX, deltaY, velocityX, velocityY, center: { x, y }, }) {
-        // @ts-ignore FIXME(TS)
-        const rect = this.view.getBoundingClientRect();
-        const ratio = PixelRatio.get();
-        return {
-            translationX: deltaX - (this.__initialX || 0),
-            translationY: deltaY - (this.__initialY || 0),
-            absoluteX: x,
-            absoluteY: y,
-            velocityX: velocityX * ratio,
-            velocityY: velocityY * ratio,
-            x: x - rect.left,
-            y: y - rect.top,
-        };
-    }
-}
-export default DraggingGestureHandler;

package/lib/typescript/web_hammer/Errors.js

@@ -1,5 +0,0 @@
-export class GesturePropError extends Error {
-    constructor(name, value, expectedType) {
-        super(`Invalid property \`${name}: ${value}\` expected \`${expectedType}\``);
-    }
-}