react-native-gesture-handler 2.16.2 → 2.17.1

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

@@ -0,0 +1,65 @@
+import { registerHandler } from '../../handlersRegistry';
+import RNGestureHandlerModule from '../../../RNGestureHandlerModule';
+import { filterConfig, scheduleFlushOperations } from '../../gestureHandlerCommon';
+import { ActionType } from '../../../ActionType';
+import { Platform } from 'react-native';
+import { ghQueueMicrotask } from '../../../ghQueueMicrotask';
+import { extractGestureRelations, checkGestureCallbacksForWorklets, ALLOWED_PROPS } from './utils';
+export function attachHandlers({
+  preparedGesture,
+  gestureConfig,
+  gesturesToAttach,
+  viewTag,
+  webEventHandlersRef
+}) {
+  gestureConfig.initialize(); // use queueMicrotask to extract handlerTags, because all refs should be initialized
+  // when it's ran
+
+  ghQueueMicrotask(() => {
+    if (!preparedGesture.isMounted) {
+      return;
+    }
+
+    gestureConfig.prepare();
+  });
+
+  for (const handler of gesturesToAttach) {
+    checkGestureCallbacksForWorklets(handler);
+    RNGestureHandlerModule.createGestureHandler(handler.handlerName, handler.handlerTag, filterConfig(handler.config, ALLOWED_PROPS));
+    registerHandler(handler.handlerTag, handler, handler.config.testId);
+  } // use queueMicrotask to extract handlerTags, because all refs should be initialized
+  // when it's ran
+
+
+  ghQueueMicrotask(() => {
+    if (!preparedGesture.isMounted) {
+      return;
+    }
+
+    for (const handler of gesturesToAttach) {
+      RNGestureHandlerModule.updateGestureHandler(handler.handlerTag, filterConfig(handler.config, ALLOWED_PROPS, extractGestureRelations(handler)));
+    }
+
+    scheduleFlushOperations();
+  });
+
+  for (const gesture of gesturesToAttach) {
+    const actionType = gesture.shouldUseReanimated ? ActionType.REANIMATED_WORKLET : ActionType.JS_FUNCTION_NEW_API;
+
+    if (Platform.OS === 'web') {
+      RNGestureHandlerModule.attachGestureHandler(gesture.handlerTag, viewTag, ActionType.JS_FUNCTION_OLD_API, // ignored on web
+      webEventHandlersRef);
+    } else {
+      RNGestureHandlerModule.attachGestureHandler(gesture.handlerTag, viewTag, actionType);
+    }
+  }
+
+  preparedGesture.attachedGestures = gesturesToAttach;
+
+  if (preparedGesture.animatedHandlers) {
+    const isAnimatedGesture = g => g.shouldUseReanimated;
+
+    preparedGesture.animatedHandlers.value = gesturesToAttach.filter(isAnimatedGesture).map(g => g.handlers);
+  }
+}
+//# sourceMappingURL=attachHandlers.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["attachHandlers.ts"],"names":["registerHandler","RNGestureHandlerModule","filterConfig","scheduleFlushOperations","ActionType","Platform","ghQueueMicrotask","extractGestureRelations","checkGestureCallbacksForWorklets","ALLOWED_PROPS","attachHandlers","preparedGesture","gestureConfig","gesturesToAttach","viewTag","webEventHandlersRef","initialize","isMounted","prepare","handler","createGestureHandler","handlerName","handlerTag","config","testId","updateGestureHandler","gesture","actionType","shouldUseReanimated","REANIMATED_WORKLET","JS_FUNCTION_NEW_API","OS","attachGestureHandler","JS_FUNCTION_OLD_API","attachedGestures","animatedHandlers","isAnimatedGesture","g","value","filter","map","handlers"],"mappings":"AAEA,SAASA,eAAT,QAAgC,wBAAhC;AACA,OAAOC,sBAAP,MAAmC,iCAAnC;AACA,SACEC,YADF,EAEEC,uBAFF,QAGO,4BAHP;AAKA,SAASC,UAAT,QAA2B,qBAA3B;AACA,SAASC,QAAT,QAAyB,cAAzB;AAEA,SAASC,gBAAT,QAAiC,2BAAjC;AAEA,SACEC,uBADF,EAEEC,gCAFF,EAGEC,aAHF,QAIO,SAJP;AAcA,OAAO,SAASC,cAAT,CAAwB;AAC7BC,EAAAA,eAD6B;AAE7BC,EAAAA,aAF6B;AAG7BC,EAAAA,gBAH6B;AAI7BC,EAAAA,OAJ6B;AAK7BC,EAAAA;AAL6B,CAAxB,EAMkB;AACvBH,EAAAA,aAAa,CAACI,UAAd,GADuB,CAGvB;AACA;;AACAV,EAAAA,gBAAgB,CAAC,MAAM;AACrB,QAAI,CAACK,eAAe,CAACM,SAArB,EAAgC;AAC9B;AACD;;AACDL,IAAAA,aAAa,CAACM,OAAd;AACD,GALe,CAAhB;;AAOA,OAAK,MAAMC,OAAX,IAAsBN,gBAAtB,EAAwC;AACtCL,IAAAA,gCAAgC,CAACW,OAAD,CAAhC;AACAlB,IAAAA,sBAAsB,CAACmB,oBAAvB,CACED,OAAO,CAACE,WADV,EAEEF,OAAO,CAACG,UAFV,EAGEpB,YAAY,CAACiB,OAAO,CAACI,MAAT,EAAiBd,aAAjB,CAHd;AAMAT,IAAAA,eAAe,CAACmB,OAAO,CAACG,UAAT,EAAqBH,OAArB,EAA8BA,OAAO,CAACI,MAAR,CAAeC,MAA7C,CAAf;AACD,GArBsB,CAuBvB;AACA;;;AACAlB,EAAAA,gBAAgB,CAAC,MAAM;AACrB,QAAI,CAACK,eAAe,CAACM,SAArB,EAAgC;AAC9B;AACD;;AACD,SAAK,MAAME,OAAX,IAAsBN,gBAAtB,EAAwC;AACtCZ,MAAAA,sBAAsB,CAACwB,oBAAvB,CACEN,OAAO,CAACG,UADV,EAEEpB,YAAY,CACViB,OAAO,CAACI,MADE,EAEVd,aAFU,EAGVF,uBAAuB,CAACY,OAAD,CAHb,CAFd;AAQD;;AAEDhB,IAAAA,uBAAuB;AACxB,GAhBe,CAAhB;;AAkBA,OAAK,MAAMuB,OAAX,IAAsBb,gBAAtB,EAAwC;AACtC,UAAMc,UAAU,GAAGD,OAAO,CAACE,mBAAR,GACfxB,UAAU,CAACyB,kBADI,GAEfzB,UAAU,CAAC0B,mBAFf;;AAIA,QAAIzB,QAAQ,CAAC0B,EAAT,KAAgB,KAApB,EAA2B;AAEvB9B,MAAAA,sBAAsB,CAAC+B,oBADzB,CAGEN,OAAO,CAACJ,UAHV,EAIER,OAJF,EAKEV,UAAU,CAAC6B,mBALb,EAKkC;AAChClB,MAAAA,mBANF;AAQD,KATD,MASO;AACLd,MAAAA,sBAAsB,CAAC+B,oBAAvB,CACEN,OAAO,CAACJ,UADV,EAEER,OAFF,EAGEa,UAHF;AAKD;AACF;;AAEDhB,EAAAA,eAAe,CAACuB,gBAAhB,GAAmCrB,gBAAnC;;AAEA,MAAIF,eAAe,CAACwB,gBAApB,EAAsC;AACpC,UAAMC,iBAAiB,GAAIC,CAAD,IAAoBA,CAAC,CAACT,mBAAhD;;AAEAjB,IAAAA,eAAe,CAACwB,gBAAhB,CAAiCG,KAAjC,GAAyCzB,gBAAgB,CACtD0B,MADsC,CAC/BH,iBAD+B,EAEtCI,GAFsC,CAEjCH,CAAD,IAAOA,CAAC,CAACI,QAFyB,CAAzC;AAKD;AACF","sourcesContent":["import React from 'react';\nimport { GestureType, HandlerCallbacks } from '../gesture';\nimport { registerHandler } from '../../handlersRegistry';\nimport RNGestureHandlerModule from '../../../RNGestureHandlerModule';\nimport {\n  filterConfig,\n  scheduleFlushOperations,\n} from '../../gestureHandlerCommon';\nimport { ComposedGesture } from '../gestureComposition';\nimport { ActionType } from '../../../ActionType';\nimport { Platform } from 'react-native';\nimport type RNGestureHandlerModuleWeb from '../../../RNGestureHandlerModule.web';\nimport { ghQueueMicrotask } from '../../../ghQueueMicrotask';\nimport { AttachedGestureState, WebEventHandler } from './types';\nimport {\n  extractGestureRelations,\n  checkGestureCallbacksForWorklets,\n  ALLOWED_PROPS,\n} from './utils';\n\ninterface AttachHandlersConfig {\n  preparedGesture: AttachedGestureState;\n  gestureConfig: ComposedGesture | GestureType;\n  gesturesToAttach: GestureType[];\n  viewTag: number;\n  webEventHandlersRef: React.RefObject<WebEventHandler>;\n}\n\nexport function attachHandlers({\n  preparedGesture,\n  gestureConfig,\n  gesturesToAttach,\n  viewTag,\n  webEventHandlersRef,\n}: AttachHandlersConfig) {\n  gestureConfig.initialize();\n\n  // use queueMicrotask to extract handlerTags, because all refs should be initialized\n  // when it's ran\n  ghQueueMicrotask(() => {\n    if (!preparedGesture.isMounted) {\n      return;\n    }\n    gestureConfig.prepare();\n  });\n\n  for (const handler of gesturesToAttach) {\n    checkGestureCallbacksForWorklets(handler);\n    RNGestureHandlerModule.createGestureHandler(\n      handler.handlerName,\n      handler.handlerTag,\n      filterConfig(handler.config, ALLOWED_PROPS)\n    );\n\n    registerHandler(handler.handlerTag, handler, handler.config.testId);\n  }\n\n  // use queueMicrotask to extract handlerTags, because all refs should be initialized\n  // when it's ran\n  ghQueueMicrotask(() => {\n    if (!preparedGesture.isMounted) {\n      return;\n    }\n    for (const handler of gesturesToAttach) {\n      RNGestureHandlerModule.updateGestureHandler(\n        handler.handlerTag,\n        filterConfig(\n          handler.config,\n          ALLOWED_PROPS,\n          extractGestureRelations(handler)\n        )\n      );\n    }\n\n    scheduleFlushOperations();\n  });\n\n  for (const gesture of gesturesToAttach) {\n    const actionType = gesture.shouldUseReanimated\n      ? ActionType.REANIMATED_WORKLET\n      : ActionType.JS_FUNCTION_NEW_API;\n\n    if (Platform.OS === 'web') {\n      (\n        RNGestureHandlerModule.attachGestureHandler as typeof RNGestureHandlerModuleWeb.attachGestureHandler\n      )(\n        gesture.handlerTag,\n        viewTag,\n        ActionType.JS_FUNCTION_OLD_API, // ignored on web\n        webEventHandlersRef\n      );\n    } else {\n      RNGestureHandlerModule.attachGestureHandler(\n        gesture.handlerTag,\n        viewTag,\n        actionType\n      );\n    }\n  }\n\n  preparedGesture.attachedGestures = gesturesToAttach;\n\n  if (preparedGesture.animatedHandlers) {\n    const isAnimatedGesture = (g: GestureType) => g.shouldUseReanimated;\n\n    preparedGesture.animatedHandlers.value = gesturesToAttach\n      .filter(isAnimatedGesture)\n      .map((g) => g.handlers) as unknown as HandlerCallbacks<\n      Record<string, unknown>\n    >[];\n  }\n}\n"]}

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

