react-native-gesture-handler 2.26.0 → 2.27.1

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

@@ -0,0 +1,420 @@
+import { State } from '../../State';
+import { DEFAULT_TOUCH_SLOP } from '../constants';
+import { WheelDevice } from '../interfaces';
+import GestureHandler from './GestureHandler';
+const DEFAULT_MIN_POINTERS = 1;
+const DEFAULT_MAX_POINTERS = 10;
+const DEFAULT_MIN_DIST_SQ = DEFAULT_TOUCH_SLOP * DEFAULT_TOUCH_SLOP;
+export default class PanGestureHandler extends GestureHandler {
+    customActivationProperties = [
+        'activeOffsetXStart',
+        'activeOffsetXEnd',
+        'failOffsetXStart',
+        'failOffsetXEnd',
+        'activeOffsetYStart',
+        'activeOffsetYEnd',
+        'failOffsetYStart',
+        'failOffsetYEnd',
+        'minVelocityX',
+        'minVelocityY',
+        'minVelocity',
+    ];
+    velocityX = 0;
+    velocityY = 0;
+    minDistSq = DEFAULT_MIN_DIST_SQ;
+    activeOffsetXStart = -Number.MAX_SAFE_INTEGER;
+    activeOffsetXEnd = Number.MIN_SAFE_INTEGER;
+    failOffsetXStart = Number.MIN_SAFE_INTEGER;
+    failOffsetXEnd = Number.MAX_SAFE_INTEGER;
+    activeOffsetYStart = Number.MAX_SAFE_INTEGER;
+    activeOffsetYEnd = Number.MIN_SAFE_INTEGER;
+    failOffsetYStart = Number.MIN_SAFE_INTEGER;
+    failOffsetYEnd = Number.MAX_SAFE_INTEGER;
+    minVelocityX = Number.MAX_SAFE_INTEGER;
+    minVelocityY = Number.MAX_SAFE_INTEGER;
+    minVelocitySq = Number.MAX_SAFE_INTEGER;
+    minPointers = DEFAULT_MIN_POINTERS;
+    maxPointers = DEFAULT_MAX_POINTERS;
+    startX = 0;
+    startY = 0;
+    offsetX = 0;
+    offsetY = 0;
+    lastX = 0;
+    lastY = 0;
+    stylusData;
+    activateAfterLongPress = 0;
+    activationTimeout = 0;
+    enableTrackpadTwoFingerGesture = false;
+    endWheelTimeout = 0;
+    wheelDevice = WheelDevice.UNDETERMINED;
+    updateGestureConfig({ enabled = true, ...props }) {
+        this.resetConfig();
+        super.updateGestureConfig({ enabled: enabled, ...props });
+        this.checkCustomActivationCriteria(this.customActivationProperties);
+        if (this.config.minDist !== undefined) {
+            this.minDistSq = this.config.minDist * this.config.minDist;
+        }
+        else if (this.hasCustomActivationCriteria) {
+            this.minDistSq = Number.MAX_SAFE_INTEGER;
+        }
+        if (this.config.minPointers !== undefined) {
+            this.minPointers = this.config.minPointers;
+        }
+        if (this.config.maxPointers !== undefined) {
+            this.maxPointers = this.config.maxPointers;
+        }
+        if (this.config.minVelocity !== undefined) {
+            this.minVelocityX = this.config.minVelocity;
+            this.minVelocityY = this.config.minVelocity;
+        }
+        if (this.config.minVelocityX !== undefined) {
+            this.minVelocityX = this.config.minVelocityX;
+        }
+        if (this.config.minVelocityY !== undefined) {
+            this.minVelocityY = this.config.minVelocityY;
+        }
+        if (this.config.activateAfterLongPress !== undefined) {
+            this.activateAfterLongPress = this.config.activateAfterLongPress;
+        }
+        if (this.config.activeOffsetXStart !== undefined) {
+            this.activeOffsetXStart = this.config.activeOffsetXStart;
+            if (this.config.activeOffsetXEnd === undefined) {
+                this.activeOffsetXEnd = Number.MAX_SAFE_INTEGER;
+            }
+        }
+        if (this.config.activeOffsetXEnd !== undefined) {
+            this.activeOffsetXEnd = this.config.activeOffsetXEnd;
+            if (this.config.activeOffsetXStart === undefined) {
+                this.activeOffsetXStart = Number.MIN_SAFE_INTEGER;
+            }
+        }
+        if (this.config.failOffsetXStart !== undefined) {
+            this.failOffsetXStart = this.config.failOffsetXStart;
+            if (this.config.failOffsetXEnd === undefined) {
+                this.failOffsetXEnd = Number.MAX_SAFE_INTEGER;
+            }
+        }
+        if (this.config.failOffsetXEnd !== undefined) {
+            this.failOffsetXEnd = this.config.failOffsetXEnd;
+            if (this.config.failOffsetXStart === undefined) {
+                this.failOffsetXStart = Number.MIN_SAFE_INTEGER;
+            }
+        }
+        if (this.config.activeOffsetYStart !== undefined) {
+            this.activeOffsetYStart = this.config.activeOffsetYStart;
+            if (this.config.activeOffsetYEnd === undefined) {
+                this.activeOffsetYEnd = Number.MAX_SAFE_INTEGER;
+            }
+        }
+        if (this.config.activeOffsetYEnd !== undefined) {
+            this.activeOffsetYEnd = this.config.activeOffsetYEnd;
+            if (this.config.activeOffsetYStart === undefined) {
+                this.activeOffsetYStart = Number.MIN_SAFE_INTEGER;
+            }
+        }
+        if (this.config.failOffsetYStart !== undefined) {
+            this.failOffsetYStart = this.config.failOffsetYStart;
+            if (this.config.failOffsetYEnd === undefined) {
+                this.failOffsetYEnd = Number.MAX_SAFE_INTEGER;
+            }
+        }
+        if (this.config.failOffsetYEnd !== undefined) {
+            this.failOffsetYEnd = this.config.failOffsetYEnd;
+            if (this.config.failOffsetYStart === undefined) {
+                this.failOffsetYStart = Number.MIN_SAFE_INTEGER;
+            }
+        }
+        if (this.config.enableTrackpadTwoFingerGesture !== undefined) {
+            this.enableTrackpadTwoFingerGesture =
+                this.config.enableTrackpadTwoFingerGesture;
+        }
+    }
+    resetConfig() {
+        super.resetConfig();
+        this.activeOffsetXStart = -Number.MAX_SAFE_INTEGER;
+        this.activeOffsetXEnd = Number.MIN_SAFE_INTEGER;
+        this.failOffsetXStart = Number.MIN_SAFE_INTEGER;
+        this.failOffsetXEnd = Number.MAX_SAFE_INTEGER;
+        this.activeOffsetYStart = Number.MAX_SAFE_INTEGER;
+        this.activeOffsetYEnd = Number.MIN_SAFE_INTEGER;
+        this.failOffsetYStart = Number.MIN_SAFE_INTEGER;
+        this.failOffsetYEnd = Number.MAX_SAFE_INTEGER;
+        this.minVelocityX = Number.MAX_SAFE_INTEGER;
+        this.minVelocityY = Number.MAX_SAFE_INTEGER;
+        this.minVelocitySq = Number.MAX_SAFE_INTEGER;
+        this.minDistSq = DEFAULT_MIN_DIST_SQ;
+        this.minPointers = DEFAULT_MIN_POINTERS;
+        this.maxPointers = DEFAULT_MAX_POINTERS;
+        this.activateAfterLongPress = 0;
+    }
+    transformNativeEvent() {
+        const translationX = this.getTranslationX();
+        const translationY = this.getTranslationY();
+        return {
+            ...super.transformNativeEvent(),
+            translationX: isNaN(translationX) ? 0 : translationX,
+            translationY: isNaN(translationY) ? 0 : translationY,
+            velocityX: this.velocityX,
+            velocityY: this.velocityY,
+            stylusData: this.stylusData,
+        };
+    }
+    getTranslationX() {
+        return this.lastX - this.startX + this.offsetX;
+    }
+    getTranslationY() {
+        return this.lastY - this.startY + this.offsetY;
+    }
+    clearActivationTimeout() {
+        clearTimeout(this.activationTimeout);
+    }
+    updateLastCoords() {
+        const { x, y } = this.tracker.getAbsoluteCoordsAverage();
+        this.lastX = x;
+        this.lastY = y;
+    }
+    updateVelocity(pointerId) {
+        const velocities = this.tracker.getVelocity(pointerId);
+        this.velocityX = velocities?.x ?? 0;
+        this.velocityY = velocities?.y ?? 0;
+    }
+    // Events Handling
+    onPointerDown(event) {
+        if (!this.isButtonInConfig(event.button)) {
+            return;
+        }
+        this.tracker.addToTracker(event);
+        this.stylusData = event.stylusData;
+        super.onPointerDown(event);
+        this.updateLastCoords();
+        this.startX = this.lastX;
+        this.startY = this.lastY;
+        this.tryBegin(event);
+        this.checkBegan();
+        this.tryToSendTouchEvent(event);
+    }
+    onPointerAdd(event) {
+        this.tracker.addToTracker(event);
+        super.onPointerAdd(event);
+        this.tryBegin(event);
+        this.offsetX += this.lastX - this.startX;
+        this.offsetY += this.lastY - this.startY;
+        this.updateLastCoords();
+        this.startX = this.lastX;
+        this.startY = this.lastY;
+        if (this.tracker.trackedPointersCount > this.maxPointers) {
+            if (this.state === State.ACTIVE) {
+                this.cancel();
+            }
+            else {
+                this.fail();
+            }
+        }
+        else {
+            this.checkBegan();
+        }
+    }
+    onPointerUp(event) {
+        this.stylusData = event.stylusData;
+        super.onPointerUp(event);
+        if (this.state === State.ACTIVE) {
+            const lastCoords = this.tracker.getAbsoluteCoordsAverage();
+            this.lastX = lastCoords.x;
+            this.lastY = lastCoords.y;
+        }
+        this.tracker.removeFromTracker(event.pointerId);
+        if (this.tracker.trackedPointersCount === 0) {
+            this.clearActivationTimeout();
+        }
+        if (this.state === State.ACTIVE) {
+            this.end();
+        }
+        else {
+            this.resetProgress();
+            this.fail();
+        }
+    }
+    onPointerRemove(event) {
+        super.onPointerRemove(event);
+        this.tracker.removeFromTracker(event.pointerId);
+        this.offsetX += this.lastX - this.startX;
+        this.offsetY += this.lastY - this.startY;
+        this.updateLastCoords();
+        this.startX = this.lastX;
+        this.startY = this.lastY;
+        if (!(this.state === State.ACTIVE &&
+            this.tracker.trackedPointersCount < this.minPointers)) {
+            this.checkBegan();
+        }
+    }
+    onPointerMove(event) {
+        this.tracker.track(event);
+        this.stylusData = event.stylusData;
+        this.updateLastCoords();
+        this.updateVelocity(event.pointerId);
+        this.checkBegan();
+        super.onPointerMove(event);
+    }
+    onPointerOutOfBounds(event) {
+        if (this.shouldCancelWhenOutside) {
+            return;
+        }
+        this.tracker.track(event);
+        this.stylusData = event.stylusData;
+        this.updateLastCoords();
+        this.updateVelocity(event.pointerId);
+        this.checkBegan();
+        if (this.state === State.ACTIVE) {
+            super.onPointerOutOfBounds(event);
+        }
+    }
+    scheduleWheelEnd(event) {
+        clearTimeout(this.endWheelTimeout);
+        this.endWheelTimeout = setTimeout(() => {
+            if (this.state === State.ACTIVE) {
+                this.end();
+                this.tracker.removeFromTracker(event.pointerId);
+                this.state = State.UNDETERMINED;
+            }
+            this.wheelDevice = WheelDevice.UNDETERMINED;
+        }, 30);
+    }
+    onWheel(event) {
+        if (this.wheelDevice === WheelDevice.MOUSE ||
+            !this.enableTrackpadTwoFingerGesture) {
+            return;
+        }
+        if (this.state === State.UNDETERMINED) {
+            this.wheelDevice =
+                event.wheelDeltaY % 120 !== 0
+                    ? WheelDevice.TOUCHPAD
+                    : WheelDevice.MOUSE;
+            if (this.wheelDevice === WheelDevice.MOUSE) {
+                this.scheduleWheelEnd(event);
+                return;
+            }
+            this.tracker.addToTracker(event);
+            this.updateLastCoords();
+            this.startX = this.lastX;
+            this.startY = this.lastY;
+            this.begin();
+            this.activate();
+        }
+        this.tracker.track(event);
+        this.updateLastCoords();
+        this.updateVelocity(event.pointerId);
+        this.tryToSendMoveEvent(false, event);
+        this.scheduleWheelEnd(event);
+    }
+    shouldActivate() {
+        const dx = this.getTranslationX();
+        if (this.activeOffsetXStart !== Number.MAX_SAFE_INTEGER &&
+            dx < this.activeOffsetXStart) {
+            return true;
+        }
+        if (this.activeOffsetXEnd !== Number.MIN_SAFE_INTEGER &&
+            dx > this.activeOffsetXEnd) {
+            return true;
+        }
+        const dy = this.getTranslationY();
+        if (this.activeOffsetYStart !== Number.MAX_SAFE_INTEGER &&
+            dy < this.activeOffsetYStart) {
+            return true;
+        }
+        if (this.activeOffsetYEnd !== Number.MIN_SAFE_INTEGER &&
+            dy > this.activeOffsetYEnd) {
+            return true;
+        }
+        const distanceSq = dx * dx + dy * dy;
+        if (this.minDistSq !== Number.MAX_SAFE_INTEGER &&
+            distanceSq >= this.minDistSq) {
+            return true;
+        }
+        const vx = this.velocityX;
+        if (this.minVelocityX !== Number.MAX_SAFE_INTEGER &&
+            ((this.minVelocityX < 0 && vx <= this.minVelocityX) ||
+                (this.minVelocityX >= 0 && this.minVelocityX <= vx))) {
+            return true;
+        }
+        const vy = this.velocityY;
+        if (this.minVelocityY !== Number.MAX_SAFE_INTEGER &&
+            ((this.minVelocityY < 0 && vy <= this.minVelocityY) ||
+                (this.minVelocityY >= 0 && this.minVelocityY <= vy))) {
+            return true;
+        }
+        const velocitySq = vx * vx + vy * vy;
+        return (this.minVelocitySq !== Number.MAX_SAFE_INTEGER &&
+            velocitySq >= this.minVelocitySq);
+    }
+    shouldFail() {
+        const dx = this.getTranslationX();
+        const dy = this.getTranslationY();
+        const distanceSq = dx * dx + dy * dy;
+        if (this.activateAfterLongPress > 0 && distanceSq > DEFAULT_MIN_DIST_SQ) {
+            this.clearActivationTimeout();
+            return true;
+        }
+        if (this.failOffsetXStart !== Number.MIN_SAFE_INTEGER &&
+            dx < this.failOffsetXStart) {
+            return true;
+        }
+        if (this.failOffsetXEnd !== Number.MAX_SAFE_INTEGER &&
+            dx > this.failOffsetXEnd) {
+            return true;
+        }
+        if (this.failOffsetYStart !== Number.MIN_SAFE_INTEGER &&
+            dy < this.failOffsetYStart) {
+            return true;
+        }
+        return (this.failOffsetYEnd !== Number.MAX_SAFE_INTEGER &&
+            dy > this.failOffsetYEnd);
+    }
+    tryBegin(event) {
+        if (this.state === State.UNDETERMINED &&
+            this.tracker.trackedPointersCount >= this.minPointers) {
+            this.resetProgress();
+            this.offsetX = 0;
+            this.offsetY = 0;
+            this.velocityX = 0;
+            this.velocityY = 0;
+            this.begin();
+            if (this.activateAfterLongPress > 0) {
+                this.activationTimeout = setTimeout(() => {
+                    this.activate();
+                }, this.activateAfterLongPress);
+            }
+        }
+        else {
+            this.updateVelocity(event.pointerId);
+        }
+    }
+    checkBegan() {
+        if (this.state === State.BEGAN) {
+            if (this.shouldFail()) {
+                this.fail();
+            }
+            else if (this.shouldActivate()) {
+                this.activate();
+            }
+        }
+    }
+    activate(force = false) {
+        if (this.state !== State.ACTIVE) {
+            this.resetProgress();
+        }
+        super.activate(force);
+    }
+    onCancel() {
+        this.clearActivationTimeout();
+    }
+    onReset() {
+        this.clearActivationTimeout();
+    }
+    resetProgress() {
+        if (this.state === State.ACTIVE) {
+            return;
+        }
+        this.startX = this.lastX;
+        this.startY = this.lastY;
+    }
+}

