react-native-gesture-handler 2.25.0 → 2.26.0

package/lib/module/handlers/gestures/GestureDetector/index.js

@@ -1,3 +1,5 @@
+"use strict";
+
 /* eslint-disable react/no-unused-prop-types */
 import React, { useContext, useEffect, useLayoutEffect, useMemo, useRef } from 'react';
 import { Platform } from 'react-native';
@@ -13,24 +15,20 @@ import { Wrap, AnimatedWrap } from './Wrap';
 import { useDetectorUpdater } from './useDetectorUpdater';
 import { useViewRefHandler } from './useViewRefHandler';
 import { useMountReactions } from './useMountReactions';
-
+import { jsx as _jsx } from "react/jsx-runtime";
 function propagateDetectorConfig(props, gesture) {
   const keysToPropagate = ['userSelect', 'enableContextMenu', 'touchAction'];
-
   for (const key of keysToPropagate) {
     const value = props[key];
-
     if (value === undefined) {
       continue;
     }
-
     for (const g of gesture.toGestureArray()) {
       const config = g.config;
       config[key] = value;
     }
   }
 }
-
 /**
  * `GestureDetector` is responsible for creating and updating native gesture handlers based on the config of provided gesture.
  *
@@ -48,18 +46,17 @@ function propagateDetectorConfig(props, gesture) {
  */
 export const GestureDetector = props => {
   const rootViewContext = useContext(GestureHandlerRootViewContext);
-
   if (__DEV__ && !rootViewContext && !isTestEnv() && Platform.OS !== 'web') {
     throw new Error('GestureDetector must be used as a descendant of GestureHandlerRootView. Otherwise the gestures will not be recognized. See https://docs.swmansion.com/react-native-gesture-handler/docs/installation for more details.');
-  } // Gesture config should be wrapped with useMemo to prevent unnecessary re-renders
-
+  }
 
+  // Gesture config should be wrapped with useMemo to prevent unnecessary re-renders
   const gestureConfig = props.gesture;
   propagateDetectorConfig(props, gestureConfig);
   const gesturesToAttach = useMemo(() => gestureConfig.toGestureArray(), [gestureConfig]);
   const shouldUseReanimated = gesturesToAttach.some(g => g.shouldUseReanimated);
-  const webEventHandlersRef = useWebEventHandlers(); // Store state in ref to prevent unnecessary renders
-
+  const webEventHandlersRef = useWebEventHandlers();
+  // Store state in ref to prevent unnecessary renders
   const state = useRef({
     firstRender: true,
     viewRef: null,
@@ -74,9 +71,10 @@ export const GestureDetector = props => {
     isMounted: false
   }).current;
   const updateAttachedGestures = useDetectorUpdater(state, preparedGesture, gesturesToAttach, gestureConfig, webEventHandlersRef);
-  const refHandler = useViewRefHandler(state, updateAttachedGestures); // Reanimated event should be rebuilt only when gestures are reattached, otherwise
-  // config update will be enough as all necessary items are stored in shared values anyway
+  const refHandler = useViewRefHandler(state, updateAttachedGestures);
 
+  // Reanimated event should be rebuilt only when gestures are reattached, otherwise
+  // config update will be enough as all necessary items are stored in shared values anyway
   const needsToRebuildReanimatedEvent = state.firstRender || state.forceRebuildReanimatedEvent || needsToReattach(preparedGesture, gesturesToAttach);
   state.forceRebuildReanimatedEvent = false;
   useAnimatedGesture(preparedGesture, needsToRebuildReanimatedEvent);
@@ -103,16 +101,17 @@ export const GestureDetector = props => {
     }
   }, [props]);
   useMountReactions(updateAttachedGestures, preparedGesture);
-
   if (shouldUseReanimated) {
-    return /*#__PURE__*/React.createElement(AnimatedWrap, {
+    return /*#__PURE__*/_jsx(AnimatedWrap, {
       ref: refHandler,
-      onGestureHandlerEvent: preparedGesture.animatedEventHandler
-    }, props.children);
+      onGestureHandlerEvent: preparedGesture.animatedEventHandler,
+      children: props.children
+    });
   } else {
-    return /*#__PURE__*/React.createElement(Wrap, {
-      ref: refHandler
-    }, props.children);
+    return /*#__PURE__*/_jsx(Wrap, {
+      ref: refHandler,
+      children: props.children
+    });
   }
 };
 //# sourceMappingURL=index.js.map

