react-native-gesture-handler 2.27.1 → 2.28.0

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

@@ -1,32 +0,0 @@
-import { isFabric, tagMessage } from '../../../utils';
-import { getShadowNodeFromRef } from '../../../getShadowNodeFromRef';
-import { useCallback } from 'react';
-import findNodeHandle from '../../../findNodeHandle';
-// 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.isViewFlatteningDisabled) {
-            const node = getShadowNodeFromRef(ref);
-            if (global.isViewFlatteningDisabled(node) === false) {
-                console.error(tagMessage('GestureDetector has received a child that may get view-flattened. ' +
-                    '\nTo prevent it from misbehaving you need to wrap the child with a `<View collapsable={false}>`.'));
-            }
-        }
-    }, [state, updateAttachedGestures]);
-    return refHandler;
-}

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

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

package/lib/typescript/handlers/gestures/eventReceiver.js

@@ -1,105 +0,0 @@
-import { DeviceEventEmitter } from 'react-native';
-import { State } from '../../State';
-import { TouchEventType } from '../../TouchEventType';
-import { findHandler, findOldGestureHandler } from '../handlersRegistry';
-import { GestureStateManager, } from './gestureStateManager';
-let gestureHandlerEventSubscription = null;
-let gestureHandlerStateChangeEventSubscription = null;
-const gestureStateManagers = new Map();
-const lastUpdateEvent = [];
-function isStateChangeEvent(event) {
-    // @ts-ignore oldState doesn't exist on GestureTouchEvent and that's the point
-    return event.oldState != null;
-}
-function isTouchEvent(event) {
-    return event.eventType != null;
-}
-export function onGestureHandlerEvent(event) {
-    const handler = findHandler(event.handlerTag);
-    if (handler) {
-        if (isStateChangeEvent(event)) {
-            if (event.oldState === State.UNDETERMINED &&
-                event.state === State.BEGAN) {
-                handler.handlers.onBegin?.(event);
-            }
-            else if ((event.oldState === State.BEGAN ||
-                event.oldState === State.UNDETERMINED) &&
-                event.state === State.ACTIVE) {
-                handler.handlers.onStart?.(event);
-                lastUpdateEvent[handler.handlers.handlerTag] = event;
-            }
-            else if (event.oldState !== event.state && event.state === State.END) {
-                if (event.oldState === State.ACTIVE) {
-                    handler.handlers.onEnd?.(event, true);
-                }
-                handler.handlers.onFinalize?.(event, true);
-                lastUpdateEvent[handler.handlers.handlerTag] = undefined;
-            }
-            else if ((event.state === State.FAILED || event.state === State.CANCELLED) &&
-                event.oldState !== event.state) {
-                if (event.oldState === State.ACTIVE) {
-                    handler.handlers.onEnd?.(event, false);
-                }
-                handler.handlers.onFinalize?.(event, false);
-                gestureStateManagers.delete(event.handlerTag);
-                lastUpdateEvent[handler.handlers.handlerTag] = undefined;
-            }
-        }
-        else if (isTouchEvent(event)) {
-            if (!gestureStateManagers.has(event.handlerTag)) {
-                gestureStateManagers.set(event.handlerTag, GestureStateManager.create(event.handlerTag));
-            }
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            const manager = gestureStateManagers.get(event.handlerTag);
-            switch (event.eventType) {
-                case TouchEventType.TOUCHES_DOWN:
-                    handler.handlers?.onTouchesDown?.(event, manager);
-                    break;
-                case TouchEventType.TOUCHES_MOVE:
-                    handler.handlers?.onTouchesMove?.(event, manager);
-                    break;
-                case TouchEventType.TOUCHES_UP:
-                    handler.handlers?.onTouchesUp?.(event, manager);
-                    break;
-                case TouchEventType.TOUCHES_CANCELLED:
-                    handler.handlers?.onTouchesCancelled?.(event, manager);
-                    break;
-            }
-        }
-        else {
-            handler.handlers.onUpdate?.(event);
-            if (handler.handlers.onChange && handler.handlers.changeEventCalculator) {
-                handler.handlers.onChange?.(handler.handlers.changeEventCalculator?.(event, lastUpdateEvent[handler.handlers.handlerTag]));
-                lastUpdateEvent[handler.handlers.handlerTag] = event;
-            }
-        }
-    }
-    else {
-        const oldHandler = findOldGestureHandler(event.handlerTag);
-        if (oldHandler) {
-            const nativeEvent = { nativeEvent: event };
-            if (isStateChangeEvent(event)) {
-                oldHandler.onGestureStateChange(nativeEvent);
-            }
-            else {
-                oldHandler.onGestureEvent(nativeEvent);
-            }
-            return;
-        }
-    }
-}
-export function startListening() {
-    stopListening();
-    gestureHandlerEventSubscription = DeviceEventEmitter.addListener('onGestureHandlerEvent', onGestureHandlerEvent);
-    gestureHandlerStateChangeEventSubscription = DeviceEventEmitter.addListener('onGestureHandlerStateChange', onGestureHandlerEvent);
-}
-export function stopListening() {
-    if (gestureHandlerEventSubscription) {
-        gestureHandlerEventSubscription.remove();
-        gestureHandlerEventSubscription = null;
-    }
-    if (gestureHandlerStateChangeEventSubscription) {
-        gestureHandlerStateChangeEventSubscription.remove();
-        gestureHandlerStateChangeEventSubscription = null;
-    }
-}

