react-native-gesture-handler 1.10.0 → 2.0.0

package/lib/typescript/components/Swipeable.d.ts

@@ -0,0 +1,150 @@
+import * as React from 'react';
+import { Component } from 'react';
+import { Animated, StyleProp, ViewStyle } from 'react-native';
+import { PanGestureHandlerProps } from '../handlers/PanGestureHandler';
+declare type SwipeableExcludes = Exclude<keyof PanGestureHandlerProps, 'onGestureEvent' | 'onHandlerStateChange'>;
+export interface SwipeableProps extends Pick<PanGestureHandlerProps, SwipeableExcludes> {
+    /**
+     * Enables two-finger gestures on supported devices, for example iPads with
+     * trackpads. If not enabled the gesture will require click + drag, with
+     * `enableTrackpadTwoFingerGesture` swiping with two fingers will also trigger
+     * the gesture.
+     */
+    enableTrackpadTwoFingerGesture?: boolean;
+    /**
+     * Specifies how much the visual interaction will be delayed compared to the
+     * gesture distance. e.g. value of 1 will indicate that the swipeable panel
+     * should exactly follow the gesture, 2 means it is going to be two times
+     * "slower".
+     */
+    friction?: number;
+    /**
+     * Distance from the left edge at which released panel will animate to the
+     * open state (or the open panel will animate into the closed state). By
+     * default it's a half of the panel's width.
+     */
+    leftThreshold?: number;
+    /**
+     * Distance from the right edge at which released panel will animate to the
+     * open state (or the open panel will animate into the closed state). By
+     * default it's a half of the panel's width.
+     */
+    rightThreshold?: number;
+    /**
+     * Value indicating if the swipeable panel can be pulled further than the left
+     * actions panel's width. It is set to true by default as long as the left
+     * panel render method is present.
+     */
+    overshootLeft?: boolean;
+    /**
+     * Value indicating if the swipeable panel can be pulled further than the
+     * right actions panel's width. It is set to true by default as long as the
+     * right panel render method is present.
+     */
+    overshootRight?: boolean;
+    /**
+     * Specifies how much the visual interaction will be delayed compared to the
+     * gesture distance at overshoot. Default value is 1, it mean no friction, for
+     * a native feel, try 8 or above.
+     */
+    overshootFriction?: number;
+    /**
+     * Called when left action panel gets open.
+     */
+    onSwipeableLeftOpen?: () => void;
+    /**
+     * Called when right action panel gets open.
+     */
+    onSwipeableRightOpen?: () => void;
+    /**
+     * Called when action panel gets open (either right or left).
+     */
+    onSwipeableOpen?: () => void;
+    /**
+     * Called when action panel is closed.
+     */
+    onSwipeableClose?: () => void;
+    /**
+     * Called when left action panel starts animating on open.
+     */
+    onSwipeableLeftWillOpen?: () => void;
+    /**
+     * Called when right action panel starts animating on open.
+     */
+    onSwipeableRightWillOpen?: () => void;
+    /**
+     * Called when action panel starts animating on open (either right or left).
+     */
+    onSwipeableWillOpen?: () => void;
+    /**
+     * Called when action panel starts animating on close.
+     */
+    onSwipeableWillClose?: () => void;
+    /**
+     *
+     * This map describes the values to use as inputRange for extra interpolation:
+     * AnimatedValue: [startValue, endValue]
+     *
+     * progressAnimatedValue: [0, 1] dragAnimatedValue: [0, +]
+     *
+     * To support `rtl` flexbox layouts use `flexDirection` styling.
+     * */
+    renderLeftActions?: (progressAnimatedValue: Animated.AnimatedInterpolation, dragAnimatedValue: Animated.AnimatedInterpolation) => React.ReactNode;
+    /**
+     *
+     * This map describes the values to use as inputRange for extra interpolation:
+     * AnimatedValue: [startValue, endValue]
+     *
+     * progressAnimatedValue: [0, 1] dragAnimatedValue: [0, -]
+     *
+     * To support `rtl` flexbox layouts use `flexDirection` styling.
+     * */
+    renderRightActions?: (progressAnimatedValue: Animated.AnimatedInterpolation, dragAnimatedValue: Animated.AnimatedInterpolation) => React.ReactNode;
+    useNativeAnimations?: boolean;
+    animationOptions?: Record<string, unknown>;
+    /**
+     * Style object for the container (`Animated.View`), for example to override
+     * `overflow: 'hidden'`.
+     */
+    containerStyle?: StyleProp<ViewStyle>;
+    /**
+     * Style object for the children container (`Animated.View`), for example to
+     * apply `flex: 1`
+     */
+    childrenContainerStyle?: StyleProp<ViewStyle>;
+}
+declare type SwipeableState = {
+    dragX: Animated.Value;
+    rowTranslation: Animated.Value;
+    rowState: number;
+    leftWidth?: number;
+    rightOffset?: number;
+    rowWidth?: number;
+};
+export default class Swipeable extends Component<SwipeableProps, SwipeableState> {
+    static defaultProps: {
+        friction: number;
+        overshootFriction: number;
+        useNativeAnimations: boolean;
+    };
+    constructor(props: SwipeableProps);
+    UNSAFE_componentWillUpdate(props: SwipeableProps, state: SwipeableState): void;
+    private onGestureEvent?;
+    private transX?;
+    private showLeftAction?;
+    private leftActionTranslate?;
+    private showRightAction?;
+    private rightActionTranslate?;
+    private updateAnimatedEvent;
+    private onTapHandlerStateChange;
+    private onHandlerStateChange;
+    private handleRelease;
+    private animateRow;
+    private onRowLayout;
+    private currentOffset;
+    close: () => void;
+    openLeft: () => void;
+    openRight: () => void;
+    render(): JSX.Element;
+}
+export {};