package/lib/module/handlers/gestures/GestureDetector/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["index.tsx"],"names":["React","useContext","useEffect","useLayoutEffect","useMemo","useRef","Platform","findNodeHandle","isTestEnv","GestureHandlerRootViewContext","useAnimatedGesture","attachHandlers","needsToReattach","dropHandlers","useWebEventHandlers","Wrap","AnimatedWrap","useDetectorUpdater","useViewRefHandler","useMountReactions","propagateDetectorConfig","props","gesture","keysToPropagate","key","value","undefined","g","toGestureArray","config","GestureDetector","rootViewContext","__DEV__","OS","Error","gestureConfig","gesturesToAttach","shouldUseReanimated","some","webEventHandlersRef","state","firstRender","viewRef","previousViewTag","forceRebuildReanimatedEvent","current","preparedGesture","attachedGestures","animatedEventHandler","animatedHandlers","isMounted","updateAttachedGestures","refHandler","needsToRebuildReanimatedEvent","viewTag","children"],"mappings":"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","sourcesContent":["/* eslint-disable react/no-unused-prop-types */\nimport React, {\n  useContext,\n  useEffect,\n  useLayoutEffect,\n  useMemo,\n  useRef,\n} from 'react';\nimport { Platform } from 'react-native';\nimport findNodeHandle from '../../../findNodeHandle';\nimport { GestureType } from '../gesture';\nimport { UserSelect, TouchAction } from '../../gestureHandlerCommon';\nimport { ComposedGesture } from '../gestureComposition';\nimport { isTestEnv } from '../../../utils';\n\nimport GestureHandlerRootViewContext from '../../../GestureHandlerRootViewContext';\nimport { AttachedGestureState, GestureDetectorState } from './types';\nimport { useAnimatedGesture } from './useAnimatedGesture';\nimport { attachHandlers } from './attachHandlers';\nimport { needsToReattach } from './needsToReattach';\nimport { dropHandlers } from './dropHandlers';\nimport { useWebEventHandlers } from './utils';\nimport { Wrap, AnimatedWrap } from './Wrap';\nimport { useDetectorUpdater } from './useDetectorUpdater';\nimport { useViewRefHandler } from './useViewRefHandler';\nimport { useMountReactions } from './useMountReactions';\n\nfunction propagateDetectorConfig(\n  props: GestureDetectorProps,\n  gesture: ComposedGesture | GestureType\n) {\n  const keysToPropagate: (keyof GestureDetectorProps)[] = [\n    'userSelect',\n    'enableContextMenu',\n    'touchAction',\n  ];\n\n  for (const key of keysToPropagate) {\n    const value = props[key];\n    if (value === undefined) {\n      continue;\n    }\n\n    for (const g of gesture.toGestureArray()) {\n      const config = g.config as { [key: string]: unknown };\n      config[key] = value;\n    }\n  }\n}\n\ninterface GestureDetectorProps {\n  children?: React.ReactNode;\n  /**\n   * A gesture object containing the configuration and callbacks.\n   * Can be any of:\n   * - base gestures (`Tap`, `Pan`, ...)\n   * - `ComposedGesture` (`Race`, `Simultaneous`, `Exclusive`)\n   */\n  gesture: ComposedGesture | GestureType;\n  /**\n   * #### Web only\n   * This parameter allows to specify which `userSelect` property should be applied to underlying view.\n   * Possible values are `\"none\" | \"auto\" | \"text\"`. Default value is set to `\"none\"`.\n   */\n  userSelect?: UserSelect;\n  /**\n   * #### Web only\n   * Specifies whether context menu should be enabled after clicking on underlying view with right mouse button.\n   * Default value is set to `false`.\n   */\n  enableContextMenu?: boolean;\n  /**\n   * #### Web only\n   * This parameter allows to specify which `touchAction` property should be applied to underlying view.\n   * Supports all CSS touch-action values (e.g. `\"none\"`, `\"pan-y\"`). Default value is set to `\"none\"`.\n   */\n  touchAction?: TouchAction;\n}\n\n/**\n * `GestureDetector` is responsible for creating and updating native gesture handlers based on the config of provided gesture.\n *\n * ### Props\n * - `gesture`\n * - `userSelect` (**Web only**)\n * - `enableContextMenu` (**Web only**)\n * - `touchAction` (**Web only**)\n *\n * ### Remarks\n * - Gesture Detector will use first native view in its subtree to recognize gestures, however if this view is used only to group its children it may get automatically collapsed.\n * - Using the same instance of a gesture across multiple Gesture Detectors is not possible.\n *\n * @see https://docs.swmansion.com/react-native-gesture-handler/docs/gestures/gesture-detector\n */\nexport const GestureDetector = (props: GestureDetectorProps) => {\n  const rootViewContext = useContext(GestureHandlerRootViewContext);\n  if (__DEV__ && !rootViewContext && !isTestEnv() && Platform.OS !== 'web') {\n    throw new Error(\n      'GestureDetector must be used as a descendant of GestureHandlerRootView. Otherwise the gestures will not be recognized. See https://docs.swmansion.com/react-native-gesture-handler/docs/installation for more details.'\n    );\n  }\n\n  // Gesture config should be wrapped with useMemo to prevent unnecessary re-renders\n  const gestureConfig = props.gesture;\n  propagateDetectorConfig(props, gestureConfig);\n\n  const gesturesToAttach = useMemo(\n    () => gestureConfig.toGestureArray(),\n    [gestureConfig]\n  );\n  const shouldUseReanimated = gesturesToAttach.some(\n    (g) => g.shouldUseReanimated\n  );\n\n  const webEventHandlersRef = useWebEventHandlers();\n  // Store state in ref to prevent unnecessary renders\n  const state = useRef<GestureDetectorState>({\n    firstRender: true,\n    viewRef: null,\n    previousViewTag: -1,\n    forceRebuildReanimatedEvent: false,\n  }).current;\n\n  const preparedGesture = React.useRef<AttachedGestureState>({\n    attachedGestures: [],\n    animatedEventHandler: null,\n    animatedHandlers: null,\n    shouldUseReanimated: shouldUseReanimated,\n    isMounted: false,\n  }).current;\n\n  const updateAttachedGestures = useDetectorUpdater(\n    state,\n    preparedGesture,\n    gesturesToAttach,\n    gestureConfig,\n    webEventHandlersRef\n  );\n\n  const refHandler = useViewRefHandler(state, updateAttachedGestures);\n\n  // Reanimated event should be rebuilt only when gestures are reattached, otherwise\n  // config update will be enough as all necessary items are stored in shared values anyway\n  const needsToRebuildReanimatedEvent =\n    state.firstRender ||\n    state.forceRebuildReanimatedEvent ||\n    needsToReattach(preparedGesture, gesturesToAttach);\n  state.forceRebuildReanimatedEvent = false;\n\n  useAnimatedGesture(preparedGesture, needsToRebuildReanimatedEvent);\n\n  useLayoutEffect(() => {\n    const viewTag = findNodeHandle(state.viewRef) as number;\n    preparedGesture.isMounted = true;\n\n    attachHandlers({\n      preparedGesture,\n      gestureConfig,\n      gesturesToAttach,\n      webEventHandlersRef,\n      viewTag,\n    });\n\n    return () => {\n      preparedGesture.isMounted = false;\n      dropHandlers(preparedGesture);\n    };\n  }, []);\n\n  useEffect(() => {\n    if (state.firstRender) {\n      state.firstRender = false;\n    } else {\n      updateAttachedGestures();\n    }\n  }, [props]);\n\n  useMountReactions(updateAttachedGestures, preparedGesture);\n\n  if (shouldUseReanimated) {\n    return (\n      <AnimatedWrap\n        ref={refHandler}\n        onGestureHandlerEvent={preparedGesture.animatedEventHandler}>\n        {props.children}\n      </AnimatedWrap>\n    );\n  } else {\n    return <Wrap ref={refHandler}>{props.children}</Wrap>;\n  }\n};\n"]}
+{"version":3,"names":["React","useContext","useEffect","useLayoutEffect","useMemo","useRef","Platform","findNodeHandle","isTestEnv","GestureHandlerRootViewContext","useAnimatedGesture","attachHandlers","needsToReattach","dropHandlers","useWebEventHandlers","Wrap","AnimatedWrap","useDetectorUpdater","useViewRefHandler","useMountReactions","jsx","_jsx","propagateDetectorConfig","props","gesture","keysToPropagate","key","value","undefined","g","toGestureArray","config","GestureDetector","rootViewContext","__DEV__","OS","Error","gestureConfig","gesturesToAttach","shouldUseReanimated","some","webEventHandlersRef","state","firstRender","viewRef","previousViewTag","forceRebuildReanimatedEvent","current","preparedGesture","attachedGestures","animatedEventHandler","animatedHandlers","isMounted","updateAttachedGestures","refHandler","needsToRebuildReanimatedEvent","viewTag","ref","onGestureHandlerEvent","children"],"sourceRoot":"../../../../../src","sources":["handlers/gestures/GestureDetector/index.tsx"],"mappings":"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","ignoreList":[]}

package/lib/module/handlers/gestures/GestureDetector/needsToReattach.js

@@ -1,3 +1,5 @@
+"use strict";
+
 // Checks whether the gesture should be reattached to the view, this will happen when:
 // - The number of gestures in the preparedGesture is different than the number of gestures in the gesture
 // - The handlerName is different in any of the gestures
@@ -6,13 +8,11 @@ export function needsToReattach(preparedGesture, newGestures) {
   if (newGestures.length !== preparedGesture.attachedGestures.length) {
     return true;
   }
-
   for (let i = 0; i < newGestures.length; i++) {
     if (newGestures[i].handlerName !== preparedGesture.attachedGestures[i].handlerName || newGestures[i].shouldUseReanimated !== preparedGesture.attachedGestures[i].shouldUseReanimated) {
       return true;
     }
   }
-
   return false;
 }
 //# sourceMappingURL=needsToReattach.js.map

package/lib/module/handlers/gestures/GestureDetector/needsToReattach.js.map

@@ -1 +1 @@
-{"version":3,"sources":["needsToReattach.ts"],"names":["needsToReattach","preparedGesture","newGestures","length","attachedGestures","i","handlerName","shouldUseReanimated"],"mappings":"AAGA;AACA;AACA;AACA;AACA,OAAO,SAASA,eAAT,CACLC,eADK,EAELC,WAFK,EAGL;AACA,MAAIA,WAAW,CAACC,MAAZ,KAAuBF,eAAe,CAACG,gBAAhB,CAAiCD,MAA5D,EAAoE;AAClE,WAAO,IAAP;AACD;;AACD,OAAK,IAAIE,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGH,WAAW,CAACC,MAAhC,EAAwCE,CAAC,EAAzC,EAA6C;AAC3C,QACEH,WAAW,CAACG,CAAD,CAAX,CAAeC,WAAf,KACEL,eAAe,CAACG,gBAAhB,CAAiCC,CAAjC,EAAoCC,WADtC,IAEAJ,WAAW,CAACG,CAAD,CAAX,CAAeE,mBAAf,KACEN,eAAe,CAACG,gBAAhB,CAAiCC,CAAjC,EAAoCE,mBAJxC,EAKE;AACA,aAAO,IAAP;AACD;AACF;;AAED,SAAO,KAAP;AACD","sourcesContent":["import { GestureType } from '../gesture';\nimport { AttachedGestureState } from './types';\n\n// Checks whether the gesture should be reattached to the view, this will happen when:\n// - The number of gestures in the preparedGesture is different than the number of gestures in the gesture\n// - The handlerName is different in any of the gestures\n// - At least one of the gestures changed the thread it runs on\nexport function needsToReattach(\n  preparedGesture: AttachedGestureState,\n  newGestures: GestureType[]\n) {\n  if (newGestures.length !== preparedGesture.attachedGestures.length) {\n    return true;\n  }\n  for (let i = 0; i < newGestures.length; i++) {\n    if (\n      newGestures[i].handlerName !==\n        preparedGesture.attachedGestures[i].handlerName ||\n      newGestures[i].shouldUseReanimated !==\n        preparedGesture.attachedGestures[i].shouldUseReanimated\n    ) {\n      return true;\n    }\n  }\n\n  return false;\n}\n"]}
+{"version":3,"names":["needsToReattach","preparedGesture","newGestures","length","attachedGestures","i","handlerName","shouldUseReanimated"],"sourceRoot":"../../../../../src","sources":["handlers/gestures/GestureDetector/needsToReattach.ts"],"mappings":";;AAGA;AACA;AACA;AACA;AACA,OAAO,SAASA,eAAeA,CAC7BC,eAAqC,EACrCC,WAA0B,EAC1B;EACA,IAAIA,WAAW,CAACC,MAAM,KAAKF,eAAe,CAACG,gBAAgB,CAACD,MAAM,EAAE;IAClE,OAAO,IAAI;EACb;EACA,KAAK,IAAIE,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGH,WAAW,CAACC,MAAM,EAAEE,CAAC,EAAE,EAAE;IAC3C,IACEH,WAAW,CAACG,CAAC,CAAC,CAACC,WAAW,KACxBL,eAAe,CAACG,gBAAgB,CAACC,CAAC,CAAC,CAACC,WAAW,IACjDJ,WAAW,CAACG,CAAC,CAAC,CAACE,mBAAmB,KAChCN,eAAe,CAACG,gBAAgB,CAACC,CAAC,CAAC,CAACE,mBAAmB,EACzD;MACA,OAAO,IAAI;IACb;EACF;EAEA,OAAO,KAAK;AACd","ignoreList":[]}

