react-native-gesture-handler 3.0.0-beta.2 → 3.0.0-beta.4

package/src/web/handlers/NativeViewGestureHandler.ts

@@ -1,25 +1,40 @@
 import { Platform } from 'react-native';
-import { State } from '../../State';
-import { DEFAULT_TOUCH_SLOP } from '../constants';
-import { AdaptedEvent, Config, PropsRef } from '../interfaces';
 
-import GestureHandler from './GestureHandler';
-import { ActionType } from '../../ActionType';
-import { GestureHandlerDelegate } from '../tools/GestureHandlerDelegate';
-import IGestureHandler from './IGestureHandler';
+import { type ActionType, usesNativeOrVirtualDetector } from '../../ActionType';
+import { State } from '../../State';
+import { deepEqual } from '../../utils';
+import type { NativeHandlerData } from '../../v3/hooks/gestures/native/NativeTypes';
+import type { HandlerData } from '../../v3/types';
 import { SingleGestureName } from '../../v3/types';
+import {
+  DEFAULT_TOUCH_SLOP,
+  NATIVE_GESTURE_ROLE_ATTRIBUTE,
+} from '../constants';
+import type { AdaptedEvent, Config, PropsRef } from '../interfaces';
+import { NativeGestureRole } from '../interfaces';
+import type { GestureHandlerDelegate } from '../tools/GestureHandlerDelegate';
+import {
+  dispatchGestureLifecycleEvent,
+  GestureLifecycleEvent,
+} from '../tools/GestureLifecycleEvents';
+import GestureHandler from './GestureHandler';
+import type IGestureHandler from './IGestureHandler';
+
 export default class NativeViewGestureHandler extends GestureHandler {
-  private buttonRole!: boolean;
+  public override readonly isContinuous = true;
+  private role: NativeGestureRole | null = null;
 
-  // TODO: Implement logic for activation on start
-  // @ts-ignore Logic yet to be implemented
+  // TODO: Implement logic for activation on start properly
   private shouldActivateOnStart = false;
   private disallowInterruption = false;
+  private yieldsToContinuousGestures = false;
 
   private startX = 0;
   private startY = 0;
   private minDistSq = DEFAULT_TOUCH_SLOP * DEFAULT_TOUCH_SLOP;
 
+  private lastActiveHandlerData: HandlerData<NativeHandlerData> | null = null;
+
   public constructor(
     delegate: GestureHandlerDelegate<unknown, IGestureHandler>
   ) {
@@ -43,7 +58,19 @@ export default class NativeViewGestureHandler extends GestureHandler {
     const view = this.delegate.view as HTMLElement;
 
     this.restoreViewStyles(view);
-    this.buttonRole = view.getAttribute('role') === 'button';
+
+    if (usesNativeOrVirtualDetector(this.actionType)) {
+      this.role =
+        (view.getAttribute(
+          NATIVE_GESTURE_ROLE_ATTRIBUTE
+        ) as NativeGestureRole) ?? null;
+    } else {
+      if (view.getAttribute('role') === 'button') {
+        this.role = NativeGestureRole.Button;
+      } else if (view.querySelector(':scope > input[role="switch"]') !== null) {
+        this.role = NativeGestureRole.Switch;
+      }
+    }
   }
 
   public override updateGestureConfig(config: Config): void {
@@ -55,6 +82,9 @@ export default class NativeViewGestureHandler extends GestureHandler {
     if (config.disallowInterruption !== undefined) {
       this.disallowInterruption = config.disallowInterruption;
     }
+    if (config.yieldsToContinuousGestures !== undefined) {
+      this.yieldsToContinuousGestures = config.yieldsToContinuousGestures;
+    }
 
     const view = this.delegate.view as HTMLElement;
     this.restoreViewStyles(view);
@@ -66,7 +96,7 @@ export default class NativeViewGestureHandler extends GestureHandler {
     }
 
     view.style['touchAction'] = 'auto';
-    // @ts-ignore Turns on defualt touch behavior on Safari
+    // @ts-ignore Turns on default touch behavior on Safari
     view.style['WebkitTouchCallout'] = 'auto';
   }
 
@@ -93,10 +123,19 @@ export default class NativeViewGestureHandler extends GestureHandler {
 
     this.begin();
 
+    dispatchGestureLifecycleEvent(
+      this.delegate.view as HTMLElement | null,
+      GestureLifecycleEvent.Began
+    );
+
     const view = this.delegate.view as HTMLElement;
     const isRNGHText = view.hasAttribute('rnghtext');
 
-    if (this.buttonRole || isRNGHText) {
+    if (
+      (this.role === NativeGestureRole.Button && this.shouldActivateOnStart) ||
+      this.role === NativeGestureRole.Switch ||
+      isRNGHText
+    ) {
       this.activate();
     }
   }
@@ -109,12 +148,15 @@ export default class NativeViewGestureHandler extends GestureHandler {
     const dy = this.startY - lastCoords.y;
     const distSq = dx * dx + dy * dy;
 
-    if (distSq >= this.minDistSq) {
-      if (this.buttonRole && this.state === State.ACTIVE) {
-        this.cancel();
-      } else if (!this.buttonRole && this.state === State.BEGAN) {
-        this.activate();
-      }
+    if (
+      this.role === NativeGestureRole.Switch ||
+      this.role === NativeGestureRole.Button
+    ) {
+      return;
+    }
+
+    if (distSq >= this.minDistSq && this.state === State.BEGAN) {
+      this.activate();
     }
   }
 
@@ -138,6 +180,13 @@ export default class NativeViewGestureHandler extends GestureHandler {
     this.tracker.removeFromTracker(event.pointerId);
 
     if (this.tracker.trackedPointersCount === 0) {
+      if (
+        this.role === NativeGestureRole.Button &&
+        this.state === State.BEGAN
+      ) {
+        this.activate();
+      }
+
       if (this.state === State.ACTIVE) {
         this.end();
       } else {
@@ -147,7 +196,7 @@ export default class NativeViewGestureHandler extends GestureHandler {
   }
 
   public override shouldRecognizeSimultaneously(
-    handler: GestureHandler
+    handler: IGestureHandler
   ): boolean {
     if (super.shouldRecognizeSimultaneously(handler)) {
       return true;
@@ -156,12 +205,15 @@ export default class NativeViewGestureHandler extends GestureHandler {
     if (
       handler instanceof NativeViewGestureHandler &&
       handler.state === State.ACTIVE &&
-      handler.disallowsInterruption()
+      handler.disallowsInterruption() &&
+      !handler.yieldsToContinuousGestures
     ) {
       return false;
     }
 
-    const canBeInterrupted = !this.disallowInterruption;
+    const canBeInterrupted =
+      !this.disallowInterruption ||
+      (this.yieldsToContinuousGestures && handler.isContinuous);
 
     if (
       this.state === State.ACTIVE &&
@@ -176,8 +228,16 @@ export default class NativeViewGestureHandler extends GestureHandler {
     );
   }
 
-  public override shouldBeCancelledByOther(_handler: GestureHandler): boolean {
-    return !this.disallowInterruption;
+  public override detach(): void {
+    super.detach();
+    this.role = null;
+  }
+
+  public override shouldBeCancelledByOther(handler: IGestureHandler): boolean {
+    return (
+      !this.disallowInterruption ||
+      (this.yieldsToContinuousGestures && handler.isContinuous)
+    );
   }
 
   public override shouldAttachGestureToChildView(): boolean {
@@ -189,7 +249,32 @@ export default class NativeViewGestureHandler extends GestureHandler {
   }
 
   public isButton(): boolean {
-    return this.buttonRole;
+    return this.role === NativeGestureRole.Button;
+  }
+
+  public override shouldBeginWithRecordedHandlers(
+    recorded: IGestureHandler[]
+  ): boolean {
+    if (!this.isButton()) {
+      return true;
+    }
+
+    const self = this as IGestureHandler;
+    return recorded.every(
+      (other) =>
+        other.shouldRecognizeSimultaneously(self) ||
+        self.shouldRecognizeSimultaneously(other) ||
+        other.delegate.view === this.delegate.view ||
+        other.name === SingleGestureName.Hover
+    );
+  }
+
+  protected override onCancel(): void {
+    super.onCancel();
+    dispatchGestureLifecycleEvent(
+      this.delegate.view as HTMLElement | null,
+      GestureLifecycleEvent.Canceled
+    );
   }
 
   protected override transformNativeEvent(): Record<string, unknown> {
@@ -199,4 +284,22 @@ export default class NativeViewGestureHandler extends GestureHandler {
       ),
     };
   }
+
+  protected override shouldSuppressActiveUpdate(
+    handlerData: HandlerData<NativeHandlerData>
+  ): boolean {
+    if (
+      this.lastActiveHandlerData &&
+      deepEqual(this.lastActiveHandlerData, handlerData)
+    ) {
+      return true;
+    }
+    this.lastActiveHandlerData = handlerData;
+    return false;
+  }
+
+  public override reset(): void {
+    super.reset();
+    this.lastActiveHandlerData = null;
+  }
 }

package/src/web/handlers/PanGestureHandler.ts

@@ -1,22 +1,24 @@
+import type { StylusData } from '../../handlers/gestureHandlerCommon';
 import { State } from '../../State';
+import { SingleGestureName } from '../../v3/types';
 import { DEFAULT_TOUCH_SLOP } from '../constants';
-import { AdaptedEvent, Config, WheelDevice } from '../interfaces';
-import { StylusData } from '../../handlers/gestureHandlerCommon';
-
+import type { AdaptedEvent, Config } from '../interfaces';
+import { WheelDevice } from '../interfaces';
+import type { GestureHandlerDelegate } from '../tools/GestureHandlerDelegate';
 import GestureHandler from './GestureHandler';
-import { GestureHandlerDelegate } from '../tools/GestureHandlerDelegate';
-import IGestureHandler from './IGestureHandler';
-import { SingleGestureName } from '../../v3/types';
+import type IGestureHandler from './IGestureHandler';
 
 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 {
+  public override readonly isContinuous = true;
+
   public velocityX = 0;
   public velocityY = 0;
 
-  private minDist?: number = undefined;
+  private minDist?: number | undefined = undefined;
   private minDistSq = DEFAULT_MIN_DIST_SQ;
 
   private activeOffsetXStart = -Number.MAX_SAFE_INTEGER;

package/src/web/handlers/PinchGestureHandler.ts

@@ -1,17 +1,17 @@
+import type { ActionType } from '../../ActionType';
 import { State } from '../../State';
+import { SingleGestureName } from '../../v3/types';
 import { DEFAULT_TOUCH_SLOP } from '../constants';
-import { AdaptedEvent, PropsRef } from '../interfaces';
-
+import type { ScaleGestureListener } from '../detectors/ScaleGestureDetector';
+import ScaleGestureDetector from '../detectors/ScaleGestureDetector';
+import type { AdaptedEvent, PropsRef } from '../interfaces';
+import type { GestureHandlerDelegate } from '../tools/GestureHandlerDelegate';
 import GestureHandler from './GestureHandler';
-import ScaleGestureDetector, {
-  ScaleGestureListener,
-} from '../detectors/ScaleGestureDetector';
-import { ActionType } from '../../ActionType';
-import { GestureHandlerDelegate } from '../tools/GestureHandlerDelegate';
-import IGestureHandler from './IGestureHandler';
-import { SingleGestureName } from '../../v3/types';
+import type IGestureHandler from './IGestureHandler';
 
 export default class PinchGestureHandler extends GestureHandler {
+  public override readonly isContinuous = true;
+
   private scale = 1;
   private velocity = 0;
 
@@ -70,9 +70,14 @@ export default class PinchGestureHandler extends GestureHandler {
   }
 
   protected override transformNativeEvent() {
+    const focal = this.delegate.absoluteToLocal(
+      this.scaleGestureDetector.focusX,
+      this.scaleGestureDetector.focusY
+    );
+
     return {
-      focalX: this.scaleGestureDetector.focusX,
-      focalY: this.scaleGestureDetector.focusY,
+      focalX: focal.x,
+      focalY: focal.y,
       velocity: this.velocity,
       scale: this.scale,
     };
@@ -86,19 +91,18 @@ export default class PinchGestureHandler extends GestureHandler {
   protected override onPointerAdd(event: AdaptedEvent): void {
     this.tracker.addToTracker(event);
     super.onPointerAdd(event);
-    this.tryBegin();
     this.scaleGestureDetector.onTouchEvent(event, this.tracker);
+    this.tryBegin();
   }
 
   protected override onPointerUp(event: AdaptedEvent): void {
     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) {
+      // We don't have to call it in the else branch as it would simply return `true`.
+      this.scaleGestureDetector.onTouchEvent(event, this.tracker);
+
       this.end();
     } else {
       this.fail();
@@ -109,26 +113,22 @@ export default class PinchGestureHandler extends GestureHandler {
     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();
-    }
   }
 
   protected override onPointerMove(event: AdaptedEvent): void {
+    this.tracker.track(event);
     if (this.tracker.trackedPointersCount < 2) {
       return;
     }
-    this.tracker.track(event);
 
     this.scaleGestureDetector.onTouchEvent(event, this.tracker);
     super.onPointerMove(event);
   }
   protected override onPointerOutOfBounds(event: AdaptedEvent): void {
+    this.tracker.track(event);
     if (this.tracker.trackedPointersCount < 2) {
       return;
     }
-    this.tracker.track(event);
 
     this.scaleGestureDetector.onTouchEvent(event, this.tracker);
     super.onPointerOutOfBounds(event);

package/src/web/handlers/RotationGestureHandler.ts

@@ -1,18 +1,18 @@
+import type { ActionType } from '../../ActionType';
 import { State } from '../../State';
-import { AdaptedEvent, PropsRef } from '../interfaces';
-
-import GestureHandler from './GestureHandler';
-import RotationGestureDetector, {
-  RotationGestureListener,
-} from '../detectors/RotationGestureDetector';
-import { ActionType } from '../../ActionType';
-import { GestureHandlerDelegate } from '../tools/GestureHandlerDelegate';
-import IGestureHandler from './IGestureHandler';
 import { SingleGestureName } from '../../v3/types';
+import type { RotationGestureListener } from '../detectors/RotationGestureDetector';
+import RotationGestureDetector from '../detectors/RotationGestureDetector';
+import type { AdaptedEvent, PropsRef } from '../interfaces';
+import type { GestureHandlerDelegate } from '../tools/GestureHandlerDelegate';
+import GestureHandler from './GestureHandler';
+import type IGestureHandler from './IGestureHandler';
 
 const ROTATION_RECOGNITION_THRESHOLD = Math.PI / 36;
 
 export default class RotationGestureHandler extends GestureHandler {
+  public override readonly isContinuous = true;
+
   private rotation = 0;
   private velocity = 0;
 
@@ -41,7 +41,11 @@ export default class RotationGestureHandler extends GestureHandler {
       return true;
     },
     onRotationEnd: (_detector: RotationGestureDetector): void => {
-      this.end();
+      if (this.state === State.ACTIVE) {
+        this.end();
+      } else {
+        this.fail();
+      }
     },
   };
 
@@ -66,24 +70,25 @@ export default class RotationGestureHandler extends GestureHandler {
   }
 
   protected override transformNativeEvent() {
+    const anchor = this.getAnchor();
+
     return {
       rotation: this.rotation ? this.rotation : 0,
-      anchorX: this.getAnchorX(),
-      anchorY: this.getAnchorY(),
+      anchorX: anchor.x,
+      anchorY: anchor.y,
       velocity: this.velocity ? this.velocity : 0,
     };
   }
 
-  public getAnchorX(): number {
-    const anchorX = this.rotationGestureDetector.anchorX;
-
-    return anchorX ? anchorX : this.cachedAnchorX;
-  }
+  private getAnchor(): { x: number; y: number } {
+    const absX = this.rotationGestureDetector.anchorX;
+    const absY = this.rotationGestureDetector.anchorY;
 
-  public getAnchorY(): number {
-    const anchorY = this.rotationGestureDetector.anchorY;
+    if (Number.isFinite(absX) && Number.isFinite(absY)) {
+      return this.delegate.absoluteToLocal(absX, absY);
+    }
 
-    return anchorY ? anchorY : this.cachedAnchorY;
+    return { x: this.cachedAnchorX, y: this.cachedAnchorY };
   }
 
   protected override onPointerDown(event: AdaptedEvent): void {
@@ -95,23 +100,19 @@ export default class RotationGestureHandler extends GestureHandler {
     this.tracker.addToTracker(event);
     super.onPointerAdd(event);
 
-    this.tryBegin();
     this.rotationGestureDetector.onTouchEvent(event, this.tracker);
+    this.tryBegin();
   }
 
   protected override onPointerMove(event: AdaptedEvent): void {
+    this.tracker.track(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);
+    const anchor = this.getAnchor();
+    this.cachedAnchorX = anchor.x;
+    this.cachedAnchorY = anchor.y;
 
     this.rotationGestureDetector.onTouchEvent(event, this.tracker);
 
@@ -119,18 +120,14 @@ export default class RotationGestureHandler extends GestureHandler {
   }
 
   protected override onPointerOutOfBounds(event: AdaptedEvent): void {
+    this.tracker.track(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);
+    const anchor = this.getAnchor();
+    this.cachedAnchorX = anchor.x;
+    this.cachedAnchorY = anchor.y;
 
     this.rotationGestureDetector.onTouchEvent(event, this.tracker);
 
@@ -141,16 +138,6 @@ export default class RotationGestureHandler extends GestureHandler {
     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();
-    }
   }
 
   protected override onPointerRemove(event: AdaptedEvent): void {

package/src/web/handlers/TapGestureHandler.ts

@@ -1,10 +1,10 @@
 import { State } from '../../State';
 import { SingleGestureName } from '../../v3/types';
-import { AdaptedEvent, Config, EventTypes } from '../interfaces';
-import { GestureHandlerDelegate } from '../tools/GestureHandlerDelegate';
-
+import type { AdaptedEvent, Config } from '../interfaces';
+import { EventTypes } from '../interfaces';
+import type { GestureHandlerDelegate } from '../tools/GestureHandlerDelegate';
 import GestureHandler from './GestureHandler';
-import IGestureHandler from './IGestureHandler';
+import type IGestureHandler from './IGestureHandler';
 
 const DEFAULT_MAX_DURATION_MS = 500;
 const DEFAULT_MAX_DELAY_MS = 500;

package/src/web/interfaces.ts

@@ -1,28 +1,28 @@
-import {
-  UserSelect,
+import type { Directions } from '../Directions';
+import type {
   ActiveCursor,
+  GestureTouchEvent,
   MouseButton,
-  TouchAction,
   StylusData,
-  GestureTouchEvent,
+  TouchAction,
+  UserSelect,
 } from '../handlers/gestureHandlerCommon';
-import { Directions } from '../Directions';
-import { PointerType } from '../PointerType';
-import {
+import type { PointerType } from '../PointerType';
+import type { State } from '../State';
+import type {
   GestureStateChangeEventWithHandlerData,
   GestureUpdateEventWithHandlerData,
 } from '../v3/types';
-import { State } from '../State';
 
 export interface HitSlop {
-  left?: number;
-  right?: number;
-  top?: number;
-  bottom?: number;
-  horizontal?: number;
-  vertical?: number;
-  width?: number;
-  height?: number;
+  left?: number | undefined;
+  right?: number | undefined;
+  top?: number | undefined;
+  bottom?: number | undefined;
+  horizontal?: number | undefined;
+  vertical?: number | undefined;
+  width?: number | undefined;
+  height?: number | undefined;
 }
 
 export interface Handler {
@@ -44,21 +44,21 @@ type ConfigArgs =
 
 export interface Config extends Record<string, ConfigArgs> {
   enabled: boolean;
-  simultaneousHandlers?: Handler[] | null;
-  waitFor?: Handler[] | null;
-  blocksHandlers?: Handler[] | null;
-  hitSlop?: HitSlop;
-  shouldCancelWhenOutside?: boolean;
-  userSelect?: UserSelect;
-  activeCursor?: ActiveCursor;
-  mouseButton?: MouseButton;
-  enableContextMenu?: boolean;
-  touchAction?: TouchAction;
-  manualActivation?: boolean;
-  dispatchesAnimatedEvents?: false;
-  dispatchesReanimatedEvents?: boolean;
-  needsPointerData?: false;
-  testID?: string;
+  simultaneousHandlers?: Handler[] | null | undefined;
+  waitFor?: Handler[] | null | undefined;
+  blocksHandlers?: Handler[] | null | undefined;
+  hitSlop?: HitSlop | undefined;
+  shouldCancelWhenOutside?: boolean | undefined;
+  userSelect?: UserSelect | undefined;
+  activeCursor?: ActiveCursor | undefined;
+  mouseButton?: MouseButton | undefined;
+  enableContextMenu?: boolean | undefined;
+  touchAction?: TouchAction | undefined;
+  manualActivation?: boolean | undefined;
+  dispatchesAnimatedEvents?: false | undefined;
+  dispatchesReanimatedEvents?: boolean | undefined;
+  needsPointerData?: false | undefined;
+  testID?: string | undefined;
 
   activateAfterLongPress?: number;
   failOffsetXStart?: number;
@@ -88,6 +88,7 @@ export interface Config extends Record<string, ConfigArgs> {
   maxDeltaY?: number;
   shouldActivateOnStart?: boolean;
   disallowInterruption?: boolean;
+  yieldsToContinuousGestures?: boolean;
   direction?: Directions;
   enableTrackpadTwoFingerGesture?: boolean;
 }
@@ -98,7 +99,7 @@ export interface GestureHandlerNativeEvent
   numberOfPointers: number;
   state: State;
   handlerTag: number;
-  oldState?: State;
+  oldState?: State | undefined;
   pointerType: PointerType;
 }
 
@@ -147,9 +148,9 @@ export interface AdaptedEvent {
   eventType: EventTypes;
   pointerType: PointerType;
   time: number;
-  button?: MouseButton;
-  stylusData?: StylusData;
-  wheelDeltaY?: number;
+  button?: MouseButton | undefined;
+  stylusData?: StylusData | undefined;
+  wheelDeltaY?: number | undefined;
 }
 
 export enum EventTypes {
@@ -177,3 +178,9 @@ export type GestureHandlerRef = {
 export type SVGRef = {
   elementRef: { current: SVGElement };
 };
+
+export enum NativeGestureRole {
+  Button = 'GestureHandlerButton',
+  Switch = 'Switch',
+  ScrollView = 'ScrollView',
+}

package/src/web/tools/EventManager.ts

@@ -1,5 +1,5 @@
 /* eslint-disable @typescript-eslint/no-empty-function */
-import { AdaptedEvent, EventTypes } from '../interfaces';
+import type { AdaptedEvent, EventTypes } from '../interfaces';
 
 type PointerEventCallback = (event: AdaptedEvent) => void;
 

package/src/web/tools/GestureHandlerDelegate.ts

@@ -13,6 +13,10 @@ export interface GestureHandlerDelegate<TComponent, THandler> {
   updateDOM(): void;
   isPointerInBounds({ x, y }: { x: number; y: number }): boolean;
   measureView(): MeasureResult;
+  absoluteToLocal(
+    absoluteX: number,
+    absoluteY: number
+  ): { x: number; y: number };
   reset(): void;
 
   onBegin(): void;