package/{dist/src → lib/typescript}/components/touchables/GenericTouchable.d.ts

@@ -1,7 +1,6 @@
-/// <reference types="node" />
 import { Component } from 'react';
 import { StyleProp, ViewStyle, TouchableWithoutFeedbackProps } from 'react-native';
-import { GestureEvent, HandlerStateChangeEvent } from '../../handlers/gestureHandlers';
+import { GestureEvent, HandlerStateChangeEvent } from '../../handlers/gestureHandlerCommon';
 import { NativeViewGestureHandlerPayload } from '../../handlers/NativeViewGestureHandler';
 import { TouchableNativeFeedbackExtraProps } from './TouchableNativeFeedback.android';
 /**
@@ -31,7 +30,7 @@ interface InternalProps {
     extraButtonProps: TouchableNativeFeedbackExtraProps;
     onStateChange?: (oldState: TouchableState, newState: TouchableState) => void;
 }
-declare type Timeout = null | NodeJS.Timeout | undefined;
+declare type Timeout = ReturnType<typeof setTimeout> | null | undefined;
 /**
  * GenericTouchable is not intented to be used as it is.
  * Should be treated as a source for the rest of touchables
@@ -41,6 +40,7 @@ export default class GenericTouchable extends Component<GenericTouchableProps &
         delayLongPress: number;
         extraButtonProps: {
             rippleColor: string;
+            exclusive: boolean;
         };
     };
     pressInTimeout: Timeout;

package/{dist/src → lib/typescript}/components/touchables/TouchableHighlight.d.ts

@@ -20,6 +20,7 @@ export default class TouchableHighlight extends Component<TouchableHighlightProp
         delayLongPress: number;
         extraButtonProps: {
             rippleColor: string;
+            exclusive: boolean;
         };
     };
     constructor(props: TouchableHighlightProps & GenericTouchableProps);

package/{dist/src → lib/typescript}/components/touchables/TouchableOpacity.d.ts

@@ -10,6 +10,7 @@ export default class TouchableOpacity extends Component<TouchableOpacityProps &
         delayLongPress: number;
         extraButtonProps: {
             rippleColor: string;
+            exclusive: boolean;
         };
     };
     getChildStyleOpacityWithDefault: () => number;

package/{dist/src → lib/typescript}/components/touchables/TouchableWithoutFeedback.d.ts

@@ -1,4 +1,6 @@
-import React from 'react';
+import * as React from 'react';
 import GenericTouchable, { GenericTouchableProps } from './GenericTouchable';
-declare const TouchableWithoutFeedback: React.ForwardRefExoticComponent<GenericTouchableProps & React.RefAttributes<GenericTouchable>>;
+declare const TouchableWithoutFeedback: React.ForwardRefExoticComponent<GenericTouchableProps & {
+    children?: React.ReactNode;
+} & React.RefAttributes<GenericTouchable>>;
 export default TouchableWithoutFeedback;

package/lib/typescript/gestureHandlerRootHOC.d.ts

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

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

@@ -0,0 +1,33 @@
+import { BaseGestureHandlerProps } from './gestureHandlerCommon';
+export declare const flingGestureHandlerProps: readonly ["numberOfPointers", "direction"];
+export declare type FlingGestureHandlerEventPayload = {
+    x: number;
+    y: number;
+    absoluteX: number;
+    absoluteY: number;
+};
+export interface FlingGestureConfig {
+    /**
+     * Expressed allowed direction of movement. It's possible to pass one or many
+     * directions in one parameter:
+     *
+     * ```js
+     * direction={Directions.RIGHT | Directions.LEFT}
+     * ```
+     *
+     * or
+     *
+     * ```js
+     * direction={Directions.DOWN}
+     * ```
+     */
+    direction?: number;
+    /**
+     * Determine exact number of points required to handle the fling gesture.
+     */
+    numberOfPointers?: number;
+}
+export interface FlingGestureHandlerProps extends BaseGestureHandlerProps<FlingGestureHandlerEventPayload>, FlingGestureConfig {
+}
+export declare type FlingGestureHandler = typeof FlingGestureHandler;
+export declare const FlingGestureHandler: import("react").ComponentType<FlingGestureHandlerProps & import("react").RefAttributes<any>>;

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

