react-native-gesture-handler 2.13.4 → 2.14.1

package/lib/typescript/handlers/gestures/rotationGesture.d.ts

@@ -1,12 +1,12 @@
 import { ContinousBaseGesture } from './gesture';
 import { RotationGestureHandlerEventPayload } from '../RotationGestureHandler';
 import { GestureUpdateEvent } from '../gestureHandlerCommon';
-declare type RotationGestureChangeEventPayload = {
+type RotationGestureChangeEventPayload = {
     rotationChange: number;
 };
 export declare class RotationGesture extends ContinousBaseGesture<RotationGestureHandlerEventPayload, RotationGestureChangeEventPayload> {
     constructor();
     onChange(callback: (event: GestureUpdateEvent<RotationGestureHandlerEventPayload & RotationGestureChangeEventPayload>) => void): this;
 }
-export declare type RotationGestureType = InstanceType<typeof RotationGesture>;
+export type RotationGestureType = InstanceType<typeof RotationGesture>;
 export {};

package/lib/typescript/handlers/gestures/tapGesture.d.ts

@@ -11,4 +11,4 @@ export declare class TapGesture extends BaseGesture<TapGestureHandlerEventPayloa
     maxDeltaX(delta: number): this;
     maxDeltaY(delta: number): this;
 }
-export declare type TapGestureType = InstanceType<typeof TapGesture>;
+export type TapGestureType = InstanceType<typeof TapGesture>;

package/lib/typescript/jestUtils/jestUtils.d.ts

@@ -17,12 +17,12 @@ import { PanGestureHandler, PanGestureHandlerEventPayload } from '../handlers/Pa
 import { PinchGestureHandler, PinchGestureHandlerEventPayload } from '../handlers/PinchGestureHandler';
 import { RotationGestureHandler, RotationGestureHandlerEventPayload } from '../handlers/RotationGestureHandler';
 import { TapGestureHandler, TapGestureHandlerEventPayload } from '../handlers/TapGestureHandler';
-declare type GestureHandlerTestEvent<TEventPayload extends Record<string, unknown> = Record<string, unknown>> = (GestureEvent<TEventPayload> | HandlerStateChangeEvent<TEventPayload>)['nativeEvent'];
-declare type AllGestures = TapGesture | PanGesture | LongPressGesture | RotationGesture | PinchGesture | FlingGesture | ForceTouchGesture | NativeGesture;
-declare type AllHandlers = TapGestureHandler | PanGestureHandler | LongPressGestureHandler | RotationGestureHandler | PinchGestureHandler | FlingGestureHandler | ForceTouchGestureHandler | NativeViewGestureHandler;
-declare type ClassComponentConstructor<P> = new (props: P) => React.Component<P, any, any>;
-declare type ExtractPayloadFromProps<T> = T extends BaseGestureHandlerProps<infer TPayload> ? TPayload : never;
-declare type ExtractConfig<T> = T extends BaseGesture<infer TGesturePayload> ? TGesturePayload : T extends ClassComponentConstructor<infer THandlerProps> ? ExtractPayloadFromProps<THandlerProps> : Record<string, unknown>;
+type GestureHandlerTestEvent<TEventPayload extends Record<string, unknown> = Record<string, unknown>> = (GestureEvent<TEventPayload> | HandlerStateChangeEvent<TEventPayload>)['nativeEvent'];
+type AllGestures = TapGesture | PanGesture | LongPressGesture | RotationGesture | PinchGesture | FlingGesture | ForceTouchGesture | NativeGesture;
+type AllHandlers = TapGestureHandler | PanGestureHandler | LongPressGestureHandler | RotationGestureHandler | PinchGestureHandler | FlingGestureHandler | ForceTouchGestureHandler | NativeViewGestureHandler;
+type ClassComponentConstructor<P> = new (props: P) => React.Component<P, any, any>;
+type ExtractPayloadFromProps<T> = T extends BaseGestureHandlerProps<infer TPayload> ? TPayload : never;
+type ExtractConfig<T> = T extends BaseGesture<infer TGesturePayload> ? TGesturePayload : T extends ClassComponentConstructor<infer THandlerProps> ? ExtractPayloadFromProps<THandlerProps> : Record<string, unknown>;
 export declare function fireGestureHandler<THandler extends AllGestures | AllHandlers>(componentOrGesture: ReactTestInstance | GestureType, eventList?: Partial<GestureHandlerTestEvent<ExtractConfig<THandler>>>[]): void;
 export declare function getByGestureTestId(testID: string): BaseGesture<Record<string, unknown>> | BaseGesture<Record<string, never>> | BaseGesture<TapGestureHandlerEventPayload> | BaseGesture<PanGestureHandlerEventPayload> | BaseGesture<LongPressGestureHandlerEventPayload> | BaseGesture<RotationGestureHandlerEventPayload> | BaseGesture<PinchGestureHandlerEventPayload> | BaseGesture<ForceTouchGestureHandlerEventPayload> | BaseGesture<NativeViewGestureHandlerPayload>;
 export {};

