react-native-gesture-handler 3.0.0-beta.3 → 3.0.0-beta.5

package/src/web/handlers/GestureHandler.ts

@@ -14,6 +14,7 @@ import { tagMessage } from '../../utils';
 import type {
   GestureStateChangeEventWithHandlerData,
   GestureUpdateEventWithHandlerData,
+  HandlerData,
   SingleGestureName,
 } from '../../v3/types';
 import type {
@@ -45,7 +46,7 @@ export default abstract class GestureHandler implements IGestureHandler {
 
   private viewRef: number | null = null;
   private propsRef: React.RefObject<PropsRef> | null = null;
-  private actionType: ActionType | null = null;
+  protected actionType: ActionType | null = null;
   private forAnimated: boolean = false;
   private forReanimated: boolean = false;
   private _handlerTag!: number;
@@ -302,6 +303,12 @@ export default abstract class GestureHandler implements IGestureHandler {
     );
   }
 
+  public shouldBeginWithRecordedHandlers(
+    _recorded: IGestureHandler[]
+  ): boolean {
+    return true;
+  }
+
   public shouldAttachGestureToChildView(): boolean {
     return false;
   }
@@ -355,8 +362,9 @@ export default abstract class GestureHandler implements IGestureHandler {
   protected onPointerCancel(_event: AdaptedEvent): void {
     // No need to send a cancel touch event explicitly here. `cancel` will
     // handle cancelling all tracked touches if the handler expects pointer data.
-    this.cancel();
-    this.reset();
+    if (GestureHandlerOrchestrator.instance.isHandlerRecorded(this)) {
+      this.cancel();
+    }
   }
   protected onPointerOutOfBounds(event: AdaptedEvent): void {
     this.tryToSendMoveEvent(true, event);
@@ -430,11 +438,13 @@ export default abstract class GestureHandler implements IGestureHandler {
       onGestureHandlerReanimatedStateChange,
     }: PropsRef = this.propsRef!.current;
 
+    const isStateChange = this.lastSentState !== newState;
+
     const resultEvent: ResultEvent = !usesNativeOrVirtualDetector(
       this.actionType
     )
       ? this.transformEventData(newState, oldState)
-      : this.lastSentState !== newState
+      : isStateChange
         ? this.transformStateChangeEvent(newState, oldState)
         : this.transformUpdateEvent(newState);
 
@@ -442,7 +452,7 @@ export default abstract class GestureHandler implements IGestureHandler {
     // Here the order is flipped to avoid workarounds such as making backup of the state and setting it to undefined first, then changing it back
     // Flipping order with setting oldState to undefined solves issue, when events were being sent twice instead of once
     // However, this may cause trouble in the future (but for now we don't know that)
-    if (this.lastSentState !== newState) {
+    if (isStateChange) {
       this.lastSentState = newState;
 
       if (this.forReanimated) {
@@ -456,6 +466,16 @@ export default abstract class GestureHandler implements IGestureHandler {
       return;
     }
 
+    // Cover only V3 path due to different event shape
+    if (!isStateChange && usesNativeOrVirtualDetector(this.actionType)) {
+      const handlerData = (
+        resultEvent.nativeEvent as GestureUpdateEventWithHandlerData<unknown>
+      ).handlerData;
+      if (this.shouldSuppressActiveUpdate(handlerData)) {
+        return;
+      }
+    }
+
     (resultEvent.nativeEvent as GestureHandlerNativeEvent).oldState = undefined;
 
     if (this.forReanimated) {
@@ -467,6 +487,12 @@ export default abstract class GestureHandler implements IGestureHandler {
     }
   };
 
+  protected shouldSuppressActiveUpdate(
+    _handlerData: HandlerData<unknown>
+  ): boolean {
+    return false;
+  }
+
   private transformEventData(
     newState: State,
     oldState: State
@@ -744,7 +770,6 @@ export default abstract class GestureHandler implements IGestureHandler {
     const enabledChanged = this.maybeUpdateEnabled(config.enabled);
 
     if (config.hitSlop !== undefined) {
-      this.hitSlop = config.hitSlop;
       this.hitSlop = config.hitSlop;
       this.validateHitSlops();
     }
@@ -1072,6 +1097,11 @@ export default abstract class GestureHandler implements IGestureHandler {
     this._name = value;
   }
 
+  /**
+   * Whether the handler represents a continuous gesture rather than a discrete one.
+   */
+  public readonly isContinuous: boolean = false;
+
   public getTrackedPointersID(): number[] {
     return this.tracker.trackedPointersIDs;
   }

package/src/web/handlers/HoverGestureHandler.ts

@@ -8,6 +8,8 @@ import GestureHandler from './GestureHandler';
 import type IGestureHandler from './IGestureHandler';
 
 export default class HoverGestureHandler extends GestureHandler {
+  public override readonly isContinuous = true;
+
   private stylusData: StylusData | undefined;
 
   public constructor(
@@ -52,9 +54,4 @@ export default class HoverGestureHandler extends GestureHandler {
 
     super.onPointerMove(event);
   }
-
-  protected override onPointerCancel(event: AdaptedEvent): void {
-    super.onPointerCancel(event);
-    this.reset();
-  }
 }

package/src/web/handlers/IGestureHandler.ts

@@ -22,6 +22,7 @@ export default interface IGestureHandler {
   readonly delegate: GestureHandlerDelegate<unknown, this>;
   readonly tracker: PointerTracker;
   readonly name: SingleGestureName;
+  readonly isContinuous: boolean;
   state: State;
   shouldCancelWhenOutside: boolean;
   shouldResetProgress: boolean;
@@ -53,6 +54,7 @@ export default interface IGestureHandler {
   shouldRequireToWaitForFailure: (handler: IGestureHandler) => boolean;
   shouldRecognizeSimultaneously: (handler: IGestureHandler) => boolean;
   shouldBeCancelledByOther: (handler: IGestureHandler) => boolean;
+  shouldBeginWithRecordedHandlers: (recorded: IGestureHandler[]) => boolean;
   shouldAttachGestureToChildView: () => boolean;
 
   sendEvent: (newState: State, oldState: State) => void;

package/src/web/handlers/ManualGestureHandler.ts

@@ -5,6 +5,8 @@ import GestureHandler from './GestureHandler';
 import type IGestureHandler from './IGestureHandler';
 
 export default class ManualGestureHandler extends GestureHandler {
+  public override readonly isContinuous = true;
+
   public constructor(
     delegate: GestureHandlerDelegate<unknown, IGestureHandler>
   ) {

package/src/web/handlers/NativeViewGestureHandler.ts

@@ -1,25 +1,40 @@
 import { Platform } from 'react-native';
 
-import type { ActionType } from '../../ActionType';
+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 } from '../constants';
+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 {
@@ -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: IGestureHandler): 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

@@ -13,6 +13,8 @@ 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;
 

package/src/web/handlers/PinchGestureHandler.ts

@@ -10,6 +10,8 @@ import GestureHandler from './GestureHandler';
 import type IGestureHandler from './IGestureHandler';
 
 export default class PinchGestureHandler extends GestureHandler {
+  public override readonly isContinuous = true;
+
   private scale = 1;
   private velocity = 0;
 
@@ -89,8 +91,8 @@ 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 {
@@ -111,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

@@ -11,6 +11,8 @@ 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;
 
@@ -98,11 +100,12 @@ 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;
     }
@@ -111,14 +114,13 @@ export default class RotationGestureHandler extends GestureHandler {
     this.cachedAnchorX = anchor.x;
     this.cachedAnchorY = anchor.y;
 
-    this.tracker.track(event);
-
     this.rotationGestureDetector.onTouchEvent(event, this.tracker);
 
     super.onPointerMove(event);
   }
 
   protected override onPointerOutOfBounds(event: AdaptedEvent): void {
+    this.tracker.track(event);
     if (this.tracker.trackedPointersCount < 2) {
       return;
     }
@@ -127,8 +129,6 @@ export default class RotationGestureHandler extends GestureHandler {
     this.cachedAnchorX = anchor.x;
     this.cachedAnchorY = anchor.y;
 
-    this.tracker.track(event);
-
     this.rotationGestureDetector.onTouchEvent(event, this.tracker);
 
     super.onPointerOutOfBounds(event);

package/src/web/interfaces.ts

@@ -88,6 +88,7 @@ export interface Config extends Record<string, ConfigArgs> {
   maxDeltaY?: number;
   shouldActivateOnStart?: boolean;
   disallowInterruption?: boolean;
+  yieldsToContinuousGestures?: boolean;
   direction?: Directions;
   enableTrackpadTwoFingerGesture?: boolean;
 }
@@ -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/GestureHandlerOrchestrator.ts

@@ -32,6 +32,10 @@ export default class GestureHandlerOrchestrator {
     handler.activationIndex = Number.MAX_VALUE;
   }
 
+  public isHandlerRecorded(handler: IGestureHandler): boolean {
+    return this.gestureHandlers.includes(handler);
+  }
+
   public removeHandlerFromOrchestrator(handler: IGestureHandler): void {
     const indexInGestureHandlers = this.gestureHandlers.indexOf(handler);
     const indexInAwaitingHandlers = this.awaitingHandlers.indexOf(handler);
@@ -266,15 +270,19 @@ export default class GestureHandlerOrchestrator {
   }
 
   public recordHandlerIfNotPresent(handler: IGestureHandler): void {
-    if (this.gestureHandlers.includes(handler)) {
+    if (this.isHandlerRecorded(handler)) {
       return;
     }
 
-    this.gestureHandlers.push(handler);
-
     handler.active = false;
     handler.awaiting = false;
     handler.activationIndex = Number.MAX_SAFE_INTEGER;
+
+    if (!handler.shouldBeginWithRecordedHandlers(this.gestureHandlers)) {
+      handler.cancel();
+    }
+
+    this.gestureHandlers.push(handler);
   }
 
   private shouldHandlerWaitForOther(

package/src/web/tools/GestureLifecycleEvents.ts

@@ -0,0 +1,14 @@
+export const GestureLifecycleEvent = {
+  Began: 'gh:gestureBegan',
+  Canceled: 'gh:gestureCanceled',
+} as const;
+
+export type GestureLifecycleEventName =
+  (typeof GestureLifecycleEvent)[keyof typeof GestureLifecycleEvent];
+
+export function dispatchGestureLifecycleEvent(
+  view: HTMLElement | null | undefined,
+  name: GestureLifecycleEventName
+): void {
+  view?.dispatchEvent(new CustomEvent(name));
+}

package/src/web/tools/NodeManager.ts

@@ -2,6 +2,8 @@ import type { ValueOf } from '../../typeUtils';
 import type { Gestures } from '../Gestures';
 import type IGestureHandler from '../handlers/IGestureHandler';
 
+type HandlerReadyCallback = (handler: IGestureHandler) => void;
+
 // eslint-disable-next-line @typescript-eslint/no-extraneous-class
 export default abstract class NodeManager {
   private static gestures: Record<
@@ -9,6 +11,9 @@ export default abstract class NodeManager {
     InstanceType<ValueOf<typeof Gestures>>
   > = {};
 
+  private static observers: Map<number, Map<object, HandlerReadyCallback>> =
+    new Map();
+
   public static getHandler(tag: number): IGestureHandler {
     if (tag in this.gestures) {
       return this.gestures[tag] as IGestureHandler;
@@ -17,6 +22,10 @@ export default abstract class NodeManager {
     throw new Error(`No handler for tag ${tag}`);
   }
 
+  public static hasHandler(tag: number): boolean {
+    return tag in this.gestures;
+  }
+
   public static createGestureHandler(
     handlerTag: number,
     handler: InstanceType<ValueOf<typeof Gestures>>
@@ -29,6 +38,15 @@ export default abstract class NodeManager {
 
     this.gestures[handlerTag] = handler;
     this.gestures[handlerTag].handlerTag = handlerTag;
+
+    const pending = this.observers.get(handlerTag);
+    if (pending) {
+      // Snapshot before iterating — callbacks may call back into observeHandler / cancelObservation
+      // and mutate the underlying map.
+      for (const callback of Array.from(pending.values())) {
+        callback(handler as IGestureHandler);
+      }
+    }
   }
 
   public static dropGestureHandler(handlerTag: number): void {
@@ -50,6 +68,45 @@ export default abstract class NodeManager {
     this.gestures[handlerTag].detach();
   }
 
+  // Invokes `callback` every time a handler with `tag` is created and, if the handler already exists,
+  // immediately before returning. The observation persists until explicitly cancelled: the registry
+  // holds both `owner` and `callback` strongly, so callers MUST call `cancelObservation` or
+  // `cancelAllObservationsForOwner` when the owner is going away (typically in effect cleanup) to
+  // avoid leaking. Observing the same tag twice with the same `owner` replaces the previous callback.
+  public static observeHandler(
+    tag: number,
+    owner: object,
+    callback: HandlerReadyCallback
+  ): void {
+    let table = this.observers.get(tag);
+    if (!table) {
+      table = new Map();
+      this.observers.set(tag, table);
+    }
+    table.set(owner, callback);
+
+    if (tag in this.gestures) {
+      callback(this.gestures[tag] as IGestureHandler);
+    }
+  }
+
+  public static cancelObservation(tag: number, owner: object): void {
+    const table = this.observers.get(tag);
+    if (!table) {
+      return;
+    }
+    table.delete(owner);
+    if (table.size === 0) {
+      this.observers.delete(tag);
+    }
+  }
+
+  public static cancelAllObservationsForOwner(owner: object): void {
+    for (const tag of this.observers.keys()) {
+      this.cancelObservation(tag, owner);
+    }
+  }
+
   public static get nodes() {
     return { ...this.gestures };
   }

package/src/web/tools/PointerEventManager.ts

@@ -162,6 +162,18 @@ export default class PointerEventManager extends EventManager<HTMLElement> {
     const adaptedEvent: AdaptedEvent = this.mapEvent(event, EventTypes.LEAVE);
 
     this.onPointerMoveOut(adaptedEvent);
+
+    // When the view is not capturing the pointer (e.g. when `role="button"`),
+    // `pointermove` stops firing once the pointer leaves the view's bounds, so
+    // the out-of-bounds detection in `pointerMoveCallback` never runs. Fall back
+    // to the DOM `pointerleave` event for any tracked, in-bounds pointer.
+    if (
+      this.trackedPointers.has(event.pointerId) &&
+      this.pointersInBounds.indexOf(event.pointerId) >= 0
+    ) {
+      this.onPointerLeave(adaptedEvent);
+      this.markAsOutOfBounds(event.pointerId);
+    }
   };
 
   private lostPointerCaptureCallback = (event: PointerEvent) => {

package/lib/module/RNRenderer.js

@@ -1,6 +0,0 @@
-"use strict";
-
-// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-// @ts-nocheck
-export { default as RNRenderer } from 'react-native/Libraries/Renderer/shims/ReactNative';
-//# sourceMappingURL=RNRenderer.js.map

package/lib/module/RNRenderer.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["default","RNRenderer"],"sourceRoot":"../../src","sources":["RNRenderer.ts"],"mappings":";;AAAA;AACA;AACA,SAASA,OAAO,IAAIC,UAAU,QAAQ,mDAAmD","ignoreList":[]}