react-native-gesture-handler 2.27.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

@@ -0,0 +1,27 @@
+import { AdaptedEvent } from '../interfaces';
+import GestureHandler from './GestureHandler';
+export default class PinchGestureHandler extends GestureHandler {
+    private scale;
+    private velocity;
+    private startingSpan;
+    private spanSlop;
+    private scaleDetectorListener;
+    private scaleGestureDetector;
+    init(ref: number, propsRef: React.RefObject<unknown>): void;
+    protected transformNativeEvent(): {
+        focalX: number;
+        focalY: number;
+        velocity: number;
+        scale: number;
+    };
+    protected onPointerDown(event: AdaptedEvent): void;
+    protected onPointerAdd(event: AdaptedEvent): void;
+    protected onPointerUp(event: AdaptedEvent): void;
+    protected onPointerRemove(event: AdaptedEvent): void;
+    protected onPointerMove(event: AdaptedEvent): void;
+    protected onPointerOutOfBounds(event: AdaptedEvent): void;
+    private tryBegin;
+    activate(force?: boolean): void;
+    protected onReset(): void;
+    protected resetProgress(): void;
+}

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

@@ -0,0 +1 @@
+{"version":3,"file":"PinchGestureHandler.d.ts","sourceRoot":"","sources":["../../../../src/web/handlers/PinchGestureHandler.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAE7C,OAAO,cAAc,MAAM,kBAAkB,CAAC;AAK9C,MAAM,CAAC,OAAO,OAAO,mBAAoB,SAAQ,cAAc;IAC7D,OAAO,CAAC,KAAK,CAAK;IAClB,OAAO,CAAC,QAAQ,CAAK;IAErB,OAAO,CAAC,YAAY,CAAK;IACzB,OAAO,CAAC,QAAQ,CAAsB;IAEtC,OAAO,CAAC,qBAAqB,CA4B3B;IAEF,OAAO,CAAC,oBAAoB,CAE1B;IAEK,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC,OAAO,CAAC;IAM3D,SAAS,CAAC,oBAAoB;;;;;;IAS9B,SAAS,CAAC,aAAa,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI;IAOlD,SAAS,CAAC,YAAY,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI;IAOjD,SAAS,CAAC,WAAW,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI;IAehD,SAAS,CAAC,eAAe,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI;IAUpD,SAAS,CAAC,aAAa,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI;IASlD,SAAS,CAAC,oBAAoB,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI;IAUzD,OAAO,CAAC,QAAQ;IAST,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,GAAG,IAAI;IAQtC,SAAS,CAAC,OAAO,IAAI,IAAI;IAIzB,SAAS,CAAC,aAAa,IAAI,IAAI;CAOhC"}

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

@@ -0,0 +1,27 @@
+import { AdaptedEvent } from '../interfaces';
+import GestureHandler from './GestureHandler';
+export default class RotationGestureHandler extends GestureHandler {
+    private rotation;
+    private velocity;
+    private cachedAnchorX;
+    private cachedAnchorY;
+    private rotationGestureListener;
+    private rotationGestureDetector;
+    init(ref: number, propsRef: React.RefObject<unknown>): void;
+    protected transformNativeEvent(): {
+        rotation: number;
+        anchorX: number;
+        anchorY: number;
+        velocity: number;
+    };
+    getAnchorX(): number;
+    getAnchorY(): number;
+    protected onPointerDown(event: AdaptedEvent): void;
+    protected onPointerAdd(event: AdaptedEvent): void;
+    protected onPointerMove(event: AdaptedEvent): void;
+    protected onPointerOutOfBounds(event: AdaptedEvent): void;
+    protected onPointerUp(event: AdaptedEvent): void;
+    protected onPointerRemove(event: AdaptedEvent): void;
+    protected tryBegin(): void;
+    protected onReset(): void;
+}

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

@@ -0,0 +1 @@
+{"version":3,"file":"RotationGestureHandler.d.ts","sourceRoot":"","sources":["../../../../src/web/handlers/RotationGestureHandler.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAE7C,OAAO,cAAc,MAAM,kBAAkB,CAAC;AAO9C,MAAM,CAAC,OAAO,OAAO,sBAAuB,SAAQ,cAAc;IAChE,OAAO,CAAC,QAAQ,CAAK;IACrB,OAAO,CAAC,QAAQ,CAAK;IAErB,OAAO,CAAC,aAAa,CAAK;IAC1B,OAAO,CAAC,aAAa,CAAK;IAE1B,OAAO,CAAC,uBAAuB,CAwB7B;IAEF,OAAO,CAAC,uBAAuB,CAC6B;IAErD,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC,OAAO,CAAC,GAAG,IAAI;IAMlE,SAAS,CAAC,oBAAoB;;;;;;IASvB,UAAU,IAAI,MAAM;IAMpB,UAAU,IAAI,MAAM;IAM3B,SAAS,CAAC,aAAa,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI;IAOlD,SAAS,CAAC,YAAY,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI;IAQjD,SAAS,CAAC,aAAa,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI;IAmBlD,SAAS,CAAC,oBAAoB,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI;IAmBzD,SAAS,CAAC,WAAW,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI;IAgBhD,SAAS,CAAC,eAAe,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI;IAMpD,SAAS,CAAC,QAAQ,IAAI,IAAI;IAQ1B,SAAS,CAAC,OAAO,IAAI,IAAI;CAS1B"}