package/lib/typescript/typeUtils.d.ts

@@ -1 +1 @@
-export declare type ValueOf<T> = T[keyof T];
+export type ValueOf<T> = T[keyof T];

package/lib/typescript/utils.d.ts

@@ -1,9 +1,5 @@
-export declare const REACT_NATIVE_VERSION: {
-    major: number;
-    minor: number;
-};
 export declare function toArray<T>(object: T | T[]): T[];
-export declare type withPrevAndCurrentMapFn<T, Transformed> = (previous: Transformed | null, current: T) => Transformed;
+export type withPrevAndCurrentMapFn<T, Transformed> = (previous: Transformed | null, current: T) => Transformed;
 export declare function withPrevAndCurrent<T, Transformed>(array: T[], mapFn: withPrevAndCurrentMapFn<T, Transformed>): Transformed[];
 export declare function hasProperty(object: object, key: string): boolean;
 export declare function isJestEnv(): boolean;

package/lib/typescript/web/interfaces.d.ts

@@ -14,11 +14,12 @@ export interface HitSlop {
 export interface Handler {
     handlerTag: number;
 }
-declare type ConfigArgs = number | boolean | HitSlop | UserSelect | ActiveCursor | Directions | Handler[] | null | undefined;
+type ConfigArgs = number | boolean | HitSlop | UserSelect | ActiveCursor | Directions | Handler[] | null | undefined;
 export interface Config extends Record<string, ConfigArgs> {
     enabled?: boolean;
     simultaneousHandlers?: Handler[] | null;
     waitFor?: Handler[] | null;
+    blocksHandlers?: Handler[] | null;
     hitSlop?: HitSlop;
     shouldCancelWhenOutside?: boolean;
     userSelect?: UserSelect;
@@ -53,7 +54,7 @@ export interface Config extends Record<string, ConfigArgs> {
     disallowInterruption?: boolean;
     direction?: Directions;
 }
-declare type NativeEventArgs = number | State | boolean | undefined;
+type NativeEventArgs = number | State | boolean | undefined;
 interface NativeEvent extends Record<string, NativeEventArgs> {
     numberOfPointers: number;
     state: State;
@@ -69,7 +70,7 @@ export interface PointerData {
     absoluteX: number;
     absoluteY: number;
 }
-declare type TouchNativeArgs = number | State | TouchEventType | PointerData[];
+type TouchNativeArgs = number | State | TouchEventType | PointerData[];
 interface NativeTouchEvent extends Record<string, TouchNativeArgs> {
     handlerTag: number;
     state: State;

package/lib/typescript/web/tools/GestureHandlerOrchestrator.d.ts

@@ -4,7 +4,6 @@ export default class GestureHandlerOrchestrator {
     private static instance;
     private gestureHandlers;
     private awaitingHandlers;
-    private handlersToCancel;
     private handlingChangeSemaphore;
     private activationIndex;
     private constructor();

package/lib/typescript/web/tools/InteractionManager.d.ts

@@ -4,11 +4,12 @@ export default class InteractionManager {
     private static instance;
     private readonly waitForRelations;
     private readonly simultaneousRelations;
+    private readonly blocksHandlersRelations;
     private constructor();
     configureInteractions(handler: GestureHandler, config: Config): void;
     shouldWaitForHandlerFailure(handler: GestureHandler, otherHandler: GestureHandler): boolean;
     shouldRecognizeSimultaneously(handler: GestureHandler, otherHandler: GestureHandler): boolean;
-    shouldRequireHandlerToWaitForFailure(_handler: GestureHandler, _otherHandler: GestureHandler): boolean;
+    shouldRequireHandlerToWaitForFailure(handler: GestureHandler, otherHandler: GestureHandler): boolean;
     shouldHandlerBeCancelledBy(_handler: GestureHandler, _otherHandler: GestureHandler): boolean;
     dropRelationsForHandlerWithTag(handlerTag: number): void;
     reset(): void;

package/lib/typescript/web_hammer/GestureHandler.d.ts

@@ -1,8 +1,8 @@
 import { findNodeHandle } from 'react-native';
 import { State } from '../State';
 import { EventMap } from './constants';
-export declare type HammerInputExt = Omit<HammerInput, 'destroy' | 'handler' | 'init'>;
-export declare type Config = Partial<{
+export type HammerInputExt = Omit<HammerInput, 'destroy' | 'handler' | 'init'>;
+export type Config = Partial<{
     enabled: boolean;
     minPointers: number;
     maxPointers: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-gesture-handler",
-  "version": "2.13.4",
+  "version": "2.14.1",
   "description": "Experimental implementation of a new declarative API for gesture handling in react-native",
   "scripts": {
     "prepare": "bob build && husky install",
@@ -31,8 +31,8 @@
     "android/src/main/AndroidManifest.xml",
     "android/src/main/java/",
     "android/src/main/jni/",
-    "android/src/fabric/java",
-    "android/src/paper/java",
+    "android/fabric/src/main/java",
+    "android/paper/src/main/java",
     "android/common/src/main/java/",
     "android/reanimated/src/main/java/",
     "android/noreanimated/src/main/java/",
@@ -77,12 +77,13 @@
     "@babel/preset-env": "^7.12.11",
     "@babel/preset-typescript": "^7.12.7",
     "@babel/runtime": "^7.12.5",
+    "@react-native/babel-preset": "^0.73.18",
     "@testing-library/jest-native": "^4.0.4",
     "@testing-library/react-native": "^9.0.0",
     "@types/hammerjs": "^2.0.38",
     "@types/hoist-non-react-statics": "^3.3.1",
     "@types/jest": "^27.0.3",
-    "@types/react": "^18.0.24",
+    "@types/react": "^18.2.6",
     "@types/react-test-renderer": "^17.0.0",
     "@typescript-eslint/eslint-plugin": "^4.33.0",
     "@typescript-eslint/parser": "^4.33.0",
@@ -97,17 +98,16 @@
     "husky": "^8.0.1",
     "jest": "^26.6.3",
     "lint-staged": "^12.3.2",
-    "metro-react-native-babel-preset": "^0.64.0",
     "prettier": "^2.7.1",
     "react": "18.2.0",
     "react-dom": "^16.12.0",
-    "react-native": "0.72.0-rc.5",
+    "react-native": "0.73.0-rc.5",
     "react-native-builder-bob": "^0.17.1",
     "react-native-reanimated": "^2.3.1",
     "react-native-web": "^0.11.7",
     "react-test-renderer": "17.0.2",
     "release-it": "^13.6.5",
-    "typescript": "^4.5.5"
+    "typescript": "5.0.4"
   },
   "peerDependencies": {
     "react": "*",

package/src/components/gestureHandlerRootHOC.tsx

@@ -3,9 +3,7 @@ import { StyleSheet, StyleProp, ViewStyle } from 'react-native';
 import hoistNonReactStatics from 'hoist-non-react-statics';
 import GestureHandlerRootView from './GestureHandlerRootView';
 
-export default function gestureHandlerRootHOC<
-  P extends Record<string, unknown>
->(
+export default function gestureHandlerRootHOC<P extends object>(
   Component: React.ComponentType<P>,
   containerStyles?: StyleProp<ViewStyle>
 ): React.ComponentType<P> {

package/src/components/touchables/TouchableNativeFeedback.android.tsx

@@ -56,7 +56,8 @@ export default class TouchableNativeFeedback extends Component<TouchableNativeFe
     rippleRadius,
   });
 
-  static canUseNativeForeground = () => Platform.Version >= 23;
+  static canUseNativeForeground = () =>
+    Platform.OS === 'android' && Platform.Version >= 23;
 
   getExtraButtonProps() {
     const extraProps: TouchableNativeFeedbackExtraProps = {};

package/src/components/touchables/TouchableWithoutFeedback.tsx

@@ -2,11 +2,11 @@ import * as React from 'react';
 import { PropsWithChildren } from 'react';
 import GenericTouchable, { GenericTouchableProps } from './GenericTouchable';
 
-export type TouchableWithoutFeedbackProps = GenericTouchable;
+export type TouchableWithoutFeedbackProps = GenericTouchableProps;
 
 const TouchableWithoutFeedback = React.forwardRef<
-  TouchableWithoutFeedbackProps,
-  PropsWithChildren<GenericTouchableProps>
+  GenericTouchable,
+  PropsWithChildren<TouchableWithoutFeedbackProps>
 >((props, ref) => <GenericTouchable ref={ref} {...props} />);
 
 TouchableWithoutFeedback.defaultProps = GenericTouchable.defaultProps;

package/src/getReactNativeVersion.ts

@@ -0,0 +1,11 @@
+import pack from 'react-native/package.json';
+
+const [majorStr, minorStr] = pack.version.split('.');
+const REACT_NATIVE_VERSION = {
+  major: parseInt(majorStr, 10),
+  minor: parseInt(minorStr, 10),
+};
+
+export function getReactNativeVersion() {
+  return REACT_NATIVE_VERSION;
+}

package/src/getReactNativeVersion.web.ts

@@ -0,0 +1,3 @@
+export function getReactNativeVersion() {
+  throw new Error('getReactNativeVersion is not supported on web');
+}

package/src/handlers/gestureHandlerCommon.ts

@@ -23,7 +23,11 @@ const commonProps = [
   'activeCursor',
 ] as const;
 
-const componentInteractionProps = ['waitFor', 'simultaneousHandlers'] as const;
+const componentInteractionProps = [
+  'waitFor',
+  'simultaneousHandlers',
+  'blocksHandlers',
+] as const;
 
 export const baseGestureHandlerProps = [
   ...commonProps,
@@ -155,6 +159,7 @@ export type BaseGestureHandlerProps<
   id?: string;
   waitFor?: React.Ref<unknown> | React.Ref<unknown>[];
   simultaneousHandlers?: React.Ref<unknown> | React.Ref<unknown>[];
+  blocksHandlers?: React.Ref<unknown> | React.Ref<unknown>[];
   testID?: string;
   cancelsTouchesInView?: boolean;
   // TODO(TS) - fix event types

package/src/handlers/gestures/GestureDetector.tsx

@@ -37,12 +37,8 @@ import { State } from '../../State';
 import { TouchEventType } from '../../TouchEventType';
 import { ComposedGesture } from './gestureComposition';
 import { ActionType } from '../../ActionType';
-import {
-  isFabric,
-  isJestEnv,
-  REACT_NATIVE_VERSION,
-  tagMessage,
-} from '../../utils';
+import { isFabric, isJestEnv, tagMessage } from '../../utils';
+import { getReactNativeVersion } from '../../getReactNativeVersion';
 import { getShadowNodeFromRef } from '../../getShadowNodeFromRef';
 import { Platform } from 'react-native';
 import type RNGestureHandlerModuleWeb from '../../RNGestureHandlerModule.web';
@@ -197,11 +193,17 @@ function attachHandlers({
         );
       }
 
+      let blocksHandlers: number[] = [];
+      if (handler.config.blocksHandlers) {
+        blocksHandlers = extractValidHandlerTags(handler.config.blocksHandlers);
+      }
+
       RNGestureHandlerModule.updateGestureHandler(
         handler.handlerTag,
         filterConfig(handler.config, ALLOWED_PROPS, {
           simultaneousHandlers: simultaneousWith,
           waitFor: requireToFail,
+          blocksHandlers: blocksHandlers,
         })
       );
     }
@@ -565,6 +567,7 @@ function validateDetectorChildren(ref: any) {
   //         /       \
   //   NativeView  NativeView
   if (__DEV__ && Platform.OS !== 'web') {
+    const REACT_NATIVE_VERSION = getReactNativeVersion();
     // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
     const wrapType =
       REACT_NATIVE_VERSION.minor > 63 || REACT_NATIVE_VERSION.major > 0

package/src/handlers/gestures/gesture.ts

@@ -41,6 +41,7 @@ export interface BaseGestureConfig
   ref?: React.MutableRefObject<GestureType | undefined>;
   requireToFail?: GestureRef[];
   simultaneousWith?: GestureRef[];
+  blocksHandlers?: GestureRef[];
   needsPointerData?: boolean;
   manualActivation?: boolean;
   runOnJS?: boolean;
@@ -144,7 +145,7 @@ export abstract class BaseGesture<
   }
 
   private addDependency(
-    key: 'simultaneousWith' | 'requireToFail',
+    key: 'simultaneousWith' | 'requireToFail' | 'blocksHandlers',
     gesture: Exclude<GestureRef, number>
   ) {
     const value = this.config[key];
@@ -275,6 +276,13 @@ export abstract class BaseGesture<
     return this;
   }
 
+  blocksExternalGesture(...gestures: Exclude<GestureRef, number>[]) {
+    for (const gesture of gestures) {
+      this.addDependency('blocksHandlers', gesture);
+    }
+    return this;
+  }
+
   withTestId(id: string) {
     this.config.testId = id;
     return this;

package/src/handlers/gestures/gestureStateManager.ts

@@ -18,45 +18,47 @@ const warningMessage = tagMessage(
 const REANIMATED_AVAILABLE = Reanimated?.useSharedValue !== undefined;
 const setGestureState = Reanimated?.setGestureState;
 
+function create(handlerTag: number): GestureStateManagerType {
+  'worklet';
+  return {
+    begin: () => {
+      'worklet';
+      if (REANIMATED_AVAILABLE) {
+        setGestureState(handlerTag, State.BEGAN);
+      } else {
+        console.warn(warningMessage);
+      }
+    },
+
+    activate: () => {
+      'worklet';
+      if (REANIMATED_AVAILABLE) {
+        setGestureState(handlerTag, State.ACTIVE);
+      } else {
+        console.warn(warningMessage);
+      }
+    },
+
+    fail: () => {
+      'worklet';
+      if (REANIMATED_AVAILABLE) {
+        setGestureState(handlerTag, State.FAILED);
+      } else {
+        console.warn(warningMessage);
+      }
+    },
+
+    end: () => {
+      'worklet';
+      if (REANIMATED_AVAILABLE) {
+        setGestureState(handlerTag, State.END);
+      } else {
+        console.warn(warningMessage);
+      }
+    },
+  };
+}
+
 export const GestureStateManager = {
-  create(handlerTag: number): GestureStateManagerType {
-    'worklet';
-    return {
-      begin: () => {
-        'worklet';
-        if (REANIMATED_AVAILABLE) {
-          setGestureState(handlerTag, State.BEGAN);
-        } else {
-          console.warn(warningMessage);
-        }
-      },
-
-      activate: () => {
-        'worklet';
-        if (REANIMATED_AVAILABLE) {
-          setGestureState(handlerTag, State.ACTIVE);
-        } else {
-          console.warn(warningMessage);
-        }
-      },
-
-      fail: () => {
-        'worklet';
-        if (REANIMATED_AVAILABLE) {
-          setGestureState(handlerTag, State.FAILED);
-        } else {
-          console.warn(warningMessage);
-        }
-      },
-
-      end: () => {
-        'worklet';
-        if (REANIMATED_AVAILABLE) {
-          setGestureState(handlerTag, State.END);
-        } else {
-          console.warn(warningMessage);
-        }
-      },
-    };
-  },
+  create,
 };

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/FlingGestureHandler.ts

@@ -5,7 +5,7 @@ import { AdaptedEvent, Config } from '../interfaces';
 import GestureHandler from './GestureHandler';
 
 const DEFAULT_MAX_DURATION_MS = 800;
-const DEFAULT_MIN_ACCEPTABLE_DELTA = 160;
+const DEFAULT_MIN_ACCEPTABLE_DELTA = 32;
 const DEFAULT_DIRECTION = Direction.RIGHT;
 const DEFAULT_NUMBER_OF_TOUCHES_REQUIRED = 1;
 
@@ -141,11 +141,11 @@ export default class FlingGestureHandler extends GestureHandler {
   }
 
   private onUp(event: AdaptedEvent): void {
-    this.tracker.removeFromTracker(event.pointerId);
-    if (this.currentState !== State.BEGAN) {
-      return;
+    if (this.currentState === State.BEGAN) {
+      this.endFling();
     }
-    this.endFling();
+
+    this.tracker.removeFromTracker(event.pointerId);
   }
 
   public activate(force?: boolean): void {

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 {