package/lib/typescript/handlers/gestures/flingGesture.js

@@ -1,27 +0,0 @@
-import { BaseGesture } from './gesture';
-export class FlingGesture extends BaseGesture {
-    config = {};
-    constructor() {
-        super();
-        this.handlerName = 'FlingGestureHandler';
-    }
-    /**
-     * Determine exact number of points required to handle the fling gesture.
-     * @param pointers
-     */
-    numberOfPointers(pointers) {
-        this.config.numberOfPointers = pointers;
-        return this;
-    }
-    /**
-     * Expressed allowed direction of movement.
-     * Expected values are exported as constants in the Directions object.
-     * Arguments can be combined using `|` operator. Default value is set to `MouseButton.LEFT`.
-     * @param direction
-     * @see https://docs.swmansion.com/react-native-gesture-handler/docs/gestures/fling-gesture/#directionvalue-directions
-     */
-    direction(direction) {
-        this.config.direction = direction;
-        return this;
-    }
-}

package/lib/typescript/handlers/gestures/forceTouchGesture.js

@@ -1,57 +0,0 @@
-import { ContinousBaseGesture } from './gesture';
-function changeEventCalculator(current, previous) {
-    'worklet';
-    let changePayload;
-    if (previous === undefined) {
-        changePayload = {
-            forceChange: current.force,
-        };
-    }
-    else {
-        changePayload = {
-            forceChange: current.force - previous.force,
-        };
-    }
-    return { ...current, ...changePayload };
-}
-/**
- * @deprecated ForceTouch gesture is deprecated and will be removed in the future.
- */
-export class ForceTouchGesture extends ContinousBaseGesture {
-    config = {};
-    constructor() {
-        super();
-        this.handlerName = 'ForceTouchGestureHandler';
-    }
-    /**
-     * A minimal pressure that is required before gesture can activate.
-     * Should be a value from range [0.0, 1.0]. Default is 0.2.
-     * @param force
-     */
-    minForce(force) {
-        this.config.minForce = force;
-        return this;
-    }
-    /**
-     * A maximal pressure that could be applied for gesture.
-     * If the pressure is greater, gesture fails. Should be a value from range [0.0, 1.0].
-     * @param force
-     */
-    maxForce(force) {
-        this.config.maxForce = force;
-        return this;
-    }
-    /**
-     * Value defining if haptic feedback has to be performed on activation.
-     * @param value
-     */
-    feedbackOnActivation(value) {
-        this.config.feedbackOnActivation = value;
-        return this;
-    }
-    onChange(callback) {
-        // @ts-ignore TS being overprotective, ForceTouchGestureHandlerEventPayload is Record
-        this.handlers.changeEventCalculator = changeEventCalculator;
-        return super.onChange(callback);
-    }
-}