package/lib/typescript/web/handlers/PinchGestureHandler.d.ts

@@ -25,4 +25,3 @@ export default class PinchGestureHandler extends GestureHandler {
     protected onReset(): void;
     protected resetProgress(): void;
 }
-//# sourceMappingURL=PinchGestureHandler.d.ts.map

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

@@ -0,0 +1,117 @@
+import { State } from '../../State';
+import { DEFAULT_TOUCH_SLOP } from '../constants';
+import GestureHandler from './GestureHandler';
+import ScaleGestureDetector from '../detectors/ScaleGestureDetector';
+export default class PinchGestureHandler extends GestureHandler {
+    scale = 1;
+    velocity = 0;
+    startingSpan = 0;
+    spanSlop = DEFAULT_TOUCH_SLOP;
+    scaleDetectorListener = {
+        onScaleBegin: (detector) => {
+            this.startingSpan = detector.currentSpan;
+            return true;
+        },
+        onScale: (detector) => {
+            const prevScaleFactor = this.scale;
+            this.scale *= detector.calculateScaleFactor(this.tracker.trackedPointersCount);
+            const delta = detector.timeDelta;
+            if (delta > 0) {
+                this.velocity = (this.scale - prevScaleFactor) / delta;
+            }
+            if (Math.abs(this.startingSpan - detector.currentSpan) >= this.spanSlop &&
+                this.state === State.BEGAN) {
+                this.activate();
+            }
+            return true;
+        },
+        onScaleEnd: (_detector
+        // eslint-disable-next-line @typescript-eslint/no-empty-function
+        ) => { },
+    };
+    scaleGestureDetector = new ScaleGestureDetector(this.scaleDetectorListener);
+    init(ref, propsRef) {
+        super.init(ref, propsRef);
+        this.shouldCancelWhenOutside = false;
+    }
+    transformNativeEvent() {
+        return {
+            focalX: this.scaleGestureDetector.focusX,
+            focalY: this.scaleGestureDetector.focusY,
+            velocity: this.velocity,
+            scale: this.scale,
+        };
+    }
+    onPointerDown(event) {
+        this.tracker.addToTracker(event);
+        super.onPointerDown(event);
+        this.tryToSendTouchEvent(event);
+    }
+    onPointerAdd(event) {
+        this.tracker.addToTracker(event);
+        super.onPointerAdd(event);
+        this.tryBegin();
+        this.scaleGestureDetector.onTouchEvent(event, this.tracker);
+    }
+    onPointerUp(event) {
+        super.onPointerUp(event);
+        this.tracker.removeFromTracker(event.pointerId);
+        if (this.state !== State.ACTIVE) {
+            return;
+        }
+        this.scaleGestureDetector.onTouchEvent(event, this.tracker);
+        if (this.state === State.ACTIVE) {
+            this.end();
+        }
+        else {
+            this.fail();
+        }
+    }
+    onPointerRemove(event) {
+        super.onPointerRemove(event);
+        this.scaleGestureDetector.onTouchEvent(event, this.tracker);
+        this.tracker.removeFromTracker(event.pointerId);
+        if (this.state === State.ACTIVE && this.tracker.trackedPointersCount < 2) {
+            this.end();
+        }
+    }
+    onPointerMove(event) {
+        if (this.tracker.trackedPointersCount < 2) {
+            return;
+        }
+        this.tracker.track(event);
+        this.scaleGestureDetector.onTouchEvent(event, this.tracker);
+        super.onPointerMove(event);
+    }
+    onPointerOutOfBounds(event) {
+        if (this.tracker.trackedPointersCount < 2) {
+            return;
+        }
+        this.tracker.track(event);
+        this.scaleGestureDetector.onTouchEvent(event, this.tracker);
+        super.onPointerOutOfBounds(event);
+    }
+    tryBegin() {
+        if (this.state !== State.UNDETERMINED) {
+            return;
+        }
+        this.resetProgress();
+        this.begin();
+    }
+    activate(force) {
+        if (this.state !== State.ACTIVE) {
+            this.resetProgress();
+        }
+        super.activate(force);
+    }
+    onReset() {
+        this.resetProgress();
+    }
+    resetProgress() {
+        if (this.state === State.ACTIVE) {
+            return;
+        }
+        this.velocity = 0;
+        this.scale = 1;
+    }
+}

