react-native-gesture-handler 2.27.1 → 2.28.0

package/lib/typescript/handlers/ForceTouchGestureHandler.js

@@ -1,37 +0,0 @@
-import React from 'react';
-import { tagMessage } from '../utils';
-import PlatformConstants from '../PlatformConstants';
-import createHandler from './createHandler';
-import { baseGestureHandlerProps, } from './gestureHandlerCommon';
-export const forceTouchGestureHandlerProps = [
-    'minForce',
-    'maxForce',
-    'feedbackOnActivation',
-];
-// implicit `children` prop has been removed in @types/react^18.0.0
-class ForceTouchFallback extends React.Component {
-    static forceTouchAvailable = false;
-    componentDidMount() {
-        console.warn(tagMessage('ForceTouchGestureHandler is not available on this platform. Please use ForceTouchGestureHandler.forceTouchAvailable to conditionally render other components that would provide a fallback behavior specific to your usecase'));
-    }
-    render() {
-        return this.props.children;
-    }
-}
-export const forceTouchHandlerName = 'ForceTouchGestureHandler';
-/**
- * @deprecated ForceTouchGestureHandler will be removed in the future version of Gesture Handler. Use `Gesture.ForceTouch()` instead.
- */
-// eslint-disable-next-line @typescript-eslint/no-redeclare -- backward compatibility; see description on the top of gestureHandlerCommon.ts file
-export const ForceTouchGestureHandler = PlatformConstants?.forceTouchAvailable
-    ? createHandler({
-        name: forceTouchHandlerName,
-        allowedProps: [
-            ...baseGestureHandlerProps,
-            ...forceTouchGestureHandlerProps,
-        ],
-        config: {},
-    })
-    : ForceTouchFallback;
-ForceTouchGestureHandler.forceTouchAvailable =
-    PlatformConstants?.forceTouchAvailable || false;

package/lib/typescript/handlers/GestureHandlerEventPayload.js

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

package/lib/typescript/handlers/LongPressGestureHandler.js

@@ -1,22 +0,0 @@
-import createHandler from './createHandler';
-import { baseGestureHandlerProps, } from './gestureHandlerCommon';
-export const longPressGestureHandlerProps = [
-    'minDurationMs',
-    'maxDist',
-    'numberOfPointers',
-];
-export const longPressHandlerName = 'LongPressGestureHandler';
-/**
- * @deprecated LongPressGestureHandler will be removed in the future version of Gesture Handler. Use `Gesture.LongPress()` instead.
- */
-// eslint-disable-next-line @typescript-eslint/no-redeclare -- backward compatibility; see description on the top of gestureHandlerCommon.ts file
-export const LongPressGestureHandler = createHandler({
-    name: longPressHandlerName,
-    allowedProps: [
-        ...baseGestureHandlerProps,
-        ...longPressGestureHandlerProps,
-    ],
-    config: {
-        shouldCancelWhenOutside: true,
-    },
-});

package/lib/typescript/handlers/NativeViewGestureHandler.js

@@ -1,20 +0,0 @@
-import createHandler from './createHandler';
-import { baseGestureHandlerProps, } from './gestureHandlerCommon';
-export const nativeViewGestureHandlerProps = [
-    'shouldActivateOnStart',
-    'disallowInterruption',
-];
-export const nativeViewProps = [
-    ...baseGestureHandlerProps,
-    ...nativeViewGestureHandlerProps,
-];
-export const nativeViewHandlerName = 'NativeViewGestureHandler';
-/**
- * @deprecated NativeViewGestureHandler will be removed in the future version of Gesture Handler. Use `Gesture.Native()` instead.
- */
-// eslint-disable-next-line @typescript-eslint/no-redeclare -- backward compatibility; see description on the top of gestureHandlerCommon.ts file
-export const NativeViewGestureHandler = createHandler({
-    name: nativeViewHandlerName,
-    allowedProps: nativeViewProps,
-    config: {},
-});

package/lib/typescript/handlers/PanGestureHandler.js

