react-native-gesture-handler 2.27.0 → 2.27.1

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

@@ -0,0 +1,91 @@
+export default class InteractionManager {
+    static _instance;
+    waitForRelations = new Map();
+    simultaneousRelations = new Map();
+    blocksHandlersRelations = new Map();
+    // Private becaues of singleton
+    // eslint-disable-next-line no-useless-constructor, @typescript-eslint/no-empty-function
+    constructor() { }
+    configureInteractions(handler, config) {
+        this.dropRelationsForHandlerWithTag(handler.handlerTag);
+        if (config.waitFor) {
+            const waitFor = [];
+            config.waitFor.forEach((otherHandler) => {
+                // New API reference
+                if (typeof otherHandler === 'number') {
+                    waitFor.push(otherHandler);
+                }
+                else {
+                    // Old API reference
+                    waitFor.push(otherHandler.handlerTag);
+                }
+            });
+            this.waitForRelations.set(handler.handlerTag, waitFor);
+        }
+        if (config.simultaneousHandlers) {
+            const simultaneousHandlers = [];
+            config.simultaneousHandlers.forEach((otherHandler) => {
+                if (typeof otherHandler === 'number') {
+                    simultaneousHandlers.push(otherHandler);
+                }
+                else {
+                    simultaneousHandlers.push(otherHandler.handlerTag);
+                }
+            });
+            this.simultaneousRelations.set(handler.handlerTag, simultaneousHandlers);
+        }
+        if (config.blocksHandlers) {
+            const blocksHandlers = [];
+            config.blocksHandlers.forEach((otherHandler) => {
+                if (typeof otherHandler === 'number') {
+                    blocksHandlers.push(otherHandler);
+                }
+                else {
+                    blocksHandlers.push(otherHandler.handlerTag);
+                }
+            });
+            this.blocksHandlersRelations.set(handler.handlerTag, blocksHandlers);
+        }
+    }
+    shouldWaitForHandlerFailure(handler, otherHandler) {
+        const waitFor = this.waitForRelations.get(handler.handlerTag);
+        return (waitFor?.find((tag) => {
+            return tag === otherHandler.handlerTag;
+        }) !== undefined);
+    }
+    shouldRecognizeSimultaneously(handler, otherHandler) {
+        const simultaneousHandlers = this.simultaneousRelations.get(handler.handlerTag);
+        return (simultaneousHandlers?.find((tag) => {
+            return tag === otherHandler.handlerTag;
+        }) !== undefined);
+    }
+    shouldRequireHandlerToWaitForFailure(handler, otherHandler) {
+        const waitFor = this.blocksHandlersRelations.get(handler.handlerTag);
+        return (waitFor?.find((tag) => {
+            return tag === otherHandler.handlerTag;
+        }) !== undefined);
+    }
+    shouldHandlerBeCancelledBy(_handler, otherHandler) {
+        // We check constructor name instead of using `instanceof` in order do avoid circular dependencies
+        const isNativeHandler = otherHandler.constructor.name === 'NativeViewGestureHandler';
+        const isActive = otherHandler.active;
+        const isButton = otherHandler.isButton?.() === true;
+        return isNativeHandler && isActive && !isButton;
+    }
+    dropRelationsForHandlerWithTag(handlerTag) {
+        this.waitForRelations.delete(handlerTag);
+        this.simultaneousRelations.delete(handlerTag);
+        this.blocksHandlersRelations.delete(handlerTag);
+    }
+    reset() {
+        this.waitForRelations.clear();
+        this.simultaneousRelations.clear();
+        this.blocksHandlersRelations.clear();
+    }
+    static get instance() {
+        if (!this._instance) {
+            this._instance = new InteractionManager();
+        }
+        return this._instance;
+    }
+}

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

@@ -0,0 +1,13 @@
+import { AdaptedEvent, EventTypes } from '../interfaces';
+import EventManager from './EventManager';
+export default class KeyboardEventManager extends EventManager<HTMLElement> {
+    private activationKeys;
+    private cancelationKeys;
+    private isPressed;
+    private keyDownCallback;
+    private keyUpCallback;
+    private dispatchEvent;
+    registerListeners(): void;
+    unregisterListeners(): void;
+    protected mapEvent(event: KeyboardEvent, eventType: EventTypes): AdaptedEvent;
+}

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