package/lib/module/handlers/gestures/GestureDetector/types.js

@@ -1,2 +1,4 @@
+"use strict";
+
 export {};
 //# sourceMappingURL=types.js.map

package/lib/module/handlers/gestures/GestureDetector/types.js.map

@@ -1 +1 @@
-{"version":3,"sources":[],"names":[],"mappings":"","sourcesContent":[]}
+{"version":3,"names":[],"sourceRoot":"../../../../../src","sources":["handlers/gestures/GestureDetector/types.ts"],"mappings":"","ignoreList":[]}

package/lib/module/handlers/gestures/GestureDetector/updateHandlers.js

@@ -1,3 +1,5 @@
+"use strict";
+
 import { registerHandler } from '../../handlersRegistry';
 import RNGestureHandlerModule from '../../../RNGestureHandlerModule';
 import { filterConfig, scheduleFlushOperations } from '../../utils';
@@ -5,56 +7,54 @@ import { ghQueueMicrotask } from '../../../ghQueueMicrotask';
 import { extractGestureRelations, checkGestureCallbacksForWorklets, ALLOWED_PROPS } from './utils';
 export function updateHandlers(preparedGesture, gestureConfig, newGestures) {
   gestureConfig.prepare();
-
   for (let i = 0; i < newGestures.length; i++) {
     const handler = preparedGesture.attachedGestures[i];
-    checkGestureCallbacksForWorklets(handler); // Only update handlerTag when it's actually different, it may be the same
-    // if gesture config object is wrapped with useMemo
+    checkGestureCallbacksForWorklets(handler);
 
+    // Only update handlerTag when it's actually different, it may be the same
+    // if gesture config object is wrapped with useMemo
     if (newGestures[i].handlerTag !== handler.handlerTag) {
       newGestures[i].handlerTag = handler.handlerTag;
       newGestures[i].handlers.handlerTag = handler.handlerTag;
     }
-  } // Store attached gestures to avoid crash when gestures changed after queueing micro task
+  }
 
+  // Store attached gestures to avoid crash when gestures changed after queueing micro task
+  const attachedGestures = preparedGesture.attachedGestures;
 
-  const attachedGestures = preparedGesture.attachedGestures; // Use queueMicrotask to extract handlerTags, because when it's ran, all refs should be updated
+  // Use queueMicrotask to extract handlerTags, because when it's ran, all refs should be updated
   // and handlerTags in BaseGesture references should be updated in the loop above (we need to wait
   // in case of external relations)
-
   ghQueueMicrotask(() => {
     if (!preparedGesture.isMounted) {
       return;
-    } // Stop if attached gestures changed after queueing micro task
-
+    }
 
+    // Stop if attached gestures changed after queueing micro task
     if (attachedGestures !== preparedGesture.attachedGestures) {
       return;
-    } // If amount of gesture configs changes, we need to update the callbacks in shared value
-
+    }
 
+    // If amount of gesture configs changes, we need to update the callbacks in shared value
     let shouldUpdateSharedValueIfUsed = attachedGestures.length !== newGestures.length;
-
     for (let i = 0; i < newGestures.length; i++) {
-      const handler = attachedGestures[i]; // If the gestureId is different (gesture isn't wrapped with useMemo or its dependencies changed),
-      // we need to update the shared value, assuming the gesture runs on UI thread or the thread changed
+      const handler = attachedGestures[i];
 
+      // If the gestureId is different (gesture isn't wrapped with useMemo or its dependencies changed),
+      // we need to update the shared value, assuming the gesture runs on UI thread or the thread changed
       if (handler.handlers.gestureId !== newGestures[i].handlers.gestureId && (newGestures[i].shouldUseReanimated || handler.shouldUseReanimated)) {
         shouldUpdateSharedValueIfUsed = true;
       }
-
       handler.config = newGestures[i].config;
       handler.handlers = newGestures[i].handlers;
       RNGestureHandlerModule.updateGestureHandler(handler.handlerTag, filterConfig(handler.config, ALLOWED_PROPS, extractGestureRelations(handler)));
       registerHandler(handler.handlerTag, handler, handler.config.testId);
     }
-
     if (preparedGesture.animatedHandlers && shouldUpdateSharedValueIfUsed) {
       const newHandlersValue = attachedGestures.filter(g => g.shouldUseReanimated) // Ignore gestures that shouldn't run on UI
       .map(g => g.handlers);
       preparedGesture.animatedHandlers.value = newHandlersValue;
     }
-
     scheduleFlushOperations();
   });
 }

package/lib/module/handlers/gestures/GestureDetector/updateHandlers.js.map