@@ -1,128 +0,0 @@
-import createHandler from './createHandler';
-import { baseGestureHandlerProps, } from './gestureHandlerCommon';
-export const panGestureHandlerProps = [
-    'activeOffsetY',
-    'activeOffsetX',
-    'failOffsetY',
-    'failOffsetX',
-    'minDist',
-    'minVelocity',
-    'minVelocityX',
-    'minVelocityY',
-    'minPointers',
-    'maxPointers',
-    'avgTouches',
-    'enableTrackpadTwoFingerGesture',
-    'activateAfterLongPress',
-];
-export const panGestureHandlerCustomNativeProps = [
-    'activeOffsetYStart',
-    'activeOffsetYEnd',
-    'activeOffsetXStart',
-    'activeOffsetXEnd',
-    'failOffsetYStart',
-    'failOffsetYEnd',
-    'failOffsetXStart',
-    'failOffsetXEnd',
-];
-export const panHandlerName = 'PanGestureHandler';
-/**
- * @deprecated PanGestureHandler will be removed in the future version of Gesture Handler. Use `Gesture.Pan()` instead.
- */
-// eslint-disable-next-line @typescript-eslint/no-redeclare -- backward compatibility; see description on the top of gestureHandlerCommon.ts file
-export const PanGestureHandler = createHandler({
-    name: panHandlerName,
-    allowedProps: [
-        ...baseGestureHandlerProps,
-        ...panGestureHandlerProps,
-    ],
-    config: {},
-    transformProps: managePanProps,
-    customNativeProps: panGestureHandlerCustomNativeProps,
-});
-function validatePanGestureHandlerProps(props) {
-    if (Array.isArray(props.activeOffsetX) &&
-        (props.activeOffsetX[0] > 0 || props.activeOffsetX[1] < 0)) {
-        throw new Error(`First element of activeOffsetX should be negative, a the second one should be positive`);
-    }
-    if (Array.isArray(props.activeOffsetY) &&
-        (props.activeOffsetY[0] > 0 || props.activeOffsetY[1] < 0)) {
-        throw new Error(`First element of activeOffsetY should be negative, a the second one should be positive`);
-    }
-    if (Array.isArray(props.failOffsetX) &&
-        (props.failOffsetX[0] > 0 || props.failOffsetX[1] < 0)) {
-        throw new Error(`First element of failOffsetX should be negative, a the second one should be positive`);
-    }
-    if (Array.isArray(props.failOffsetY) &&
-        (props.failOffsetY[0] > 0 || props.failOffsetY[1] < 0)) {
-        throw new Error(`First element of failOffsetY should be negative, a the second one should be positive`);
-    }
-    if (props.minDist && (props.failOffsetX || props.failOffsetY)) {
-        throw new Error(`It is not supported to use minDist with failOffsetX or failOffsetY, use activeOffsetX and activeOffsetY instead`);
-    }
-    if (props.minDist && (props.activeOffsetX || props.activeOffsetY)) {
-        throw new Error(`It is not supported to use minDist with activeOffsetX or activeOffsetY`);
-    }
-}
-function transformPanGestureHandlerProps(props) {
-    const res = { ...props };
-    if (props.activeOffsetX !== undefined) {
-        delete res.activeOffsetX;
-        if (Array.isArray(props.activeOffsetX)) {
-            res.activeOffsetXStart = props.activeOffsetX[0];
-            res.activeOffsetXEnd = props.activeOffsetX[1];
-        }
-        else if (props.activeOffsetX < 0) {
-            res.activeOffsetXStart = props.activeOffsetX;
-        }
-        else {
-            res.activeOffsetXEnd = props.activeOffsetX;
-        }
-    }
-    if (props.activeOffsetY !== undefined) {
-        delete res.activeOffsetY;
-        if (Array.isArray(props.activeOffsetY)) {
-            res.activeOffsetYStart = props.activeOffsetY[0];
-            res.activeOffsetYEnd = props.activeOffsetY[1];
-        }
-        else if (props.activeOffsetY < 0) {
-            res.activeOffsetYStart = props.activeOffsetY;
-        }
-        else {
-            res.activeOffsetYEnd = props.activeOffsetY;
-        }
-    }
-    if (props.failOffsetX !== undefined) {
-        delete res.failOffsetX;
-        if (Array.isArray(props.failOffsetX)) {
-            res.failOffsetXStart = props.failOffsetX[0];
-            res.failOffsetXEnd = props.failOffsetX[1];
-        }
-        else if (props.failOffsetX < 0) {
-            res.failOffsetXStart = props.failOffsetX;
-        }
-        else {
-            res.failOffsetXEnd = props.failOffsetX;
-        }
-    }
-    if (props.failOffsetY !== undefined) {
-        delete res.failOffsetY;
-        if (Array.isArray(props.failOffsetY)) {
-            res.failOffsetYStart = props.failOffsetY[0];
-            res.failOffsetYEnd = props.failOffsetY[1];
-        }
-        else if (props.failOffsetY < 0) {
-            res.failOffsetYStart = props.failOffsetY;
-        }
-        else {
-            res.failOffsetYEnd = props.failOffsetY;
-        }
-    }
-    return res;
-}
-export function managePanProps(props) {
-    if (__DEV__) {
-        validatePanGestureHandlerProps(props);
-    }
-    return transformPanGestureHandlerProps(props);
-}