package/lib/typescript/handlers/gestures/gesture.js

@@ -1,303 +0,0 @@
-import { getNextHandlerTag } from '../getNextHandlerTag';
-import { isRemoteDebuggingEnabled } from '../../utils';
-export const CALLBACK_TYPE = {
-    UNDEFINED: 0,
-    BEGAN: 1,
-    START: 2,
-    UPDATE: 3,
-    CHANGE: 4,
-    END: 5,
-    FINALIZE: 6,
-    TOUCHES_DOWN: 7,
-    TOUCHES_MOVE: 8,
-    TOUCHES_UP: 9,
-    TOUCHES_CANCELLED: 10,
-};
-export class Gesture {
-}
-let nextGestureId = 0;
-export class BaseGesture extends Gesture {
-    gestureId = -1;
-    handlerTag = -1;
-    handlerName = '';
-    config = {};
-    handlers = {
-        gestureId: -1,
-        handlerTag: -1,
-        isWorklet: [],
-    };
-    constructor() {
-        super();
-        // Used to check whether the gesture config has been updated when wrapping it
-        // with `useMemo`. Since every config will have a unique id, when the dependencies
-        // don't change, the config won't be recreated and the id will stay the same.
-        // If the id is different, it means that the config has changed and the gesture
-        // needs to be updated.
-        this.gestureId = nextGestureId++;
-        this.handlers.gestureId = this.gestureId;
-    }
-    addDependency(key, gesture) {
-        const value = this.config[key];
-        this.config[key] = value
-            ? Array().concat(value, gesture)
-            : [gesture];
-    }
-    /**
-     * Sets a `ref` to the gesture object, allowing for interoperability with the old API.
-     * @param ref
-     */
-    withRef(ref) {
-        this.config.ref = ref;
-        return this;
-    }
-    // eslint-disable-next-line @typescript-eslint/ban-types
-    isWorklet(callback) {
-        // @ts-ignore if callback is a worklet, the property will be available, if not then the check will return false
-        return callback.__workletHash !== undefined;
-    }
-    /**
-     * Set the callback that is being called when given gesture handler starts receiving touches.
-     * At the moment of this callback the handler is in `BEGAN` state and we don't know yet if it will recognize the gesture at all.
-     * @param callback
-     */
-    onBegin(callback) {
-        this.handlers.onBegin = callback;
-        this.handlers.isWorklet[CALLBACK_TYPE.BEGAN] = this.isWorklet(callback);
-        return this;
-    }
-    /**
-     * Set the callback that is being called when the gesture is recognized by the handler and it transitions to the `ACTIVE` state.
-     * @param callback
-     */
-    onStart(callback) {
-        this.handlers.onStart = callback;
-        this.handlers.isWorklet[CALLBACK_TYPE.START] = this.isWorklet(callback);
-        return this;
-    }
-    /**
-     * Set the callback that is being called when the gesture that was recognized by the handler finishes and handler reaches `END` state.
-     * It will be called only if the handler was previously in the `ACTIVE` state.
-     * @param callback
-     */
-    onEnd(callback) {
-        this.handlers.onEnd = callback;
-        // @ts-ignore if callback is a worklet, the property will be available, if not then the check will return false
-        this.handlers.isWorklet[CALLBACK_TYPE.END] = this.isWorklet(callback);
-        return this;
-    }
-    /**
-     * Set the callback that is being called when the handler finalizes handling gesture - the gesture was recognized and has finished or it failed to recognize.
-     * @param callback
-     */
-    onFinalize(callback) {
-        this.handlers.onFinalize = callback;
-        // @ts-ignore if callback is a worklet, the property will be available, if not then the check will return false
-        this.handlers.isWorklet[CALLBACK_TYPE.FINALIZE] = this.isWorklet(callback);
-        return this;
-    }
-    /**
-     * Set the `onTouchesDown` callback which is called every time a pointer is placed on the screen.
-     * @param callback
-     */
-    onTouchesDown(callback) {
-        this.config.needsPointerData = true;
-        this.handlers.onTouchesDown = callback;
-        this.handlers.isWorklet[CALLBACK_TYPE.TOUCHES_DOWN] =
-            this.isWorklet(callback);
-        return this;
-    }
-    /**
-     * Set the `onTouchesMove` callback which is called every time a pointer is moved on the screen.
-     * @param callback
-     */
-    onTouchesMove(callback) {
-        this.config.needsPointerData = true;
-        this.handlers.onTouchesMove = callback;
-        this.handlers.isWorklet[CALLBACK_TYPE.TOUCHES_MOVE] =
-            this.isWorklet(callback);
-        return this;
-    }
-    /**
-     * Set the `onTouchesUp` callback which is called every time a pointer is lifted from the screen.
-     * @param callback
-     */
-    onTouchesUp(callback) {
-        this.config.needsPointerData = true;
-        this.handlers.onTouchesUp = callback;
-        this.handlers.isWorklet[CALLBACK_TYPE.TOUCHES_UP] =
-            this.isWorklet(callback);
-        return this;
-    }
-    /**
-     * Set the `onTouchesCancelled` callback which is called every time a pointer stops being tracked, for example when the gesture finishes.
-     * @param callback
-     */
-    onTouchesCancelled(callback) {
-        this.config.needsPointerData = true;
-        this.handlers.onTouchesCancelled = callback;
-        this.handlers.isWorklet[CALLBACK_TYPE.TOUCHES_CANCELLED] =
-            this.isWorklet(callback);
-        return this;
-    }
-    /**
-     * Indicates whether the given handler should be analyzing stream of touch events or not.
-     * @param enabled
-     * @see https://docs.swmansion.com/react-native-gesture-handler/docs/gestures/pan-gesture#enabledvalue-boolean
-     */
-    enabled(enabled) {
-        this.config.enabled = enabled;
-        return this;
-    }
-    /**
-     * When true the handler will cancel or fail recognition (depending on its current state) whenever the finger leaves the area of the connected view.
-     * @param value
-     * @see https://docs.swmansion.com/react-native-gesture-handler/docs/gestures/pan-gesture#shouldcancelwhenoutsidevalue-boolean
-     */
-    shouldCancelWhenOutside(value) {
-        this.config.shouldCancelWhenOutside = value;
-        return this;
-    }
-    /**
-     * This parameter enables control over what part of the connected view area can be used to begin recognizing the gesture.
-     * When a negative number is provided the bounds of the view will reduce the area by the given number of points in each of the sides evenly.
-     * @param hitSlop
-     * @see https://docs.swmansion.com/react-native-gesture-handler/docs/gestures/pan-gesture#hitslopsettings
-     */
-    hitSlop(hitSlop) {
-        this.config.hitSlop = hitSlop;
-        return this;
-    }
-    /**
-     * #### Web only
-     * This parameter allows to specify which `cursor` should be used when gesture activates.
-     * Supports all CSS cursor values (e.g. `"grab"`, `"zoom-in"`). Default value is set to `"auto"`.
-     * @param activeCursor
-     */
-    activeCursor(activeCursor) {
-        this.config.activeCursor = activeCursor;
-        return this;
-    }
-    /**
-     * #### Web & Android only
-     * Allows users to choose which mouse button should handler respond to.
-     * Arguments can be combined using `|` operator, e.g. `mouseButton(MouseButton.LEFT | MouseButton.RIGHT)`.
-     * Default value is set to `MouseButton.LEFT`.
-     * @param mouseButton
-     * @see https://docs.swmansion.com/react-native-gesture-handler/docs/gestures/pan-gesture#mousebuttonvalue-mousebutton-web--android-only
-     */
-    mouseButton(mouseButton) {
-        this.config.mouseButton = mouseButton;
-        return this;
-    }
-    /**
-     * When `react-native-reanimated` is installed, the callbacks passed to the gestures are automatically workletized and run on the UI thread when called.
-     * This option allows for changing this behavior: when `true`, all the callbacks will be run on the JS thread instead of the UI thread, regardless of whether they are worklets or not.
-     * Defaults to `false`.
-     * @param runOnJS
-     */
-    runOnJS(runOnJS) {
-        this.config.runOnJS = runOnJS;
-        return this;
-    }
-    /**
-     * Allows gestures across different components to be recognized simultaneously.
-     * @param gestures
-     * @see https://docs.swmansion.com/react-native-gesture-handler/docs/fundamentals/gesture-composition/#simultaneouswithexternalgesture
-     */
-    simultaneousWithExternalGesture(...gestures) {
-        for (const gesture of gestures) {
-            this.addDependency('simultaneousWith', gesture);
-        }
-        return this;
-    }
-    /**
-     * Allows to delay activation of the handler until all handlers passed as arguments to this method fail (or don't begin at all).
-     * @param gestures
-     * @see https://docs.swmansion.com/react-native-gesture-handler/docs/fundamentals/gesture-composition/#requireexternalgesturetofail
-     */
-    requireExternalGestureToFail(...gestures) {
-        for (const gesture of gestures) {
-            this.addDependency('requireToFail', gesture);
-        }
-        return this;
-    }
-    /**
-     * Works similarily to `requireExternalGestureToFail` but the direction of the relation is reversed - instead of being one-to-many relation, it's many-to-one.
-     * @param gestures
-     * @see https://docs.swmansion.com/react-native-gesture-handler/docs/fundamentals/gesture-composition/#blocksexternalgesture
-     */
-    blocksExternalGesture(...gestures) {
-        for (const gesture of gestures) {
-            this.addDependency('blocksHandlers', gesture);
-        }
-        return this;
-    }
-    /**
-     * Sets a `testID` property for gesture object, allowing for querying for it in tests.
-     * @param id
-     */
-    withTestId(id) {
-        this.config.testId = id;
-        return this;
-    }
-    /**
-     * #### iOS only
-     * When `true`, the handler will cancel touches for native UI components (`UIButton`, `UISwitch`, etc) it's attached to when it becomes `ACTIVE`.
-     * Default value is `true`.
-     * @param value
-     */
-    cancelsTouchesInView(value) {
-        this.config.cancelsTouchesInView = value;
-        return this;
-    }
-    initialize() {
-        this.handlerTag = getNextHandlerTag();
-        this.handlers = { ...this.handlers, handlerTag: this.handlerTag };
-        if (this.config.ref) {
-            this.config.ref.current = this;
-        }
-    }
-    toGestureArray() {
-        return [this];
-    }
-    // eslint-disable-next-line @typescript-eslint/no-empty-function
-    prepare() { }
-    get shouldUseReanimated() {
-        // Use Reanimated when runOnJS isn't set explicitly,
-        // all defined callbacks are worklets
-        // and remote debugging is disabled
-        return (this.config.runOnJS !== true &&
-            !this.handlers.isWorklet.includes(false) &&
-            !isRemoteDebuggingEnabled());
-    }
-}
-export class ContinousBaseGesture extends BaseGesture {
-    /**
-     * Set the callback that is being called every time the gesture receives an update while it's active.
-     * @param callback
-     */
-    onUpdate(callback) {
-        this.handlers.onUpdate = callback;
-        this.handlers.isWorklet[CALLBACK_TYPE.UPDATE] = this.isWorklet(callback);
-        return this;
-    }
-    /**
-     * Set the callback that is being called every time the gesture receives an update while it's active.
-     * This callback will receive information about change in value in relation to the last received event.
-     * @param callback
-     */
-    onChange(callback) {
-        this.handlers.onChange = callback;
-        this.handlers.isWorklet[CALLBACK_TYPE.CHANGE] = this.isWorklet(callback);
-        return this;
-    }
-    /**
-     * When `true` the handler will not activate by itself even if its activation criteria are met.
-     * Instead you can manipulate its state using state manager.
-     * @param manualActivation
-     */
-    manualActivation(manualActivation) {
-        this.config.manualActivation = manualActivation;
-        return this;
-    }
-}