@@ -0,0 +1,43 @@
+import React from 'react';
+import { BaseGestureHandlerProps } from './gestureHandlerCommon';
+export declare const forceTouchGestureHandlerProps: readonly ["minForce", "maxForce", "feedbackOnActivation"];
+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;
+    /**
+     * The pressure of a touch.
+     */
+    force: number;
+};
+export interface ForceTouchGestureConfig {
+    /**
+     *
+     * A minimal pressure that is required before handler can activate. Should be a
+     * value from range `[0.0, 1.0]`. Default is `0.2`.
+     */
+    minForce?: number;
+    /**
+     * A maximal pressure that could be applied for handler. If the pressure is
+     * greater, handler fails. Should be a value from range `[0.0, 1.0]`.
+     */
+    maxForce?: number;
+    /**
+     * Boolean value defining if haptic feedback has to be performed on
+     * activation.
+     */
+    feedbackOnActivation?: boolean;
+}
+export interface ForceTouchGestureHandlerProps extends BaseGestureHandlerProps<ForceTouchGestureHandlerEventPayload>, ForceTouchGestureConfig {
+}
+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 {};

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

@@ -0,0 +1,55 @@
+import { BaseGestureHandlerProps } from './gestureHandlerCommon';
+export declare const longPressGestureHandlerProps: readonly ["minDurationMs", "maxDist"];
+export declare type LongPressGestureHandlerEventPayload = {
+    /**
+     * X coordinate, expressed in points, of the current position of the pointer
+     * (finger or a leading pointer when there are multiple fingers placed)
+     * relative to the view attached to the handler.
+     */
+    x: number;
+    /**
+     * Y coordinate, expressed in points, of the current position of the pointer
+     * (finger or a leading pointer when there are multiple fingers placed)
+     * relative to the view attached to the handler.
+     */
+    y: number;
+    /**
+     * X coordinate, expressed in points, of the current position of the pointer
+     * (finger or a leading pointer when there are multiple fingers placed)
+     * relative to the root view. It is recommended to use `absoluteX` instead of
+     * `x` in cases when the view attached to the handler can be transformed as an
+     * effect of the gesture.
+     */
+    absoluteX: number;
+    /**
+     * Y coordinate, expressed in points, of the current position of the pointer
+     * (finger or a leading pointer when there are multiple fingers placed)
+     * relative to the root view. It is recommended to use `absoluteY` instead of
+     * `y` in cases when the view attached to the handler can be transformed as an
+     * effect of the gesture.
+     */
+    absoluteY: number;
+    /**
+     * Duration of the long press (time since the start of the event), expressed
+     * in milliseconds.
+     */
+    duration: number;
+};
+export interface LongPressGestureConfig {
+    /**
+     * Minimum time, expressed in milliseconds, that a finger must remain pressed on
+     * the corresponding view. The default value is 500.
+     */
+    minDurationMs?: number;
+    /**
+     * Maximum distance, expressed in points, that defines how far the finger is
+     * allowed to travel during a long press gesture. If the finger travels
+     * further than the defined distance and the handler hasn't yet activated, it
+     * will fail to recognize the gesture. The default value is 10.
+     */
+    maxDist?: number;
+}
+export interface LongPressGestureHandlerProps extends BaseGestureHandlerProps<LongPressGestureHandlerEventPayload>, LongPressGestureConfig {
+}
+export declare type LongPressGestureHandler = typeof LongPressGestureHandler;
+export declare const LongPressGestureHandler: import("react").ComponentType<LongPressGestureHandlerProps & import("react").RefAttributes<any>>;

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