package/lib/typescript/handlers/PinchGestureHandler.js

@@ -1,12 +0,0 @@
-import createHandler from './createHandler';
-import { baseGestureHandlerProps, } from './gestureHandlerCommon';
-export const pinchHandlerName = 'PinchGestureHandler';
-/**
- * @deprecated PinchGestureHandler will be removed in the future version of Gesture Handler. Use `Gesture.Pinch()` instead.
- */
-// eslint-disable-next-line @typescript-eslint/no-redeclare -- backward compatibility; see description on the top of gestureHandlerCommon.ts file
-export const PinchGestureHandler = createHandler({
-    name: pinchHandlerName,
-    allowedProps: baseGestureHandlerProps,
-    config: {},
-});

package/lib/typescript/handlers/PressabilityDebugView.js

@@ -1,2 +0,0 @@
-// @ts-ignore it's not exported so we need to import it from path
-export { PressabilityDebugView } from 'react-native/Libraries/Pressability/PressabilityDebug';

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

@@ -1,4 +0,0 @@
-// PressabilityDebugView is not implemented in react-native-web
-export function PressabilityDebugView() {
-    return null;
-}

package/lib/typescript/handlers/RotationGestureHandler.js

@@ -1,12 +0,0 @@
-import createHandler from './createHandler';
-import { baseGestureHandlerProps, } from './gestureHandlerCommon';
-export const rotationHandlerName = 'RotationGestureHandler';
-/**
- * @deprecated RotationGestureHandler will be removed in the future version of Gesture Handler. Use `Gesture.Rotation()` instead.
- */
-// eslint-disable-next-line @typescript-eslint/no-redeclare -- backward compatibility; see description on the top of gestureHandlerCommon.ts file
-export const RotationGestureHandler = createHandler({
-    name: rotationHandlerName,
-    allowedProps: baseGestureHandlerProps,
-    config: {},
-});

package/lib/typescript/handlers/TapGestureHandler.js

@@ -1,26 +0,0 @@
-import createHandler from './createHandler';
-import { baseGestureHandlerProps, } from './gestureHandlerCommon';
-export const tapGestureHandlerProps = [
-    'maxDurationMs',
-    'maxDelayMs',
-    'numberOfTaps',
-    'maxDeltaX',
-    'maxDeltaY',
-    'maxDist',
-    'minPointers',
-];
-export const tapHandlerName = 'TapGestureHandler';
-/**
- * @deprecated TapGestureHandler will be removed in the future version of Gesture Handler. Use `Gesture.Tap()` instead.
- */
-// eslint-disable-next-line @typescript-eslint/no-redeclare -- backward compatibility; see description on the top of gestureHandlerCommon.ts file
-export const TapGestureHandler = createHandler({
-    name: tapHandlerName,
-    allowedProps: [
-        ...baseGestureHandlerProps,
-        ...tapGestureHandlerProps,
-    ],
-    config: {
-        shouldCancelWhenOutside: true,
-    },
-});

package/lib/typescript/handlers/createHandler.js