@@ -1 +1 @@
-{"version":3,"sources":["updateHandlers.ts"],"names":["registerHandler","RNGestureHandlerModule","filterConfig","scheduleFlushOperations","ghQueueMicrotask","extractGestureRelations","checkGestureCallbacksForWorklets","ALLOWED_PROPS","updateHandlers","preparedGesture","gestureConfig","newGestures","prepare","i","length","handler","attachedGestures","handlerTag","handlers","isMounted","shouldUpdateSharedValueIfUsed","gestureId","shouldUseReanimated","config","updateGestureHandler","testId","animatedHandlers","newHandlersValue","filter","g","map","value"],"mappings":"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","sourcesContent":["import { GestureType, HandlerCallbacks } from '../gesture';\nimport { registerHandler } from '../../handlersRegistry';\nimport RNGestureHandlerModule from '../../../RNGestureHandlerModule';\nimport { filterConfig, scheduleFlushOperations } from '../../utils';\nimport { ComposedGesture } from '../gestureComposition';\nimport { ghQueueMicrotask } from '../../../ghQueueMicrotask';\nimport { AttachedGestureState } from './types';\nimport {\n  extractGestureRelations,\n  checkGestureCallbacksForWorklets,\n  ALLOWED_PROPS,\n} from './utils';\n\nexport function updateHandlers(\n  preparedGesture: AttachedGestureState,\n  gestureConfig: ComposedGesture | GestureType,\n  newGestures: GestureType[]\n) {\n  gestureConfig.prepare();\n\n  for (let i = 0; i < newGestures.length; i++) {\n    const handler = preparedGesture.attachedGestures[i];\n    checkGestureCallbacksForWorklets(handler);\n\n    // Only update handlerTag when it's actually different, it may be the same\n    // if gesture config object is wrapped with useMemo\n    if (newGestures[i].handlerTag !== handler.handlerTag) {\n      newGestures[i].handlerTag = handler.handlerTag;\n      newGestures[i].handlers.handlerTag = handler.handlerTag;\n    }\n  }\n\n  // Store attached gestures to avoid crash when gestures changed after queueing micro task\n  const attachedGestures = preparedGesture.attachedGestures;\n\n  // Use queueMicrotask to extract handlerTags, because when it's ran, all refs should be updated\n  // and handlerTags in BaseGesture references should be updated in the loop above (we need to wait\n  // in case of external relations)\n  ghQueueMicrotask(() => {\n    if (!preparedGesture.isMounted) {\n      return;\n    }\n\n    // Stop if attached gestures changed after queueing micro task\n    if (attachedGestures !== preparedGesture.attachedGestures) {\n      return;\n    }\n\n    // If amount of gesture configs changes, we need to update the callbacks in shared value\n    let shouldUpdateSharedValueIfUsed =\n      attachedGestures.length !== newGestures.length;\n\n    for (let i = 0; i < newGestures.length; i++) {\n      const handler = attachedGestures[i];\n\n      // If the gestureId is different (gesture isn't wrapped with useMemo or its dependencies changed),\n      // we need to update the shared value, assuming the gesture runs on UI thread or the thread changed\n      if (\n        handler.handlers.gestureId !== newGestures[i].handlers.gestureId &&\n        (newGestures[i].shouldUseReanimated || handler.shouldUseReanimated)\n      ) {\n        shouldUpdateSharedValueIfUsed = true;\n      }\n\n      handler.config = newGestures[i].config;\n      handler.handlers = newGestures[i].handlers;\n\n      RNGestureHandlerModule.updateGestureHandler(\n        handler.handlerTag,\n        filterConfig(\n          handler.config,\n          ALLOWED_PROPS,\n          extractGestureRelations(handler)\n        )\n      );\n\n      registerHandler(handler.handlerTag, handler, handler.config.testId);\n    }\n\n    if (preparedGesture.animatedHandlers && shouldUpdateSharedValueIfUsed) {\n      const newHandlersValue = attachedGestures\n        .filter((g) => g.shouldUseReanimated) // Ignore gestures that shouldn't run on UI\n        .map((g) => g.handlers) as unknown as HandlerCallbacks<\n        Record<string, unknown>\n      >[];\n\n      preparedGesture.animatedHandlers.value = newHandlersValue;\n    }\n\n    scheduleFlushOperations();\n  });\n}\n"]}
+{"version":3,"names":["registerHandler","RNGestureHandlerModule","filterConfig","scheduleFlushOperations","ghQueueMicrotask","extractGestureRelations","checkGestureCallbacksForWorklets","ALLOWED_PROPS","updateHandlers","preparedGesture","gestureConfig","newGestures","prepare","i","length","handler","attachedGestures","handlerTag","handlers","isMounted","shouldUpdateSharedValueIfUsed","gestureId","shouldUseReanimated","config","updateGestureHandler","testId","animatedHandlers","newHandlersValue","filter","g","map","value"],"sourceRoot":"../../../../../src","sources":["handlers/gestures/GestureDetector/updateHandlers.ts"],"mappings":";;AACA,SAASA,eAAe,QAAQ,wBAAwB;AACxD,OAAOC,sBAAsB,MAAM,iCAAiC;AACpE,SAASC,YAAY,EAAEC,uBAAuB,QAAQ,aAAa;AAEnE,SAASC,gBAAgB,QAAQ,2BAA2B;AAE5D,SACEC,uBAAuB,EACvBC,gCAAgC,EAChCC,aAAa,QACR,SAAS;AAEhB,OAAO,SAASC,cAAcA,CAC5BC,eAAqC,EACrCC,aAA4C,EAC5CC,WAA0B,EAC1B;EACAD,aAAa,CAACE,OAAO,CAAC,CAAC;EAEvB,KAAK,IAAIC,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGF,WAAW,CAACG,MAAM,EAAED,CAAC,EAAE,EAAE;IAC3C,MAAME,OAAO,GAAGN,eAAe,CAACO,gBAAgB,CAACH,CAAC,CAAC;IACnDP,gCAAgC,CAACS,OAAO,CAAC;;IAEzC;IACA;IACA,IAAIJ,WAAW,CAACE,CAAC,CAAC,CAACI,UAAU,KAAKF,OAAO,CAACE,UAAU,EAAE;MACpDN,WAAW,CAACE,CAAC,CAAC,CAACI,UAAU,GAAGF,OAAO,CAACE,UAAU;MAC9CN,WAAW,CAACE,CAAC,CAAC,CAACK,QAAQ,CAACD,UAAU,GAAGF,OAAO,CAACE,UAAU;IACzD;EACF;;EAEA;EACA,MAAMD,gBAAgB,GAAGP,eAAe,CAACO,gBAAgB;;EAEzD;EACA;EACA;EACAZ,gBAAgB,CAAC,MAAM;IACrB,IAAI,CAACK,eAAe,CAACU,SAAS,EAAE;MAC9B;IACF;;IAEA;IACA,IAAIH,gBAAgB,KAAKP,eAAe,CAACO,gBAAgB,EAAE;MACzD;IACF;;IAEA;IACA,IAAII,6BAA6B,GAC/BJ,gBAAgB,CAACF,MAAM,KAAKH,WAAW,CAACG,MAAM;IAEhD,KAAK,IAAID,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGF,WAAW,CAACG,MAAM,EAAED,CAAC,EAAE,EAAE;MAC3C,MAAME,OAAO,GAAGC,gBAAgB,CAACH,CAAC,CAAC;;MAEnC;MACA;MACA,IACEE,OAAO,CAACG,QAAQ,CAACG,SAAS,KAAKV,WAAW,CAACE,CAAC,CAAC,CAACK,QAAQ,CAACG,SAAS,KAC/DV,WAAW,CAACE,CAAC,CAAC,CAACS,mBAAmB,IAAIP,OAAO,CAACO,mBAAmB,CAAC,EACnE;QACAF,6BAA6B,GAAG,IAAI;MACtC;MAEAL,OAAO,CAACQ,MAAM,GAAGZ,WAAW,CAACE,CAAC,CAAC,CAACU,MAAM;MACtCR,OAAO,CAACG,QAAQ,GAAGP,WAAW,CAACE,CAAC,CAAC,CAACK,QAAQ;MAE1CjB,sBAAsB,CAACuB,oBAAoB,CACzCT,OAAO,CAACE,UAAU,EAClBf,YAAY,CACVa,OAAO,CAACQ,MAAM,EACdhB,aAAa,EACbF,uBAAuB,CAACU,OAAO,CACjC,CACF,CAAC;MAEDf,eAAe,CAACe,OAAO,CAACE,UAAU,EAAEF,OAAO,EAAEA,OAAO,CAACQ,MAAM,CAACE,MAAM,CAAC;IACrE;IAEA,IAAIhB,eAAe,CAACiB,gBAAgB,IAAIN,6BAA6B,EAAE;MACrE,MAAMO,gBAAgB,GAAGX,gBAAgB,CACtCY,MAAM,CAAEC,CAAC,IAAKA,CAAC,CAACP,mBAAmB,CAAC,CAAC;MAAA,CACrCQ,GAAG,CAAED,CAAC,IAAKA,CAAC,CAACX,QAAQ,CAErB;MAEHT,eAAe,CAACiB,gBAAgB,CAACK,KAAK,GAAGJ,gBAAgB;IAC3D;IAEAxB,uBAAuB,CAAC,CAAC;EAC3B,CAAC,CAAC;AACJ","ignoreList":[]}

package/lib/module/handlers/gestures/GestureDetector/useAnimatedGesture.js

@@ -1,122 +1,102 @@
+"use strict";
+
 import { CALLBACK_TYPE } from '../gesture';
 import { Reanimated } from '../reanimatedWrapper';
 import { GestureStateManager } from '../gestureStateManager';
 import { State } from '../../../State';
 import { TouchEventType } from '../../../TouchEventType';
 import { tagMessage } from '../../../utils';
-
 function getHandler(type, gesture) {
   'worklet';
 
   switch (type) {
     case CALLBACK_TYPE.BEGAN:
       return gesture.onBegin;
-
     case CALLBACK_TYPE.START:
       return gesture.onStart;
-
     case CALLBACK_TYPE.UPDATE:
       return gesture.onUpdate;
-
     case CALLBACK_TYPE.CHANGE:
       return gesture.onChange;
-
     case CALLBACK_TYPE.END:
       return gesture.onEnd;
-
     case CALLBACK_TYPE.FINALIZE:
       return gesture.onFinalize;
-
     case CALLBACK_TYPE.TOUCHES_DOWN:
       return gesture.onTouchesDown;
-
     case CALLBACK_TYPE.TOUCHES_MOVE:
       return gesture.onTouchesMove;
-
     case CALLBACK_TYPE.TOUCHES_UP:
       return gesture.onTouchesUp;
-
     case CALLBACK_TYPE.TOUCHES_CANCELLED:
       return gesture.onTouchesCancelled;
   }
 }
-
 function touchEventTypeToCallbackType(eventType) {
   'worklet';
 
   switch (eventType) {
     case TouchEventType.TOUCHES_DOWN:
       return CALLBACK_TYPE.TOUCHES_DOWN;
-
     case TouchEventType.TOUCHES_MOVE:
       return CALLBACK_TYPE.TOUCHES_MOVE;
-
     case TouchEventType.TOUCHES_UP:
       return CALLBACK_TYPE.TOUCHES_UP;
-
     case TouchEventType.TOUCHES_CANCELLED:
       return CALLBACK_TYPE.TOUCHES_CANCELLED;
   }
-
   return CALLBACK_TYPE.UNDEFINED;
 }
