react-native-gesture-handler 2.27.0 → 2.27.1

package/lib/typescript/handlers/gestureHandlerTypesCompat.d.ts

@@ -0,0 +1,52 @@
+import type { BaseButtonProps, BorderlessButtonProps, RawButtonProps, RectButtonProps } from '../components/GestureButtonsProps';
+import { GestureEvent, GestureEventPayload, HandlerStateChangeEvent, HandlerStateChangeEventPayload } from './gestureHandlerCommon';
+import type { FlingGestureHandlerProps } from './FlingGestureHandler';
+import type { FlingGestureHandlerEventPayload, ForceTouchGestureHandlerEventPayload, LongPressGestureHandlerEventPayload, PanGestureHandlerEventPayload, PinchGestureHandlerEventPayload, RotationGestureHandlerEventPayload, TapGestureHandlerEventPayload, NativeViewGestureHandlerPayload } from './GestureHandlerEventPayload';
+import type { ForceTouchGestureHandlerProps } from './ForceTouchGestureHandler';
+import type { LongPressGestureHandlerProps } from './LongPressGestureHandler';
+import type { PanGestureHandlerProps } from './PanGestureHandler';
+import type { PinchGestureHandlerProps } from './PinchGestureHandler';
+import type { RotationGestureHandlerProps } from './RotationGestureHandler';
+import type { TapGestureHandlerProps } from './TapGestureHandler';
+import type { NativeViewGestureHandlerProps } from './NativeViewGestureHandler';
+export type GestureHandlerGestureEventNativeEvent = GestureEventPayload;
+export type GestureHandlerStateChangeNativeEvent = HandlerStateChangeEventPayload;
+export type GestureHandlerGestureEvent = GestureEvent;
+export type GestureHandlerStateChangeEvent = HandlerStateChangeEvent;
+export type NativeViewGestureHandlerGestureEvent = GestureEvent<NativeViewGestureHandlerPayload>;
+export type NativeViewGestureHandlerStateChangeEvent = HandlerStateChangeEvent<NativeViewGestureHandlerPayload>;
+export type TapGestureHandlerGestureEvent = GestureEvent<TapGestureHandlerEventPayload>;
+export type TapGestureHandlerStateChangeEvent = HandlerStateChangeEvent<TapGestureHandlerEventPayload>;
+/**
+ * @deprecated ForceTouchGestureHandler is deprecated and will be removed in the future.
+ */
+export type ForceTouchGestureHandlerGestureEvent = GestureEvent<ForceTouchGestureHandlerEventPayload>;
+/**
+ * @deprecated ForceTouchGestureHandler is deprecated and will be removed in the future.
+ */
+export type ForceTouchGestureHandlerStateChangeEvent = HandlerStateChangeEvent<ForceTouchGestureHandlerEventPayload>;
+export type LongPressGestureHandlerGestureEvent = GestureEvent<LongPressGestureHandlerEventPayload>;
+export type LongPressGestureHandlerStateChangeEvent = HandlerStateChangeEvent<LongPressGestureHandlerEventPayload>;
+export type PanGestureHandlerGestureEvent = GestureEvent<PanGestureHandlerEventPayload>;
+export type PanGestureHandlerStateChangeEvent = HandlerStateChangeEvent<PanGestureHandlerEventPayload>;
+export type PinchGestureHandlerGestureEvent = GestureEvent<PinchGestureHandlerEventPayload>;
+export type PinchGestureHandlerStateChangeEvent = HandlerStateChangeEvent<PinchGestureHandlerEventPayload>;
+export type RotationGestureHandlerGestureEvent = GestureEvent<RotationGestureHandlerEventPayload>;
+export type RotationGestureHandlerStateChangeEvent = HandlerStateChangeEvent<RotationGestureHandlerEventPayload>;
+export type FlingGestureHandlerGestureEvent = GestureEvent<FlingGestureHandlerEventPayload>;
+export type FlingGestureHandlerStateChangeEvent = HandlerStateChangeEvent<FlingGestureHandlerEventPayload>;
+export type NativeViewGestureHandlerProperties = NativeViewGestureHandlerProps;
+export type TapGestureHandlerProperties = TapGestureHandlerProps;
+export type LongPressGestureHandlerProperties = LongPressGestureHandlerProps;
+export type PanGestureHandlerProperties = PanGestureHandlerProps;
+export type PinchGestureHandlerProperties = PinchGestureHandlerProps;
+export type RotationGestureHandlerProperties = RotationGestureHandlerProps;
+export type FlingGestureHandlerProperties = FlingGestureHandlerProps;
+/**
+ * @deprecated ForceTouch gesture is deprecated and will be removed in the future.
+ */
+export type ForceTouchGestureHandlerProperties = ForceTouchGestureHandlerProps;
+export type RawButtonProperties = RawButtonProps;
+export type BaseButtonProperties = BaseButtonProps;
+export type RectButtonProperties = RectButtonProps;
+export type BorderlessButtonProperties = BorderlessButtonProps;

