react-native-gesture-handler 1.10.0 → 2.0.0

package/dist/src/components/touchables/TouchableNativeFeedback.android.js

@@ -1,62 +0,0 @@
-import { Platform, } from 'react-native';
-import React, { Component } from 'react';
-import GenericTouchable from './GenericTouchable';
-/**
- * TouchableNativeFeedback behaves slightly different than RN's TouchableNativeFeedback.
- * There's small difference with handling long press ripple since RN's implementation calls
- * ripple animation via bridge. This solution leaves all animations' handling for native components so
- * it follows native behaviours.
- */
-export default class TouchableNativeFeedback extends Component {
-    getExtraButtonProps() {
-        const extraProps = {};
-        const { background } = this.props;
-        if (background) {
-            // I changed type values to match those used in RN
-            // TODO(TS): check if it works the same as previous implementation - looks like it works the same as RN component, so it should be ok
-            if (background.type === 'RippleAndroid') {
-                extraProps['borderless'] = background.borderless;
-                extraProps['rippleColor'] = background.color;
-            }
-            else if (background.type === 'ThemeAttrAndroid') {
-                extraProps['borderless'] =
-                    background.attribute === 'selectableItemBackgroundBorderless';
-            }
-            // I moved it from above since it should be available in all options
-            extraProps['rippleRadius'] = background.rippleRadius;
-        }
-        extraProps['foreground'] = this.props.useForeground;
-        return extraProps;
-    }
-    render() {
-        const { style = {}, ...rest } = this.props;
-        return (<GenericTouchable {...rest} style={style} extraButtonProps={this.getExtraButtonProps()}/>);
-    }
-}
-TouchableNativeFeedback.defaultProps = {
-    ...GenericTouchable.defaultProps,
-    useForeground: true,
-    extraButtonProps: {
-        // Disable hiding ripple on Android
-        rippleColor: null,
-    },
-};
-// could be taken as RNTouchableNativeFeedback.SelectableBackground etc. but the API may change
-TouchableNativeFeedback.SelectableBackground = (rippleRadius) => ({
-    type: 'ThemeAttrAndroid',
-    // I added `attribute` prop to clone the implementation of RN and be able to use only 2 types
-    attribute: 'selectableItemBackground',
-    rippleRadius,
-});
-TouchableNativeFeedback.SelectableBackgroundBorderless = (rippleRadius) => ({
-    type: 'ThemeAttrAndroid',
-    attribute: 'selectableItemBackgroundBorderless',
-    rippleRadius,
-});
-TouchableNativeFeedback.Ripple = (color, borderless, rippleRadius) => ({
-    type: 'RippleAndroid',
-    color,
-    borderless,
-    rippleRadius,
-});
-TouchableNativeFeedback.canUseNativeForeground = () => Platform.Version >= 23;

package/dist/src/components/touchables/TouchableOpacity.js

@@ -1,49 +0,0 @@
-import { Animated, Easing, StyleSheet, View, } from 'react-native';
-import GenericTouchable, { TOUCHABLE_STATE, } from './GenericTouchable';
-import React, { Component } from 'react';
-/**
- * TouchableOpacity bases on timing animation which has been used in RN's core
- */
-export default class TouchableOpacity extends Component {
-    constructor() {
-        super(...arguments);
-        // opacity is 1 one by default but could be overwritten
-        this.getChildStyleOpacityWithDefault = () => {
-            const childStyle = StyleSheet.flatten(this.props.style) || {};
-            return childStyle.opacity == null ? 1 : childStyle.opacity;
-        };
-        this.opacity = new Animated.Value(this.getChildStyleOpacityWithDefault());
-        this.setOpacityTo = (value, duration) => {
-            Animated.timing(this.opacity, {
-                toValue: value,
-                duration: duration,
-                easing: Easing.inOut(Easing.quad),
-                useNativeDriver: true,
-            }).start();
-        };
-        this.onStateChange = (_from, to) => {
-            if (to === TOUCHABLE_STATE.BEGAN) {
-                this.setOpacityTo(this.props.activeOpacity, 0);
-            }
-            else if (to === TOUCHABLE_STATE.UNDETERMINED ||
-                to === TOUCHABLE_STATE.MOVED_OUTSIDE) {
-                this.setOpacityTo(this.getChildStyleOpacityWithDefault(), 150);
-            }
-        };
-    }
-    render() {
-        const { style = {}, ...rest } = this.props;
-        return (<GenericTouchable {...rest} style={[
-            style,
-            {
-                opacity: this.opacity,
-            },
-        ]} onStateChange={this.onStateChange}>
-        {this.props.children ? this.props.children : <View />}
-      </GenericTouchable>);
-    }
-}
-TouchableOpacity.defaultProps = {
-    ...GenericTouchable.defaultProps,
-    activeOpacity: 0.2,
-};