package/lib/typescript/web/handlers/RotationGestureHandler.d.ts

@@ -25,4 +25,3 @@ export default class RotationGestureHandler extends GestureHandler {
     protected tryBegin(): void;
     protected onReset(): void;
 }
-//# sourceMappingURL=RotationGestureHandler.d.ts.map

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

@@ -0,0 +1,122 @@
+import { State } from '../../State';
+import GestureHandler from './GestureHandler';
+import RotationGestureDetector from '../detectors/RotationGestureDetector';
+const ROTATION_RECOGNITION_THRESHOLD = Math.PI / 36;
+export default class RotationGestureHandler extends GestureHandler {
+    rotation = 0;
+    velocity = 0;
+    cachedAnchorX = 0;
+    cachedAnchorY = 0;
+    rotationGestureListener = {
+        onRotationBegin: (_detector) => true,
+        onRotation: (detector) => {
+            const previousRotation = this.rotation;
+            this.rotation += detector.rotation;
+            const delta = detector.timeDelta;
+            if (delta > 0) {
+                this.velocity = (this.rotation - previousRotation) / delta;
+            }
+            if (Math.abs(this.rotation) >= ROTATION_RECOGNITION_THRESHOLD &&
+                this.state === State.BEGAN) {
+                this.activate();
+            }
+            return true;
+        },
+        onRotationEnd: (_detector) => {
+            this.end();
+        },
+    };
+    rotationGestureDetector = new RotationGestureDetector(this.rotationGestureListener);
+    init(ref, propsRef) {
+        super.init(ref, propsRef);
+        this.shouldCancelWhenOutside = false;
+    }
+    transformNativeEvent() {
+        return {
+            rotation: this.rotation ? this.rotation : 0,
+            anchorX: this.getAnchorX(),
+            anchorY: this.getAnchorY(),
+            velocity: this.velocity ? this.velocity : 0,
+        };
+    }
+    getAnchorX() {
+        const anchorX = this.rotationGestureDetector.anchorX;
+        return anchorX ? anchorX : this.cachedAnchorX;
+    }
+    getAnchorY() {
+        const anchorY = this.rotationGestureDetector.anchorY;
+        return anchorY ? anchorY : this.cachedAnchorY;
+    }
+    onPointerDown(event) {
+        this.tracker.addToTracker(event);
+        super.onPointerDown(event);
+        this.tryToSendTouchEvent(event);
+    }
+    onPointerAdd(event) {
+        this.tracker.addToTracker(event);
+        super.onPointerAdd(event);
+        this.tryBegin();
+        this.rotationGestureDetector.onTouchEvent(event, this.tracker);
+    }
+    onPointerMove(event) {
+        if (this.tracker.trackedPointersCount < 2) {
+            return;
+        }
+        if (this.getAnchorX()) {
+            this.cachedAnchorX = this.getAnchorX();
+        }
+        if (this.getAnchorY()) {
+            this.cachedAnchorY = this.getAnchorY();
+        }
+        this.tracker.track(event);
+        this.rotationGestureDetector.onTouchEvent(event, this.tracker);
+        super.onPointerMove(event);
+    }
+    onPointerOutOfBounds(event) {
+        if (this.tracker.trackedPointersCount < 2) {
+            return;
+        }
+        if (this.getAnchorX()) {
+            this.cachedAnchorX = this.getAnchorX();
+        }
+        if (this.getAnchorY()) {
+            this.cachedAnchorY = this.getAnchorY();
+        }
+        this.tracker.track(event);
+        this.rotationGestureDetector.onTouchEvent(event, this.tracker);
+        super.onPointerOutOfBounds(event);
+    }
+    onPointerUp(event) {
+        super.onPointerUp(event);
+        this.tracker.removeFromTracker(event.pointerId);
+        this.rotationGestureDetector.onTouchEvent(event, this.tracker);
+        if (this.state !== State.ACTIVE) {
+            return;
+        }
+        if (this.state === State.ACTIVE) {
+            this.end();
+        }
+        else {
+            this.fail();
+        }
+    }
+    onPointerRemove(event) {
+        super.onPointerRemove(event);
+        this.rotationGestureDetector.onTouchEvent(event, this.tracker);
+        this.tracker.removeFromTracker(event.pointerId);
+    }
+    tryBegin() {
+        if (this.state !== State.UNDETERMINED) {
+            return;
+        }
+        this.begin();
+    }
+    onReset() {
+        if (this.state === State.ACTIVE) {
+            return;
+        }
+        this.rotation = 0;
+        this.velocity = 0;
+        this.rotationGestureDetector.reset();
+    }
+}