package/lib/typescript/handlers/gestureHandlerTypesCompat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gestureHandlerTypesCompat.d.ts","sourceRoot":"","sources":["../../../src/handlers/gestureHandlerTypesCompat.ts"],"names":[],"mappings":"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"}

package/lib/typescript/handlers/gestureHandlerTypesCompat.js

@@ -0,0 +1 @@
+export {};

package/lib/typescript/handlers/gestures/GestureDetector/Wrap.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+export declare class Wrap extends React.Component<{
+    onGestureHandlerEvent?: unknown;
+    children?: React.ReactNode;
+}> {
+    render(): React.FunctionComponentElement<{
+        collapsable: boolean;
+    }>;
+}
+export declare const AnimatedWrap: typeof Wrap | React.ComponentClass<{
+    onGestureHandlerEvent?: unknown;
+    children?: React.ReactNode;
+}, any>;

package/lib/typescript/handlers/gestures/GestureDetector/Wrap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Wrap.d.ts","sourceRoot":"","sources":["../../../../../src/handlers/gestures/GestureDetector/Wrap.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAI1B,qBAAa,IAAK,SAAQ,KAAK,CAAC,SAAS,CAAC;IACxC,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAEhC,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;CAC5B,CAAC;IACA,MAAM;;;CAsBP;AAED,eAAO,MAAM,YAAY;4BA5BC,OAAO;eAEpB,KAAK,CAAC,SAAS;OA2BgC,CAAC"}

package/lib/typescript/handlers/gestures/GestureDetector/Wrap.js

@@ -0,0 +1,22 @@
+import React from 'react';
+import { Reanimated } from '../reanimatedWrapper';
+import { tagMessage } from '../../../utils';
+export class Wrap extends React.Component {
+    render() {
+        try {
+            // I don't think that fighting with types over such a simple function is worth it
+            // The only thing it does is add 'collapsable: false' to the child component
+            // to make sure it is in the native view hierarchy so the detector can find
+            // correct viewTag to attach to.
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const child = React.Children.only(this.props.children);
+            return React.cloneElement(child, { collapsable: false }, 
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+            child.props.children);
+        }
+        catch (e) {
+            throw new Error(tagMessage(`GestureDetector got more than one view as a child. If you want the gesture to work on multiple views, wrap them with a common parent and attach the gesture to that view.`));
+        }
+    }
+}
+export const AnimatedWrap = Reanimated?.default?.createAnimatedComponent(Wrap) ?? Wrap;

package/lib/typescript/handlers/gestures/GestureDetector/Wrap.web.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+export declare const Wrap: React.ForwardRefExoticComponent<{
+    children?: React.ReactNode | undefined;
+} & React.RefAttributes<HTMLDivElement>>;
+export declare const AnimatedWrap: React.ForwardRefExoticComponent<{
+    children?: React.ReactNode | undefined;
+} & React.RefAttributes<HTMLDivElement>>;

package/lib/typescript/handlers/gestures/GestureDetector/Wrap.web.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Wrap.web.d.ts","sourceRoot":"","sources":["../../../../../src/handlers/gestures/GestureDetector/Wrap.web.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAqB,MAAM,OAAO,CAAC;AAK1C,eAAO,MAAM,IAAI;;wCAgChB,CAAC;AAIF,eAAO,MAAM,YAAY;;wCAAO,CAAC"}

package/lib/typescript/handlers/gestures/GestureDetector/Wrap.web.js

