react-native-gesture-handler 2.27.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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"createNativeWrapper.d.ts","sourceRoot":"","sources":["../../../src/handlers/createNativeWrapper.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAG/B,OAAO,EAEL,6BAA6B,EAE9B,MAAM,4BAA4B,CAAC;AAepC,MAAM,CAAC,OAAO,UAAU,mBAAmB,CAAC,CAAC,EAC3C,SAAS,EAAE,KAAK,CAAC,aAAa,CAAC,CAAC,CAAC,EACjC,MAAM,GAAE,QAAQ,CAAC,6BAA6B,CAAM,6IAiErD"}

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

@@ -0,0 +1 @@
+export { customDirectEventTypes } from 'react-native/Libraries/Renderer/shims/ReactNativeViewConfigRegistry';

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

@@ -0,0 +1 @@
+{"version":3,"file":"customDirectEventTypes.d.ts","sourceRoot":"","sources":["../../../src/handlers/customDirectEventTypes.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,sBAAsB,EAAE,MAAM,qEAAqE,CAAC"}

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

@@ -0,0 +1,2 @@
+declare const customDirectEventTypes: {};
+export { customDirectEventTypes };

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

@@ -0,0 +1 @@
+{"version":3,"file":"customDirectEventTypes.web.d.ts","sourceRoot":"","sources":["../../../src/handlers/customDirectEventTypes.web.ts"],"names":[],"mappings":"AAEA,QAAA,MAAM,sBAAsB,IAAK,CAAC;AAElC,OAAO,EAAE,sBAAsB,EAAE,CAAC"}

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

@@ -0,0 +1,78 @@
+import * as React from 'react';
+import { State } from '../State';
+import { TouchEventType } from '../TouchEventType';
+import { ValueOf } from '../typeUtils';
+import { PointerType } from '../PointerType';
+export declare const baseGestureHandlerProps: readonly ["id", "enabled", "shouldCancelWhenOutside", "hitSlop", "cancelsTouchesInView", "userSelect", "activeCursor", "mouseButton", "enableContextMenu", "touchAction", "waitFor", "simultaneousHandlers", "blocksHandlers", "onBegan", "onFailed", "onCancelled", "onActivated", "onEnded", "onGestureEvent", "onHandlerStateChange"];
+export declare const baseGestureHandlerWithDetectorProps: string[];
+export interface GestureEventPayload {
+    handlerTag: number;
+    numberOfPointers: number;
+    state: ValueOf<typeof State>;
+    pointerType: PointerType;
+}
+export interface HandlerStateChangeEventPayload extends GestureEventPayload {
+    oldState: ValueOf<typeof State>;
+}
+export type HitSlop = number | null | undefined | Partial<Record<'left' | 'right' | 'top' | 'bottom' | 'vertical' | 'horizontal', number>> | Record<'width' | 'left', number> | Record<'width' | 'right', number> | Record<'height' | 'top', number> | Record<'height' | 'bottom', number>;
+export type UserSelect = 'none' | 'auto' | 'text';
+export type ActiveCursor = 'auto' | 'default' | 'none' | 'context-menu' | 'help' | 'pointer' | 'progress' | 'wait' | 'cell' | 'crosshair' | 'text' | 'vertical-text' | 'alias' | 'copy' | 'move' | 'no-drop' | 'not-allowed' | 'grab' | 'grabbing' | 'e-resize' | 'n-resize' | 'ne-resize' | 'nw-resize' | 's-resize' | 'se-resize' | 'sw-resize' | 'w-resize' | 'ew-resize' | 'ns-resize' | 'nesw-resize' | 'nwse-resize' | 'col-resize' | 'row-resize' | 'all-scroll' | 'zoom-in' | 'zoom-out';
+export declare enum MouseButton {
+    LEFT = 1,
+    RIGHT = 2,
+    MIDDLE = 4,
+    BUTTON_4 = 8,
+    BUTTON_5 = 16,
+    ALL = 31
+}
+export type TouchAction = 'auto' | 'none' | 'pan-x' | 'pan-left' | 'pan-right' | 'pan-y' | 'pan-up' | 'pan-down' | 'pinch-zoom' | 'manipulation' | 'inherit' | 'initial' | 'revert' | 'revert-layer' | 'unset';
+export interface GestureEvent<ExtraEventPayloadT = Record<string, unknown>> {
+    nativeEvent: Readonly<GestureEventPayload & ExtraEventPayloadT>;
+}
+export interface HandlerStateChangeEvent<ExtraEventPayloadT = Record<string, unknown>> {
+    nativeEvent: Readonly<HandlerStateChangeEventPayload & ExtraEventPayloadT>;
+}
+export type TouchData = {
+    id: number;
+    x: number;
+    y: number;
+    absoluteX: number;
+    absoluteY: number;
+};
+export type GestureTouchEvent = {
+    handlerTag: number;
+    numberOfTouches: number;
+    state: ValueOf<typeof State>;
+    eventType: TouchEventType;
+    allTouches: TouchData[];
+    changedTouches: TouchData[];
+    pointerType: PointerType;
+};
+export type GestureUpdateEvent<GestureEventPayloadT = Record<string, unknown>> = GestureEventPayload & GestureEventPayloadT;
+export type GestureStateChangeEvent<GestureStateChangeEventPayloadT = Record<string, unknown>> = HandlerStateChangeEventPayload & GestureStateChangeEventPayloadT;
+export type CommonGestureConfig = {
+    enabled?: boolean;
+    shouldCancelWhenOutside?: boolean;
+    hitSlop?: HitSlop;
+    userSelect?: UserSelect;
+    activeCursor?: ActiveCursor;
+    mouseButton?: MouseButton;
+    enableContextMenu?: boolean;
+    touchAction?: TouchAction;
+};
+export type BaseGestureHandlerProps<ExtraEventPayloadT extends Record<string, unknown> = Record<string, unknown>> = CommonGestureConfig & {
+    id?: string;
+    waitFor?: React.Ref<unknown> | React.Ref<unknown>[];
+    simultaneousHandlers?: React.Ref<unknown> | React.Ref<unknown>[];
+    blocksHandlers?: React.Ref<unknown> | React.Ref<unknown>[];
+    testID?: string;
+    cancelsTouchesInView?: boolean;
+    onBegan?: (event: HandlerStateChangeEvent) => void;
+    onFailed?: (event: HandlerStateChangeEvent) => void;
+    onCancelled?: (event: HandlerStateChangeEvent) => void;
+    onActivated?: (event: HandlerStateChangeEvent) => void;
+    onEnded?: (event: HandlerStateChangeEvent) => void;
+    onGestureEvent?: (event: GestureEvent<ExtraEventPayloadT>) => void;
+    onHandlerStateChange?: (event: HandlerStateChangeEvent<ExtraEventPayloadT>) => void;
+    children?: React.ReactNode;
+};

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

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

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 = {}));