-
 function runWorklet(type, gesture, event, ...args) {
   'worklet';
 
   const handler = getHandler(type, gesture);
-
   if (gesture.isWorklet[type]) {
     // @ts-ignore Logic below makes sure the correct event is send to the
     // correct handler.
-    handler === null || handler === void 0 ? void 0 : handler(event, ...args);
+    handler?.(event, ...args);
   } else if (handler) {
     console.warn(tagMessage('Animated gesture callback must be a worklet'));
   }
 }
-
 function isStateChangeEvent(event) {
-  'worklet'; // @ts-ignore Yes, the oldState prop is missing on GestureTouchEvent, that's the point
+  'worklet';
 
+  // @ts-ignore Yes, the oldState prop is missing on GestureTouchEvent, that's the point
   return event.oldState != null;
 }
-
 function isTouchEvent(event) {
   'worklet';
 
   return event.eventType != null;
 }
-
 export function useAnimatedGesture(preparedGesture, needsRebuild) {
   if (!Reanimated) {
     return;
-  } // Hooks are called conditionally, but the condition is whether the
+  }
+
+  // Hooks are called conditionally, but the condition is whether the
   // react-native-reanimated is installed, which shouldn't change while running
   // eslint-disable-next-line react-hooks/rules-of-hooks
+  const sharedHandlersCallbacks = Reanimated.useSharedValue(null);
 
+  // eslint-disable-next-line react-hooks/rules-of-hooks
+  const lastUpdateEvent = Reanimated.useSharedValue([]);
 
-  const sharedHandlersCallbacks = Reanimated.useSharedValue(null); // eslint-disable-next-line react-hooks/rules-of-hooks
-
-  const lastUpdateEvent = Reanimated.useSharedValue([]); // not every gesture needs a state controller, init them lazily
-
+  // not every gesture needs a state controller, init them lazily
   const stateControllers = [];
-
   const callback = event => {
     'worklet';
 
     const currentCallback = sharedHandlersCallbacks.value;
-
     if (!currentCallback) {
       return;
     }
-
     for (let i = 0; i < currentCallback.length; i++) {
       const gesture = currentCallback[i];
-
       if (event.handlerTag !== gesture.handlerTag) {
         continue;
       }
-
       if (isStateChangeEvent(event)) {
         if (event.oldState === State.UNDETERMINED && event.state === State.BEGAN) {
           runWorklet(CALLBACK_TYPE.BEGAN, gesture, event);
@@ -127,37 +107,31 @@ export function useAnimatedGesture(preparedGesture, needsRebuild) {
           if (event.oldState === State.ACTIVE) {
             runWorklet(CALLBACK_TYPE.END, gesture, event, true);
           }
-
           runWorklet(CALLBACK_TYPE.FINALIZE, gesture, event, true);
         } else if ((event.state === State.FAILED || event.state === State.CANCELLED) && event.state !== event.oldState) {
           if (event.oldState === State.ACTIVE) {
             runWorklet(CALLBACK_TYPE.END, gesture, event, false);
           }
-
           runWorklet(CALLBACK_TYPE.FINALIZE, gesture, event, false);
         }
       } else if (isTouchEvent(event)) {
         if (!stateControllers[i]) {
           stateControllers[i] = GestureStateManager.create(event.handlerTag);
         }
-
         if (event.eventType !== TouchEventType.UNDETERMINED) {
           runWorklet(touchEventTypeToCallbackType(event.eventType), gesture, event, stateControllers[i]);
         }
       } else {
         runWorklet(CALLBACK_TYPE.UPDATE, gesture, event);
-
         if (gesture.onChange && gesture.changeEventCalculator) {
-          var _gesture$changeEventC;
-
-          runWorklet(CALLBACK_TYPE.CHANGE, gesture, (_gesture$changeEventC = gesture.changeEventCalculator) === null || _gesture$changeEventC === void 0 ? void 0 : _gesture$changeEventC.call(gesture, event, lastUpdateEvent.value[gesture.handlerTag]));
+          runWorklet(CALLBACK_TYPE.CHANGE, gesture, gesture.changeEventCalculator?.(event, lastUpdateEvent.value[gesture.handlerTag]));
           lastUpdateEvent.value[gesture.handlerTag] = event;
         }
       }
     }
-  }; // eslint-disable-next-line react-hooks/rules-of-hooks
-
+  };
 
+  // eslint-disable-next-line react-hooks/rules-of-hooks
   const event = Reanimated.useEvent(callback, ['onGestureHandlerStateChange', 'onGestureHandlerEvent'], needsRebuild);
   preparedGesture.animatedEventHandler = event;
   preparedGesture.animatedHandlers = sharedHandlersCallbacks;

package/lib/module/handlers/gestures/GestureDetector/useAnimatedGesture.js.map

