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

package/src/v3/detectors/utils.ts

@@ -9,25 +9,26 @@ import {
   isComposedGesture,
   prepareRelations,
 } from '../hooks/utils/relationUtils';
-import { NativeProxy } from '../NativeProxy';
-import type { Gesture } from '../types';
+import type { Gesture, GestureRelations } from '../types';
 import { ComposedGestureName } from '../types';
 
 // The tree consists of ComposedGestures and NativeGestures. NativeGestures are always leaf nodes.
 export const traverseAndConfigureRelations = (
   node: Gesture,
+  relationsByTag: Map<number, GestureRelations>,
   simultaneousHandlers: Set<number>,
   waitFor: number[] = []
 ) => {
   // If we are in the leaf node, we want to fill gesture relations arrays with current
-  // waitFor and simultaneousHandlers. We also want to configure relations on the native side.
+  // waitFor and simultaneousHandlers. We also want to record the resulting relations for
+  // this handler so the caller can push them to the native side.
   if (!isComposedGesture(node)) {
     node.gestureRelations = prepareRelations(node.config, node.handlerTag);
 
     node.gestureRelations.simultaneousHandlers.push(...simultaneousHandlers);
     node.gestureRelations.waitFor.push(...waitFor);
 
-    NativeProxy.configureRelations(node.handlerTag, {
+    relationsByTag.set(node.handlerTag, {
       waitFor: node.gestureRelations.waitFor,
       simultaneousHandlers: node.gestureRelations.simultaneousHandlers,
       blocksHandlers: node.gestureRelations.blocksHandlers,
@@ -73,7 +74,12 @@ export const traverseAndConfigureRelations = (
       const length = waitFor.length;
 
       // We traverse the child, passing the current `waitFor` and `simultaneousHandlers`.
-      traverseAndConfigureRelations(child, simultaneousHandlers, waitFor);
+      traverseAndConfigureRelations(
+        child,
+        relationsByTag,
+        simultaneousHandlers,
+        waitFor
+      );
 
       // After traversing the child, we need to update `waitFor` and `simultaneousHandlers`
 
@@ -122,7 +128,12 @@ export const traverseAndConfigureRelations = (
       // We don't want to mark gesture as simultaneous with itself, so we remove its tag from the set.
       const hasRemovedTag = simultaneousHandlers.delete(child.handlerTag);
 
-      traverseAndConfigureRelations(child, simultaneousHandlers, waitFor);
+      traverseAndConfigureRelations(
+        child,
+        relationsByTag,
+        simultaneousHandlers,
+        waitFor
+      );
 
       if (hasRemovedTag) {
         simultaneousHandlers.add(child.handlerTag);
@@ -138,7 +149,9 @@ export const traverseAndConfigureRelations = (
 
 export function configureRelations<TConfig, THandlerData>(
   gesture: Gesture<TConfig, THandlerData>
-) {
+): Map<number, GestureRelations> {
+  const relationsByTag = new Map<number, GestureRelations>();
+
   if (isComposedGesture(gesture)) {
     const simultaneousHandlers = new Set<number>(
       gesture.externalSimultaneousHandlers
@@ -151,13 +164,16 @@ export function configureRelations<TConfig, THandlerData>(
       );
     }
 
-    traverseAndConfigureRelations(gesture, simultaneousHandlers);
-  } else {
-    NativeProxy.configureRelations(
-      gesture.handlerTag,
-      gesture.gestureRelations
+    traverseAndConfigureRelations(
+      gesture,
+      relationsByTag,
+      simultaneousHandlers
     );
+  } else {
+    relationsByTag.set(gesture.handlerTag, gesture.gestureRelations);
   }
+
+  return relationsByTag;
 }
 
 export function ensureNativeDetectorComponent(

package/src/v3/hooks/callbacks/useReanimatedEventHandler.ts

@@ -1,4 +1,4 @@
-import { useMemo } from 'react';
+import { useEffect, useMemo, useRef } from 'react';
 
 import type { ReanimatedHandler } from '../../../handlers/gestures/reanimatedWrapper';
 import { Reanimated } from '../../../handlers/gestures/reanimatedWrapper';
@@ -10,6 +10,12 @@ import type {
 } from '../../types';
 import { eventHandler } from './eventHandler';
 
+const REANIMATED_EVENT_NAMES = [
+  'onGestureHandlerReanimatedEvent',
+  'onGestureHandlerReanimatedStateChange',
+  'onGestureHandlerReanimatedTouchEvent',
+];
+
 const workletNOOP = () => {
   'worklet';
   // no-op
@@ -59,14 +65,24 @@ export function useReanimatedEventHandler<
     );
   };
 
+  // Fast Refresh invalidates `useMemo` caches but preserves `useRef`, so the
+  // `handlerTag` computed with `useMemo([])` in `useGesture` can regenerate
+  // on FR. Without forcing a rebuild, the registered worklet keeps the old
+  // `handlerTag` in its closure and `isEventForHandlerWithTag` rejects every
+  // event emitted by the freshly-created native handler.
+  const prevHandlerTagRef = useRef(handlerTag);
+  const handlerTagChanged = prevHandlerTagRef.current !== handlerTag;
+
+  // Write after commit so interrupted or re-invoked renders don't desync the
+  // ref from what was actually committed.
+  useEffect(() => {
+    prevHandlerTagRef.current = handlerTag;
+  }, [handlerTag]);
+
   const reanimatedEvent = Reanimated?.useEvent(
     callback,
-    [
-      'onGestureHandlerReanimatedEvent',
-      'onGestureHandlerReanimatedStateChange',
-      'onGestureHandlerReanimatedTouchEvent',
-    ],
-    !!reanimatedHandler?.doDependenciesDiffer
+    REANIMATED_EVENT_NAMES,
+    handlerTagChanged || !!reanimatedHandler?.doDependenciesDiffer
   );
 
   return reanimatedEvent;

package/src/v3/hooks/gestures/fling/useFlingGesture.ts

@@ -8,7 +8,11 @@ import type {
   FlingHandlerData,
 } from './FlingTypes';
 
-export function useFlingGesture(config: FlingGestureConfig): FlingGesture {
+const EMPTY_FLING_CONFIG: FlingGestureConfig = {};
+
+export function useFlingGesture(
+  config: FlingGestureConfig = EMPTY_FLING_CONFIG
+): FlingGesture {
   const flingConfig = useClonedAndRemappedConfig<
     FlingGestureProperties,
     FlingHandlerData

package/src/v3/hooks/gestures/hover/useHoverGesture.ts

@@ -44,7 +44,11 @@ function transformHoverProps(
 
 const HoverPropsMapping = new Map<string, string>([['effect', 'hoverEffect']]);
 
-export function useHoverGesture(config: HoverGestureConfig): HoverGesture {
+const EMPTY_HOVER_CONFIG: HoverGestureConfig = {};
+
+export function useHoverGesture(
+  config: HoverGestureConfig = EMPTY_HOVER_CONFIG
+): HoverGesture {
   const hoverConfig = useClonedAndRemappedConfig<
     HoverGestureProperties,
     HoverHandlerData,

package/src/v3/hooks/gestures/longPress/useLongPressGesture.ts

@@ -28,8 +28,10 @@ function transformLongPressProps(
   return config;
 }
 
+const EMPTY_LONG_PRESS_CONFIG: LongPressGestureConfig = {};
+
 export function useLongPressGesture(
-  config: LongPressGestureConfig
+  config: LongPressGestureConfig = EMPTY_LONG_PRESS_CONFIG
 ): LongPressGesture {
   const longPressConfig = useClonedAndRemappedConfig<
     LongPressGestureProperties,

package/src/v3/hooks/gestures/manual/useManualGesture.ts

@@ -8,7 +8,11 @@ import type {
   ManualHandlerData,
 } from './ManualTypes';
 
-export function useManualGesture(config: ManualGestureConfig): ManualGesture {
+const EMPTY_MANUAL_CONFIG: ManualGestureConfig = {};
+
+export function useManualGesture(
+  config: ManualGestureConfig = EMPTY_MANUAL_CONFIG
+): ManualGesture {
   const manualConfig = useClonedAndRemappedConfig<
     ManualGestureProperties,
     ManualHandlerData

package/src/v3/hooks/gestures/native/NativeTypes.ts

@@ -20,11 +20,23 @@ export type NativeGestureNativeProperties = {
    * `NativeViewGestureHandler` receives an `ACTIVE` state event.
    */
   disallowInterruption?: boolean;
+
+  /**
+   * Composes with `disallowInterruption`. When both are `true`, the handler still
+   * resists discrete gestures but yields to continuous gestures, so a wrapping
+   * gesture can take over the touch stream. No-op when `disallowInterruption` is
+   * `false`.
+   */
+  yieldsToContinuousGestures?: boolean;
 };
 
 export const NativeHandlerNativeProperties = new Set<
   keyof NativeGestureNativeProperties
->(['shouldActivateOnStart', 'disallowInterruption']);
+>([
+  'shouldActivateOnStart',
+  'disallowInterruption',
+  'yieldsToContinuousGestures',
+]);
 
 export type NativeHandlerData = {
   pointerInside: boolean;

package/src/v3/hooks/gestures/native/useNativeGesture.ts

@@ -8,7 +8,11 @@ import type {
   NativeHandlerData,
 } from './NativeTypes';
 
-export function useNativeGesture(config: NativeGestureConfig): NativeGesture {
+const EMPTY_NATIVE_CONFIG: NativeGestureConfig = {};
+
+export function useNativeGesture(
+  config: NativeGestureConfig = EMPTY_NATIVE_CONFIG
+): NativeGesture {
   const nativeConfig = useClonedAndRemappedConfig<
     NativeGestureProperties,
     NativeHandlerData

package/src/v3/hooks/gestures/pan/usePanGesture.ts

@@ -139,7 +139,11 @@ function transformPanProps(
   return config;
 }
 
-export function usePanGesture(config: PanGestureConfig): PanGesture {
+const EMPTY_PAN_CONFIG: PanGestureConfig = {};
+
+export function usePanGesture(
+  config: PanGestureConfig = EMPTY_PAN_CONFIG
+): PanGesture {
   if (__DEV__) {
     validatePanConfig(config);
   }

package/src/v3/hooks/gestures/pinch/usePinchGesture.ts

@@ -40,7 +40,11 @@ function transformPinchProps(
 
 const PinchPropsMapping = new Map<string, string>();
 
-export function usePinchGesture(config: PinchGestureConfig): PinchGesture {
+const EMPTY_PINCH_CONFIG: PinchGestureConfig = {};
+
+export function usePinchGesture(
+  config: PinchGestureConfig = EMPTY_PINCH_CONFIG
+): PinchGesture {
   const pinchConfig = useClonedAndRemappedConfig<
     PinchGestureProperties,
     PinchHandlerData,

package/src/v3/hooks/gestures/rotation/useRotationGesture.ts

@@ -42,8 +42,10 @@ function transformRotationProps(
 
 const RotationPropsMapping = new Map<string, string>();
 
+const EMPTY_ROTATION_CONFIG: RotationGestureConfig = {};
+
 export function useRotationGesture(
-  config: RotationGestureConfig
+  config: RotationGestureConfig = EMPTY_ROTATION_CONFIG
 ): RotationGesture {
   const rotationConfig = useClonedAndRemappedConfig<
     RotationGestureProperties,

package/src/v3/hooks/gestures/tap/useTapGesture.ts

@@ -18,7 +18,11 @@ const TapPropsMapping = new Map<
   ['maxDelay', 'maxDelayMs'],
 ]);
 
-export function useTapGesture(config: TapGestureConfig): TapGesture {
+const EMPTY_TAP_CONFIG: TapGestureConfig = {};
+
+export function useTapGesture(
+  config: TapGestureConfig = EMPTY_TAP_CONFIG
+): TapGesture {
   const tapConfig = useClonedAndRemappedConfig<
     TapGestureProperties,
     TapHandlerData,

package/src/v3/hooks/useGesture.ts

@@ -1,4 +1,4 @@
-import { useEffect, useMemo, useRef } from 'react';
+import { useEffect, useMemo } from 'react';
 
 import { getNextHandlerTag } from '../../handlers/getNextHandlerTag';
 import {
@@ -16,7 +16,6 @@ import type {
 import { useGestureCallbacks } from './useGestureCallbacks';
 import {
   bindSharedValues,
-  prepareConfig,
   prepareConfigForNativeSide,
   prepareRelations,
   unbindSharedValues,
@@ -41,9 +40,6 @@ export function useGesture<
     );
   }
 
-  // This has to be done ASAP as other hooks depend `shouldUseReanimatedDetector`.
-  prepareConfig(config);
-
   // TODO: Call only necessary hooks depending on which callbacks are defined (?)
   const { jsEventHandler, reanimatedEventHandler, animatedEventHandler } =
     useGestureCallbacks(handlerTag, config);
@@ -65,15 +61,6 @@ export function useGesture<
     [handlerTag, config.simultaneousWith, config.requireToFail, config.block]
   );
 
-  const currentGestureRef = useRef({ type: '', handlerTag: -1 });
-  if (
-    currentGestureRef.current.handlerTag !== handlerTag ||
-    currentGestureRef.current.type !== (type as string)
-  ) {
-    currentGestureRef.current = { type, handlerTag };
-    NativeProxy.createGestureHandler(type, handlerTag, {});
-  }
-
   const gesture = useMemo(
     () => ({
       handlerTag,
@@ -98,11 +85,10 @@ export function useGesture<
   );
 
   useEffect(() => {
-    return () => {
-      if (currentGestureRef.current.handlerTag === handlerTag) {
-        currentGestureRef.current = { type: '', handlerTag: -1 };
-      }
+    NativeProxy.createGestureHandler(type, handlerTag, {});
+    scheduleFlushOperations();
 
+    return () => {
       NativeProxy.dropGestureHandler(handlerTag);
       scheduleFlushOperations();
     };

package/src/v3/hooks/utils/configUtils.ts

@@ -16,7 +16,7 @@ import {
 } from './propsWhiteList';
 import { hasWorkletEventHandlers, maybeUnpackValue } from './reanimatedUtils';
 
-export function prepareConfig<
+export function resolveInternalConfigProps<
   TConfig extends object,
   THandlerData,
   TExtendedHandlerData extends THandlerData,
@@ -87,9 +87,8 @@ export function prepareConfigForNativeSide<
   for (const [key, value] of Object.entries(config)) {
     // @ts-ignore That's the point, we want to see if key exists in the whitelists
     if (allowedNativeProps.has(key) || handlerPropsWhiteList.has(key)) {
-      Object.assign(filteredConfig, {
-        [key]: Reanimated?.isSharedValue(value) ? value.value : value,
-      });
+      (filteredConfig as Record<string, unknown>)[key] =
+        Reanimated?.isSharedValue(value) ? value.value : value;
     } else if (PropsToFilter.has(key)) {
       continue;
     } else {
@@ -125,7 +124,7 @@ function remapProps<
   TInternalConfig extends Record<string, unknown>,
 >(
   config: TConfig & TInternalConfig,
-  propsMapping: Map<string, string>
+  propsMapping: ReadonlyMap<string, string>
 ): TInternalConfig {
   type MergedConfig = TConfig & TInternalConfig;
 
@@ -142,6 +141,11 @@ function remapProps<
   return config;
 }
 
+const DEFAULT_PROPS_MAPPING = new Map<string, string>();
+const DEFAULT_PROPS_TRANSFORMER = <TConfig extends object>(
+  config: TConfig
+): TConfig => config;
+
 export function useClonedAndRemappedConfig<
   TConfig extends Record<string, unknown>,
   THandlerData,
@@ -151,8 +155,10 @@ export function useClonedAndRemappedConfig<
   config: ExcludeInternalConfigProps<
     BaseGestureConfig<TConfig, THandlerData, TExtendedHandlerData>
   >,
-  propsMapping: Map<string, string> = new Map(),
-  propsTransformer: (config: TInternalConfig) => TInternalConfig = (cfg) => cfg
+  propsMapping: ReadonlyMap<string, string> = DEFAULT_PROPS_MAPPING,
+  propsTransformer: (
+    config: TInternalConfig
+  ) => TInternalConfig = DEFAULT_PROPS_TRANSFORMER
 ): BaseGestureConfig<TInternalConfig, THandlerData, TExtendedHandlerData> {
   return useMemo(() => {
     const clonedConfig = cloneConfig<
@@ -161,11 +167,15 @@ export function useClonedAndRemappedConfig<
       TExtendedHandlerData
     >(config);
 
-    return propsTransformer(
+    const transformedConfig = propsTransformer(
       remapProps<TConfig, TInternalConfig>(
         clonedConfig as TConfig & TInternalConfig,
         propsMapping
       )
     );
+
+    resolveInternalConfigProps(transformedConfig);
+
+    return transformedConfig;
   }, [config, propsMapping, propsTransformer]);
 }

package/src/v3/hooks/utils/eventHandlersUtils.ts

@@ -16,38 +16,49 @@ export function useMemoizedGestureCallbacks<
 >(
   callbacks: GestureCallbacks<THandlerData, TExtendedHandlerData>
 ): GestureCallbacks<THandlerData, TExtendedHandlerData> {
-  return useMemo(
-    () => ({
-      ...(callbacks.onBegin ? { onBegin: callbacks.onBegin } : {}),
-      ...(callbacks.onActivate ? { onActivate: callbacks.onActivate } : {}),
-      ...(callbacks.onDeactivate
-        ? { onDeactivate: callbacks.onDeactivate }
-        : {}),
-      ...(callbacks.onFinalize ? { onFinalize: callbacks.onFinalize } : {}),
-      ...(callbacks.onUpdate ? { onUpdate: callbacks.onUpdate } : {}),
-      ...(callbacks.onTouchesDown
-        ? { onTouchesDown: callbacks.onTouchesDown }
-        : {}),
-      ...(callbacks.onTouchesMove
-        ? { onTouchesMove: callbacks.onTouchesMove }
-        : {}),
-      ...(callbacks.onTouchesUp ? { onTouchesUp: callbacks.onTouchesUp } : {}),
-      ...(callbacks.onTouchesCancel
-        ? { onTouchesCancel: callbacks.onTouchesCancel }
-        : {}),
-    }),
-    [
-      callbacks.onActivate,
-      callbacks.onBegin,
-      callbacks.onDeactivate,
-      callbacks.onFinalize,
-      callbacks.onTouchesCancel,
-      callbacks.onTouchesDown,
-      callbacks.onTouchesMove,
-      callbacks.onTouchesUp,
-      callbacks.onUpdate,
-    ]
-  );
+  return useMemo(() => {
+    const memoized: GestureCallbacks<THandlerData, TExtendedHandlerData> = {};
+
+    if (callbacks.onBegin) {
+      memoized.onBegin = callbacks.onBegin;
+    }
+    if (callbacks.onActivate) {
+      memoized.onActivate = callbacks.onActivate;
+    }
+    if (callbacks.onDeactivate) {
+      memoized.onDeactivate = callbacks.onDeactivate;
+    }
+    if (callbacks.onFinalize) {
+      memoized.onFinalize = callbacks.onFinalize;
+    }
+    if (callbacks.onUpdate) {
+      memoized.onUpdate = callbacks.onUpdate;
+    }
+    if (callbacks.onTouchesDown) {
+      memoized.onTouchesDown = callbacks.onTouchesDown;
+    }
+    if (callbacks.onTouchesMove) {
+      memoized.onTouchesMove = callbacks.onTouchesMove;
+    }
+    if (callbacks.onTouchesUp) {
+      memoized.onTouchesUp = callbacks.onTouchesUp;
+    }
+    if (callbacks.onTouchesCancel) {
+      memoized.onTouchesCancel = callbacks.onTouchesCancel;
+    }
+
+    return memoized;
+  }, [
+    callbacks.onActivate,
+    callbacks.onBegin,
+    callbacks.onDeactivate,
+    callbacks.onFinalize,
+    callbacks.onTouchesCancel,
+    callbacks.onTouchesDown,
+    callbacks.onTouchesMove,
+    callbacks.onTouchesUp,
+    callbacks.onUpdate,
+  ]);
 }
 
 function getHandler<THandlerData, TExtendedHandlerData extends THandlerData>(

package/src/v3/hooks/utils/index.ts

@@ -1,5 +1,4 @@
 export {
-  prepareConfig,
   prepareConfigForNativeSide,
   useClonedAndRemappedConfig,
 } from './configUtils';

package/src/v3/hooks/utils/propsWhiteList.ts

@@ -23,6 +23,7 @@ const CommonConfig = new Set<keyof CommonGestureConfig>([
   'mouseButton',
   'testID',
   'cancelsTouchesInView',
+  'cancelsJSResponder',
   'manualActivation',
 ]);
 

package/src/v3/hooks/utils/reanimatedUtils.ts

@@ -2,7 +2,6 @@ import { Reanimated } from '../../../handlers/gestures/reanimatedWrapper';
 import { NativeProxy } from '../../NativeProxy';
 import type {
   BaseGestureConfig,
-  GestureCallbacks,
   SharedValue,
   SharedValueOrT,
 } from '../../types';
@@ -21,7 +20,7 @@ function hash(str: string) {
   return h >>> 0;
 }
 
-const SHARED_VALUE_OFFSET = 1.618;
+export const SHARED_VALUE_OFFSET = 1.618;
 
 // Don't transfer entire NativeProxy to the UI thread
 const { updateGestureHandlerConfig } = NativeProxy;
@@ -101,14 +100,15 @@ export function hasWorkletEventHandlers<
   THandlerData,
   TExtendedHandlerData extends THandlerData,
 >(config: BaseGestureConfig<TConfig, THandlerData, TExtendedHandlerData>) {
-  return Object.entries(config).some(
-    ([key, value]) =>
-      HandlerCallbacks.has(
-        key as keyof GestureCallbacks<THandlerData, TExtendedHandlerData>
-      ) &&
-      typeof value === 'function' &&
-      '__workletHash' in value
-  );
+  for (const key of HandlerCallbacks) {
+    const value = config[key];
+
+    if (typeof value === 'function' && '__workletHash' in value) {
+      return true;
+    }
+  }
+
+  return false;
 }
 
 export function maybeUnpackValue<T>(

package/src/v3/types/ConfigTypes.ts

@@ -77,6 +77,7 @@ export type CommonGestureConfig = {
     activeCursor?: ActiveCursor | undefined;
     mouseButton?: MouseButton | undefined;
     cancelsTouchesInView?: boolean | undefined;
+    cancelsJSResponder?: boolean | undefined;
     manualActivation?: boolean | undefined;
   },
   ActiveCursor | MouseButton

package/src/web/constants.ts

@@ -1,2 +1,3 @@
 export const DEFAULT_TOUCH_SLOP = 15;
 export const MINIMAL_RECOGNIZABLE_MAGNITUDE = 0.1;
+export const NATIVE_GESTURE_ROLE_ATTRIBUTE = 'rngh-role';

package/src/web/detectors/RotationGestureDetector.ts

@@ -84,15 +84,23 @@ export default class RotationGestureDetector
     this.onRotationEnd(this);
   }
 
-  private setKeyPointers(tracker: PointerTracker): void {
+  private setKeyPointers(tracker: PointerTracker, excludeId?: number): void {
     if (this.keyPointers[0] && this.keyPointers[1]) {
       return;
     }
 
-    const pointerIDs: IterableIterator<number> = tracker.trackedPointers.keys();
+    let assigned = 0;
 
-    this.keyPointers[0] = pointerIDs.next().value as number;
-    this.keyPointers[1] = pointerIDs.next().value as number;
+    for (const id of tracker.trackedPointers.keys()) {
+      if (id === excludeId) {
+        continue;
+      }
+
+      this.keyPointers[assigned++] = id;
+      if (assigned === 2) {
+        break;
+      }
+    }
   }
 
   public onTouchEvent(event: AdaptedEvent, tracker: PointerTracker): boolean {
@@ -132,7 +140,13 @@ export default class RotationGestureDetector
         }
 
         if (this.keyPointers.indexOf(event.pointerId) >= 0) {
-          this.finish();
+          if (tracker.trackedPointersCount <= 2) {
+            this.reset();
+          } else {
+            this.keyPointers = [NaN, NaN];
+            this.setKeyPointers(tracker, event.pointerId);
+            this.previousAngle = NaN;
+          }
         }
 
         break;

package/src/web/detectors/ScaleGestureDetector.ts

@@ -44,10 +44,16 @@ export default class ScaleGestureDetector implements ScaleGestureListener {
     const action: EventTypes = event.eventType;
     const numOfPointers = tracker.trackedPointersCount;
 
+    // When the last second pointer lifts (going down to 1), pause without
+    // touching span/time state so the gesture resumes cleanly on re-add.
+    // When 3+ → 2+ pointers, fall through so configChanged resets the span
+    // baseline to the remaining pointer set and avoids a scale jump.
+    if (action === EventTypes.ADDITIONAL_POINTER_UP && numOfPointers <= 2) {
+      return true;
+    }
+
     const streamComplete: boolean =
-      action === EventTypes.UP ||
-      action === EventTypes.ADDITIONAL_POINTER_UP ||
-      action === EventTypes.CANCEL;
+      action === EventTypes.UP || action === EventTypes.CANCEL;
 
     if (action === EventTypes.DOWN || streamComplete) {
       if (this.inProgress) {