react-native-gesture-handler 2.26.0 → 2.27.1

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

@@ -0,0 +1,179 @@
+import EventManager from './EventManager';
+import { MouseButton } from '../../handlers/gestureHandlerCommon';
+import { EventTypes } from '../interfaces';
+import { PointerTypeMapping, calculateViewScale, tryExtractStylusData, isPointerInBounds, } from '../utils';
+import { PointerType } from '../../PointerType';
+const POINTER_CAPTURE_EXCLUDE_LIST = new Set(['SELECT', 'INPUT']);
+export default class PointerEventManager extends EventManager {
+    trackedPointers = new Set();
+    mouseButtonsMapper = new Map();
+    lastPosition;
+    constructor(view) {
+        super(view);
+        this.mouseButtonsMapper.set(0, MouseButton.LEFT);
+        this.mouseButtonsMapper.set(1, MouseButton.MIDDLE);
+        this.mouseButtonsMapper.set(2, MouseButton.RIGHT);
+        this.mouseButtonsMapper.set(3, MouseButton.BUTTON_4);
+        this.mouseButtonsMapper.set(4, MouseButton.BUTTON_5);
+        this.lastPosition = {
+            x: -Infinity,
+            y: -Infinity,
+        };
+    }
+    pointerDownCallback = (event) => {
+        if (!isPointerInBounds(this.view, { x: event.clientX, y: event.clientY })) {
+            return;
+        }
+        const adaptedEvent = this.mapEvent(event, EventTypes.DOWN);
+        const target = event.target;
+        if (!POINTER_CAPTURE_EXCLUDE_LIST.has(target.tagName)) {
+            target.setPointerCapture(adaptedEvent.pointerId);
+        }
+        this.markAsInBounds(adaptedEvent.pointerId);
+        this.trackedPointers.add(adaptedEvent.pointerId);
+        if (++this.activePointersCounter > 1) {
+            adaptedEvent.eventType = EventTypes.ADDITIONAL_POINTER_DOWN;
+            this.onPointerAdd(adaptedEvent);
+        }
+        else {
+            this.onPointerDown(adaptedEvent);
+        }
+    };
+    pointerUpCallback = (event) => {
+        // When we call reset on gesture handlers, it also resets their event managers
+        // In some handlers (like RotationGestureHandler) reset is called before all pointers leave view
+        // This means, that activePointersCounter will be set to 0, while there are still remaining pointers on view
+        // Removing them will end in activePointersCounter going below 0, therefore handlers won't behave properly
+        if (this.activePointersCounter === 0) {
+            return;
+        }
+        const adaptedEvent = this.mapEvent(event, EventTypes.UP);
+        const target = event.target;
+        if (!POINTER_CAPTURE_EXCLUDE_LIST.has(target.tagName)) {
+            target.releasePointerCapture(adaptedEvent.pointerId);
+        }
+        this.markAsOutOfBounds(adaptedEvent.pointerId);
+        this.trackedPointers.delete(adaptedEvent.pointerId);
+        if (--this.activePointersCounter > 0) {
+            adaptedEvent.eventType = EventTypes.ADDITIONAL_POINTER_UP;
+            this.onPointerRemove(adaptedEvent);
+        }
+        else {
+            this.onPointerUp(adaptedEvent);
+        }
+    };
+    pointerMoveCallback = (event) => {
+        const adaptedEvent = this.mapEvent(event, EventTypes.MOVE);
+        const target = event.target;
+        // You may be wondering why are we setting pointer capture here, when we
+        // already set it in `pointerdown` handler. Well, that's a great question,
+        // for which I don't have an answer. Specification (https://www.w3.org/TR/pointerevents2/#dom-element-setpointercapture)
+        // says that the requirement for `setPointerCapture` to work is that pointer
+        // must be in 'active buttons state`, otherwise it will fail silently, which
+        // is lovely. Obviously, when `pointerdown` is fired, one of the buttons
+        // (when using mouse) is pressed, but that doesn't mean that `setPointerCapture`
+        // will succeed, for some reason. Since it fails silently, we don't actually know
+        // if it worked or not (there's `gotpointercapture` event, but the complexity of
+        // incorporating it here seems stupid), so we just call it again here, every time
+        // pointer moves until it succeeds.
+        // God, I do love web development.
+        if (!target?.hasPointerCapture(event.pointerId) &&
+            !POINTER_CAPTURE_EXCLUDE_LIST.has(target.tagName)) {
+            target.setPointerCapture(event.pointerId);
+        }
+        const inBounds = isPointerInBounds(this.view, {
+            x: adaptedEvent.x,
+            y: adaptedEvent.y,
+        });
+        const pointerIndex = this.pointersInBounds.indexOf(adaptedEvent.pointerId);
+        if (inBounds) {
+            if (pointerIndex < 0) {
+                adaptedEvent.eventType = EventTypes.ENTER;
+                this.onPointerEnter(adaptedEvent);
+                this.markAsInBounds(adaptedEvent.pointerId);
+            }
+            else {
+                this.onPointerMove(adaptedEvent);
+            }
+        }
+        else {
+            if (pointerIndex >= 0) {
+                adaptedEvent.eventType = EventTypes.LEAVE;
+                this.onPointerLeave(adaptedEvent);
+                this.markAsOutOfBounds(adaptedEvent.pointerId);
+            }
+            else {
+                this.onPointerOutOfBounds(adaptedEvent);
+            }
+        }
+        this.lastPosition.x = event.x;
+        this.lastPosition.y = event.y;
+    };
+    pointerCancelCallback = (event) => {
+        const adaptedEvent = this.mapEvent(event, EventTypes.CANCEL);
+        this.onPointerCancel(adaptedEvent);
+        this.markAsOutOfBounds(adaptedEvent.pointerId);
+        this.activePointersCounter = 0;
+        this.trackedPointers.clear();
+    };
+    pointerEnterCallback = (event) => {
+        const adaptedEvent = this.mapEvent(event, EventTypes.ENTER);
+        this.onPointerMoveOver(adaptedEvent);
+    };
+    pointerLeaveCallback = (event) => {
+        const adaptedEvent = this.mapEvent(event, EventTypes.LEAVE);
+        this.onPointerMoveOut(adaptedEvent);
+    };
+    lostPointerCaptureCallback = (event) => {
+        const adaptedEvent = this.mapEvent(event, EventTypes.CANCEL);
+        if (this.trackedPointers.has(adaptedEvent.pointerId)) {
+            // In some cases the `pointerup` event is not fired, but `lostpointercapture` is.
+            // Here we simulate the `pointercancel` event to make sure the gesture handler stops tracking it.
+            this.onPointerCancel(adaptedEvent);
+            this.activePointersCounter = 0;
+            this.trackedPointers.clear();
+        }
+    };
+    registerListeners() {
+        this.view.addEventListener('pointerdown', this.pointerDownCallback);
+        this.view.addEventListener('pointerup', this.pointerUpCallback);
+        this.view.addEventListener('pointermove', this.pointerMoveCallback);
+        this.view.addEventListener('pointercancel', this.pointerCancelCallback);
+        // onPointerEnter and onPointerLeave are triggered by a custom logic responsible for
+        // handling shouldCancelWhenOutside flag, and are unreliable unless the pointer is down.
+        // We therefore use pointerenter and pointerleave events to handle the hover gesture,
+        // mapping them to onPointerMoveOver and onPointerMoveOut respectively.
+        this.view.addEventListener('pointerenter', this.pointerEnterCallback);
+        this.view.addEventListener('pointerleave', this.pointerLeaveCallback);
+        this.view.addEventListener('lostpointercapture', this.lostPointerCaptureCallback);
+    }
+    unregisterListeners() {
+        this.view.removeEventListener('pointerdown', this.pointerDownCallback);
+        this.view.removeEventListener('pointerup', this.pointerUpCallback);
+        this.view.removeEventListener('pointermove', this.pointerMoveCallback);
+        this.view.removeEventListener('pointercancel', this.pointerCancelCallback);
+        this.view.removeEventListener('pointerenter', this.pointerEnterCallback);
+        this.view.removeEventListener('pointerleave', this.pointerLeaveCallback);
+        this.view.removeEventListener('lostpointercapture', this.lostPointerCaptureCallback);
+    }
+    mapEvent(event, eventType) {
+        const rect = this.view.getBoundingClientRect();
+        const { scaleX, scaleY } = calculateViewScale(this.view);
+        return {
+            x: event.clientX,
+            y: event.clientY,
+            offsetX: (event.clientX - rect.left) / scaleX,
+            offsetY: (event.clientY - rect.top) / scaleY,
+            pointerId: event.pointerId,
+            eventType: eventType,
+            pointerType: PointerTypeMapping.get(event.pointerType) ?? PointerType.OTHER,
+            button: this.mouseButtonsMapper.get(event.button),
+            time: event.timeStamp,
+            stylusData: tryExtractStylusData(event),
+        };
+    }
+    resetManager() {
+        super.resetManager();
+        this.trackedPointers.clear();
+    }
+}

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