@@ -1 +1 @@
-{"version":3,"sources":["useAnimatedGesture.ts"],"names":["CALLBACK_TYPE","Reanimated","GestureStateManager","State","TouchEventType","tagMessage","getHandler","type","gesture","BEGAN","onBegin","START","onStart","UPDATE","onUpdate","CHANGE","onChange","END","onEnd","FINALIZE","onFinalize","TOUCHES_DOWN","onTouchesDown","TOUCHES_MOVE","onTouchesMove","TOUCHES_UP","onTouchesUp","TOUCHES_CANCELLED","onTouchesCancelled","touchEventTypeToCallbackType","eventType","UNDEFINED","runWorklet","event","args","handler","isWorklet","console","warn","isStateChangeEvent","oldState","isTouchEvent","useAnimatedGesture","preparedGesture","needsRebuild","sharedHandlersCallbacks","useSharedValue","lastUpdateEvent","stateControllers","callback","currentCallback","value","i","length","handlerTag","UNDETERMINED","state","ACTIVE","undefined","FAILED","CANCELLED","create","changeEventCalculator","useEvent","animatedEventHandler","animatedHandlers"],"mappings":"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","sourcesContent":["import { HandlerCallbacks, CALLBACK_TYPE } from '../gesture';\nimport { Reanimated } from '../reanimatedWrapper';\nimport {\n  GestureTouchEvent,\n  GestureUpdateEvent,\n  GestureStateChangeEvent,\n} from '../../gestureHandlerCommon';\nimport {\n  GestureStateManager,\n  GestureStateManagerType,\n} from '../gestureStateManager';\nimport { State } from '../../../State';\nimport { TouchEventType } from '../../../TouchEventType';\nimport { tagMessage } from '../../../utils';\nimport { AttachedGestureState } from './types';\n\nfunction getHandler(\n  type: CALLBACK_TYPE,\n  gesture: HandlerCallbacks<Record<string, unknown>>\n) {\n  'worklet';\n  switch (type) {\n    case CALLBACK_TYPE.BEGAN:\n      return gesture.onBegin;\n    case CALLBACK_TYPE.START:\n      return gesture.onStart;\n    case CALLBACK_TYPE.UPDATE:\n      return gesture.onUpdate;\n    case CALLBACK_TYPE.CHANGE:\n      return gesture.onChange;\n    case CALLBACK_TYPE.END:\n      return gesture.onEnd;\n    case CALLBACK_TYPE.FINALIZE:\n      return gesture.onFinalize;\n    case CALLBACK_TYPE.TOUCHES_DOWN:\n      return gesture.onTouchesDown;\n    case CALLBACK_TYPE.TOUCHES_MOVE:\n      return gesture.onTouchesMove;\n    case CALLBACK_TYPE.TOUCHES_UP:\n      return gesture.onTouchesUp;\n    case CALLBACK_TYPE.TOUCHES_CANCELLED:\n      return gesture.onTouchesCancelled;\n  }\n}\n\nfunction touchEventTypeToCallbackType(\n  eventType: TouchEventType\n): CALLBACK_TYPE {\n  'worklet';\n  switch (eventType) {\n    case TouchEventType.TOUCHES_DOWN:\n      return CALLBACK_TYPE.TOUCHES_DOWN;\n    case TouchEventType.TOUCHES_MOVE:\n      return CALLBACK_TYPE.TOUCHES_MOVE;\n    case TouchEventType.TOUCHES_UP:\n      return CALLBACK_TYPE.TOUCHES_UP;\n    case TouchEventType.TOUCHES_CANCELLED:\n      return CALLBACK_TYPE.TOUCHES_CANCELLED;\n  }\n  return CALLBACK_TYPE.UNDEFINED;\n}\n\nfunction runWorklet(\n  type: CALLBACK_TYPE,\n  gesture: HandlerCallbacks<Record<string, unknown>>,\n  event: GestureStateChangeEvent | GestureUpdateEvent | GestureTouchEvent,\n  ...args: unknown[]\n) {\n  'worklet';\n  const handler = getHandler(type, gesture);\n  if (gesture.isWorklet[type]) {\n    // @ts-ignore Logic below makes sure the correct event is send to the\n    // correct handler.\n    handler?.(event, ...args);\n  } else if (handler) {\n    console.warn(tagMessage('Animated gesture callback must be a worklet'));\n  }\n}\n\nfunction isStateChangeEvent(\n  event: GestureUpdateEvent | GestureStateChangeEvent | GestureTouchEvent\n): event is GestureStateChangeEvent {\n  'worklet';\n  // @ts-ignore Yes, the oldState prop is missing on GestureTouchEvent, that's the point\n  return event.oldState != null;\n}\n\nfunction isTouchEvent(\n  event: GestureUpdateEvent | GestureStateChangeEvent | GestureTouchEvent\n): event is GestureTouchEvent {\n  'worklet';\n  return event.eventType != null;\n}\n\nexport function useAnimatedGesture(\n  preparedGesture: AttachedGestureState,\n  needsRebuild: boolean\n) {\n  if (!Reanimated) {\n    return;\n  }\n\n  // Hooks are called conditionally, but the condition is whether the\n  // react-native-reanimated is installed, which shouldn't change while running\n  // eslint-disable-next-line react-hooks/rules-of-hooks\n  const sharedHandlersCallbacks = Reanimated.useSharedValue<\n    HandlerCallbacks<Record<string, unknown>>[] | null\n  >(null);\n\n  // eslint-disable-next-line react-hooks/rules-of-hooks\n  const lastUpdateEvent = Reanimated.useSharedValue<\n    (GestureUpdateEvent | undefined)[]\n  >([]);\n\n  // not every gesture needs a state controller, init them lazily\n  const stateControllers: GestureStateManagerType[] = [];\n\n  const callback = (\n    event: GestureStateChangeEvent | GestureUpdateEvent | GestureTouchEvent\n  ) => {\n    'worklet';\n\n    const currentCallback = sharedHandlersCallbacks.value;\n    if (!currentCallback) {\n      return;\n    }\n\n    for (let i = 0; i < currentCallback.length; i++) {\n      const gesture = currentCallback[i];\n\n      if (event.handlerTag !== gesture.handlerTag) {\n        continue;\n      }\n\n      if (isStateChangeEvent(event)) {\n        if (\n          event.oldState === State.UNDETERMINED &&\n          event.state === State.BEGAN\n        ) {\n          runWorklet(CALLBACK_TYPE.BEGAN, gesture, event);\n        } else if (\n          (event.oldState === State.BEGAN ||\n            event.oldState === State.UNDETERMINED) &&\n          event.state === State.ACTIVE\n        ) {\n          runWorklet(CALLBACK_TYPE.START, gesture, event);\n          lastUpdateEvent.value[gesture.handlerTag] = undefined;\n        } else if (\n          event.oldState !== event.state &&\n          event.state === State.END\n        ) {\n          if (event.oldState === State.ACTIVE) {\n            runWorklet(CALLBACK_TYPE.END, gesture, event, true);\n          }\n          runWorklet(CALLBACK_TYPE.FINALIZE, gesture, event, true);\n        } else if (\n          (event.state === State.FAILED || event.state === State.CANCELLED) &&\n          event.state !== event.oldState\n        ) {\n          if (event.oldState === State.ACTIVE) {\n            runWorklet(CALLBACK_TYPE.END, gesture, event, false);\n          }\n          runWorklet(CALLBACK_TYPE.FINALIZE, gesture, event, false);\n        }\n      } else if (isTouchEvent(event)) {\n        if (!stateControllers[i]) {\n          stateControllers[i] = GestureStateManager.create(event.handlerTag);\n        }\n\n        if (event.eventType !== TouchEventType.UNDETERMINED) {\n          runWorklet(\n            touchEventTypeToCallbackType(event.eventType),\n            gesture,\n            event,\n            stateControllers[i]\n          );\n        }\n      } else {\n        runWorklet(CALLBACK_TYPE.UPDATE, gesture, event);\n\n        if (gesture.onChange && gesture.changeEventCalculator) {\n          runWorklet(\n            CALLBACK_TYPE.CHANGE,\n            gesture,\n            gesture.changeEventCalculator?.(\n              event,\n              lastUpdateEvent.value[gesture.handlerTag]\n            )\n          );\n\n          lastUpdateEvent.value[gesture.handlerTag] = event;\n        }\n      }\n    }\n  };\n\n  // eslint-disable-next-line react-hooks/rules-of-hooks\n  const event = Reanimated.useEvent(\n    callback,\n    ['onGestureHandlerStateChange', 'onGestureHandlerEvent'],\n    needsRebuild\n  );\n\n  preparedGesture.animatedEventHandler = event;\n  preparedGesture.animatedHandlers = sharedHandlersCallbacks;\n}\n"]}
+{"version":3,"names":["CALLBACK_TYPE","Reanimated","GestureStateManager","State","TouchEventType","tagMessage","getHandler","type","gesture","BEGAN","onBegin","START","onStart","UPDATE","onUpdate","CHANGE","onChange","END","onEnd","FINALIZE","onFinalize","TOUCHES_DOWN","onTouchesDown","TOUCHES_MOVE","onTouchesMove","TOUCHES_UP","onTouchesUp","TOUCHES_CANCELLED","onTouchesCancelled","touchEventTypeToCallbackType","eventType","UNDEFINED","runWorklet","event","args","handler","isWorklet","console","warn","isStateChangeEvent","oldState","isTouchEvent","useAnimatedGesture","preparedGesture","needsRebuild","sharedHandlersCallbacks","useSharedValue","lastUpdateEvent","stateControllers","callback","currentCallback","value","i","length","handlerTag","UNDETERMINED","state","ACTIVE","undefined","FAILED","CANCELLED","create","changeEventCalculator","useEvent","animatedEventHandler","animatedHandlers"],"sourceRoot":"../../../../../src","sources":["handlers/gestures/GestureDetector/useAnimatedGesture.ts"],"mappings":"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","ignoreList":[]}

package/lib/module/handlers/gestures/GestureDetector/useDetectorUpdater.js

@@ -1,21 +1,24 @@
+"use strict";
+
 import { useCallback } from 'react';
 import { attachHandlers } from './attachHandlers';
 import { updateHandlers } from './updateHandlers';
 import { needsToReattach } from './needsToReattach';
 import { dropHandlers } from './dropHandlers';
 import { useForceRender, validateDetectorChildren } from './utils';
-import findNodeHandle from '../../../findNodeHandle'; // Returns a function that's responsible for updating the attached gestures
+import findNodeHandle from '../../../findNodeHandle';
+
+// Returns a function that's responsible for updating the attached gestures
 // If the view has changed, it will reattach the handlers to the new view
 // If the view remains the same, it will update the handlers with the new config
