react-native-gesture-handler 2.13.3 → 2.14.0

package/src/utils.ts

@@ -1,11 +1,3 @@
-import pack from 'react-native/package.json';
-
-const [majorStr, minorStr] = pack.version.split('.');
-export const REACT_NATIVE_VERSION = {
-  major: parseInt(majorStr, 10),
-  minor: parseInt(minorStr, 10),
-};
-
 export function toArray<T>(object: T | T[]): T[] {
   if (!Array.isArray(object)) {
     return [object];

package/src/web/handlers/GestureHandler.ts

@@ -821,7 +821,7 @@ function invokeNullableMethod(
     return;
   }
 
-  const { argMapping } = method.__nodeConfig;
+  const { argMapping }: { argMapping: unknown } = method.__nodeConfig;
   if (!Array.isArray(argMapping)) {
     return;
   }

package/src/web/interfaces.ts

@@ -32,6 +32,7 @@ export interface Config extends Record<string, ConfigArgs> {
   enabled?: boolean;
   simultaneousHandlers?: Handler[] | null;
   waitFor?: Handler[] | null;
+  blocksHandlers?: Handler[] | null;
   hitSlop?: HitSlop;
   shouldCancelWhenOutside?: boolean;
   userSelect?: UserSelect;

package/src/web/tools/GestureHandlerOrchestrator.ts

@@ -9,7 +9,6 @@ export default class GestureHandlerOrchestrator {
 
   private gestureHandlers: GestureHandler[] = [];
   private awaitingHandlers: GestureHandler[] = [];
-  private handlersToCancel: GestureHandler[] = [];
 
   private handlingChangeSemaphore = 0;
   private activationIndex = 0;
@@ -34,7 +33,6 @@ export default class GestureHandlerOrchestrator {
   public removeHandlerFromOrchestrator(handler: GestureHandler): void {
     this.gestureHandlers.splice(this.gestureHandlers.indexOf(handler), 1);
     this.awaitingHandlers.splice(this.awaitingHandlers.indexOf(handler), 1);
-    this.handlersToCancel.splice(this.handlersToCancel.indexOf(handler), 1);
   }
 
   private cleanupFinishedHandlers(): void {
@@ -177,17 +175,12 @@ export default class GestureHandlerOrchestrator {
     handler.setShouldResetProgress(true);
     handler.setActivationIndex(this.activationIndex++);
 
-    this.gestureHandlers.forEach((otherHandler) => {
-      // Order of arguments is correct - we check whether current handler should cancel existing handlers
-
-      if (this.shouldHandlerBeCancelledBy(otherHandler, handler)) {
-        this.handlersToCancel.push(otherHandler);
+    for (let i = this.gestureHandlers.length - 1; i >= 0; --i) {
+      if (this.shouldHandlerBeCancelledBy(this.gestureHandlers[i], handler)) {
+        this.gestureHandlers[i].cancel();
       }
-    });
-
-    for (let i = this.handlersToCancel.length - 1; i >= 0; --i) {
-      this.handlersToCancel[i]?.cancel();
     }
+
     this.awaitingHandlers.forEach((otherHandler) => {
       if (this.shouldHandlerBeCancelledBy(otherHandler, handler)) {
         otherHandler?.cancel();
@@ -212,8 +205,6 @@ export default class GestureHandlerOrchestrator {
         }
       }
     }
-
-    this.handlersToCancel = [];
   }
 
   private addAwaitingHandler(handler: GestureHandler): void {

package/src/web/tools/InteractionManager.ts

@@ -5,6 +5,7 @@ export default class InteractionManager {
   private static instance: InteractionManager;
   private readonly waitForRelations: Map<number, number[]> = new Map();
   private readonly simultaneousRelations: Map<number, number[]> = new Map();
+  private readonly blocksHandlersRelations: Map<number, number[]> = new Map();
 
   // Private becaues of singleton
   // eslint-disable-next-line no-useless-constructor, @typescript-eslint/no-empty-function
@@ -40,6 +41,19 @@ export default class InteractionManager {
 
       this.simultaneousRelations.set(handler.getTag(), simultaneousHandlers);
     }
+
+    if (config.blocksHandlers) {
+      const blocksHandlers: number[] = [];
+      config.blocksHandlers.forEach((otherHandler: Handler): void => {
+        if (typeof otherHandler === 'number') {
+          blocksHandlers.push(otherHandler);
+        } else {
+          blocksHandlers.push(otherHandler.handlerTag);
+        }
+      });
+
+      this.blocksHandlersRelations.set(handler.getTag(), blocksHandlers);
+    }
   }
 
   public shouldWaitForHandlerFailure(
@@ -49,20 +63,12 @@ export default class InteractionManager {
     const waitFor: number[] | undefined = this.waitForRelations.get(
       handler.getTag()
     );
-    if (!waitFor) {
-      return false;
-    }
-
-    let shouldWait = false;
-
-    waitFor.forEach((tag: number): void => {
-      if (tag === otherHandler.getTag()) {
-        shouldWait = true;
-        return; //Returns from callback
-      }
-    });
 
-    return shouldWait;
+    return (
+      waitFor?.find((tag: number) => {
+        return tag === otherHandler.getTag();
+      }) !== undefined
+    );
   }
 
   public shouldRecognizeSimultaneously(
@@ -71,28 +77,27 @@ export default class InteractionManager {
   ): boolean {
     const simultaneousHandlers: number[] | undefined =
       this.simultaneousRelations.get(handler.getTag());
-    if (!simultaneousHandlers) {
-      return false;
-    }
-
-    let shouldRecognizeSimultaneously = false;
 
-    simultaneousHandlers.forEach((tag: number): void => {
-      if (tag === otherHandler.getTag()) {
-        shouldRecognizeSimultaneously = true;
-        return;
-      }
-    });
-
-    return shouldRecognizeSimultaneously;
+    return (
+      simultaneousHandlers?.find((tag: number) => {
+        return tag === otherHandler.getTag();
+      }) !== undefined
+    );
   }
 
   public shouldRequireHandlerToWaitForFailure(
-    _handler: GestureHandler,
-    _otherHandler: GestureHandler
+    handler: GestureHandler,
+    otherHandler: GestureHandler
   ): boolean {
-    //TODO: Implement logic
-    return false;
+    const waitFor: number[] | undefined = this.blocksHandlersRelations.get(
+      handler.getTag()
+    );
+
+    return (
+      waitFor?.find((tag: number) => {
+        return tag === otherHandler.getTag();
+      }) !== undefined
+    );
   }
 
   public shouldHandlerBeCancelledBy(
@@ -106,11 +111,13 @@ export default class InteractionManager {
   public dropRelationsForHandlerWithTag(handlerTag: number): void {
     this.waitForRelations.delete(handlerTag);
     this.simultaneousRelations.delete(handlerTag);
+    this.blocksHandlersRelations.delete(handlerTag);
   }
 
   public reset() {
     this.waitForRelations.clear();
     this.simultaneousRelations.clear();
+    this.blocksHandlersRelations.clear();
   }
 
   public static getInstance(): InteractionManager {

package/src/web/tools/PointerEventManager.ts

@@ -19,7 +19,10 @@ export default class PointerEventManager extends EventManager<HTMLElement> {
       const adaptedEvent: AdaptedEvent = this.mapEvent(event, EventTypes.DOWN);
       const target = event.target as HTMLElement;
 
-      target.setPointerCapture(adaptedEvent.pointerId);
+      if (target instanceof HTMLDivElement) {
+        target.setPointerCapture(adaptedEvent.pointerId);
+      }
+
       this.markAsInBounds(adaptedEvent.pointerId);
       this.trackedPointers.add(adaptedEvent.pointerId);
 
@@ -47,7 +50,10 @@ export default class PointerEventManager extends EventManager<HTMLElement> {
       const adaptedEvent: AdaptedEvent = this.mapEvent(event, EventTypes.UP);
       const target = event.target as HTMLElement;
 
-      target.releasePointerCapture(adaptedEvent.pointerId);
+      if (target instanceof HTMLDivElement) {
+        target.releasePointerCapture(adaptedEvent.pointerId);
+      }
+
       this.markAsOutOfBounds(adaptedEvent.pointerId);
       this.trackedPointers.delete(adaptedEvent.pointerId);
 
@@ -79,7 +85,10 @@ export default class PointerEventManager extends EventManager<HTMLElement> {
       // 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)) {
+      if (
+        !target.hasPointerCapture(event.pointerId) &&
+        target instanceof HTMLDivElement
+      ) {
         target.setPointerCapture(event.pointerId);
       }
 

package/android/src/main/java/com/swmansion/gesturehandler/react/RNGestureHandlerEventDataExtractor.kt

@@ -1,8 +0,0 @@
-package com.swmansion.gesturehandler.react
-
-import com.facebook.react.bridge.WritableMap
-import com.swmansion.gesturehandler.core.GestureHandler
-
-interface RNGestureHandlerEventDataExtractor<T : GestureHandler<T>> {
-  fun extractEventData(handler: T, eventData: WritableMap)
-}