@@ -23,9 +23,9 @@ export default class PointerTracker {
     getVelocity(pointerId: number): {
         x: number;
         y: number;
-    };
-    getLastAbsoluteCoords(pointerId?: number): Point;
-    getLastRelativeCoords(pointerId?: number): Point;
+    } | null;
+    getLastAbsoluteCoords(pointerId?: number): Point | undefined;
+    getLastRelativeCoords(pointerId?: number): Point | undefined;
     getAbsoluteCoordsAverage(): {
         x: number;
         y: number;
@@ -48,4 +48,3 @@ export default class PointerTracker {
     get trackedPointersIDs(): number[];
     get trackedPointers(): Map<number, TrackerElement>;
 }
-//# sourceMappingURL=PointerTracker.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"PointerTracker.d.ts","sourceRoot":"","sources":["../../../../src/web/tools/PointerTracker.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAGpD,MAAM,WAAW,cAAc;IAC7B,eAAe,EAAE,KAAK,CAAC;IACvB,cAAc,EAAE,KAAK,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB;AAID,MAAM,CAAC,OAAO,OAAO,cAAc;IACjC,OAAO,CAAC,eAAe,CAAyB;IAChD,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAG7B;IAEJ,OAAO,CAAC,cAAc,CAAkD;IAExE,OAAO,CAAC,kBAAkB,CAAS;IAEnC,OAAO,CAAC,sBAAsB,CAAyB;IACvD,OAAO,CAAC,sBAAsB,CAAyB;;IAUhD,YAAY,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI;IAsBvC,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IAK1C,KAAK,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI;IA2BvC,OAAO,CAAC,eAAe;IASvB,OAAO,CAAC,mBAAmB;IAOpB,qBAAqB,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM;IAUnD,WAAW,CAAC,SAAS,EAAE,MAAM;WAEqB,MAAM;WACN,MAAM;;IAIxD,qBAAqB,CAAC,SAAS,CAAC,EAAE,MAAM,GAEtB,KAAK;IAGvB,qBAAqB,CAAC,SAAS,CAAC,EAAE,MAAM,GAEvB,KAAK;IAQtB,wBAAwB;;;;IAcxB,wBAAwB;;;;IAcxB,oBAAoB,CAAC,cAAc,CAAC,EAAE,MAAM;;;;IAa5C,oBAAoB,CAAC,cAAc,CAAC,EAAE,MAAM;;;;IAa5C,YAAY,IAAI,IAAI;WAUb,mBAAmB,CAC/B,UAAU,EAAE,MAAM,EAAE,EACpB,UAAU,EAAE,MAAM,EAAE,GACnB,OAAO;IAIV,IAAW,oBAAoB,IAAI,MAAM,CAExC;IAED,IAAW,kBAAkB,aAQ5B;IAED,IAAW,eAAe,gCAEzB;CACF"}
+{"version":3,"file":"PointerTracker.d.ts","sourceRoot":"","sources":["../../../../src/web/tools/PointerTracker.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAGpD,MAAM,WAAW,cAAc;IAC7B,eAAe,EAAE,KAAK,CAAC;IACvB,cAAc,EAAE,KAAK,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB;AAID,MAAM,CAAC,OAAO,OAAO,cAAc;IACjC,OAAO,CAAC,eAAe,CAAyB;IAChD,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAG7B;IAEJ,OAAO,CAAC,cAAc,CAAkD;IAExE,OAAO,CAAC,kBAAkB,CAAS;IAEnC,OAAO,CAAC,sBAAsB,CAAyB;IACvD,OAAO,CAAC,sBAAsB,CAAyB;;IAUhD,YAAY,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI;IAsBvC,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IAK1C,KAAK,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI;IAyBvC,OAAO,CAAC,eAAe;IASvB,OAAO,CAAC,mBAAmB;IAOpB,qBAAqB,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM;IAUnD,WAAW,CAAC,SAAS,EAAE,MAAM;;;;IAW7B,qBAAqB,CAAC,SAAS,CAAC,EAAE,MAAM;IAKxC,qBAAqB,CAAC,SAAS,CAAC,EAAE,MAAM;IAUxC,wBAAwB;;;;IAcxB,wBAAwB;;;;IAcxB,oBAAoB,CAAC,cAAc,CAAC,EAAE,MAAM;;;;IAa5C,oBAAoB,CAAC,cAAc,CAAC,EAAE,MAAM;;;;IAa5C,YAAY,IAAI,IAAI;WAUb,mBAAmB,CAC/B,UAAU,EAAE,MAAM,EAAE,EACpB,UAAU,EAAE,MAAM,EAAE,GACnB,OAAO;IAIV,IAAW,oBAAoB,IAAI,MAAM,CAExC;IAED,IAAW,kBAAkB,aAQ5B;IAED,IAAW,eAAe,gCAEzB;CACF"}

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

@@ -8,9 +8,8 @@ export default class Vector {
     private readonly _magnitude;
     constructor(x: number, y: number);
     static fromDirection(direction: Directions | DiagonalDirections): Vector;
-    static fromVelocity(tracker: PointerTracker, pointerId: number): Vector;
+    static fromVelocity(tracker: PointerTracker, pointerId: number): Vector | null;
     get magnitude(): number;
     computeSimilarity(vector: Vector): number;
     isSimilar(vector: Vector, threshold: number): boolean;
 }
-//# sourceMappingURL=Vector.d.ts.map

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

@@ -11,4 +11,3 @@ export default class VelocityTracker {
     get velocity(): [number, number];
     reset(): void;
 }
-//# sourceMappingURL=VelocityTracker.d.ts.map

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

@@ -9,4 +9,3 @@ export default class WheelEventManager extends EventManager<HTMLElement> {
     protected mapEvent(event: WheelEvent): AdaptedEvent;
     resetManager(): void;
 }
-//# sourceMappingURL=WheelEventManager.d.ts.map

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

@@ -12,4 +12,3 @@ export declare function tryExtractStylusData(event: PointerEvent): StylusData |
 export declare const RNSVGElements: Set<string>;
 export declare function isRNSVGElement(viewRef: SVGRef | GestureHandlerRef): boolean;
 export declare function isRNSVGNode(node: any): boolean;
-//# sourceMappingURL=utils.d.ts.map