@@ -0,0 +1,24 @@
+import React, { forwardRef } from 'react';
+import { tagMessage } from '../../../utils';
+import { isRNSVGNode } from '../../../web/utils';
+export const Wrap = forwardRef(({ children }, ref) => {
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const child = React.Children.only(children);
+        if (isRNSVGNode(child)) {
+            const clone = React.cloneElement(child, { ref }, 
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+            child.props.children);
+            return clone;
+        }
+        return (<div ref={ref} style={{ display: 'contents' }}>
+          {child}
+        </div>);
+    }
+    catch (e) {
+        throw new Error(tagMessage(`GestureDetector got more than one view as a child. If you want the gesture to work on multiple views, wrap them with a common parent and attach the gesture to that view.`));
+    }
+});
+// On web we never take a path with Reanimated,
+// therefore we can simply export Wrap
+export const AnimatedWrap = Wrap;

package/lib/typescript/handlers/gestures/GestureDetector/attachHandlers.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+import { GestureType } from '../gesture';
+import { ComposedGesture } from '../gestureComposition';
+import { AttachedGestureState, WebEventHandler } from './types';
+interface AttachHandlersConfig {
+    preparedGesture: AttachedGestureState;
+    gestureConfig: ComposedGesture | GestureType;
+    gesturesToAttach: GestureType[];
+    viewTag: number;
+    webEventHandlersRef: React.RefObject<WebEventHandler>;
+}
+export declare function attachHandlers({ preparedGesture, gestureConfig, gesturesToAttach, viewTag, webEventHandlersRef, }: AttachHandlersConfig): void;
+export {};

package/lib/typescript/handlers/gestures/GestureDetector/attachHandlers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attachHandlers.d.ts","sourceRoot":"","sources":["../../../../../src/handlers/gestures/GestureDetector/attachHandlers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,EAAE,WAAW,EAAoB,MAAM,YAAY,CAAC;AAI3D,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAKxD,OAAO,EAAE,oBAAoB,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAQhE,UAAU,oBAAoB;IAC5B,eAAe,EAAE,oBAAoB,CAAC;IACtC,aAAa,EAAE,eAAe,GAAG,WAAW,CAAC;IAC7C,gBAAgB,EAAE,WAAW,EAAE,CAAC;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,mBAAmB,EAAE,KAAK,CAAC,SAAS,CAAC,eAAe,CAAC,CAAC;CACvD;AAED,wBAAgB,cAAc,CAAC,EAC7B,eAAe,EACf,aAAa,EACb,gBAAgB,EAChB,OAAO,EACP,mBAAmB,GACpB,EAAE,oBAAoB,QA+EtB"}

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

@@ -0,0 +1,55 @@
+import { registerHandler } from '../../handlersRegistry';
+import RNGestureHandlerModule from '../../../RNGestureHandlerModule';
+import { filterConfig, scheduleFlushOperations } from '../../utils';
+import { ActionType } from '../../../ActionType';
+import { Platform } from 'react-native';
+import { ghQueueMicrotask } from '../../../ghQueueMicrotask';
+import { extractGestureRelations, checkGestureCallbacksForWorklets, ALLOWED_PROPS, } from './utils';
+import { MountRegistry } from '../../../mountRegistry';
+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);
+        }
+        MountRegistry.gestureWillMount(gesture);
+    }
+    preparedGesture.attachedGestures = gesturesToAttach;
+    if (preparedGesture.animatedHandlers) {
+        const isAnimatedGesture = (g) => g.shouldUseReanimated;
+        preparedGesture.animatedHandlers.value = gesturesToAttach
+            .filter(isAnimatedGesture)
+            .map((g) => g.handlers);
+    }
+}

package/lib/typescript/handlers/gestures/GestureDetector/dropHandlers.d.ts

@@ -0,0 +1,2 @@
+import { AttachedGestureState } from './types';
+export declare function dropHandlers(preparedGesture: AttachedGestureState): void;

package/lib/typescript/handlers/gestures/GestureDetector/dropHandlers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dropHandlers.d.ts","sourceRoot":"","sources":["../../../../../src/handlers/gestures/GestureDetector/dropHandlers.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAG/C,wBAAgB,YAAY,CAAC,eAAe,EAAE,oBAAoB,QAUjE"}

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

@@ -0,0 +1,12 @@
+import { unregisterHandler } from '../../handlersRegistry';
+import RNGestureHandlerModule from '../../../RNGestureHandlerModule';
+import { scheduleFlushOperations } from '../../utils';
+import { MountRegistry } from '../../../mountRegistry';
+export function dropHandlers(preparedGesture) {
+    for (const handler of preparedGesture.attachedGestures) {
+        RNGestureHandlerModule.dropGestureHandler(handler.handlerTag);
+        unregisterHandler(handler.handlerTag, handler.config.testId);
+        MountRegistry.gestureWillUnmount(handler);
+    }
+    scheduleFlushOperations();
+}