package/lib/typescript/web/handlers/TapGestureHandler.d.ts

@@ -23,6 +23,7 @@ export default class TapGestureHandler extends GestureHandler {
     private clearTimeouts;
     private startTap;
     private endTap;
+    private updateLastCoords;
     protected onPointerDown(event: AdaptedEvent): void;
     protected onPointerAdd(event: AdaptedEvent): void;
     protected onPointerUp(event: AdaptedEvent): void;
@@ -36,4 +37,3 @@ export default class TapGestureHandler extends GestureHandler {
     protected onCancel(): void;
     protected resetProgress(): void;
 }
-//# sourceMappingURL=TapGestureHandler.d.ts.map

package/lib/typescript/web/handlers/TapGestureHandler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TapGestureHandler.d.ts","sourceRoot":"","sources":["../../../../src/web/handlers/TapGestureHandler.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,EAAc,MAAM,eAAe,CAAC;AAEjE,OAAO,cAAc,MAAM,kBAAkB,CAAC;AAO9C,MAAM,CAAC,OAAO,OAAO,iBAAkB,SAAQ,cAAc;IAC3D,OAAO,CAAC,SAAS,CAA2B;IAC5C,OAAO,CAAC,SAAS,CAA2B;IAC5C,OAAO,CAAC,SAAS,CAA2B;IAC5C,OAAO,CAAC,aAAa,CAA2B;IAChD,OAAO,CAAC,UAAU,CAAwB;IAE1C,OAAO,CAAC,YAAY,CAA0B;IAC9C,OAAO,CAAC,mBAAmB,CAAkC;IAC7D,OAAO,CAAC,0BAA0B,CAAK;IAEvC,OAAO,CAAC,MAAM,CAAK;IACnB,OAAO,CAAC,MAAM,CAAK;IACnB,OAAO,CAAC,OAAO,CAAK;IACpB,OAAO,CAAC,OAAO,CAAK;IACpB,OAAO,CAAC,KAAK,CAAK;IAClB,OAAO,CAAC,KAAK,CAAK;IAElB,OAAO,CAAC,WAAW,CAAqB;IACxC,OAAO,CAAC,YAAY,CAAqB;IAEzC,OAAO,CAAC,SAAS,CAAK;IAEf,mBAAmB,CAAC,EAAE,OAAc,EAAE,GAAG,KAAK,EAAE,EAAE,MAAM,GAAG,IAAI;IAgCtE,SAAS,CAAC,WAAW,IAAI,IAAI;IAY7B,OAAO,CAAC,aAAa;IAKrB,OAAO,CAAC,QAAQ;IAMhB,OAAO,CAAC,MAAM;IAcd,SAAS,CAAC,aAAa,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI;IAqBlD,SAAS,CAAC,YAAY,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI;IAkBjD,SAAS,CAAC,WAAW,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI;IAYhD,SAAS,CAAC,eAAe,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI;IAiBpD,SAAS,CAAC,aAAa,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI;IAalD,SAAS,CAAC,oBAAoB,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI;IAazD,OAAO,CAAC,WAAW;IA8BnB,OAAO,CAAC,kBAAkB;IAW1B,OAAO,CAAC,UAAU;IAyBX,QAAQ,IAAI,IAAI;IAMvB,SAAS,CAAC,QAAQ,IAAI,IAAI;IAK1B,SAAS,CAAC,aAAa,IAAI,IAAI;CAKhC"}
+{"version":3,"file":"TapGestureHandler.d.ts","sourceRoot":"","sources":["../../../../src/web/handlers/TapGestureHandler.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,EAAc,MAAM,eAAe,CAAC;AAEjE,OAAO,cAAc,MAAM,kBAAkB,CAAC;AAO9C,MAAM,CAAC,OAAO,OAAO,iBAAkB,SAAQ,cAAc;IAC3D,OAAO,CAAC,SAAS,CAA2B;IAC5C,OAAO,CAAC,SAAS,CAA2B;IAC5C,OAAO,CAAC,SAAS,CAA2B;IAC5C,OAAO,CAAC,aAAa,CAA2B;IAChD,OAAO,CAAC,UAAU,CAAwB;IAE1C,OAAO,CAAC,YAAY,CAA0B;IAC9C,OAAO,CAAC,mBAAmB,CAAkC;IAC7D,OAAO,CAAC,0BAA0B,CAAK;IAEvC,OAAO,CAAC,MAAM,CAAK;IACnB,OAAO,CAAC,MAAM,CAAK;IACnB,OAAO,CAAC,OAAO,CAAK;IACpB,OAAO,CAAC,OAAO,CAAK;IACpB,OAAO,CAAC,KAAK,CAAK;IAClB,OAAO,CAAC,KAAK,CAAK;IAElB,OAAO,CAAC,WAAW,CAAqB;IACxC,OAAO,CAAC,YAAY,CAAqB;IAEzC,OAAO,CAAC,SAAS,CAAK;IAEf,mBAAmB,CAAC,EAAE,OAAc,EAAE,GAAG,KAAK,EAAE,EAAE,MAAM,GAAG,IAAI;IAgCtE,SAAS,CAAC,WAAW,IAAI,IAAI;IAY7B,OAAO,CAAC,aAAa;IAKrB,OAAO,CAAC,QAAQ;IAMhB,OAAO,CAAC,MAAM;IAad,OAAO,CAAC,gBAAgB;IAQxB,SAAS,CAAC,aAAa,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI;IAqBlD,SAAS,CAAC,YAAY,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI;IAgBjD,SAAS,CAAC,WAAW,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI;IAUhD,SAAS,CAAC,eAAe,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI;IAepD,SAAS,CAAC,aAAa,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI;IAUlD,SAAS,CAAC,oBAAoB,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI;IAUzD,OAAO,CAAC,WAAW;IA8BnB,OAAO,CAAC,kBAAkB;IAW1B,OAAO,CAAC,UAAU;IAyBX,QAAQ,IAAI,IAAI;IAMvB,SAAS,CAAC,QAAQ,IAAI,IAAI;IAK1B,SAAS,CAAC,aAAa,IAAI,IAAI;CAKhC"}