@@ -0,0 +1,12 @@
+import { unregisterHandler } from '../../handlersRegistry';
+import RNGestureHandlerModule from '../../../RNGestureHandlerModule';
+import { scheduleFlushOperations } from '../../gestureHandlerCommon';
+export function dropHandlers(preparedGesture) {
+  for (const handler of preparedGesture.attachedGestures) {
+    RNGestureHandlerModule.dropGestureHandler(handler.handlerTag);
+    unregisterHandler(handler.handlerTag, handler.config.testId);
+  }
+
+  scheduleFlushOperations();
+}
+//# sourceMappingURL=dropHandlers.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["dropHandlers.ts"],"names":["unregisterHandler","RNGestureHandlerModule","scheduleFlushOperations","dropHandlers","preparedGesture","handler","attachedGestures","dropGestureHandler","handlerTag","config","testId"],"mappings":"AAAA,SAASA,iBAAT,QAAkC,wBAAlC;AACA,OAAOC,sBAAP,MAAmC,iCAAnC;AACA,SAASC,uBAAT,QAAwC,4BAAxC;AAGA,OAAO,SAASC,YAAT,CAAsBC,eAAtB,EAA6D;AAClE,OAAK,MAAMC,OAAX,IAAsBD,eAAe,CAACE,gBAAtC,EAAwD;AACtDL,IAAAA,sBAAsB,CAACM,kBAAvB,CAA0CF,OAAO,CAACG,UAAlD;AAEAR,IAAAA,iBAAiB,CAACK,OAAO,CAACG,UAAT,EAAqBH,OAAO,CAACI,MAAR,CAAeC,MAApC,CAAjB;AACD;;AAEDR,EAAAA,uBAAuB;AACxB","sourcesContent":["import { unregisterHandler } from '../../handlersRegistry';\nimport RNGestureHandlerModule from '../../../RNGestureHandlerModule';\nimport { scheduleFlushOperations } from '../../gestureHandlerCommon';\nimport { AttachedGestureState } from './types';\n\nexport function dropHandlers(preparedGesture: AttachedGestureState) {\n  for (const handler of preparedGesture.attachedGestures) {\n    RNGestureHandlerModule.dropGestureHandler(handler.handlerTag);\n\n    unregisterHandler(handler.handlerTag, handler.config.testId);\n  }\n\n  scheduleFlushOperations();\n}\n"]}

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