package/lib/typescript/handlers/gestures/GestureDetector/index.d.ts

@@ -0,0 +1,49 @@
+import React from 'react';
+import { GestureType } from '../gesture';
+import { UserSelect, TouchAction } from '../../gestureHandlerCommon';
+import { ComposedGesture } from '../gestureComposition';
+interface GestureDetectorProps {
+    children?: React.ReactNode;
+    /**
+     * A gesture object containing the configuration and callbacks.
+     * Can be any of:
+     * - base gestures (`Tap`, `Pan`, ...)
+     * - `ComposedGesture` (`Race`, `Simultaneous`, `Exclusive`)
+     */
+    gesture: ComposedGesture | GestureType;
+    /**
+     * #### Web only
+     * This parameter allows to specify which `userSelect` property should be applied to underlying view.
+     * Possible values are `"none" | "auto" | "text"`. Default value is set to `"none"`.
+     */
+    userSelect?: UserSelect;
+    /**
+     * #### Web only
+     * Specifies whether context menu should be enabled after clicking on underlying view with right mouse button.
+     * Default value is set to `false`.
+     */
+    enableContextMenu?: boolean;
+    /**
+     * #### Web only
+     * This parameter allows to specify which `touchAction` property should be applied to underlying view.
+     * Supports all CSS touch-action values (e.g. `"none"`, `"pan-y"`). Default value is set to `"none"`.
+     */
+    touchAction?: TouchAction;
+}
+/**
+ * `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 declare const GestureDetector: (props: GestureDetectorProps) => React.JSX.Element;
+export {};

package/lib/typescript/handlers/gestures/GestureDetector/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/handlers/gestures/GestureDetector/index.tsx"],"names":[],"mappings":"AACA,OAAO,KAMN,MAAM,OAAO,CAAC;AAGf,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AACzC,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AACrE,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAsCxD,UAAU,oBAAoB;IAC5B,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;IAC3B;;;;;OAKG;IACH,OAAO,EAAE,eAAe,GAAG,WAAW,CAAC;IACvC;;;;OAIG;IACH,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB;;;;OAIG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B;;;;OAIG;IACH,WAAW,CAAC,EAAE,WAAW,CAAC;CAC3B;AAED;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,eAAe,GAAI,OAAO,oBAAoB,sBAgG1D,CAAC"}

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

@@ -0,0 +1,114 @@
+/* eslint-disable react/no-unused-prop-types */
+import React, { useContext, useEffect, useLayoutEffect, useMemo, useRef, } from 'react';
+import { Platform } from 'react-native';
+import findNodeHandle from '../../../findNodeHandle';
+import { isTestEnv } 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';
+import { useMountReactions } from './useMountReactions';
+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 && !isTestEnv() && Platform.OS !== 'web') {
+        throw new Error('GestureDetector must be used as a descendant of GestureHandlerRootView. Otherwise the gestures will not be recognized. See https://docs.swmansion.com/react-native-gesture-handler/docs/installation for more details.');
+    }
+    // Gesture config should be wrapped with useMemo to prevent unnecessary re-renders
+    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]);
+    useMountReactions(updateAttachedGestures, preparedGesture);
+    if (shouldUseReanimated) {
+        return (<AnimatedWrap ref={refHandler} onGestureHandlerEvent={preparedGesture.animatedEventHandler}>
+        {props.children}
+      </AnimatedWrap>);
+    }
+    else {
+        return <Wrap ref={refHandler}>{props.children}</Wrap>;
+    }
+};

package/lib/typescript/handlers/gestures/GestureDetector/needsToReattach.d.ts

@@ -0,0 +1,3 @@
+import { GestureType } from '../gesture';
+import { AttachedGestureState } from './types';
+export declare function needsToReattach(preparedGesture: AttachedGestureState, newGestures: GestureType[]): boolean;

package/lib/typescript/handlers/gestures/GestureDetector/needsToReattach.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"needsToReattach.d.ts","sourceRoot":"","sources":["../../../../../src/handlers/gestures/GestureDetector/needsToReattach.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AACzC,OAAO,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAM/C,wBAAgB,eAAe,CAC7B,eAAe,EAAE,oBAAoB,EACrC,WAAW,EAAE,WAAW,EAAE,WAiB3B"}