package/dist/src/components/touchables/TouchableWithoutFeedback.js

@@ -1,5 +0,0 @@
-import React from 'react';
-import GenericTouchable from './GenericTouchable';
-const TouchableWithoutFeedback = React.forwardRef((props, ref) => <GenericTouchable ref={ref} {...props}/>);
-TouchableWithoutFeedback.defaultProps = GenericTouchable.defaultProps;
-export default TouchableWithoutFeedback;

package/dist/src/gestureHandlerRootHOC.d.ts

@@ -1,3 +0,0 @@
-import React from 'react';
-import { StyleProp, ViewStyle } from 'react-native';
-export default function gestureHandlerRootHOC(Component: React.ComponentType<Record<string, unknown>>, containerStyles?: StyleProp<ViewStyle>): React.ComponentType<Record<string, unknown>>;

package/dist/src/gestureHandlerRootHOC.js

@@ -1,17 +0,0 @@
-import React from 'react';
-import { StyleSheet } from 'react-native';
-import hoistNonReactStatics from 'hoist-non-react-statics';
-import GestureHandlerRootView from './GestureHandlerRootView';
-export default function gestureHandlerRootHOC(Component, containerStyles) {
-    function Wrapper(props) {
-        return (<GestureHandlerRootView style={[styles.container, containerStyles]}>
-        <Component {...props}/>
-      </GestureHandlerRootView>);
-    }
-    Wrapper.displayName = `gestureHandlerRootHOC(${Component.displayName || Component.name})`;
-    hoistNonReactStatics(Wrapper, Component);
-    return Wrapper;
-}
-const styles = StyleSheet.create({
-    container: { flex: 1 },
-});

package/dist/src/handlers/NativeViewGestureHandler.d.ts

@@ -1,12 +0,0 @@
-/// <reference types="react" />
-import { BaseGestureHandlerProps } from './gestureHandlers';
-export interface NativeViewGestureHandlerProps extends BaseGestureHandlerProps<NativeViewGestureHandlerPayload> {
-    shouldActivateOnStart?: boolean;
-    disallowInterruption?: boolean;
-}
-export declare type NativeViewGestureHandlerPayload = {
-    pointerInside: boolean;
-};
-export declare const nativeViewProps: readonly ["id", "enabled", "minPointers", "waitFor", "simultaneousHandlers", "shouldCancelWhenOutside", "hitSlop", "onBegan", "onFailed", "onCancelled", "onActivated", "onEnded", "onGestureEvent", "onHandlerStateChange", "shouldActivateOnStart", "disallowInterruption"];
-export declare type NativeViewGestureHandler = typeof NativeViewGestureHandler;
-export declare const NativeViewGestureHandler: import("react").ComponentType<NativeViewGestureHandlerProps & import("react").RefAttributes<any>>;

package/dist/src/handlers/NativeViewGestureHandler.js

