react-native-gesture-handler 2.22.1 → 2.23.0

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

@@ -5,49 +5,46 @@ 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;
     }
-  } // 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;
-    } // 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 = preparedGesture.attachedGestures.length !== newGestures.length;
-
     for (let i = 0; i < newGestures.length; i++) {
-      const handler = preparedGesture.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 = preparedGesture.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 = preparedGesture.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":"AACA,SAASA,eAAT,QAAgC,wBAAhC;AACA,OAAOC,sBAAP,MAAmC,iCAAnC;AACA,SAASC,YAAT,EAAuBC,uBAAvB,QAAsD,aAAtD;AAEA,SAASC,gBAAT,QAAiC,2BAAjC;AAEA,SACEC,uBADF,EAEEC,gCAFF,EAGEC,aAHF,QAIO,SAJP;AAMA,OAAO,SAASC,cAAT,CACLC,eADK,EAELC,aAFK,EAGLC,WAHK,EAIL;AACAD,EAAAA,aAAa,CAACE,OAAd;;AAEA,OAAK,IAAIC,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGF,WAAW,CAACG,MAAhC,EAAwCD,CAAC,EAAzC,EAA6C;AAC3C,UAAME,OAAO,GAAGN,eAAe,CAACO,gBAAhB,CAAiCH,CAAjC,CAAhB;AACAP,IAAAA,gCAAgC,CAACS,OAAD,CAAhC,CAF2C,CAI3C;AACA;;AACA,QAAIJ,WAAW,CAACE,CAAD,CAAX,CAAeI,UAAf,KAA8BF,OAAO,CAACE,UAA1C,EAAsD;AACpDN,MAAAA,WAAW,CAACE,CAAD,CAAX,CAAeI,UAAf,GAA4BF,OAAO,CAACE,UAApC;AACAN,MAAAA,WAAW,CAACE,CAAD,CAAX,CAAeK,QAAf,CAAwBD,UAAxB,GAAqCF,OAAO,CAACE,UAA7C;AACD;AACF,GAbD,CAeA;AACA;AACA;;;AACAb,EAAAA,gBAAgB,CAAC,MAAM;AACrB,QAAI,CAACK,eAAe,CAACU,SAArB,EAAgC;AAC9B;AACD,KAHoB,CAKrB;;;AACA,QAAIC,6BAA6B,GAC/BX,eAAe,CAACO,gBAAhB,CAAiCF,MAAjC,KAA4CH,WAAW,CAACG,MAD1D;;AAGA,SAAK,IAAID,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGF,WAAW,CAACG,MAAhC,EAAwCD,CAAC,EAAzC,EAA6C;AAC3C,YAAME,OAAO,GAAGN,eAAe,CAACO,gBAAhB,CAAiCH,CAAjC,CAAhB,CAD2C,CAG3C;AACA;;AACA,UACEE,OAAO,CAACG,QAAR,CAAiBG,SAAjB,KAA+BV,WAAW,CAACE,CAAD,CAAX,CAAeK,QAAf,CAAwBG,SAAvD,KACCV,WAAW,CAACE,CAAD,CAAX,CAAeS,mBAAf,IAAsCP,OAAO,CAACO,mBAD/C,CADF,EAGE;AACAF,QAAAA,6BAA6B,GAAG,IAAhC;AACD;;AAEDL,MAAAA,OAAO,CAACQ,MAAR,GAAiBZ,WAAW,CAACE,CAAD,CAAX,CAAeU,MAAhC;AACAR,MAAAA,OAAO,CAACG,QAAR,GAAmBP,WAAW,CAACE,CAAD,CAAX,CAAeK,QAAlC;AAEAjB,MAAAA,sBAAsB,CAACuB,oBAAvB,CACET,OAAO,CAACE,UADV,EAEEf,YAAY,CACVa,OAAO,CAACQ,MADE,EAEVhB,aAFU,EAGVF,uBAAuB,CAACU,OAAD,CAHb,CAFd;AASAf,MAAAA,eAAe,CAACe,OAAO,CAACE,UAAT,EAAqBF,OAArB,EAA8BA,OAAO,CAACQ,MAAR,CAAeE,MAA7C,CAAf;AACD;;AAED,QAAIhB,eAAe,CAACiB,gBAAhB,IAAoCN,6BAAxC,EAAuE;AACrE,YAAMO,gBAAgB,GAAGlB,eAAe,CAACO,gBAAhB,CACtBY,MADsB,CACdC,CAAD,IAAOA,CAAC,CAACP,mBADM,EACe;AADf,OAEtBQ,GAFsB,CAEjBD,CAAD,IAAOA,CAAC,CAACX,QAFS,CAAzB;AAMAT,MAAAA,eAAe,CAACiB,gBAAhB,CAAiCK,KAAjC,GAAyCJ,gBAAzC;AACD;;AAEDxB,IAAAA,uBAAuB;AACxB,GA/Ce,CAAhB;AAgDD","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  // 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    // If amount of gesture configs changes, we need to update the callbacks in shared value\n    let shouldUpdateSharedValueIfUsed =\n      preparedGesture.attachedGestures.length !== newGestures.length;\n\n    for (let i = 0; i < newGestures.length; i++) {\n      const handler = preparedGesture.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 = preparedGesture.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"],"sources":["updateHandlers.ts"],"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  // 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    // If amount of gesture configs changes, we need to update the callbacks in shared value\n    let shouldUpdateSharedValueIfUsed =\n      preparedGesture.attachedGestures.length !== newGestures.length;\n\n    for (let i = 0; i < newGestures.length; i++) {\n      const handler = preparedGesture.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 = preparedGesture.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"],"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;EACA;EACAb,gBAAgB,CAAC,MAAM;IACrB,IAAI,CAACK,eAAe,CAACU,SAAS,EAAE;MAC9B;IACF;;IAEA;IACA,IAAIC,6BAA6B,GAC/BX,eAAe,CAACO,gBAAgB,CAACF,MAAM,KAAKH,WAAW,CAACG,MAAM;IAEhE,KAAK,IAAID,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGF,WAAW,CAACG,MAAM,EAAED,CAAC,EAAE,EAAE;MAC3C,MAAME,OAAO,GAAGN,eAAe,CAACO,gBAAgB,CAACH,CAAC,CAAC;;MAEnD;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,GAAGlB,eAAe,CAACO,gBAAgB,CACtDY,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

@@ -4,119 +4,97 @@ 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 === null || handler === void 0 || 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 +105,32 @@ 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]));
           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","_gesture$changeEventC","call","useEvent","animatedEventHandler","animatedHandlers"],"sources":["useAnimatedGesture.ts"],"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"],"mappings":"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","ignoreList":[]}

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