@@ -0,0 +1,115 @@
+/* eslint-disable react/no-unused-prop-types */
+import React, { useContext, useEffect, useLayoutEffect, useMemo, useRef } from 'react';
+import { Platform, findNodeHandle } from 'react-native';
+import { isJestEnv } from '../../../utils';
+import GestureHandlerRootViewContext from '../../../GestureHandlerRootViewContext';
+import { useAnimatedGesture } from './useAnimatedGesture';
+import { attachHandlers } from './attachHandlers';
+import { needsToReattach } from './needsToReattach';
+import { dropHandlers } from './dropHandlers';
+import { useWebEventHandlers } from './utils';
+import { Wrap, AnimatedWrap } from './Wrap';
+import { useDetectorUpdater } from './useDetectorUpdater';
+import { useViewRefHandler } from './useViewRefHandler';
+
+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.
+ *
+ * ### Props
+ * - `gesture`
+ * - `userSelect` (**Web only**)
+ * - `enableContextMenu` (**Web only**)
+ * - `touchAction` (**Web only**)
+ *
+ * ### Remarks
+ * - 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.
+ * - Using the same instance of a gesture across multiple Gesture Detectors is not possible.
+ *
+ * @see https://docs.swmansion.com/react-native-gesture-handler/docs/gestures/gesture-detector
+ */
+export const GestureDetector = props => {
+  const rootViewContext = useContext(GestureHandlerRootViewContext);
+
+  if (__DEV__ && !rootViewContext && !isJestEnv() && 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
+
+
+  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 state = useRef({
+    firstRender: true,
+    viewRef: null,
+    previousViewTag: -1,
+    forceRebuildReanimatedEvent: false
+  }).current;
+  const preparedGesture = React.useRef({
+    attachedGestures: [],
+    animatedEventHandler: null,
+    animatedHandlers: null,
+    shouldUseReanimated: shouldUseReanimated,
+    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 needsToRebuildReanimatedEvent = state.firstRender || state.forceRebuildReanimatedEvent || needsToReattach(preparedGesture, gesturesToAttach);
+  state.forceRebuildReanimatedEvent = false;
+  useAnimatedGesture(preparedGesture, needsToRebuildReanimatedEvent);
+  useLayoutEffect(() => {
+    const viewTag = findNodeHandle(state.viewRef);
+    preparedGesture.isMounted = true;
+    attachHandlers({
+      preparedGesture,
+      gestureConfig,
+      gesturesToAttach,
+      webEventHandlersRef,
+      viewTag
+    });
+    return () => {
+      preparedGesture.isMounted = false;
+      dropHandlers(preparedGesture);
+    };
+  }, []);
+  useEffect(() => {
+    if (state.firstRender) {
+      state.firstRender = false;
+    } else {
+      updateAttachedGestures();
+    }
+  }, [props]);
+
+  if (shouldUseReanimated) {
+    return /*#__PURE__*/React.createElement(AnimatedWrap, {
+      ref: refHandler,
+      onGestureHandlerEvent: preparedGesture.animatedEventHandler
+    }, props.children);
+  } else {
+    return /*#__PURE__*/React.createElement(Wrap, {
+      ref: refHandler
+    }, props.children);
+  }
+};
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["index.tsx"],"names":["React","useContext","useEffect","useLayoutEffect","useMemo","useRef","Platform","findNodeHandle","isJestEnv","GestureHandlerRootViewContext","useAnimatedGesture","attachHandlers","needsToReattach","dropHandlers","useWebEventHandlers","Wrap","AnimatedWrap","useDetectorUpdater","useViewRefHandler","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, findNodeHandle } from 'react-native';\nimport { GestureType } from '../gesture';\nimport { UserSelect, TouchAction } from '../../gestureHandlerCommon';\nimport { ComposedGesture } from '../gestureComposition';\nimport { isJestEnv } 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';\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 && !isJestEnv() && 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  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"]}

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

@@ -0,0 +1,18 @@
+// 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
+// - At least one of the gestures changed the thread it runs on
+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

@@ -0,0 +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"]}

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","sourcesContent":[]}

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

@@ -0,0 +1,64 @@
+import { registerHandler } from '../../handlersRegistry';
+import RNGestureHandlerModule from '../../../RNGestureHandlerModule';
+import { filterConfig, scheduleFlushOperations } from '../../gestureHandlerCommon';
+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
+
+    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
+  // 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;
+    }
+
+    for (let i = 0; i < newGestures.length; i++) {
+      const handler = preparedGesture.attachedGestures[i];
+      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) {
+      var _preparedGesture$anim;
+
+      const previousHandlersValue = (_preparedGesture$anim = preparedGesture.animatedHandlers.value) !== null && _preparedGesture$anim !== void 0 ? _preparedGesture$anim : [];
+      const newHandlersValue = preparedGesture.attachedGestures.filter(g => g.shouldUseReanimated) // ignore gestures that shouldn't run on UI
+      .map(g => g.handlers); // if amount of gesture configs changes, we need to update the callbacks in shared value
+
+      let shouldUpdateSharedValue = previousHandlersValue.length !== newHandlersValue.length;
+
+      if (!shouldUpdateSharedValue) {
+        // if the amount is the same, we need to check if any of the configs inside has changed
+        for (let i = 0; i < newHandlersValue.length; i++) {
+          if ( // we can use the `gestureId` prop as it's unique for every config instance
+          newHandlersValue[i].gestureId !== previousHandlersValue[i].gestureId) {
+            shouldUpdateSharedValue = true;
+            break;
+          }
+        }
+      }
+
+      if (shouldUpdateSharedValue) {
+        preparedGesture.animatedHandlers.value = newHandlersValue;
+      }
+    }
+
+    scheduleFlushOperations();
+  });
+}
+//# sourceMappingURL=updateHandlers.js.map

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