@@ -1,13 +0,0 @@
-import createHandler from './createHandler';
-import { baseProps } from './gestureHandlers';
-export const nativeViewProps = [
-    ...baseProps,
-    'shouldActivateOnStart',
-    'disallowInterruption',
-];
-// eslint-disable-next-line @typescript-eslint/no-redeclare -- backward compatibility; see description on the top of gestureHandlers.ts file
-export const NativeViewGestureHandler = createHandler({
-    name: 'NativeViewGestureHandler',
-    allowedProps: nativeViewProps,
-    config: {},
-});

package/dist/src/handlers/createHandler.js

@@ -1,292 +0,0 @@
-import React from 'react';
-import { findNodeHandle as findNodeHandleRN, NativeModules, Platform, Touchable, } from 'react-native';
-// @ts-ignore - it isn't typed by TS & don't have definitelyTyped types
-import deepEqual from 'fbjs/lib/areEqual';
-import RNGestureHandlerModule from '../RNGestureHandlerModule';
-import { State } from '../State';
-function findNodeHandle(node) {
-    if (Platform.OS === 'web')
-        return node;
-    return findNodeHandleRN(node);
-}
-const { UIManager = {} } = NativeModules;
-const customGHEventsConfig = {
-    onGestureHandlerEvent: { registrationName: 'onGestureHandlerEvent' },
-    onGestureHandlerStateChange: {
-        registrationName: 'onGestureHandlerStateChange',
-    },
-};
-// 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.
-UIManager.genericDirectEventTypes = {
-    ...UIManager.genericDirectEventTypes,
-    ...customGHEventsConfig,
-};
-// In newer versions of RN the `genericDirectEventTypes` is located in the object
-// returned by UIManager.getConstants(), we need to add it there as well to make
-// it compatible with RN 61+
-if (UIManager.getConstants) {
-    UIManager.getConstants().genericDirectEventTypes = {
-        ...UIManager.getConstants().genericDirectEventTypes,
-        ...customGHEventsConfig,
-    };
-}
-// Wrap JS responder calls and notify gesture handler manager
-const { setJSResponder: oldSetJSResponder = () => {
-    //no operation
-}, clearJSResponder: oldClearJSResponder = () => {
-    //no operation
-}, } = UIManager;
-UIManager.setJSResponder = (tag, blockNativeResponder) => {
-    RNGestureHandlerModule.handleSetJSResponder(tag, blockNativeResponder);
-    oldSetJSResponder(tag, blockNativeResponder);
-};
-UIManager.clearJSResponder = () => {
-    RNGestureHandlerModule.handleClearJSResponder();
-    oldClearJSResponder();
-};
-let handlerTag = 1;
-const handlerIDToTag = {};
-function isConfigParam(param, name) {
-    // param !== Object(param) returns false if `param` is a function
-    // or an object and returns true if `param` is null
-    return (param !== undefined &&
-        (param !== Object(param) ||
-            !('__isNative' in param)) &&
-        name !== 'onHandlerStateChange' &&
-        name !== 'onGestureEvent');
-}
-function filterConfig(props, validProps, defaults = {}) {
-    const res = { ...defaults };
-    validProps.forEach((key) => {
-        const value = props[key];
-        if (isConfigParam(value, key)) {
-            let value = props[key];
-            if (key === 'simultaneousHandlers' || key === 'waitFor') {
-                value = transformIntoHandlerTags(props[key]);
-            }
-            else if (key === 'hitSlop') {
-                if (typeof value !== 'object') {
-                    value = { top: value, left: value, bottom: value, right: value };
-                }
-            }
-            res[key] = value;
-        }
-    });
-    return res;
-}
-function transformIntoHandlerTags(handlerIDs) {
-    if (!Array.isArray(handlerIDs)) {
-        handlerIDs = [handlerIDs];
-    }
-    if (Platform.OS === 'web') {
-        return handlerIDs
-            .map(({ current }) => current)
-            .filter((handle) => handle);
-    }
-    // converts handler string IDs into their numeric tags
-    return handlerIDs
-        .map((handlerID) => handlerIDToTag[handlerID] || handlerID.current?._handlerTag || -1)
-        .filter((handlerTag) => handlerTag > 0);
-}
-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',
-};
-// 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 {
-        constructor(props) {
-            super(props);
-            this.updateEnqueued = null;
-            this.onGestureHandlerEvent = (event) => {
-                if (event.nativeEvent.handlerTag === this.handlerTag) {
-                    this.props.onGestureEvent?.(event);
-                }
-                else {
-                    this.props.onGestureHandlerEvent?.(event);
-                }
-            };
-            // TODO(TS) - make sure this is right type for event
-            this.onGestureHandlerStateChange = (event) => {
-                if (event.nativeEvent.handlerTag === this.handlerTag) {
-                    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);
-                }
-            };
-            this.refHandler = (node) => {
-                this.viewNode = node;
-                const child = React.Children.only(this.props.children);
-                // TODO(TS) fix ref type
-                const { ref } = child;
-                if (ref !== null) {
-                    if (typeof ref === 'function') {
-                        ref(node);
-                    }
-                    else {
-                        ref.current = node;
-                    }
-                }
-            };
-            this.createGestureHandler = (newConfig) => {
-                this.config = newConfig;
-                RNGestureHandlerModule.createGestureHandler(name, this.handlerTag, newConfig);
-            };
-            this.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, this.propsRef);
-                }
-                else {
-                    RNGestureHandlerModule.attachGestureHandler(this.handlerTag, newViewTag);
-                }
-            };
-            this.updateGestureHandler = (newConfig) => {
-                this.config = newConfig;
-                RNGestureHandlerModule.updateGestureHandler(this.handlerTag, newConfig);
-            };
-            this.handlerTag = handlerTag++;
-            this.config = {};
-            this.propsRef = React.createRef();
-            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;
-            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
-                // setImmediate. 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.
-                this.updateEnqueued = setImmediate(() => {
-                    this.updateEnqueued = null;
-                    this.update();
-                });
-            }
-            this.createGestureHandler(filterConfig(transformProps ? transformProps(this.props) : this.props, [...allowedProps, ...customNativeProps], config));
-            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();
-        }
-        componentWillUnmount() {
-            RNGestureHandlerModule.dropGestureHandler(this.handlerTag);
-            if (this.updateEnqueued) {
-                clearImmediate(this.updateEnqueued);
-            }
-            // 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];
-            }
-        }
-        update() {
-            const newConfig = filterConfig(transformProps ? transformProps(this.props) : this.props, [...allowedProps, ...customNativeProps], config);
-            if (!deepEqual(this.config, newConfig)) {
-                this.updateGestureHandler(newConfig);
-            }
-        }
-        setNativeProps(updates) {
-            const mergedProps = { ...this.props, ...updates };
-            const newConfig = filterConfig(transformProps ? transformProps(mergedProps) : mergedProps, [...allowedProps, ...customNativeProps], config);
-            this.updateGestureHandler(newConfig);
-        }
-        render() {
-            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: gestureEventHandler,
-                onGestureHandlerStateChange: gestureStateEventHandler,
-            };
-            this.propsRef.current = events;
-            const child = React.Children.only(this.props.children);
-            let grandChildren = child.props.children;
-            if (Touchable.TOUCH_TARGET_DEBUG &&
-                child.type &&
-                (child.type === 'RNGestureHandlerButton' ||
-                    child.type.name === 'View' ||
-                    child.type.displayName === 'View')) {
-                grandChildren = React.Children.toArray(grandChildren);
-                grandChildren.push(Touchable.renderDebugView({
-                    color: 'mediumspringgreen',
-                    hitSlop: child.props.hitSlop,
-                }));
-            }
-            return React.cloneElement(child, {
-                ref: this.refHandler,
-                collapsable: false,
-                ...events,
-            }, grandChildren);
-        }
-    }
-    Handler.displayName = name;
-    return Handler;
-}