@@ -1,375 +0,0 @@
-import * as React from 'react';
-import { Platform, UIManager, DeviceEventEmitter, } from 'react-native';
-import { customDirectEventTypes } from './customDirectEventTypes';
-import RNGestureHandlerModule from '../RNGestureHandlerModule';
-import { State } from '../State';
-import { handlerIDToTag, registerOldGestureHandler, unregisterOldGestureHandler, } from './handlersRegistry';
-import { getNextHandlerTag } from './getNextHandlerTag';
-import { filterConfig, scheduleFlushOperations } from './utils';
-import findNodeHandle from '../findNodeHandle';
-import { deepEqual, isFabric, isReact19, isTestEnv, tagMessage, } from '../utils';
-import { ActionType } from '../ActionType';
-import { PressabilityDebugView } from './PressabilityDebugView';
-import GestureHandlerRootViewContext from '../GestureHandlerRootViewContext';
-import { ghQueueMicrotask } from '../ghQueueMicrotask';
-import { MountRegistry } from '../mountRegistry';
-const UIManagerAny = UIManager;
-customDirectEventTypes.topGestureHandlerEvent = {
-    registrationName: 'onGestureHandlerEvent',
-};
-const customGHEventsConfigFabricAndroid = {
-    topOnGestureHandlerEvent: { registrationName: 'onGestureHandlerEvent' },
-    topOnGestureHandlerStateChange: {
-        registrationName: 'onGestureHandlerStateChange',
-    },
-};
-const customGHEventsConfig = {
-    onGestureHandlerEvent: { registrationName: 'onGestureHandlerEvent' },
-    onGestureHandlerStateChange: {
-        registrationName: 'onGestureHandlerStateChange',
-    },
-    // When using React Native Gesture Handler for Animated.event with useNativeDriver: true
-    // on Android with Fabric enabled, the native part still sends the native events to JS
-    // but prefixed with "top". We cannot simply rename the events above so they are prefixed
-    // with "top" instead of "on" because in such case Animated.events would not be registered.
-    // That's why we need to register another pair of event names.
-    // The incoming events will be queued but never handled.
-    // Without this piece of code below, you'll get the following JS error:
-    // Unsupported top level event type "topOnGestureHandlerEvent" dispatched
-    ...(isFabric() &&
-        Platform.OS === 'android' &&
-        customGHEventsConfigFabricAndroid),
-};
-// Add gesture specific events to genericDirectEventTypes object exported from UIManager
-// native module.
-// Once new event types are registered with react it is possible to dispatch these
-// events to all kind of native views.
-UIManagerAny.genericDirectEventTypes = {
-    ...UIManagerAny.genericDirectEventTypes,
-    ...customGHEventsConfig,
-};
-const UIManagerConstants = UIManagerAny.getViewManagerConfig?.('getConstants');
-if (UIManagerConstants) {
-    UIManagerConstants.genericDirectEventTypes = {
-        ...UIManagerConstants.genericDirectEventTypes,
-        ...customGHEventsConfig,
-    };
-}
-// Wrap JS responder calls and notify gesture handler manager
-const { setJSResponder: oldSetJSResponder = () => {
-    // no-op
-}, clearJSResponder: oldClearJSResponder = () => {
-    // no-op
-}, } = UIManagerAny;
-UIManagerAny.setJSResponder = (tag, blockNativeResponder) => {
-    RNGestureHandlerModule.handleSetJSResponder(tag, blockNativeResponder);
-    oldSetJSResponder(tag, blockNativeResponder);
-};
-UIManagerAny.clearJSResponder = () => {
-    RNGestureHandlerModule.handleClearJSResponder();
-    oldClearJSResponder();
-};
-let allowTouches = true;
-const DEV_ON_ANDROID = __DEV__ && Platform.OS === 'android';
-// Toggled inspector blocks touch events in order to allow inspecting on Android
-// This needs to be a global variable in order to set initial state for `allowTouches` property in Handler component
-if (DEV_ON_ANDROID) {
-    DeviceEventEmitter.addListener('toggleElementInspector', () => {
-        allowTouches = !allowTouches;
-    });
-}
-function hasUnresolvedRefs(props) {
-    // TODO(TS) - add type for extract arg
-    const extract = (refs) => {
-        if (!Array.isArray(refs)) {
-            return refs && refs.current === null;
-        }
-        return refs.some((r) => r && r.current === null);
-    };
-    return extract(props['simultaneousHandlers']) || extract(props['waitFor']);
-}
-const stateToPropMappings = {
-    [State.UNDETERMINED]: undefined,
-    [State.BEGAN]: 'onBegan',
-    [State.FAILED]: 'onFailed',
-    [State.CANCELLED]: 'onCancelled',
-    [State.ACTIVE]: 'onActivated',
-    [State.END]: 'onEnded',
-};
-const UNRESOLVED_REFS_RETRY_LIMIT = 1;
-// TODO(TS) - make sure that BaseGestureHandlerProps doesn't need other generic parameter to work with custom properties.
-export default function createHandler({ name, allowedProps = [], config = {}, transformProps, customNativeProps = [], }) {
-    class Handler extends React.Component {
-        static displayName = name;
-        static contextType = GestureHandlerRootViewContext;
-        handlerTag = -1;
-        config;
-        propsRef;
-        isMountedRef;
-        viewNode;
-        viewTag;
-        inspectorToggleListener;
-        constructor(props) {
-            super(props);
-            this.config = {};
-            this.propsRef = React.createRef();
-            this.isMountedRef = React.createRef();
-            this.state = { allowTouches };
-            if (props.id) {
-                if (handlerIDToTag[props.id] !== undefined) {
-                    throw new Error(`Handler with ID "${props.id}" already registered`);
-                }
-                handlerIDToTag[props.id] = this.handlerTag;
-            }
-        }
-        componentDidMount() {
-            const props = this.props;
-            this.isMountedRef.current = true;
-            if (DEV_ON_ANDROID) {
-                this.inspectorToggleListener = DeviceEventEmitter.addListener('toggleElementInspector', () => {
-                    this.setState((_) => ({ allowTouches }));
-                    this.update(UNRESOLVED_REFS_RETRY_LIMIT);
-                });
-            }
-            if (hasUnresolvedRefs(props)) {
-                // If there are unresolved refs (e.g. ".current" has not yet been set)
-                // passed as `simultaneousHandlers` or `waitFor`, we enqueue a call to
-                // _update method that will try to update native handler props using
-                // queueMicrotask. This makes it so update() function gets called after all
-                // react components are mounted and we expect the missing ref object to
-                // be resolved by then.
-                ghQueueMicrotask(() => {
-                    this.update(UNRESOLVED_REFS_RETRY_LIMIT);
-                });
-            }
-            this.createGestureHandler(filterConfig(transformProps ? transformProps(this.props) : this.props, [...allowedProps, ...customNativeProps], config));
-            if (!this.viewNode) {
-                throw new Error(`[Gesture Handler] Failed to obtain view for ${Handler.displayName}. Note that old API doesn't support functional components.`);
-            }
-            this.attachGestureHandler(findNodeHandle(this.viewNode)); // TODO(TS) - check if this can be null
-        }
-        componentDidUpdate() {
-            const viewTag = findNodeHandle(this.viewNode);
-            if (this.viewTag !== viewTag) {
-                this.attachGestureHandler(viewTag); // TODO(TS) - check interaction between _viewTag & findNodeHandle
-            }
-            this.update(UNRESOLVED_REFS_RETRY_LIMIT);
-        }
-        componentWillUnmount() {
-            this.inspectorToggleListener?.remove();
-            this.isMountedRef.current = false;
-            if (Platform.OS !== 'web') {
-                unregisterOldGestureHandler(this.handlerTag);
-            }
-            RNGestureHandlerModule.dropGestureHandler(this.handlerTag);
-            scheduleFlushOperations();
-            // We can't use this.props.id directly due to TS generic type narrowing bug, see https://github.com/microsoft/TypeScript/issues/13995 for more context
-            const handlerID = this.props.id;
-            if (handlerID) {
-                // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
-                delete handlerIDToTag[handlerID];
-            }
-            MountRegistry.gestureHandlerWillUnmount(this);
-        }
-        onGestureHandlerEvent = (event) => {
-            if (event.nativeEvent.handlerTag === this.handlerTag) {
-                if (typeof this.props.onGestureEvent === 'function') {
-                    this.props.onGestureEvent?.(event);
-                }
-            }
-            else {
-                this.props.onGestureHandlerEvent?.(event);
-            }
-        };
-        // TODO(TS) - make sure this is right type for event
-        onGestureHandlerStateChange = (event) => {
-            if (event.nativeEvent.handlerTag === this.handlerTag) {
-                if (typeof this.props.onHandlerStateChange === 'function') {
-                    this.props.onHandlerStateChange?.(event);
-                }
-                const state = event.nativeEvent.state;
-                const stateEventName = stateToPropMappings[state];
-                const eventHandler = stateEventName && this.props[stateEventName];
-                if (eventHandler && typeof eventHandler === 'function') {
-                    eventHandler(event);
-                }
-            }
-            else {
-                this.props.onGestureHandlerStateChange?.(event);
-            }
-        };
-        refHandler = (node) => {
-            this.viewNode = node;
-            const child = React.Children.only(this.props.children);
-            // @ts-ignore Since React 19 ref is accessible as standard prop
-            // https://react.dev/blog/2024/04/25/react-19-upgrade-guide#deprecated-element-ref
-            const ref = isReact19() ? child.props?.ref : child?.ref;
-            if (!ref) {
-                return;
-            }
-            if (typeof ref === 'function') {
-                ref(node);
-            }
-            else {
-                ref.current = node;
-            }
-        };
-        createGestureHandler = (newConfig) => {
-            this.handlerTag = getNextHandlerTag();
-            this.config = newConfig;
-            RNGestureHandlerModule.createGestureHandler(name, this.handlerTag, newConfig);
-        };
-        attachGestureHandler = (newViewTag) => {
-            this.viewTag = newViewTag;
-            if (Platform.OS === 'web') {
-                // Typecast due to dynamic resolution, attachGestureHandler should have web version signature in this branch
-                RNGestureHandlerModule.attachGestureHandler(this.handlerTag, newViewTag, ActionType.JS_FUNCTION_OLD_API, // ignored on web
-                this.propsRef);
-            }
-            else {
-                registerOldGestureHandler(this.handlerTag, {
-                    onGestureEvent: this.onGestureHandlerEvent,
-                    onGestureStateChange: this.onGestureHandlerStateChange,
-                });
-                const actionType = (() => {
-                    const onGestureEvent = this.props?.onGestureEvent;
-                    const isGestureHandlerWorklet = onGestureEvent &&
-                        ('current' in onGestureEvent ||
-                            'workletEventHandler' in onGestureEvent);
-                    const onHandlerStateChange = this.props?.onHandlerStateChange;
-                    const isStateChangeHandlerWorklet = onHandlerStateChange &&
-                        ('current' in onHandlerStateChange ||
-                            'workletEventHandler' in onHandlerStateChange);
-                    const isReanimatedHandler = isGestureHandlerWorklet || isStateChangeHandlerWorklet;
-                    if (isReanimatedHandler) {
-                        // Reanimated worklet
-                        return ActionType.REANIMATED_WORKLET;
-                    }
-                    else if (onGestureEvent && '__isNative' in onGestureEvent) {
-                        // Animated.event with useNativeDriver: true
-                        return ActionType.NATIVE_ANIMATED_EVENT;
-                    }
-                    else {
-                        // JS callback or Animated.event with useNativeDriver: false
-                        return ActionType.JS_FUNCTION_OLD_API;
-                    }
-                })();
-                RNGestureHandlerModule.attachGestureHandler(this.handlerTag, newViewTag, actionType);
-            }
-            scheduleFlushOperations();
-            ghQueueMicrotask(() => {
-                MountRegistry.gestureHandlerWillMount(this);
-            });
-        };
-        updateGestureHandler = (newConfig) => {
-            this.config = newConfig;
-            RNGestureHandlerModule.updateGestureHandler(this.handlerTag, newConfig);
-            scheduleFlushOperations();
-        };
-        update(remainingTries) {
-            if (!this.isMountedRef.current) {
-                return;
-            }
-            const props = this.props;
-            // When ref is set via a function i.e. `ref={(r) => refObject.current = r}` instead of
-            // `ref={refObject}` it's possible that it won't be resolved in time. Seems like trying
-            // again is easy enough fix.
-            if (hasUnresolvedRefs(props) && remainingTries > 0) {
-                ghQueueMicrotask(() => {
-                    this.update(remainingTries - 1);
-                });
-            }
-            else {
-                const newConfig = filterConfig(transformProps ? transformProps(this.props) : this.props, [...allowedProps, ...customNativeProps], config);
-                if (!deepEqual(this.config, newConfig)) {
-                    this.updateGestureHandler(newConfig);
-                }
-            }
-        }
-        // eslint-disable-next-line @eslint-react/no-unused-class-component-members
-        setNativeProps(updates) {
-            const mergedProps = { ...this.props, ...updates };
-            const newConfig = filterConfig(transformProps ? transformProps(mergedProps) : mergedProps, [...allowedProps, ...customNativeProps], config);
-            this.updateGestureHandler(newConfig);
-        }
-        render() {
-            if (__DEV__ && !this.context && !isTestEnv() && Platform.OS !== 'web') {
-                throw new Error(name +
-                    ' 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.');
-            }
-            let gestureEventHandler = this.onGestureHandlerEvent;
-            const { onGestureEvent, onGestureHandlerEvent } = this.props;
-            if (onGestureEvent && typeof onGestureEvent !== 'function') {
-                // If it's not a method it should be an native Animated.event
-                // object. We set it directly as the handler for the view
-                // In this case nested handlers are not going to be supported
-                if (onGestureHandlerEvent) {
-                    throw new Error('Nesting touch handlers with native animated driver is not supported yet');
-                }
-                gestureEventHandler = onGestureEvent;
-            }
-            else {
-                if (onGestureHandlerEvent &&
-                    typeof onGestureHandlerEvent !== 'function') {
-                    throw new Error('Nesting touch handlers with native animated driver is not supported yet');
-                }
-            }
-            let gestureStateEventHandler = this.onGestureHandlerStateChange;
-            const { onHandlerStateChange, onGestureHandlerStateChange, } = this.props;
-            if (onHandlerStateChange && typeof onHandlerStateChange !== 'function') {
-                // If it's not a method it should be an native Animated.event
-                // object. We set it directly as the handler for the view
-                // In this case nested handlers are not going to be supported
-                if (onGestureHandlerStateChange) {
-                    throw new Error('Nesting touch handlers with native animated driver is not supported yet');
-                }
-                gestureStateEventHandler = onHandlerStateChange;
-            }
-            else {
-                if (onGestureHandlerStateChange &&
-                    typeof onGestureHandlerStateChange !== 'function') {
-                    throw new Error('Nesting touch handlers with native animated driver is not supported yet');
-                }
-            }
-            const events = {
-                onGestureHandlerEvent: this.state.allowTouches
-                    ? gestureEventHandler
-                    : undefined,
-                onGestureHandlerStateChange: this.state.allowTouches
-                    ? gestureStateEventHandler
-                    : undefined,
-            };
-            this.propsRef.current = events;
-            let child = null;
-            try {
-                child = React.Children.only(this.props.children);
-            }
-            catch (e) {
-                throw new Error(tagMessage(`${name} 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.`));
-            }
-            let grandChildren = child.props.children;
-            if (__DEV__ &&
-                child.type &&
-                (child.type === 'RNGestureHandlerButton' ||
-                    child.type.name === 'View' ||
-                    child.type.displayName === 'View')) {
-                grandChildren = React.Children.toArray(grandChildren);
-                grandChildren.push(<PressabilityDebugView key="pressabilityDebugView" color="mediumspringgreen" hitSlop={child.props.hitSlop}/>);
-            }
-            return React.cloneElement(child, {
-                ref: this.refHandler,
-                collapsable: false,
-                ...(isTestEnv()
-                    ? {
-                        handlerType: name,
-                        handlerTag: this.handlerTag,
-                        enabled: this.props.enabled,
-                    }
-                    : {}),
-                testID: this.props.testID ?? child.props.testID,
-                ...events,
-            }, grandChildren);
-        }
-    }
-    return Handler;
-}