@amazon-devices/react-native-gesture-handler 4.0.1 → 4.0.2

package/src/web/tools/NodeManager.ts

@@ -1,48 +0,0 @@
-import { ValueOf } from '../../typeUtils';
-import { Gestures } from '../Gestures';
-import type IGestureHandler from '../handlers/IGestureHandler';
-
-// eslint-disable-next-line @typescript-eslint/no-extraneous-class
-export default abstract class NodeManager {
-  private static gestures: Record<
-    number,
-    InstanceType<ValueOf<typeof Gestures>>
-  > = {};
-
-  public static getHandler(tag: number): IGestureHandler {
-    if (tag in this.gestures) {
-      return this.gestures[tag] as IGestureHandler;
-    }
-
-    throw new Error(`No handler for tag ${tag}`);
-  }
-
-  public static createGestureHandler(
-    handlerTag: number,
-    handler: InstanceType<ValueOf<typeof Gestures>>
-  ): void {
-    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;
-  }
-
-  public static dropGestureHandler(handlerTag: number): void {
-    if (!(handlerTag in this.gestures)) {
-      return;
-    }
-
-    this.gestures[handlerTag].onDestroy();
-
-    // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
-    delete this.gestures[handlerTag];
-  }
-
-  public static get nodes() {
-    return { ...this.gestures };
-  }
-}

package/src/web/tools/PointerEventManager.ts

@@ -1,226 +0,0 @@
-import EventManager from './EventManager';
-import { MouseButton } from '../../handlers/gestureHandlerCommon';
-import { AdaptedEvent, EventTypes, Point } from '../interfaces';
-import {
-  PointerTypeMapping,
-  calculateViewScale,
-  tryExtractStylusData,
-  isPointerInBounds,
-} from '../utils';
-import { PointerType } from '../../PointerType';
-
-const POINTER_CAPTURE_EXCLUDE_LIST = new Set<string>(['SELECT', 'INPUT']);
-
-export default class PointerEventManager extends EventManager<HTMLElement> {
-  private trackedPointers = new Set<number>();
-  private readonly mouseButtonsMapper = new Map<number, MouseButton>();
-  private lastPosition: Point;
-
-  constructor(view: HTMLElement) {
-    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,
-    };
-  }
-
-  private pointerDownCallback = (event: PointerEvent) => {
-    if (!isPointerInBounds(this.view, { x: event.clientX, y: event.clientY })) {
-      return;
-    }
-
-    const adaptedEvent: AdaptedEvent = this.mapEvent(event, EventTypes.DOWN);
-    const target = event.target as HTMLElement;
-
-    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);
-    }
-  };
-
-  private pointerUpCallback = (event: PointerEvent) => {
-    // 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: AdaptedEvent = this.mapEvent(event, EventTypes.UP);
-    const target = event.target as HTMLElement;
-
-    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);
-    }
-  };
-
-  private pointerMoveCallback = (event: PointerEvent) => {
-    const adaptedEvent: AdaptedEvent = this.mapEvent(event, EventTypes.MOVE);
-    const target = event.target as HTMLElement;
-
-    // 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: boolean = isPointerInBounds(this.view, {
-      x: adaptedEvent.x,
-      y: adaptedEvent.y,
-    });
-
-    const pointerIndex: number = 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;
-  };
-
-  private pointerCancelCallback = (event: PointerEvent) => {
-    const adaptedEvent: AdaptedEvent = this.mapEvent(event, EventTypes.CANCEL);
-
-    this.onPointerCancel(adaptedEvent);
-    this.markAsOutOfBounds(adaptedEvent.pointerId);
-    this.activePointersCounter = 0;
-    this.trackedPointers.clear();
-  };
-
-  private pointerEnterCallback = (event: PointerEvent) => {
-    const adaptedEvent: AdaptedEvent = this.mapEvent(event, EventTypes.ENTER);
-
-    this.onPointerMoveOver(adaptedEvent);
-  };
-
-  private pointerLeaveCallback = (event: PointerEvent) => {
-    const adaptedEvent: AdaptedEvent = this.mapEvent(event, EventTypes.LEAVE);
-
-    this.onPointerMoveOut(adaptedEvent);
-  };
-
-  private lostPointerCaptureCallback = (event: PointerEvent) => {
-    const adaptedEvent: 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();
-    }
-  };
-
-  public registerListeners(): void {
-    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
-    );
-  }
-
-  public unregisterListeners(): void {
-    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
-    );
-  }
-
-  protected mapEvent(event: PointerEvent, eventType: EventTypes): AdaptedEvent {
-    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),
-    };
-  }
-
-  public resetManager(): void {
-    super.resetManager();
-    this.trackedPointers.clear();
-  }
-}