package/dist/src/handlers/createNativeWrapper.js

@@ -1,50 +0,0 @@
-import React, { 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 = 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[key] = props[key];
-            }
-            return res;
-        }, { ...config } // watch out not to modify config
-        );
-        const _ref = useRef();
-        const _gestureHandlerRef = useRef();
-        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 {...props} ref={_ref}/>
-      </NativeViewGestureHandler>);
-    });
-    ComponentWrapper.displayName = Component.displayName || 'ComponentWrapper';
-    return ComponentWrapper;
-}

package/dist/src/handlers/gestureHandlerTypesCompat.js

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

package/dist/src/handlers/gestureHandlers.d.ts

@@ -1,158 +0,0 @@
-import React from 'react';
-import { State } from '../State';
-import { ValueOf } from '../typeUtils';
-export interface GestureEventPayload {
-    handlerTag: number;
-    numberOfPointers: number;
-    state: ValueOf<typeof State>;
-}
-export interface HandlerStateChangeEventPayload {
-    handlerTag: number;
-    numberOfPointers: number;
-    state: ValueOf<typeof State>;
-    oldState: ValueOf<typeof State>;
-}
-export interface GestureEvent<ExtraEventPayloadT = Record<string, unknown>> {
-    nativeEvent: Readonly<GestureEventPayload & ExtraEventPayloadT>;
-}
-export interface HandlerStateChangeEvent<ExtraEventPayloadT = Record<string, unknown>> {
-    nativeEvent: Readonly<HandlerStateChangeEventPayload & ExtraEventPayloadT>;
-}
-export declare type BaseGestureHandlerProps<ExtraEventPayloadT extends Record<string, unknown> = Record<string, unknown>> = {
-    id?: string;
-    enabled?: boolean;
-    minPointers?: number;
-    waitFor?: React.Ref<unknown> | React.Ref<unknown>[];
-    simultaneousHandlers?: React.Ref<unknown> | React.Ref<unknown>[];
-    shouldCancelWhenOutside?: boolean;
-    hitSlop?: number | 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>;
-    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;
-};
-export declare const baseProps: readonly ["id", "enabled", "minPointers", "waitFor", "simultaneousHandlers", "shouldCancelWhenOutside", "hitSlop", "onBegan", "onFailed", "onCancelled", "onActivated", "onEnded", "onGestureEvent", "onHandlerStateChange"];
-export declare type TapGestureHandlerEventPayload = {
-    x: number;
-    y: number;
-    absoluteX: number;
-    absoluteY: number;
-};
-export interface TapGestureHandlerProps extends BaseGestureHandlerProps<TapGestureHandlerEventPayload> {
-    minPointers?: number;
-    maxDurationMs?: number;
-    maxDelayMs?: number;
-    numberOfTaps?: number;
-    maxDeltaX?: number;
-    maxDeltaY?: number;
-    maxDist?: number;
-}
-export declare type TapGestureHandler = typeof TapGestureHandler;
-export declare const TapGestureHandler: React.ComponentType<TapGestureHandlerProps & React.RefAttributes<any>>;
-export declare type FlingGestureHandlerEventPayload = {
-    x: number;
-    y: number;
-    absoluteX: number;
-    absoluteY: number;
-};
-export interface FlingGestureHandlerProps extends BaseGestureHandlerProps<FlingGestureHandlerEventPayload> {
-    direction?: number;
-    numberOfPointers?: number;
-}
-export declare type FlingGestureHandler = typeof FlingGestureHandler;
-export declare const FlingGestureHandler: React.ComponentType<FlingGestureHandlerProps & React.RefAttributes<any>>;
-declare class ForceTouchFallback extends React.Component {
-    static forceTouchAvailable: boolean;
-    componentDidMount(): void;
-    render(): React.ReactNode;
-}
-export declare type ForceTouchGestureHandlerEventPayload = {
-    x: number;
-    y: number;
-    absoluteX: number;
-    absoluteY: number;
-    force: number;
-};
-export interface ForceTouchGestureHandlerProps extends BaseGestureHandlerProps<ForceTouchGestureHandlerEventPayload> {
-    minForce?: number;
-    maxForce?: number;
-    feedbackOnActivation?: boolean;
-}
-export declare type ForceTouchGestureHandler = typeof ForceTouchGestureHandler & {
-    forceTouchAvailable: boolean;
-};
-export declare const ForceTouchGestureHandler: typeof ForceTouchFallback | React.ComponentClass<ForceTouchGestureHandlerProps & React.RefAttributes<any>, any> | React.FunctionComponent<ForceTouchGestureHandlerProps & React.RefAttributes<any>>;
-export declare type LongPressGestureHandlerEventPayload = {
-    x: number;
-    y: number;
-    absoluteX: number;
-    absoluteY: number;
-};
-export interface LongPressGestureHandlerProps extends BaseGestureHandlerProps<LongPressGestureHandlerEventPayload> {
-    minDurationMs?: number;
-    maxDist?: number;
-}
-export declare type LongPressGestureHandler = typeof LongPressGestureHandler;
-export declare const LongPressGestureHandler: React.ComponentType<LongPressGestureHandlerProps & React.RefAttributes<any>>;
-export declare type PanGestureHandlerEventPayload = {
-    x: number;
-    y: number;
-    absoluteX: number;
-    absoluteY: number;
-    translationX: number;
-    translationY: number;
-    velocityX: number;
-    velocityY: number;
-};
-export interface PanGestureHandlerProps extends BaseGestureHandlerProps<PanGestureHandlerEventPayload> {
-    /** @deprecated  use activeOffsetX*/
-    minDeltaX?: number;
-    /** @deprecated  use activeOffsetY*/
-    minDeltaY?: number;
-    /** @deprecated  use failOffsetX*/
-    maxDeltaX?: number;
-    /** @deprecated  use failOffsetY*/
-    maxDeltaY?: number;
-    /** @deprecated  use activeOffsetX*/
-    minOffsetX?: number;
-    /** @deprecated  use failOffsetY*/
-    minOffsetY?: number;
-    activeOffsetY?: number | number[];
-    activeOffsetX?: number | number[];
-    failOffsetY?: number | number[];
-    failOffsetX?: number | number[];
-    minDist?: number;
-    minVelocity?: number;
-    minVelocityX?: number;
-    minVelocityY?: number;
-    minPointers?: number;
-    maxPointers?: number;
-    avgTouches?: boolean;
-    enableTrackpadTwoFingerGesture?: boolean;
-}
-export declare type PanGestureHandler = typeof PanGestureHandler;
-export declare const PanGestureHandler: React.ComponentType<PanGestureHandlerProps & React.RefAttributes<any>>;
-export declare type PinchGestureHandlerEventPayload = {
-    scale: number;
-    focalX: number;
-    focalY: number;
-    velocity: number;
-};
-export interface PinchGestureHandlerProps extends BaseGestureHandlerProps<PinchGestureHandlerEventPayload> {
-}
-export declare type PinchGestureHandler = typeof PinchGestureHandler;
-export declare const PinchGestureHandler: React.ComponentType<PinchGestureHandlerProps & React.RefAttributes<any>>;
-export declare type RotationGestureHandlerEventPayload = {
-    rotation: number;
-    anchorX: number;
-    anchorY: number;
-    velocity: number;
-};
-export interface RotationGestureHandlerProps extends BaseGestureHandlerProps<RotationGestureHandlerEventPayload> {
-}
-export declare type RotationGestureHandler = typeof RotationGestureHandler;
-export declare const RotationGestureHandler: React.ComponentType<RotationGestureHandlerProps & React.RefAttributes<any>>;
-export {};