@@ -0,0 +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","config","updateGestureHandler","testId","animatedHandlers","previousHandlersValue","value","newHandlersValue","filter","g","shouldUseReanimated","map","shouldUpdateSharedValue","gestureId"],"mappings":"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","sourcesContent":["import { GestureType, HandlerCallbacks } from '../gesture';\nimport { registerHandler } from '../../handlersRegistry';\nimport RNGestureHandlerModule from '../../../RNGestureHandlerModule';\nimport {\n  filterConfig,\n  scheduleFlushOperations,\n} from '../../gestureHandlerCommon';\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    for (let i = 0; i < newGestures.length; i++) {\n      const handler = preparedGesture.attachedGestures[i];\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) {\n      const previousHandlersValue =\n        preparedGesture.animatedHandlers.value ?? [];\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      // if amount of gesture configs changes, we need to update the callbacks in shared value\n      let shouldUpdateSharedValue =\n        previousHandlersValue.length !== newHandlersValue.length;\n\n      if (!shouldUpdateSharedValue) {\n        // if the amount is the same, we need to check if any of the configs inside has changed\n        for (let i = 0; i < newHandlersValue.length; i++) {\n          if (\n            // we can use the `gestureId` prop as it's unique for every config instance\n            newHandlersValue[i].gestureId !== previousHandlersValue[i].gestureId\n          ) {\n            shouldUpdateSharedValue = true;\n            break;\n          }\n        }\n      }\n\n      if (shouldUpdateSharedValue) {\n        preparedGesture.animatedHandlers.value = newHandlersValue;\n      }\n    }\n\n    scheduleFlushOperations();\n  });\n}\n"]}

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

@@ -0,0 +1,165 @@
+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);
+  } 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
+
+  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
+  // 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([]); // 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);
+        } else if ((event.oldState === State.BEGAN || event.oldState === State.UNDETERMINED) && event.state === State.ACTIVE) {
+          runWorklet(CALLBACK_TYPE.START, gesture, event);
+          lastUpdateEvent.value[gesture.handlerTag] = undefined;
+        } else if (event.oldState !== event.state && event.state === State.END) {
+          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
+
+
+  const event = Reanimated.useEvent(callback, ['onGestureHandlerStateChange', 'onGestureHandlerEvent'], needsRebuild);
+  preparedGesture.animatedEventHandler = event;
+  preparedGesture.animatedHandlers = sharedHandlersCallbacks;
+}
+//# sourceMappingURL=useAnimatedGesture.js.map

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