@@ -4,18 +4,19 @@ 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 +27,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"],"sources":["useDetectorUpdater.ts"],"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"],"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,17 @@
 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 +22,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"],"sources":["useMountReactions.ts"],"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"],"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":[]}

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

@@ -10,23 +10,21 @@ export function useViewRefHandler(state, updateAttachedGestures) {
     if (ref === null) {
       return;
     }
+    state.viewRef = ref;
 
-    state.viewRef = ref; // if it's the first render, also set the previousViewTag to prevent reattaching gestures when not needed
-
+    // if it's the first render, also set the previousViewTag to prevent reattaching gestures when not needed
     if (state.previousViewTag === -1) {
       state.previousViewTag = findNodeHandle(state.viewRef);
-    } // Pass true as `skipConfigUpdate`. Here we only want to trigger the eventual reattaching of handlers
-    // in case the view has changed. If the view doesn't change, the update will be handled by detector.
-
+    }
 
+    // Pass true as `skipConfigUpdate`. Here we only want to trigger the eventual reattaching of handlers
+    // in case the view has changed. If the view doesn't change, the update will be handled by detector.
     if (!state.firstRender) {
       updateAttachedGestures(true);
     }
-
-    if (__DEV__ && isFabric() && global.isFormsStackingContext) {
+    if (__DEV__ && isFabric() && global.isViewFlatteningDisabled) {
       const node = getShadowNodeFromRef(ref);
-
-      if (global.isFormsStackingContext(node) === false) {
+      if (global.isViewFlatteningDisabled(node) === false) {
         console.error(tagMessage('GestureDetector has received a child that may get view-flattened. ' + '\nTo prevent it from misbehaving you need to wrap the child with a `<View collapsable={false}>`.'));
       }
     }

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

@@ -1 +1 @@
-{"version":3,"sources":["useViewRefHandler.ts"],"names":["isFabric","tagMessage","getShadowNodeFromRef","useCallback","findNodeHandle","useViewRefHandler","state","updateAttachedGestures","refHandler","ref","viewRef","previousViewTag","firstRender","__DEV__","global","isFormsStackingContext","node","console","error"],"mappings":"AAAA,SAASA,QAAT,EAAmBC,UAAnB,QAAqC,gBAArC;AACA,SAASC,oBAAT,QAAqC,+BAArC;AAGA,SAAgBC,WAAhB,QAAmC,OAAnC;AACA,OAAOC,cAAP,MAA2B,yBAA3B;AAMA;AACA;AACA;AACA,OAAO,SAASC,iBAAT,CACLC,KADK,EAELC,sBAFK,EAGL;AACA,QAAMC,UAAU,GAAGL,WAAW,CAC3BM,GAAD,IAAiC;AAC/B,QAAIA,GAAG,KAAK,IAAZ,EAAkB;AAChB;AACD;;AAEDH,IAAAA,KAAK,CAACI,OAAN,GAAgBD,GAAhB,CAL+B,CAO/B;;AACA,QAAIH,KAAK,CAACK,eAAN,KAA0B,CAAC,CAA/B,EAAkC;AAChCL,MAAAA,KAAK,CAACK,eAAN,GAAwBP,cAAc,CAACE,KAAK,CAACI,OAAP,CAAtC;AACD,KAV8B,CAY/B;AACA;;;AACA,QAAI,CAACJ,KAAK,CAACM,WAAX,EAAwB;AACtBL,MAAAA,sBAAsB,CAAC,IAAD,CAAtB;AACD;;AAED,QAAIM,OAAO,IAAIb,QAAQ,EAAnB,IAAyBc,MAAM,CAACC,sBAApC,EAA4D;AAC1D,YAAMC,IAAI,GAAGd,oBAAoB,CAACO,GAAD,CAAjC;;AACA,UAAIK,MAAM,CAACC,sBAAP,CAA8BC,IAA9B,MAAwC,KAA5C,EAAmD;AACjDC,QAAAA,OAAO,CAACC,KAAR,CACEjB,UAAU,CACR,uEACE,kGAFM,CADZ;AAMD;AACF;AACF,GA9B2B,EA+B5B,CAACK,KAAD,EAAQC,sBAAR,CA/B4B,CAA9B;AAkCA,SAAOC,UAAP;AACD","sourcesContent":["import { isFabric, tagMessage } from '../../../utils';\nimport { getShadowNodeFromRef } from '../../../getShadowNodeFromRef';\n\nimport { GestureDetectorState } from './types';\nimport React, { useCallback } from 'react';\nimport findNodeHandle from '../../../findNodeHandle';\n\ndeclare const global: {\n  isFormsStackingContext: (node: unknown) => boolean | null; // JSI function\n};\n\n// Ref handler for the Wrap component attached under the GestureDetector.\n// It's responsible for setting the viewRef on the state and triggering the reattaching of handlers\n// if the view has changed.\nexport function useViewRefHandler(\n  state: GestureDetectorState,\n  updateAttachedGestures: (skipConfigUpdate?: boolean) => void\n) {\n  const refHandler = useCallback(\n    (ref: React.Component | null) => {\n      if (ref === null) {\n        return;\n      }\n\n      state.viewRef = ref;\n\n      // if it's the first render, also set the previousViewTag to prevent reattaching gestures when not needed\n      if (state.previousViewTag === -1) {\n        state.previousViewTag = findNodeHandle(state.viewRef) as number;\n      }\n\n      // Pass true as `skipConfigUpdate`. Here we only want to trigger the eventual reattaching of handlers\n      // in case the view has changed. If the view doesn't change, the update will be handled by detector.\n      if (!state.firstRender) {\n        updateAttachedGestures(true);\n      }\n\n      if (__DEV__ && isFabric() && global.isFormsStackingContext) {\n        const node = getShadowNodeFromRef(ref);\n        if (global.isFormsStackingContext(node) === false) {\n          console.error(\n            tagMessage(\n              'GestureDetector has received a child that may get view-flattened. ' +\n                '\\nTo prevent it from misbehaving you need to wrap the child with a `<View collapsable={false}>`.'\n            )\n          );\n        }\n      }\n    },\n    [state, updateAttachedGestures]\n  );\n\n  return refHandler;\n}\n"]}
+{"version":3,"names":["isFabric","tagMessage","getShadowNodeFromRef","useCallback","findNodeHandle","useViewRefHandler","state","updateAttachedGestures","refHandler","ref","viewRef","previousViewTag","firstRender","__DEV__","global","isViewFlatteningDisabled","node","console","error"],"sources":["useViewRefHandler.ts"],"sourcesContent":["import { isFabric, tagMessage } from '../../../utils';\nimport { getShadowNodeFromRef } from '../../../getShadowNodeFromRef';\n\nimport { GestureDetectorState } from './types';\nimport React, { useCallback } from 'react';\nimport findNodeHandle from '../../../findNodeHandle';\n\ndeclare const global: {\n  isViewFlatteningDisabled: (node: unknown) => boolean | null; // JSI function\n};\n\n// Ref handler for the Wrap component attached under the GestureDetector.\n// It's responsible for setting the viewRef on the state and triggering the reattaching of handlers\n// if the view has changed.\nexport function useViewRefHandler(\n  state: GestureDetectorState,\n  updateAttachedGestures: (skipConfigUpdate?: boolean) => void\n) {\n  const refHandler = useCallback(\n    (ref: React.Component | null) => {\n      if (ref === null) {\n        return;\n      }\n\n      state.viewRef = ref;\n\n      // if it's the first render, also set the previousViewTag to prevent reattaching gestures when not needed\n      if (state.previousViewTag === -1) {\n        state.previousViewTag = findNodeHandle(state.viewRef) as number;\n      }\n\n      // Pass true as `skipConfigUpdate`. Here we only want to trigger the eventual reattaching of handlers\n      // in case the view has changed. If the view doesn't change, the update will be handled by detector.\n      if (!state.firstRender) {\n        updateAttachedGestures(true);\n      }\n\n      if (__DEV__ && isFabric() && global.isViewFlatteningDisabled) {\n        const node = getShadowNodeFromRef(ref);\n        if (global.isViewFlatteningDisabled(node) === false) {\n          console.error(\n            tagMessage(\n              'GestureDetector has received a child that may get view-flattened. ' +\n                '\\nTo prevent it from misbehaving you need to wrap the child with a `<View collapsable={false}>`.'\n            )\n          );\n        }\n      }\n    },\n    [state, updateAttachedGestures]\n  );\n\n  return refHandler;\n}\n"],"mappings":"AAAA,SAASA,QAAQ,EAAEC,UAAU,QAAQ,gBAAgB;AACrD,SAASC,oBAAoB,QAAQ,+BAA+B;AAGpE,SAAgBC,WAAW,QAAQ,OAAO;AAC1C,OAAOC,cAAc,MAAM,yBAAyB;AAMpD;AACA;AACA;AACA,OAAO,SAASC,iBAAiBA,CAC/BC,KAA2B,EAC3BC,sBAA4D,EAC5D;EACA,MAAMC,UAAU,GAAGL,WAAW,CAC3BM,GAA2B,IAAK;IAC/B,IAAIA,GAAG,KAAK,IAAI,EAAE;MAChB;IACF;IAEAH,KAAK,CAACI,OAAO,GAAGD,GAAG;;IAEnB;IACA,IAAIH,KAAK,CAACK,eAAe,KAAK,CAAC,CAAC,EAAE;MAChCL,KAAK,CAACK,eAAe,GAAGP,cAAc,CAACE,KAAK,CAACI,OAAO,CAAW;IACjE;;IAEA;IACA;IACA,IAAI,CAACJ,KAAK,CAACM,WAAW,EAAE;MACtBL,sBAAsB,CAAC,IAAI,CAAC;IAC9B;IAEA,IAAIM,OAAO,IAAIb,QAAQ,CAAC,CAAC,IAAIc,MAAM,CAACC,wBAAwB,EAAE;MAC5D,MAAMC,IAAI,GAAGd,oBAAoB,CAACO,GAAG,CAAC;MACtC,IAAIK,MAAM,CAACC,wBAAwB,CAACC,IAAI,CAAC,KAAK,KAAK,EAAE;QACnDC,OAAO,CAACC,KAAK,CACXjB,UAAU,CACR,oEAAoE,GAClE,kGACJ,CACF,CAAC;MACH;IACF;EACF,CAAC,EACD,CAACK,KAAK,EAAEC,sBAAsB,CAChC,CAAC;EAED,OAAOC,UAAU;AACnB","ignoreList":[]}

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

@@ -1,5 +1,5 @@
 import { Platform } from 'react-native';
-import { isJestEnv, tagMessage } from '../../../utils';
+import { isTestEnv, tagMessage } from '../../../utils';
 import { BaseGesture } from '../gesture';
 import { flingGestureHandlerProps } from '../../FlingGestureHandler';
 import { forceTouchGestureHandlerProps } from '../../ForceTouchGestureHandler';
@@ -16,7 +16,6 @@ import { useCallback, useRef, useState } from 'react';
 import { Reanimated } from '../reanimatedWrapper';
 import { onGestureHandlerEvent } from '../eventReceiver';
 export const ALLOWED_PROPS = [...baseGestureHandlerWithDetectorProps, ...tapGestureHandlerProps, ...panGestureHandlerProps, ...panGestureHandlerCustomNativeProps, ...longPressGestureHandlerProps, ...forceTouchGestureHandlerProps, ...flingGestureHandlerProps, ...hoverGestureHandlerProps, ...nativeViewGestureHandlerProps];
-
 function convertToHandlerTag(ref) {
   if (typeof ref === 'number') {
     return ref;
@@ -24,19 +23,15 @@ function convertToHandlerTag(ref) {
     return ref.handlerTag;
   } else {
     var _ref$current$handlerT, _ref$current;
-
     // @ts-ignore in this case it should be a ref either to gesture object or
     // a gesture handler component, in both cases handlerTag property exists
     return (_ref$current$handlerT = (_ref$current = ref.current) === null || _ref$current === void 0 ? void 0 : _ref$current.handlerTag) !== null && _ref$current$handlerT !== void 0 ? _ref$current$handlerT : -1;
   }
 }
-
 function extractValidHandlerTags(interactionGroup) {
   var _interactionGroup$map, _interactionGroup$map2;
-
-  return (_interactionGroup$map = interactionGroup === null || interactionGroup === void 0 ? void 0 : (_interactionGroup$map2 = interactionGroup.map(convertToHandlerTag)) === null || _interactionGroup$map2 === void 0 ? void 0 : _interactionGroup$map2.filter(tag => tag > 0)) !== null && _interactionGroup$map !== void 0 ? _interactionGroup$map : [];
+  return (_interactionGroup$map = interactionGroup === null || interactionGroup === void 0 || (_interactionGroup$map2 = interactionGroup.map(convertToHandlerTag)) === null || _interactionGroup$map2 === void 0 ? void 0 : _interactionGroup$map2.filter(tag => tag > 0)) !== null && _interactionGroup$map !== void 0 ? _interactionGroup$map : [];
 }
-
 export function extractGestureRelations(gesture) {
   const requireToFail = extractValidHandlerTags(gesture.config.requireToFail);
   const simultaneousWith = extractValidHandlerTags(gesture.config.simultaneousWith);
@@ -50,35 +45,33 @@ export function extractGestureRelations(gesture) {
 export function checkGestureCallbacksForWorklets(gesture) {
   if (!__DEV__) {
     return;
-  } // If a gesture is explicitly marked to run on the JS thread there is no need to check
+  }
+  // If a gesture is explicitly marked to run on the JS thread there is no need to check
   // if callbacks are worklets as the user is aware they will be ran on the JS thread
-
-
   if (gesture.config.runOnJS) {
     return;
   }
-
   const areSomeNotWorklets = gesture.handlers.isWorklet.includes(false);
-  const areSomeWorklets = gesture.handlers.isWorklet.includes(true); // If some of the callbacks are worklets and some are not, and the gesture is not
-  // explicitly marked with `.runOnJS(true)` show an error
+  const areSomeWorklets = gesture.handlers.isWorklet.includes(true);
 
+  // If some of the callbacks are worklets and some are not, and the gesture is not
+  // explicitly marked with `.runOnJS(true)` show an error
   if (areSomeNotWorklets && areSomeWorklets) {
     console.error(tagMessage(`Some of the callbacks in the gesture are worklets and some are not. Either make sure that all calbacks are marked as 'worklet' if you wish to run them on the UI thread or use '.runOnJS(true)' modifier on the gesture explicitly to run all callbacks on the JS thread.`));
   }
-
   if (Reanimated === undefined) {
     // If Reanimated is not available, we can't run worklets, so we shouldn't show the warning
     return;
   }
-
-  const areAllNotWorklets = !areSomeWorklets && areSomeNotWorklets; // If none of the callbacks are worklets and the gesture is not explicitly marked with
+  const areAllNotWorklets = !areSomeWorklets && areSomeNotWorklets;
+  // If none of the callbacks are worklets and the gesture is not explicitly marked with
   // `.runOnJS(true)` show a warning
-
-  if (areAllNotWorklets && !isJestEnv()) {
+  if (areAllNotWorklets && !isTestEnv()) {
     console.warn(tagMessage(`None of the callbacks in the gesture are worklets. If you wish to run them on the JS thread use '.runOnJS(true)' modifier on the gesture to make this explicit. Otherwise, mark the callbacks as 'worklet' to run them on the UI thread.`));
   }
-} // eslint-disable-next-line @typescript-eslint/no-explicit-any
+}
 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function validateDetectorChildren(ref) {
   // Finds the first native view under the Wrap component and traverses the fiber tree upwards
   // to check whether there is more than one native view as a pseudo-direct child of GestureDetector
@@ -102,22 +95,24 @@ export function validateDetectorChildren(ref) {
   //         /       \
   //   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 ? // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-    ref._reactInternals.elementType : // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-    ref._reactInternalFiber.elementType; // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-
-    let instance = RNRenderer.findHostInstance_DEPRECATED(ref)._internalFiberInstanceHandleDEV; // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-
-
+    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 ?
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+    ref._reactInternals.elementType :
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+    ref._reactInternalFiber.elementType;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    let instance = RNRenderer.findHostInstance_DEPRECATED(ref)._internalFiberInstanceHandleDEV;
+
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
     while (instance && instance.elementType !== wrapType) {
       // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
       if (instance.sibling) {
         throw new Error('GestureDetector has more than one native view as its children. This can happen if you are using a custom component that renders multiple views, like React.Fragment. You should wrap content of GestureDetector with a <View> or <Animated.View>.');
-      } // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
-
+      }
 
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
       instance = instance.return;
     }
   }