@@ -0,0 +1 @@
+{"version":3,"file":"KeyboardEventManager.d.ts","sourceRoot":"","sources":["../../../../src/web/tools/KeyboardEventManager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AACzD,OAAO,YAAY,MAAM,gBAAgB,CAAC;AAG1C,MAAM,CAAC,OAAO,OAAO,oBAAqB,SAAQ,YAAY,CAAC,WAAW,CAAC;IACzE,OAAO,CAAC,cAAc,CAAkB;IACxC,OAAO,CAAC,eAAe,CAAW;IAClC,OAAO,CAAC,SAAS,CAAS;IAE1B,OAAO,CAAC,eAAe,CAWrB;IAEF,OAAO,CAAC,aAAa,CAMnB;IAEF,OAAO,CAAC,aAAa;IAuBd,iBAAiB,IAAI,IAAI;IAKzB,mBAAmB,IAAI,IAAI;IAKlC,SAAS,CAAC,QAAQ,CAChB,KAAK,EAAE,aAAa,EACpB,SAAS,EAAE,UAAU,GACpB,YAAY;CAwBhB"}

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

@@ -0,0 +1,73 @@
+import { EventTypes } from '../interfaces';
+import EventManager from './EventManager';
+import { PointerType } from '../../PointerType';
+export default class KeyboardEventManager extends EventManager {
+    activationKeys = ['Enter', ' '];
+    cancelationKeys = ['Tab'];
+    isPressed = false;
+    keyDownCallback = (event) => {
+        if (this.cancelationKeys.indexOf(event.key) !== -1 && this.isPressed) {
+            this.dispatchEvent(event, EventTypes.CANCEL);
+            return;
+        }
+        if (this.activationKeys.indexOf(event.key) === -1) {
+            return;
+        }
+        this.dispatchEvent(event, EventTypes.DOWN);
+    };
+    keyUpCallback = (event) => {
+        if (this.activationKeys.indexOf(event.key) === -1 || !this.isPressed) {
+            return;
+        }
+        this.dispatchEvent(event, EventTypes.UP);
+    };
+    dispatchEvent(event, eventType) {
+        if (!(event.target instanceof HTMLElement)) {
+            return;
+        }
+        const adaptedEvent = this.mapEvent(event, eventType);
+        switch (eventType) {
+            case EventTypes.UP:
+                this.isPressed = false;
+                this.onPointerUp(adaptedEvent);
+                break;
+            case EventTypes.DOWN:
+                this.isPressed = true;
+                this.onPointerDown(adaptedEvent);
+                break;
+            case EventTypes.CANCEL:
+                this.isPressed = false;
+                this.onPointerCancel(adaptedEvent);
+                break;
+        }
+    }
+    registerListeners() {
+        this.view.addEventListener('keydown', this.keyDownCallback);
+        this.view.addEventListener('keyup', this.keyUpCallback);
+    }
+    unregisterListeners() {
+        this.view.removeEventListener('keydown', this.keyDownCallback);
+        this.view.removeEventListener('keyup', this.keyUpCallback);
+    }
+    mapEvent(event, eventType) {
+        const viewRect = event.target.getBoundingClientRect();
+        const viewportPosition = {
+            x: viewRect?.x + viewRect?.width / 2,
+            y: viewRect?.y + viewRect?.height / 2,
+        };
+        const relativePosition = {
+            x: viewRect?.width / 2,
+            y: viewRect?.height / 2,
+        };
+        return {
+            x: viewportPosition.x,
+            y: viewportPosition.y,
+            offsetX: relativePosition.x,
+            offsetY: relativePosition.y,
+            pointerId: 0,
+            eventType: eventType,
+            pointerType: PointerType.KEY,
+            time: event.timeStamp,
+        };
+    }
+}

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

@@ -0,0 +1,12 @@
+declare class PolynomialFit {
+    coefficients: number[];
+    constructor(degree: number);
+}
+export default class LeastSquareSolver {
+    private x;
+    private y;
+    private w;
+    constructor(x: number[], y: number[], w: number[]);
+    solve(degree: number): PolynomialFit | null;
+}
+export {};

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

@@ -0,0 +1 @@
+{"version":3,"file":"LeastSquareSolver.d.ts","sourceRoot":"","sources":["../../../../src/web/tools/LeastSquareSolver.ts"],"names":[],"mappings":"AAwEA,cAAM,aAAa;IAKV,YAAY,EAAE,MAAM,EAAE,CAAC;gBAKlB,MAAM,EAAE,MAAM;CAG3B;AAKD,MAAM,CAAC,OAAO,OAAO,iBAAiB;IAEpC,OAAO,CAAC,CAAC,CAAW;IAEpB,OAAO,CAAC,CAAC,CAAW;IAEpB,OAAO,CAAC,CAAC,CAAW;gBAKR,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE;IAS1C,KAAK,CAAC,MAAM,EAAE,MAAM,GAAG,aAAa,GAAG,IAAI;CAuEnD"}

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

@@ -0,0 +1,147 @@
+// Implementation taken from Flutter's LeastSquareSolver
+// https://github.com/flutter/flutter/blob/master/packages/flutter/lib/src/gestures/lsq_solver.dart
+class Vector {
+    offset;
+    length;
+    elements;
+    constructor(length) {
+        this.offset = 0;
+        this.length = length;
+        this.elements = new Array(length);
+    }
+    static fromVOL(values, offset, length) {
+        const result = new Vector(0);
+        result.offset = offset;
+        result.length = length;
+        result.elements = values;
+        return result;
+    }
+    get(index) {
+        return this.elements[this.offset + index];
+    }
+    set(index, value) {
+        this.elements[this.offset + index] = value;
+    }
+    dot(other) {
+        let result = 0;
+        for (let i = 0; i < this.length; i++) {
+            result += this.get(i) * other.get(i);
+        }
+        return result;
+    }
+    norm() {
+        return Math.sqrt(this.dot(this));
+    }
+}
+class Matrix {
+    columns;
+    elements;
+    constructor(rows, columns) {
+        this.columns = columns;
+        this.elements = new Array(rows * columns);
+    }
+    get(row, column) {
+        return this.elements[row * this.columns + column];
+    }
+    set(row, column, value) {
+        this.elements[row * this.columns + column] = value;
+    }
+    getRow(row) {
+        return Vector.fromVOL(this.elements, row * this.columns, this.columns);
+    }
+}
+// An nth degree polynomial fit to a dataset.
+class PolynomialFit {
+    // The polynomial coefficients of the fit.
+    //
+    // For each `i`, the element `coefficients[i]` is the coefficient of
+    // the `i`-th power of the variable.
+    coefficients;
+    // Creates a polynomial fit of the given degree.
+    //
+    // There are n + 1 coefficients in a fit of degree n.
+    constructor(degree) {
+        this.coefficients = new Array(degree + 1);
+    }
+}
+const precisionErrorTolerance = 1e-10;
+// Uses the least-squares algorithm to fit a polynomial to a set of data.
+export default class LeastSquareSolver {
+    // The x-coordinates of each data point.
+    x;
+    // The y-coordinates of each data point.
+    y;
+    // The weight to use for each data point.
+    w;
+    // Creates a least-squares solver.
+    //
+    // The [x], [y], and [w] arguments must not be null.
+    constructor(x, y, w) {
+        this.x = x;
+        this.y = y;
+        this.w = w;
+    }
+    // Fits a polynomial of the given degree to the data points.
+    //
+    // When there is not enough data to fit a curve null is returned.
+    solve(degree) {
+        if (degree > this.x.length) {
+            // Not enough data to fit a curve.
+            return null;
+        }
+        const result = new PolynomialFit(degree);
+        // Shorthands for the purpose of notation equivalence to original C++ code.
+        const m = this.x.length;
+        const n = degree + 1;
+        // Expand the X vector to a matrix A, pre-multiplied by the weights.
+        const a = new Matrix(n, m);
+        for (let h = 0; h < m; h++) {
+            a.set(0, h, this.w[h]);
+            for (let i = 1; i < n; i++) {
+                a.set(i, h, a.get(i - 1, h) * this.x[h]);
+            }
+        }
+        // Apply the Gram-Schmidt process to A to obtain its QR decomposition.
+        // Orthonormal basis, column-major ordVectorer.
+        const q = new Matrix(n, m);
+        // Upper triangular matrix, row-major order.
+        const r = new Matrix(n, m);
+        for (let j = 0; j < n; j += 1) {
+            for (let h = 0; h < m; h += 1) {
+                q.set(j, h, a.get(j, h));
+            }
+            for (let i = 0; i < j; i += 1) {
+                const dot = q.getRow(j).dot(q.getRow(i));
+                for (let h = 0; h < m; h += 1) {
+                    q.set(j, h, q.get(j, h) - dot * q.get(i, h));
+                }
+            }
+            const norm = q.getRow(j).norm();
+            if (norm < precisionErrorTolerance) {
+                // Vectors are linearly dependent or zero so no solution.
+                return null;
+            }
+            const inverseNorm = 1.0 / norm;
+            for (let h = 0; h < m; h += 1) {
+                q.set(j, h, q.get(j, h) * inverseNorm);
+            }
+            for (let i = 0; i < n; i += 1) {
+                r.set(j, i, i < j ? 0.0 : q.getRow(j).dot(a.getRow(i)));
+            }
+        }
+        // Solve R B = Qt W Y to find B. This is easy because R is upper triangular.
+        // We just work from bottom-right to top-left calculating B's coefficients.
+        const wy = new Vector(m);
+        for (let h = 0; h < m; h += 1) {
+            wy.set(h, this.y[h] * this.w[h]);
+        }
+        for (let i = n - 1; i >= 0; i -= 1) {
+            result.coefficients[i] = q.getRow(i).dot(wy);
+            for (let j = n - 1; j > i; j -= 1) {
+                result.coefficients[i] -= r.get(i, j) * result.coefficients[j];
+            }
+            result.coefficients[i] /= r.get(i, i);
+        }
+        return result;
+    }
+}

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

@@ -0,0 +1,12 @@
+import { ValueOf } from '../../typeUtils';
+import { Gestures } from '../Gestures';
+import type IGestureHandler from '../handlers/IGestureHandler';
+export default abstract class NodeManager {
+    private static gestures;
+    static getHandler(tag: number): IGestureHandler;
+    static createGestureHandler(handlerTag: number, handler: InstanceType<ValueOf<typeof Gestures>>): void;
+    static dropGestureHandler(handlerTag: number): void;
+    static get nodes(): {
+        [x: number]: import("../handlers/PanGestureHandler").default | import("../handlers/TapGestureHandler").default | import("../handlers/LongPressGestureHandler").default | import("../handlers/PinchGestureHandler").default | import("../handlers/RotationGestureHandler").default | import("../handlers/FlingGestureHandler").default | import("../handlers/NativeViewGestureHandler").default | import("../handlers/ManualGestureHandler").default | import("../handlers/HoverGestureHandler").default;
+    };
+}

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

@@ -0,0 +1 @@
+{"version":3,"file":"NodeManager.d.ts","sourceRoot":"","sources":["../../../../src/web/tools/NodeManager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAC1C,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACvC,OAAO,KAAK,eAAe,MAAM,6BAA6B,CAAC;AAG/D,MAAM,CAAC,OAAO,CAAC,QAAQ,OAAO,WAAW;IACvC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAGhB;WAEO,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,eAAe;WAQxC,oBAAoB,CAChC,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,YAAY,CAAC,OAAO,CAAC,OAAO,QAAQ,CAAC,CAAC,GAC9C,IAAI;WAWO,kBAAkB,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IAW1D,WAAkB,KAAK;;MAEtB;CACF"}

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

@@ -0,0 +1,28 @@
+// eslint-disable-next-line @typescript-eslint/no-extraneous-class
+export default class NodeManager {
+    static gestures = {};
+    static getHandler(tag) {
+        if (tag in this.gestures) {
+            return this.gestures[tag];
+        }
+        throw new Error(`No handler for tag ${tag}`);
+    }
+    static createGestureHandler(handlerTag, handler) {
+        if (handlerTag in this.gestures) {
+            throw new Error(`Handler with tag ${handlerTag} already exists. Please ensure that no Gesture instance is used across multiple GestureDetectors.`);
+        }
+        this.gestures[handlerTag] = handler;
+        this.gestures[handlerTag].handlerTag = handlerTag;
+    }
+    static dropGestureHandler(handlerTag) {
+        if (!(handlerTag in this.gestures)) {
+            return;
+        }
+        this.gestures[handlerTag].onDestroy();
+        // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+        delete this.gestures[handlerTag];
+    }
+    static get nodes() {
+        return { ...this.gestures };
+    }
+}

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

@@ -0,0 +1,19 @@
+import EventManager from './EventManager';
+import { AdaptedEvent, EventTypes } from '../interfaces';
+export default class PointerEventManager extends EventManager<HTMLElement> {
+    private trackedPointers;
+    private readonly mouseButtonsMapper;
+    private lastPosition;
+    constructor(view: HTMLElement);
+    private pointerDownCallback;
+    private pointerUpCallback;
+    private pointerMoveCallback;
+    private pointerCancelCallback;
+    private pointerEnterCallback;
+    private pointerLeaveCallback;
+    private lostPointerCaptureCallback;
+    registerListeners(): void;
+    unregisterListeners(): void;
+    protected mapEvent(event: PointerEvent, eventType: EventTypes): AdaptedEvent;
+    resetManager(): void;
+}

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

@@ -0,0 +1 @@
+{"version":3,"file":"PointerEventManager.d.ts","sourceRoot":"","sources":["../../../../src/web/tools/PointerEventManager.ts"],"names":[],"mappings":"AAAA,OAAO,YAAY,MAAM,gBAAgB,CAAC;AAE1C,OAAO,EAAE,YAAY,EAAE,UAAU,EAAS,MAAM,eAAe,CAAC;AAWhE,MAAM,CAAC,OAAO,OAAO,mBAAoB,SAAQ,YAAY,CAAC,WAAW,CAAC;IACxE,OAAO,CAAC,eAAe,CAAqB;IAC5C,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAkC;IACrE,OAAO,CAAC,YAAY,CAAQ;gBAEhB,IAAI,EAAE,WAAW;IAe7B,OAAO,CAAC,mBAAmB,CAqBzB;IAEF,OAAO,CAAC,iBAAiB,CAyBvB;IAEF,OAAO,CAAC,mBAAmB,CAoDzB;IAEF,OAAO,CAAC,qBAAqB,CAO3B;IAEF,OAAO,CAAC,oBAAoB,CAI1B;IAEF,OAAO,CAAC,oBAAoB,CAI1B;IAEF,OAAO,CAAC,0BAA0B,CAWhC;IAEK,iBAAiB,IAAI,IAAI;IAkBzB,mBAAmB,IAAI,IAAI;IAalC,SAAS,CAAC,QAAQ,CAAC,KAAK,EAAE,YAAY,EAAE,SAAS,EAAE,UAAU,GAAG,YAAY;IAmBrE,YAAY,IAAI,IAAI;CAI5B"}

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

@@ -0,0 +1,50 @@
+import { AdaptedEvent, Point } from '../interfaces';
+export interface TrackerElement {
+    abosoluteCoords: Point;
+    relativeCoords: Point;
+    timestamp: number;
+    velocityX: number;
+    velocityY: number;
+}
+export default class PointerTracker {
+    private velocityTracker;
+    private readonly _trackedPointers;
+    private touchEventsIds;
+    private lastMovedPointerId;
+    private cachedAbsoluteAverages;
+    private cachedRelativeAverages;
+    constructor();
+    addToTracker(event: AdaptedEvent): void;
+    removeFromTracker(pointerId: number): void;
+    track(event: AdaptedEvent): void;
+    private mapTouchEventId;
+    private removeMappedTouchId;
+    getMappedTouchEventId(touchEventId: number): number;
+    getVelocity(pointerId: number): {
+        x: number;
+        y: number;
+    } | null;
+    getLastAbsoluteCoords(pointerId?: number): Point | undefined;
+    getLastRelativeCoords(pointerId?: number): Point | undefined;
+    getAbsoluteCoordsAverage(): {
+        x: number;
+        y: number;
+    };
+    getRelativeCoordsAverage(): {
+        x: number;
+        y: number;
+    };
+    getAbsoluteCoordsSum(ignoredPointer?: number): {
+        x: number;
+        y: number;
+    };
+    getRelativeCoordsSum(ignoredPointer?: number): {
+        x: number;
+        y: number;
+    };
+    resetTracker(): void;
+    static shareCommonPointers(stPointers: number[], ndPointers: number[]): boolean;
+    get trackedPointersCount(): number;
+    get trackedPointersIDs(): number[];
+    get trackedPointers(): Map<number, TrackerElement>;
+}

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

@@ -0,0 +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;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"}