react-native-gesture-handler 2.26.0 → 2.27.1

package/lib/typescript/handlers/createHandler.js

@@ -0,0 +1,375 @@
+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;
+}

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

@@ -1,4 +1,3 @@
 import * as React from 'react';
 import { NativeViewGestureHandlerProps } from './NativeViewGestureHandler';
 export default function createNativeWrapper<P>(Component: React.ComponentType<P>, config?: Readonly<NativeViewGestureHandlerProps>): React.ForwardRefExoticComponent<React.PropsWithoutRef<P & NativeViewGestureHandlerProps> & React.RefAttributes<React.ComponentType<any>>>;
-//# sourceMappingURL=createNativeWrapper.d.ts.map

package/lib/typescript/handlers/createNativeWrapper.js

@@ -0,0 +1,67 @@
+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.d.ts

@@ -1,2 +1 @@
 export { customDirectEventTypes } from 'react-native/Libraries/Renderer/shims/ReactNativeViewConfigRegistry';
-//# sourceMappingURL=customDirectEventTypes.d.ts.map

package/lib/typescript/handlers/customDirectEventTypes.js

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

package/lib/typescript/handlers/customDirectEventTypes.web.d.ts

@@ -1,3 +1,2 @@
 declare const customDirectEventTypes: {};
 export { customDirectEventTypes };
-//# sourceMappingURL=customDirectEventTypes.web.d.ts.map

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

@@ -0,0 +1,4 @@
+// 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.d.ts

@@ -76,4 +76,3 @@ export type BaseGestureHandlerProps<ExtraEventPayloadT extends Record<string, un
     onHandlerStateChange?: (event: HandlerStateChangeEvent<ExtraEventPayloadT>) => void;
     children?: React.ReactNode;
 };
-//# sourceMappingURL=gestureHandlerCommon.d.ts.map

package/lib/typescript/handlers/gestureHandlerCommon.js

@@ -0,0 +1,42 @@
+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.d.ts

@@ -17,7 +17,13 @@ export type NativeViewGestureHandlerGestureEvent = GestureEvent<NativeViewGestur
 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>;
@@ -36,9 +42,11 @@ 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;
-//# sourceMappingURL=gestureHandlerTypesCompat.d.ts.map

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

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

@@ -11,4 +11,3 @@ export declare const AnimatedWrap: typeof Wrap | React.ComponentClass<{
     onGestureHandlerEvent?: unknown;
     children?: React.ReactNode;
 }, any>;
-//# sourceMappingURL=Wrap.d.ts.map

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

@@ -5,4 +5,3 @@ export declare const Wrap: React.ForwardRefExoticComponent<{
 export declare const AnimatedWrap: React.ForwardRefExoticComponent<{
     children?: React.ReactNode | undefined;
 } & React.RefAttributes<HTMLDivElement>>;
-//# sourceMappingURL=Wrap.web.d.ts.map

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

@@ -11,4 +11,3 @@ interface AttachHandlersConfig {
 }
 export declare function attachHandlers({ preparedGesture, gestureConfig, gesturesToAttach, viewTag, webEventHandlersRef, }: AttachHandlersConfig): void;
 export {};
-//# sourceMappingURL=attachHandlers.d.ts.map