@@ -0,0 +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"]}

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

@@ -0,0 +1,41 @@
+import { useCallback } from 'react';
+import { findNodeHandle } from 'react-native';
+import { attachHandlers } from './attachHandlers';
+import { updateHandlers } from './updateHandlers';
+import { needsToReattach } from './needsToReattach';
+import { dropHandlers } from './dropHandlers';
+import { useForceRender, validateDetectorChildren } from './utils'; // 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
+  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);
+      attachHandlers({
+        preparedGesture,
+        gestureConfig,
+        gesturesToAttach,
+        webEventHandlersRef,
+        viewTag
+      });
+
+      if (didUnderlyingViewChange) {
+        state.previousViewTag = viewTag;
+        state.forceRebuildReanimatedEvent = true;
+        forceRender();
+      }
+    } else if (!skipConfigUpdate) {
+      updateHandlers(preparedGesture, gestureConfig, gesturesToAttach);
+    }
+  }, [forceRender, gestureConfig, gesturesToAttach, preparedGesture, state, webEventHandlersRef]);
+  return updateAttachedGestures;
+}
+//# sourceMappingURL=useDetectorUpdater.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["useDetectorUpdater.ts"],"names":["useCallback","findNodeHandle","attachHandlers","updateHandlers","needsToReattach","dropHandlers","useForceRender","validateDetectorChildren","useDetectorUpdater","state","preparedGesture","gesturesToAttach","gestureConfig","webEventHandlersRef","forceRender","updateAttachedGestures","skipConfigUpdate","viewTag","viewRef","didUnderlyingViewChange","previousViewTag","forceRebuildReanimatedEvent"],"mappings":"AAAA,SAAgBA,WAAhB,QAAmC,OAAnC;AACA,SAASC,cAAT,QAA+B,cAA/B;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,C,CAEA;AACA;AACA;;AACA,OAAO,SAASC,kBAAT,CACLC,KADK,EAELC,eAFK,EAGLC,gBAHK,EAILC,aAJK,EAKLC,mBALK,EAML;AACA,QAAMC,WAAW,GAAGR,cAAc,EAAlC;AACA,QAAMS,sBAAsB,GAAGf,WAAW,EACxC;AACCgB,EAAAA,gBAAD,IAAgC;AAC9B;AACA,UAAMC,OAAO,GAAGhB,cAAc,CAACQ,KAAK,CAACS,OAAP,CAA9B;AACA,UAAMC,uBAAuB,GAAGF,OAAO,KAAKR,KAAK,CAACW,eAAlD;;AAEA,QACED,uBAAuB,IACvBf,eAAe,CAACM,eAAD,EAAkBC,gBAAlB,CAFjB,EAGE;AACAJ,MAAAA,wBAAwB,CAACE,KAAK,CAACS,OAAP,CAAxB;AACAb,MAAAA,YAAY,CAACK,eAAD,CAAZ;AACAR,MAAAA,cAAc,CAAC;AACbQ,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;AAC5Bb,MAAAA,cAAc,CAACO,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 { findNodeHandle } from 'react-native';\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';\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"]}

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

@@ -0,0 +1,36 @@
+import { isFabric, tagMessage } from '../../../utils';
+import { getShadowNodeFromRef } from '../../../getShadowNodeFromRef';
+import { useCallback } from 'react';
+import { findNodeHandle } from 'react-native';
+// Ref handler for the Wrap component attached under the GestureDetector.
+// It's responsible for setting the viewRef on the state and triggering the reattaching of handlers
+// if the view has changed.
+export function useViewRefHandler(state, updateAttachedGestures) {
+  const refHandler = useCallback(ref => {
+    if (ref === null) {
+      return;
+    }
+
+    state.viewRef = ref; // 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.
+
+
+    if (!state.firstRender) {
+      updateAttachedGestures(true);
+    }
+
+    if (__DEV__ && isFabric() && global.isFormsStackingContext) {
+      const node = getShadowNodeFromRef(ref);
+
+      if (global.isFormsStackingContext(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}>`.'));
+      }
+    }
+  }, [state, updateAttachedGestures]);
+  return refHandler;
+}
+//# sourceMappingURL=useViewRefHandler.js.map