react-native-gesture-handler 2.27.1 → 2.27.2

package/lib/typescript/handlers/createNativeWrapper.js

@@ -1,67 +0,0 @@
-import * as React from 'react';
-import { useImperativeHandle, useRef } from 'react';
-import { NativeViewGestureHandler, nativeViewProps, } from './NativeViewGestureHandler';
-/*
- * This array should consist of:
- *   - All keys in propTypes from NativeGestureHandler
- *     (and all keys in GestureHandlerPropTypes)
- *   - 'onGestureHandlerEvent'
- *   - 'onGestureHandlerStateChange'
- */
-const NATIVE_WRAPPER_PROPS_FILTER = [
-    ...nativeViewProps,
-    'onGestureHandlerEvent',
-    'onGestureHandlerStateChange',
-];
-export default function createNativeWrapper(Component, config = {}) {
-    const ComponentWrapper = React.forwardRef((props, ref) => {
-        // Filter out props that should be passed to gesture handler wrapper
-        const { gestureHandlerProps, childProps } = Object.keys(props).reduce((res, key) => {
-            // TS being overly protective with it's types, see https://github.com/microsoft/TypeScript/issues/26255#issuecomment-458013731 for more info
-            const allowedKeys = NATIVE_WRAPPER_PROPS_FILTER;
-            if (allowedKeys.includes(key)) {
-                // @ts-ignore FIXME(TS)
-                res.gestureHandlerProps[key] = props[key];
-            }
-            else {
-                // @ts-ignore FIXME(TS)
-                res.childProps[key] = props[key];
-            }
-            return res;
-        }, {
-            gestureHandlerProps: { ...config }, // Watch out not to modify config
-            childProps: {
-                enabled: props.enabled,
-                hitSlop: props.hitSlop,
-                testID: props.testID,
-            },
-        });
-        const _ref = useRef(null);
-        const _gestureHandlerRef = useRef(null);
-        useImperativeHandle(ref, 
-        // @ts-ignore TODO(TS) decide how nulls work in this context
-        () => {
-            const node = _gestureHandlerRef.current;
-            // Add handlerTag for relations config
-            if (_ref.current && node) {
-                // @ts-ignore FIXME(TS) think about createHandler return type
-                _ref.current.handlerTag = node.handlerTag;
-                return _ref.current;
-            }
-            return null;
-        }, [_ref, _gestureHandlerRef]);
-        return (<NativeViewGestureHandler {...gestureHandlerProps} 
-        // @ts-ignore TODO(TS)
-        ref={_gestureHandlerRef}>
-        <Component {...childProps} ref={_ref}/>
-      </NativeViewGestureHandler>);
-    });
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-    ComponentWrapper.displayName =
-        Component?.displayName ||
-            // @ts-ignore if render doesn't exist it will return undefined and go further
-            Component?.render?.name ||
-            (typeof Component === 'string' && Component) ||
-            'ComponentWrapper';
-    return ComponentWrapper;
-}

package/lib/typescript/handlers/customDirectEventTypes.js

@@ -1,2 +0,0 @@
-// @ts-ignore - its taken straight from RN
-export { customDirectEventTypes } from 'react-native/Libraries/Renderer/shims/ReactNativeViewConfigRegistry';

package/lib/typescript/handlers/customDirectEventTypes.web.js

@@ -1,4 +0,0 @@
-// customDirectEventTypes doesn't exist in react-native-web, therefore importing it
-// directly in createHandler.tsx would end in crash.
-const customDirectEventTypes = {};
-export { customDirectEventTypes };

package/lib/typescript/handlers/gestureHandlerCommon.js

@@ -1,42 +0,0 @@
-const commonProps = [
-    'id',
-    'enabled',
-    'shouldCancelWhenOutside',
-    'hitSlop',
-    'cancelsTouchesInView',
-    'userSelect',
-    'activeCursor',
-    'mouseButton',
-    'enableContextMenu',
-    'touchAction',
-];
-const componentInteractionProps = [
-    'waitFor',
-    'simultaneousHandlers',
-    'blocksHandlers',
-];
-export const baseGestureHandlerProps = [
-    ...commonProps,
-    ...componentInteractionProps,
-    'onBegan',
-    'onFailed',
-    'onCancelled',
-    'onActivated',
-    'onEnded',
-    'onGestureEvent',
-    'onHandlerStateChange',
-];
-export const baseGestureHandlerWithDetectorProps = [
-    ...commonProps,
-    'needsPointerData',
-    'manualActivation',
-];
-export var MouseButton;
-(function (MouseButton) {
-    MouseButton[MouseButton["LEFT"] = 1] = "LEFT";
-    MouseButton[MouseButton["RIGHT"] = 2] = "RIGHT";
-    MouseButton[MouseButton["MIDDLE"] = 4] = "MIDDLE";
-    MouseButton[MouseButton["BUTTON_4"] = 8] = "BUTTON_4";
-    MouseButton[MouseButton["BUTTON_5"] = 16] = "BUTTON_5";
-    MouseButton[MouseButton["ALL"] = 31] = "ALL";
-})(MouseButton || (MouseButton = {}));

package/lib/typescript/handlers/gestureHandlerTypesCompat.js

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

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

@@ -1,22 +0,0 @@
-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.js

@@ -1,24 +0,0 @@
-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.js

@@ -1,55 +0,0 @@
-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.js

@@ -1,12 +0,0 @@
-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.js

@@ -1,114 +0,0 @@
-/* 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.js

@@ -1,18 +0,0 @@
-// 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.js

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

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

@@ -1,54 +0,0 @@
-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.js

@@ -1,137 +0,0 @@
-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?.(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) {
-                    runWorklet(CALLBACK_TYPE.CHANGE, gesture, gesture.changeEventCalculator?.(event, lastUpdateEvent.value[gesture.handlerTag]));
-                    lastUpdateEvent.value[gesture.handlerTag] = event;
-                }
-            }
-        }
-    };
-    // eslint-disable-next-line react-hooks/rules-of-hooks
-    const event = Reanimated.useEvent(callback, ['onGestureHandlerStateChange', 'onGestureHandlerEvent'], needsRebuild);
-    preparedGesture.animatedEventHandler = event;
-    preparedGesture.animatedHandlers = sharedHandlersCallbacks;
-}

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

@@ -1,48 +0,0 @@
-import { useCallback } from 'react';
-import { attachHandlers } from './attachHandlers';
-import { updateHandlers } from './updateHandlers';
-import { needsToReattach } from './needsToReattach';
-import { dropHandlers } from './dropHandlers';
-import { useForceRender, validateDetectorChildren } from './utils';
-import findNodeHandle from '../../../findNodeHandle';
-// Returns a function that's responsible for updating the attached gestures
-// 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;
-}

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

@@ -1,35 +0,0 @@
-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) => {
-            // At this point the ref in the gesture config should be updated, so we can check if one of the gestures
-            // set in a relation with the gesture got mounted. If so, we need to update the detector to propagate
-            // the changes to the native side.
-            for (const attachedGesture of state.attachedGestures) {
-                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
-                    return;
-                }
-            }
-        });
-    }, [updateDetector, state]);
-}