@@ -0,0 +1,27 @@
+import { BaseGestureHandlerProps } from './gestureHandlerCommon';
+export declare const nativeViewGestureHandlerProps: readonly ["shouldActivateOnStart", "disallowInterruption"];
+export interface NativeViewGestureConfig {
+    /**
+     * Android only.
+     *
+     * Determines whether the handler should check for an existing touch event on
+     * instantiation.
+     */
+    shouldActivateOnStart?: boolean;
+    /**
+     * When `true`, cancels all other gesture handlers when this
+     * `NativeViewGestureHandler` receives an `ACTIVE` state event.
+     */
+    disallowInterruption?: boolean;
+}
+export interface NativeViewGestureHandlerProps extends BaseGestureHandlerProps<NativeViewGestureHandlerPayload>, NativeViewGestureConfig {
+}
+export declare type NativeViewGestureHandlerPayload = {
+    /**
+     * True if gesture was performed inside of containing view, false otherwise.
+     */
+    pointerInside: boolean;
+};
+export declare const nativeViewProps: readonly ["id", "enabled", "shouldCancelWhenOutside", "hitSlop", "waitFor", "simultaneousHandlers", "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/lib/typescript/handlers/PanGestureHandler.d.ts

@@ -0,0 +1,137 @@
+import { BaseGestureHandlerProps } from './gestureHandlerCommon';
+export declare const panGestureHandlerProps: readonly ["activeOffsetY", "activeOffsetX", "failOffsetY", "failOffsetX", "minDist", "minVelocity", "minVelocityX", "minVelocityY", "minPointers", "maxPointers", "avgTouches", "enableTrackpadTwoFingerGesture"];
+export declare const panGestureHandlerCustomNativeProps: readonly ["activeOffsetYStart", "activeOffsetYEnd", "activeOffsetXStart", "activeOffsetXEnd", "failOffsetYStart", "failOffsetYEnd", "failOffsetXStart", "failOffsetXEnd"];
+export declare type PanGestureHandlerEventPayload = {
+    /**
+     * X coordinate of the current position of the pointer (finger or a leading
+     * pointer when there are multiple fingers placed) relative to the view
+     * attached to the handler. Expressed in point units.
+     */
+    x: number;
+    /**
+     * Y coordinate of the current position of the pointer (finger or a leading
+     * pointer when there are multiple fingers placed) relative to the view
+     * attached to the handler. Expressed in point units.
+     */
+    y: number;
+    /**
+     * X coordinate of the current position of the pointer (finger or a leading
+     * pointer when there are multiple fingers placed) relative to the root view.
+     * The value is expressed in point units. It is recommended to use it instead
+     * of `x` in cases when the original view can be transformed as an effect of
+     * the gesture.
+     */
+    absoluteX: number;
+    /**
+     * Y coordinate of the current position of the pointer (finger or a leading
+     * pointer when there are multiple fingers placed) relative to the root view.
+     * The value is expressed in point units. It is recommended to use it instead
+     * of `y` in cases when the original view can be transformed as an
+     * effect of the gesture.
+     */
+    absoluteY: number;
+    /**
+     * Translation of the pan gesture along X axis accumulated over the time of
+     * the gesture. The value is expressed in the point units.
+     */
+    translationX: number;
+    /**
+     * Translation of the pan gesture along Y axis accumulated over the time of
+     * the gesture. The value is expressed in the point units.
+     */
+    translationY: number;
+    /**
+     * Velocity of the pan gesture along the X axis in the current moment. The
+     * value is expressed in point units per second.
+     */
+    velocityX: number;
+    /**
+     * Velocity of the pan gesture along the Y axis in the current moment. The
+     * value is expressed in point units per second.
+     */
+    velocityY: number;
+};
+interface CommonPanProperties {
+    /**
+     * Minimum distance the finger (or multiple finger) need to travel before the
+     * handler activates. Expressed in points.
+     */
+    minDist?: number;
+    /**
+     * Android only.
+     */
+    avgTouches?: boolean;
+    /**
+     * Enables two-finger gestures on supported devices, for example iPads with
+     * trackpads. If not enabled the gesture will require click + drag, with
+     * enableTrackpadTwoFingerGesture swiping with two fingers will also trigger
+     * the gesture.
+     */
+    enableTrackpadTwoFingerGesture?: boolean;
+    /**
+     * A number of fingers that is required to be placed before handler can
+     * activate. Should be a higher or equal to 0 integer.
+     */
+    minPointers?: number;
+    /**
+     * When the given number of fingers is placed on the screen and handler hasn't
+     * yet activated it will fail recognizing the gesture. Should be a higher or
+     * equal to 0 integer.
+     */
+    maxPointers?: number;
+    minVelocity?: number;
+    minVelocityX?: number;
+    minVelocityY?: number;
+}
+export interface PanGestureConfig extends CommonPanProperties {
+    activeOffsetYStart?: number;
+    activeOffsetYEnd?: number;
+    activeOffsetXStart?: number;
+    activeOffsetXEnd?: number;
+    failOffsetYStart?: number;
+    failOffsetYEnd?: number;
+    failOffsetXStart?: number;
+    failOffsetXEnd?: number;
+}
+export interface PanGestureHandlerProps extends BaseGestureHandlerProps<PanGestureHandlerEventPayload>, CommonPanProperties {
+    /**
+     * Range along X axis (in points) where fingers travels without activation of
+     * handler. Moving outside of this range implies activation of handler. Range
+     * can be given as an array or a single number. If range is set as an array,
+     * first value must be lower or equal to 0, a the second one higher or equal
+     * to 0. If only one number `p` is given a range of `(-inf, p)` will be used
+     * if `p` is higher or equal to 0 and `(-p, inf)` otherwise.
+     */
+    activeOffsetY?: number | number[];
+    /**
+     * Range along X axis (in points) where fingers travels without activation of
+     * handler. Moving outside of this range implies activation of handler. Range
+     * can be given as an array or a single number. If range is set as an array,
+     * first value must be lower or equal to 0, a the second one higher or equal
+     * to 0. If only one number `p` is given a range of `(-inf, p)` will be used
+     * if `p` is higher or equal to 0 and `(-p, inf)` otherwise.
+     */
+    activeOffsetX?: number | number[];
+    /**
+     * When the finger moves outside this range (in points) along Y axis and
+     * handler hasn't yet activated it will fail recognizing the gesture. Range
+     * can be given as an array or a single number. If range is set as an array,
+     * first value must be lower or equal to 0, a the second one higher or equal
+     * to 0. If only one number `p` is given a range of `(-inf, p)` will be used
+     * if `p` is higher or equal to 0 and `(-p, inf)` otherwise.
+     */
+    failOffsetY?: number | number[];
+    /**
+     * When the finger moves outside this range (in points) along X axis and
+     * handler hasn't yet activated it will fail recognizing the gesture. Range
+     * can be given as an array or a single number. If range is set as an array,
+     * first value must be lower or equal to 0, a the second one higher or equal
+     * to 0. If only one number `p` is given a range of `(-inf, p)` will be used
+     * if `p` is higher or equal to 0 and `(-p, inf)` otherwise.
+     */
+    failOffsetX?: number | number[];
+}
+export declare type PanGestureHandler = typeof PanGestureHandler;
+export declare const PanGestureHandler: import("react").ComponentType<PanGestureHandlerProps & import("react").RefAttributes<any>>;
+export declare function managePanProps(props: PanGestureHandlerProps): PanGestureHandlerProps & Partial<Record<"failOffsetXStart" | "failOffsetYStart" | "failOffsetXEnd" | "failOffsetYEnd" | "activeOffsetXStart" | "activeOffsetXEnd" | "activeOffsetYStart" | "activeOffsetYEnd", number>>;
+export {};

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

@@ -0,0 +1,28 @@
+import { BaseGestureHandlerProps } from './gestureHandlerCommon';
+export declare type PinchGestureHandlerEventPayload = {
+    /**
+     * The scale factor relative to the points of the two touches in screen
+     * coordinates.
+     */
+    scale: number;
+    /**
+     * Position expressed in points along X axis of center anchor point of
+     * gesture.
+     */
+    focalX: number;
+    /**
+     * Position expressed in points along Y axis of center anchor point of
+     * gesture.
+     */
+    focalY: number;
+    /**
+     *
+     * Velocity of the pan gesture the current moment. The value is expressed in
+     * point units per second.
+     */
+    velocity: number;
+};
+export interface PinchGestureHandlerProps extends BaseGestureHandlerProps<PinchGestureHandlerEventPayload> {
+}
+export declare type PinchGestureHandler = typeof PinchGestureHandler;
+export declare const PinchGestureHandler: import("react").ComponentType<PinchGestureHandlerProps & import("react").RefAttributes<any>>;

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

@@ -0,0 +1,28 @@
+import { BaseGestureHandlerProps } from './gestureHandlerCommon';
+export declare type RotationGestureHandlerEventPayload = {
+    /**
+     * Amount rotated, expressed in radians, from the gesture's focal point
+     * (anchor).
+     */
+    rotation: number;
+    /**
+     * X coordinate, expressed in points, of the gesture's central focal point
+     * (anchor).
+     */
+    anchorX: number;
+    /**
+     * Y coordinate, expressed in points, of the gesture's central focal point
+     * (anchor).
+     */
+    anchorY: number;
+    /**
+     *
+     * Instantaneous velocity, expressed in point units per second, of the
+     * gesture.
+     */
+    velocity: number;
+};
+export interface RotationGestureHandlerProps extends BaseGestureHandlerProps<RotationGestureHandlerEventPayload> {
+}
+export declare type RotationGestureHandler = typeof RotationGestureHandler;
+export declare const RotationGestureHandler: import("react").ComponentType<RotationGestureHandlerProps & import("react").RefAttributes<any>>;

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

@@ -0,0 +1,56 @@
+import { BaseGestureHandlerProps } from './gestureHandlerCommon';
+export declare const tapGestureHandlerProps: readonly ["maxDurationMs", "maxDelayMs", "numberOfTaps", "maxDeltaX", "maxDeltaY", "maxDist", "minPointers"];
+export declare type TapGestureHandlerEventPayload = {
+    x: number;
+    y: number;
+    absoluteX: number;
+    absoluteY: number;
+};
+export interface TapGestureConfig {
+    /**
+     * Minimum number of pointers (fingers) required to be placed before the
+     * handler activates. Should be a positive integer.
+     * The default value is 1.
+     */
+    minPointers?: number;
+    /**
+     * Maximum time, expressed in milliseconds, that defines how fast a finger
+     * must be released after a touch. The default value is 500.
+     */
+    maxDurationMs?: number;
+    /**
+     * Maximum time, expressed in milliseconds, that can pass before the next tap
+     * if many taps are required. The default value is 500.
+     */
+    maxDelayMs?: number;
+    /**
+     * Number of tap gestures required to activate the handler. The default value
+     * is 1.
+     */
+    numberOfTaps?: number;
+    /**
+     * Maximum distance, expressed in points, that defines how far the finger is
+     * allowed to travel along the X axis during a tap gesture. If the finger
+     * travels further than the defined distance along the X axis and the handler
+     * hasn't yet activated, it will fail to recognize the gesture.
+     */
+    maxDeltaX?: number;
+    /**
+     * Maximum distance, expressed in points, that defines how far the finger is
+     * allowed to travel along the Y axis during a tap gesture. If the finger
+     * travels further than the defined distance along the Y axis and the handler
+     * hasn't yet activated, it will fail to recognize the gesture.
+     */
+    maxDeltaY?: number;
+    /**
+     * Maximum distance, expressed in points, that defines how far the finger is
+     * allowed to travel during a tap gesture. If the finger travels further than
+     * the defined distance and the handler hasn't yet
+     * activated, it will fail to recognize the gesture.
+     */
+    maxDist?: number;
+}
+export interface TapGestureHandlerProps extends BaseGestureHandlerProps<TapGestureHandlerEventPayload>, TapGestureConfig {
+}
+export declare type TapGestureHandler = typeof TapGestureHandler;
+export declare const TapGestureHandler: import("react").ComponentType<TapGestureHandlerProps & import("react").RefAttributes<any>>;

package/{dist/src → lib/typescript}/handlers/createHandler.d.ts

@@ -1,5 +1,5 @@
-import React from 'react';
-import { BaseGestureHandlerProps } from './gestureHandlers';
+import * as React from 'react';
+import { BaseGestureHandlerProps } from './gestureHandlerCommon';
 declare type CreateHandlerArgs<HandlerPropsT extends Record<string, unknown>> = Readonly<{
     name: string;
     allowedProps: Readonly<Extract<keyof HandlerPropsT, string>[]>;

package/{dist/src → lib/typescript}/handlers/createNativeWrapper.d.ts

@@ -1,3 +1,3 @@
-import React from 'react';
+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>>>;