package/lib/typescript/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;
+}

package/lib/typescript/handlers/gestures/GestureDetector/types.d.ts

@@ -0,0 +1,20 @@
+import { GestureType, HandlerCallbacks } from '../gesture';
+import { SharedValue } from '../reanimatedWrapper';
+import { HandlerStateChangeEvent } from '../../gestureHandlerCommon';
+export interface AttachedGestureState {
+    attachedGestures: GestureType[];
+    animatedEventHandler: unknown;
+    animatedHandlers: SharedValue<HandlerCallbacks<Record<string, unknown>>[] | null> | null;
+    shouldUseReanimated: boolean;
+    isMounted: boolean;
+}
+export interface GestureDetectorState {
+    firstRender: boolean;
+    viewRef: React.Component | null;
+    previousViewTag: number;
+    forceRebuildReanimatedEvent: boolean;
+}
+export interface WebEventHandler {
+    onGestureHandlerEvent: (event: HandlerStateChangeEvent<unknown>) => void;
+    onGestureHandlerStateChange?: (event: HandlerStateChangeEvent<unknown>) => void;
+}

package/lib/typescript/handlers/gestures/GestureDetector/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/handlers/gestures/GestureDetector/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAC3D,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,EAAE,uBAAuB,EAAE,MAAM,4BAA4B,CAAC;AAErE,MAAM,WAAW,oBAAoB;IAEnC,gBAAgB,EAAE,WAAW,EAAE,CAAC;IAEhC,oBAAoB,EAAE,OAAO,CAAC;IAE9B,gBAAgB,EAAE,WAAW,CAC3B,gBAAgB,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EAAE,GAAG,IAAI,CACnD,GAAG,IAAI,CAAC;IAET,mBAAmB,EAAE,OAAO,CAAC;IAE7B,SAAS,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,oBAAoB;IACnC,WAAW,EAAE,OAAO,CAAC;IACrB,OAAO,EAAE,KAAK,CAAC,SAAS,GAAG,IAAI,CAAC;IAChC,eAAe,EAAE,MAAM,CAAC;IACxB,2BAA2B,EAAE,OAAO,CAAC;CACtC;AAED,MAAM,WAAW,eAAe;IAC9B,qBAAqB,EAAE,CAAC,KAAK,EAAE,uBAAuB,CAAC,OAAO,CAAC,KAAK,IAAI,CAAC;IACzE,2BAA2B,CAAC,EAAE,CAC5B,KAAK,EAAE,uBAAuB,CAAC,OAAO,CAAC,KACpC,IAAI,CAAC;CACX"}

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

@@ -0,0 +1 @@
+export {};

package/lib/typescript/handlers/gestures/GestureDetector/updateHandlers.d.ts

@@ -0,0 +1,4 @@
+import { GestureType } from '../gesture';
+import { ComposedGesture } from '../gestureComposition';
+import { AttachedGestureState } from './types';
+export declare function updateHandlers(preparedGesture: AttachedGestureState, gestureConfig: ComposedGesture | GestureType, newGestures: GestureType[]): void;

package/lib/typescript/handlers/gestures/GestureDetector/updateHandlers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"updateHandlers.d.ts","sourceRoot":"","sources":["../../../../../src/handlers/gestures/GestureDetector/updateHandlers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAoB,MAAM,YAAY,CAAC;AAI3D,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAExD,OAAO,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAO/C,wBAAgB,cAAc,CAC5B,eAAe,EAAE,oBAAoB,EACrC,aAAa,EAAE,eAAe,GAAG,WAAW,EAC5C,WAAW,EAAE,WAAW,EAAE,QA2E3B"}

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

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

package/lib/typescript/handlers/gestures/GestureDetector/useAnimatedGesture.d.ts

@@ -0,0 +1,2 @@
+import { AttachedGestureState } from './types';
+export declare function useAnimatedGesture(preparedGesture: AttachedGestureState, needsRebuild: boolean): void;

package/lib/typescript/handlers/gestures/GestureDetector/useAnimatedGesture.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAnimatedGesture.d.ts","sourceRoot":"","sources":["../../../../../src/handlers/gestures/GestureDetector/useAnimatedGesture.ts"],"names":[],"mappings":"AAcA,OAAO,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAgF/C,wBAAgB,kBAAkB,CAChC,eAAe,EAAE,oBAAoB,EACrC,YAAY,EAAE,OAAO,QA6GtB"}