package/src/web/tools/PointerTracker.ts

@@ -1,228 +0,0 @@
-import { AdaptedEvent, Point } from '../interfaces';
-import VelocityTracker from './VelocityTracker';
-
-export interface TrackerElement {
-  abosoluteCoords: Point;
-  relativeCoords: Point;
-  timestamp: number;
-  velocityX: number;
-  velocityY: number;
-}
-
-const MAX_POINTERS = 20;
-
-export default class PointerTracker {
-  private velocityTracker = new VelocityTracker();
-  private readonly _trackedPointers: Map<number, TrackerElement> = new Map<
-    number,
-    TrackerElement
-  >();
-
-  private touchEventsIds: Map<number, number> = new Map<number, number>();
-
-  private lastMovedPointerId: number;
-
-  private cachedAbsoluteAverages: Point = { x: 0, y: 0 };
-  private cachedRelativeAverages: Point = { x: 0, y: 0 };
-
-  public constructor() {
-    this.lastMovedPointerId = NaN;
-
-    for (let i = 0; i < MAX_POINTERS; ++i) {
-      this.touchEventsIds.set(i, NaN);
-    }
-  }
-
-  public addToTracker(event: AdaptedEvent): void {
-    if (this.trackedPointers.has(event.pointerId)) {
-      return;
-    }
-
-    this.lastMovedPointerId = event.pointerId;
-
-    const newElement: TrackerElement = {
-      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();
-  }
-
-  public removeFromTracker(pointerId: number): void {
-    this.trackedPointers.delete(pointerId);
-    this.removeMappedTouchId(pointerId);
-  }
-
-  public track(event: AdaptedEvent): void {
-    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
-  private mapTouchEventId(id: number): void {
-    for (const [mappedId, touchId] of this.touchEventsIds) {
-      if (isNaN(touchId)) {
-        this.touchEventsIds.set(mappedId, id);
-        break;
-      }
-    }
-  }
-
-  private removeMappedTouchId(id: number): void {
-    const mappedId: number = this.getMappedTouchEventId(id);
-    if (!isNaN(mappedId)) {
-      this.touchEventsIds.set(mappedId, NaN);
-    }
-  }
-
-  public getMappedTouchEventId(touchEventId: number): number {
-    for (const [key, value] of this.touchEventsIds.entries()) {
-      if (value === touchEventId) {
-        return key;
-      }
-    }
-
-    return NaN;
-  }
-
-  public getVelocity(pointerId: number) {
-    const pointerData = this.trackedPointers.get(pointerId);
-
-    return pointerData
-      ? {
-          x: pointerData.velocityX,
-          y: pointerData.velocityY,
-        }
-      : null;
-  }
-
-  public getLastAbsoluteCoords(pointerId?: number) {
-    return this.trackedPointers.get(pointerId ?? this.lastMovedPointerId)
-      ?.abosoluteCoords;
-  }
-
-  public getLastRelativeCoords(pointerId?: number) {
-    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
-
-  public 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;
-  }
-
-  public 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;
-  }
-
-  public getAbsoluteCoordsSum(ignoredPointer?: number) {
-    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;
-  }
-
-  public getRelativeCoordsSum(ignoredPointer?: number) {
-    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;
-  }
-
-  public resetTracker(): void {
-    this.velocityTracker.reset();
-    this.trackedPointers.clear();
-    this.lastMovedPointerId = NaN;
-
-    for (let i = 0; i < MAX_POINTERS; ++i) {
-      this.touchEventsIds.set(i, NaN);
-    }
-  }
-
-  public static shareCommonPointers(
-    stPointers: number[],
-    ndPointers: number[]
-  ): boolean {
-    return stPointers.some((pointerId) => ndPointers.includes(pointerId));
-  }
-
-  public get trackedPointersCount(): number {
-    return this.trackedPointers.size;
-  }
-
-  public get trackedPointersIDs() {
-    const keys: number[] = [];
-
-    this.trackedPointers.forEach((_value, key) => {
-      keys.push(key);
-    });
-
-    return keys;
-  }
-
-  public get trackedPointers() {
-    return this._trackedPointers;
-  }
-}

package/src/web/tools/Vector.ts

@@ -1,59 +0,0 @@
-import { DiagonalDirections, Directions } from '../../Directions';
-import { MINIMAL_RECOGNIZABLE_MAGNITUDE } from '../constants';
-import PointerTracker from './PointerTracker';
-
-export default class Vector {
-  private readonly x;
-  private readonly y;
-  private readonly unitX;
-  private readonly unitY;
-  private readonly _magnitude;
-
-  constructor(x: number, y: number) {
-    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: Directions | DiagonalDirections): Vector {
-    return DirectionToVectorMappings.get(direction) ?? new Vector(0, 0);
-  }
-
-  static fromVelocity(tracker: PointerTracker, pointerId: number) {
-    const velocity = tracker.getVelocity(pointerId);
-    return velocity ? new Vector(velocity.x, velocity.y) : null;
-  }
-
-  public get magnitude() {
-    return this._magnitude;
-  }
-
-  computeSimilarity(vector: Vector) {
-    return this.unitX * vector.unitX + this.unitY * vector.unitY;
-  }
-
-  isSimilar(vector: Vector, threshold: number) {
-    return this.computeSimilarity(vector) > threshold;
-  }
-}
-
-const DirectionToVectorMappings = new Map<
-  Directions | DiagonalDirections,
-  Vector
->([
-  [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/src/web/tools/VelocityTracker.ts

@@ -1,98 +0,0 @@
-import { AdaptedEvent } from '../interfaces';
-import CircularBuffer from './CircularBuffer';
-import LeastSquareSolver from './LeastSquareSolver';
-
-export default class VelocityTracker {
-  private assumePointerMoveStoppedMilliseconds = 40;
-  private historySize = 20;
-  private horizonMilliseconds = 300;
-  private minSampleSize = 3;
-
-  private samples: CircularBuffer<AdaptedEvent>;
-
-  constructor() {
-    this.samples = new CircularBuffer<AdaptedEvent>(this.historySize);
-  }
-
-  public add(event: AdaptedEvent): void {
-    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.
-  private getVelocityEstimate(): [number, number] | null {
-    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;
-  }
-
-  public get velocity(): [number, number] {
-    const estimate = this.getVelocityEstimate();
-    if (estimate !== null) {
-      return estimate;
-    }
-    return [0, 0];
-  }
-
-  public reset(): void {
-    this.samples.clear();
-  }
-}

package/src/web/tools/WheelEventManager.ts

@@ -1,48 +0,0 @@
-import EventManager from './EventManager';
-import { AdaptedEvent, EventTypes } from '../interfaces';
-import { PointerType } from '../../PointerType';
-
-export default class WheelEventManager extends EventManager<HTMLElement> {
-  private wheelDelta = { x: 0, y: 0 };
-
-  private resetDelta = (_event: PointerEvent) => {
-    this.wheelDelta = { x: 0, y: 0 };
-  };
-
-  private wheelCallback = (event: WheelEvent) => {
-    this.wheelDelta.x += event.deltaX;
-    this.wheelDelta.y += event.deltaY;
-
-    const adaptedEvent = this.mapEvent(event);
-    this.onWheel(adaptedEvent);
-  };
-
-  public registerListeners(): void {
-    this.view.addEventListener('pointermove', this.resetDelta);
-    this.view.addEventListener('wheel', this.wheelCallback);
-  }
-
-  public unregisterListeners(): void {
-    this.view.removeEventListener('pointermove', this.resetDelta);
-    this.view.removeEventListener('wheel', this.wheelCallback);
-  }
-
-  protected mapEvent(event: WheelEvent): AdaptedEvent {
-    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,
-    };
-  }
-
-  public resetManager(): void {
-    super.resetManager();
-  }
-}