-
 export function useDetectorUpdater(state, preparedGesture, gesturesToAttach, gestureConfig, webEventHandlersRef) {
   const forceRender = useForceRender();
-  const updateAttachedGestures = useCallback( // skipConfigUpdate is used to prevent unnecessary updates when only checking if the view has changed
+  const updateAttachedGestures = useCallback(
+  // skipConfigUpdate is used to prevent unnecessary updates when only checking if the view has changed
   skipConfigUpdate => {
     // If the underlying view has changed we need to reattach handlers to the new view
     const viewTag = findNodeHandle(state.viewRef);
     const didUnderlyingViewChange = viewTag !== state.previousViewTag;
-
     if (didUnderlyingViewChange || needsToReattach(preparedGesture, gesturesToAttach)) {
       validateDetectorChildren(state.viewRef);
       dropHandlers(preparedGesture);
@@ -26,7 +29,6 @@ export function useDetectorUpdater(state, preparedGesture, gesturesToAttach, ges
         webEventHandlersRef,
         viewTag
       });
-
       if (didUnderlyingViewChange) {
         state.previousViewTag = viewTag;
         state.forceRebuildReanimatedEvent = true;

package/lib/module/handlers/gestures/GestureDetector/useDetectorUpdater.js.map

@@ -1 +1 @@
-{"version":3,"sources":["useDetectorUpdater.ts"],"names":["useCallback","attachHandlers","updateHandlers","needsToReattach","dropHandlers","useForceRender","validateDetectorChildren","findNodeHandle","useDetectorUpdater","state","preparedGesture","gesturesToAttach","gestureConfig","webEventHandlersRef","forceRender","updateAttachedGestures","skipConfigUpdate","viewTag","viewRef","didUnderlyingViewChange","previousViewTag","forceRebuildReanimatedEvent"],"mappings":"AAAA,SAAgBA,WAAhB,QAAmC,OAAnC;AASA,SAASC,cAAT,QAA+B,kBAA/B;AACA,SAASC,cAAT,QAA+B,kBAA/B;AACA,SAASC,eAAT,QAAgC,mBAAhC;AACA,SAASC,YAAT,QAA6B,gBAA7B;AACA,SAASC,cAAT,EAAyBC,wBAAzB,QAAyD,SAAzD;AACA,OAAOC,cAAP,MAA2B,yBAA3B,C,CAEA;AACA;AACA;;AACA,OAAO,SAASC,kBAAT,CACLC,KADK,EAELC,eAFK,EAGLC,gBAHK,EAILC,aAJK,EAKLC,mBALK,EAML;AACA,QAAMC,WAAW,GAAGT,cAAc,EAAlC;AACA,QAAMU,sBAAsB,GAAGf,WAAW,EACxC;AACCgB,EAAAA,gBAAD,IAAgC;AAC9B;AACA,UAAMC,OAAO,GAAGV,cAAc,CAACE,KAAK,CAACS,OAAP,CAA9B;AACA,UAAMC,uBAAuB,GAAGF,OAAO,KAAKR,KAAK,CAACW,eAAlD;;AAEA,QACED,uBAAuB,IACvBhB,eAAe,CAACO,eAAD,EAAkBC,gBAAlB,CAFjB,EAGE;AACAL,MAAAA,wBAAwB,CAACG,KAAK,CAACS,OAAP,CAAxB;AACAd,MAAAA,YAAY,CAACM,eAAD,CAAZ;AACAT,MAAAA,cAAc,CAAC;AACbS,QAAAA,eADa;AAEbE,QAAAA,aAFa;AAGbD,QAAAA,gBAHa;AAIbE,QAAAA,mBAJa;AAKbI,QAAAA;AALa,OAAD,CAAd;;AAQA,UAAIE,uBAAJ,EAA6B;AAC3BV,QAAAA,KAAK,CAACW,eAAN,GAAwBH,OAAxB;AACAR,QAAAA,KAAK,CAACY,2BAAN,GAAoC,IAApC;AACAP,QAAAA,WAAW;AACZ;AACF,KAnBD,MAmBO,IAAI,CAACE,gBAAL,EAAuB;AAC5Bd,MAAAA,cAAc,CAACQ,eAAD,EAAkBE,aAAlB,EAAiCD,gBAAjC,CAAd;AACD;AACF,GA7BuC,EA8BxC,CACEG,WADF,EAEEF,aAFF,EAGED,gBAHF,EAIED,eAJF,EAKED,KALF,EAMEI,mBANF,CA9BwC,CAA1C;AAwCA,SAAOE,sBAAP;AACD","sourcesContent":["import React, { useCallback } from 'react';\nimport { GestureType } from '../gesture';\nimport { ComposedGesture } from '../gestureComposition';\n\nimport {\n  AttachedGestureState,\n  GestureDetectorState,\n  WebEventHandler,\n} from './types';\nimport { attachHandlers } from './attachHandlers';\nimport { updateHandlers } from './updateHandlers';\nimport { needsToReattach } from './needsToReattach';\nimport { dropHandlers } from './dropHandlers';\nimport { useForceRender, validateDetectorChildren } from './utils';\nimport findNodeHandle from '../../../findNodeHandle';\n\n// Returns a function that's responsible for updating the attached gestures\n// If the view has changed, it will reattach the handlers to the new view\n// If the view remains the same, it will update the handlers with the new config\nexport function useDetectorUpdater(\n  state: GestureDetectorState,\n  preparedGesture: AttachedGestureState,\n  gesturesToAttach: GestureType[],\n  gestureConfig: ComposedGesture | GestureType,\n  webEventHandlersRef: React.RefObject<WebEventHandler>\n) {\n  const forceRender = useForceRender();\n  const updateAttachedGestures = useCallback(\n    // skipConfigUpdate is used to prevent unnecessary updates when only checking if the view has changed\n    (skipConfigUpdate?: boolean) => {\n      // If the underlying view has changed we need to reattach handlers to the new view\n      const viewTag = findNodeHandle(state.viewRef) as number;\n      const didUnderlyingViewChange = viewTag !== state.previousViewTag;\n\n      if (\n        didUnderlyingViewChange ||\n        needsToReattach(preparedGesture, gesturesToAttach)\n      ) {\n        validateDetectorChildren(state.viewRef);\n        dropHandlers(preparedGesture);\n        attachHandlers({\n          preparedGesture,\n          gestureConfig,\n          gesturesToAttach,\n          webEventHandlersRef,\n          viewTag,\n        });\n\n        if (didUnderlyingViewChange) {\n          state.previousViewTag = viewTag;\n          state.forceRebuildReanimatedEvent = true;\n          forceRender();\n        }\n      } else if (!skipConfigUpdate) {\n        updateHandlers(preparedGesture, gestureConfig, gesturesToAttach);\n      }\n    },\n    [\n      forceRender,\n      gestureConfig,\n      gesturesToAttach,\n      preparedGesture,\n      state,\n      webEventHandlersRef,\n    ]\n  );\n\n  return updateAttachedGestures;\n}\n"]}
+{"version":3,"names":["useCallback","attachHandlers","updateHandlers","needsToReattach","dropHandlers","useForceRender","validateDetectorChildren","findNodeHandle","useDetectorUpdater","state","preparedGesture","gesturesToAttach","gestureConfig","webEventHandlersRef","forceRender","updateAttachedGestures","skipConfigUpdate","viewTag","viewRef","didUnderlyingViewChange","previousViewTag","forceRebuildReanimatedEvent"],"sourceRoot":"../../../../../src","sources":["handlers/gestures/GestureDetector/useDetectorUpdater.ts"],"mappings":";;AAAA,SAAgBA,WAAW,QAAQ,OAAO;AAS1C,SAASC,cAAc,QAAQ,kBAAkB;AACjD,SAASC,cAAc,QAAQ,kBAAkB;AACjD,SAASC,eAAe,QAAQ,mBAAmB;AACnD,SAASC,YAAY,QAAQ,gBAAgB;AAC7C,SAASC,cAAc,EAAEC,wBAAwB,QAAQ,SAAS;AAClE,OAAOC,cAAc,MAAM,yBAAyB;;AAEpD;AACA;AACA;AACA,OAAO,SAASC,kBAAkBA,CAChCC,KAA2B,EAC3BC,eAAqC,EACrCC,gBAA+B,EAC/BC,aAA4C,EAC5CC,mBAAqD,EACrD;EACA,MAAMC,WAAW,GAAGT,cAAc,CAAC,CAAC;EACpC,MAAMU,sBAAsB,GAAGf,WAAW;EACxC;EACCgB,gBAA0B,IAAK;IAC9B;IACA,MAAMC,OAAO,GAAGV,cAAc,CAACE,KAAK,CAACS,OAAO,CAAW;IACvD,MAAMC,uBAAuB,GAAGF,OAAO,KAAKR,KAAK,CAACW,eAAe;IAEjE,IACED,uBAAuB,IACvBhB,eAAe,CAACO,eAAe,EAAEC,gBAAgB,CAAC,EAClD;MACAL,wBAAwB,CAACG,KAAK,CAACS,OAAO,CAAC;MACvCd,YAAY,CAACM,eAAe,CAAC;MAC7BT,cAAc,CAAC;QACbS,eAAe;QACfE,aAAa;QACbD,gBAAgB;QAChBE,mBAAmB;QACnBI;MACF,CAAC,CAAC;MAEF,IAAIE,uBAAuB,EAAE;QAC3BV,KAAK,CAACW,eAAe,GAAGH,OAAO;QAC/BR,KAAK,CAACY,2BAA2B,GAAG,IAAI;QACxCP,WAAW,CAAC,CAAC;MACf;IACF,CAAC,MAAM,IAAI,CAACE,gBAAgB,EAAE;MAC5Bd,cAAc,CAACQ,eAAe,EAAEE,aAAa,EAAED,gBAAgB,CAAC;IAClE;EACF,CAAC,EACD,CACEG,WAAW,EACXF,aAAa,EACbD,gBAAgB,EAChBD,eAAe,EACfD,KAAK,EACLI,mBAAmB,CAEvB,CAAC;EAED,OAAOE,sBAAsB;AAC/B","ignoreList":[]}

package/lib/module/handlers/gestures/GestureDetector/useMountReactions.js

@@ -1,21 +1,19 @@
+"use strict";
+
 import { transformIntoHandlerTags } from '../../utils';
 import { MountRegistry } from '../../../mountRegistry';
 import { useEffect } from 'react';
-
 function shouldUpdateDetector(relation, gesture) {
   if (relation === undefined) {
     return false;
   }
-
   for (const tag of transformIntoHandlerTags(relation)) {
     if (tag === gesture.handlerTag) {
       return true;
     }
   }
-
   return false;
 }
-
 export function useMountReactions(updateDetector, state) {
   useEffect(() => {
     return MountRegistry.addMountListener(gesture => {
@@ -26,10 +24,10 @@ export function useMountReactions(updateDetector, state) {
         const blocksHandlers = attachedGesture.config.blocksHandlers;
         const requireToFail = attachedGesture.config.requireToFail;
         const simultaneousWith = attachedGesture.config.simultaneousWith;
-
         if (shouldUpdateDetector(blocksHandlers, gesture) || shouldUpdateDetector(requireToFail, gesture) || shouldUpdateDetector(simultaneousWith, gesture)) {
-          updateDetector(); // We can safely return here, if any other gestures should be updated, they will be by the above call
+          updateDetector();
 
+          // We can safely return here, if any other gestures should be updated, they will be by the above call
           return;
         }
       }

package/lib/module/handlers/gestures/GestureDetector/useMountReactions.js.map

@@ -1 +1 @@
-{"version":3,"sources":["useMountReactions.ts"],"names":["transformIntoHandlerTags","MountRegistry","useEffect","shouldUpdateDetector","relation","gesture","undefined","tag","handlerTag","useMountReactions","updateDetector","state","addMountListener","attachedGesture","attachedGestures","blocksHandlers","config","requireToFail","simultaneousWith"],"mappings":"AAAA,SAASA,wBAAT,QAAyC,aAAzC;AACA,SAASC,aAAT,QAA8B,wBAA9B;AAEA,SAASC,SAAT,QAA0B,OAA1B;;AAGA,SAASC,oBAAT,CACEC,QADF,EAEEC,OAFF,EAGE;AACA,MAAID,QAAQ,KAAKE,SAAjB,EAA4B;AAC1B,WAAO,KAAP;AACD;;AAED,OAAK,MAAMC,GAAX,IAAkBP,wBAAwB,CAACI,QAAD,CAA1C,EAAsD;AACpD,QAAIG,GAAG,KAAKF,OAAO,CAACG,UAApB,EAAgC;AAC9B,aAAO,IAAP;AACD;AACF;;AAED,SAAO,KAAP;AACD;;AAED,OAAO,SAASC,iBAAT,CACLC,cADK,EAELC,KAFK,EAGL;AACAT,EAAAA,SAAS,CAAC,MAAM;AACd,WAAOD,aAAa,CAACW,gBAAd,CAAgCP,OAAD,IAAa;AACjD;AACA;AACA;AACA,WAAK,MAAMQ,eAAX,IAA8BF,KAAK,CAACG,gBAApC,EAAsD;AACpD,cAAMC,cAAc,GAAGF,eAAe,CAACG,MAAhB,CAAuBD,cAA9C;AACA,cAAME,aAAa,GAAGJ,eAAe,CAACG,MAAhB,CAAuBC,aAA7C;AACA,cAAMC,gBAAgB,GAAGL,eAAe,CAACG,MAAhB,CAAuBE,gBAAhD;;AAEA,YACEf,oBAAoB,CAACY,cAAD,EAAiBV,OAAjB,CAApB,IACAF,oBAAoB,CAACc,aAAD,EAAgBZ,OAAhB,CADpB,IAEAF,oBAAoB,CAACe,gBAAD,EAAmBb,OAAnB,CAHtB,EAIE;AACAK,UAAAA,cAAc,GADd,CAGA;;AACA;AACD;AACF;AACF,KApBM,CAAP;AAqBD,GAtBQ,EAsBN,CAACA,cAAD,EAAiBC,KAAjB,CAtBM,CAAT;AAuBD","sourcesContent":["import { transformIntoHandlerTags } from '../../utils';\nimport { MountRegistry } from '../../../mountRegistry';\nimport { AttachedGestureState } from './types';\nimport { useEffect } from 'react';\nimport { GestureRef } from '../gesture';\n\nfunction shouldUpdateDetector(\n  relation: GestureRef[] | undefined,\n  gesture: { handlerTag: number }\n) {\n  if (relation === undefined) {\n    return false;\n  }\n\n  for (const tag of transformIntoHandlerTags(relation)) {\n    if (tag === gesture.handlerTag) {\n      return true;\n    }\n  }\n\n  return false;\n}\n\nexport function useMountReactions(\n  updateDetector: () => void,\n  state: AttachedGestureState\n) {\n  useEffect(() => {\n    return MountRegistry.addMountListener((gesture) => {\n      // At this point the ref in the gesture config should be updated, so we can check if one of the gestures\n      // set in a relation with the gesture got mounted. If so, we need to update the detector to propagate\n      // the changes to the native side.\n      for (const attachedGesture of state.attachedGestures) {\n        const blocksHandlers = attachedGesture.config.blocksHandlers;\n        const requireToFail = attachedGesture.config.requireToFail;\n        const simultaneousWith = attachedGesture.config.simultaneousWith;\n\n        if (\n          shouldUpdateDetector(blocksHandlers, gesture) ||\n          shouldUpdateDetector(requireToFail, gesture) ||\n          shouldUpdateDetector(simultaneousWith, gesture)\n        ) {\n          updateDetector();\n\n          // We can safely return here, if any other gestures should be updated, they will be by the above call\n          return;\n        }\n      }\n    });\n  }, [updateDetector, state]);\n}\n"]}
+{"version":3,"names":["transformIntoHandlerTags","MountRegistry","useEffect","shouldUpdateDetector","relation","gesture","undefined","tag","handlerTag","useMountReactions","updateDetector","state","addMountListener","attachedGesture","attachedGestures","blocksHandlers","config","requireToFail","simultaneousWith"],"sourceRoot":"../../../../../src","sources":["handlers/gestures/GestureDetector/useMountReactions.ts"],"mappings":";;AAAA,SAASA,wBAAwB,QAAQ,aAAa;AACtD,SAASC,aAAa,QAAQ,wBAAwB;AAEtD,SAASC,SAAS,QAAQ,OAAO;AAGjC,SAASC,oBAAoBA,CAC3BC,QAAkC,EAClCC,OAA+B,EAC/B;EACA,IAAID,QAAQ,KAAKE,SAAS,EAAE;IAC1B,OAAO,KAAK;EACd;EAEA,KAAK,MAAMC,GAAG,IAAIP,wBAAwB,CAACI,QAAQ,CAAC,EAAE;IACpD,IAAIG,GAAG,KAAKF,OAAO,CAACG,UAAU,EAAE;MAC9B,OAAO,IAAI;IACb;EACF;EAEA,OAAO,KAAK;AACd;AAEA,OAAO,SAASC,iBAAiBA,CAC/BC,cAA0B,EAC1BC,KAA2B,EAC3B;EACAT,SAAS,CAAC,MAAM;IACd,OAAOD,aAAa,CAACW,gBAAgB,CAAEP,OAAO,IAAK;MACjD;MACA;MACA;MACA,KAAK,MAAMQ,eAAe,IAAIF,KAAK,CAACG,gBAAgB,EAAE;QACpD,MAAMC,cAAc,GAAGF,eAAe,CAACG,MAAM,CAACD,cAAc;QAC5D,MAAME,aAAa,GAAGJ,eAAe,CAACG,MAAM,CAACC,aAAa;QAC1D,MAAMC,gBAAgB,GAAGL,eAAe,CAACG,MAAM,CAACE,gBAAgB;QAEhE,IACEf,oBAAoB,CAACY,cAAc,EAAEV,OAAO,CAAC,IAC7CF,oBAAoB,CAACc,aAAa,EAAEZ,OAAO,CAAC,IAC5CF,oBAAoB,CAACe,gBAAgB,EAAEb,OAAO,CAAC,EAC/C;UACAK,cAAc,CAAC,CAAC;;UAEhB;UACA;QACF;MACF;IACF,CAAC,CAAC;EACJ,CAAC,EAAE,CAACA,cAAc,EAAEC,KAAK,CAAC,CAAC;AAC7B","ignoreList":[]}