react-native-gesture-handler 1.10.3 → 2.2.0

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 window. 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 window. 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

@@ -1,12 +1,27 @@
-/// <reference types="react" />
-import { BaseGestureHandlerProps } from './gestureHandlers';
-export interface NativeViewGestureHandlerProps extends BaseGestureHandlerProps<NativeViewGestureHandlerPayload> {
+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", "minPointers", "waitFor", "simultaneousHandlers", "shouldCancelWhenOutside", "hitSlop", "onBegan", "onFailed", "onCancelled", "onActivated", "onEnded", "onGestureEvent", "onHandlerStateChange", "shouldActivateOnStart", "disallowInterruption"];
+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 window.
+     * 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 window.
+     * 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/lib/typescript/handlers/createHandler.d.ts

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

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

@@ -0,0 +1,62 @@
+import * as React from 'react';
+import { State } from '../State';
+import { EventType } from '../EventType';
+import { ValueOf } from '../typeUtils';
+export declare const baseGestureHandlerProps: readonly ["id", "enabled", "shouldCancelWhenOutside", "hitSlop", "waitFor", "simultaneousHandlers", "onBegan", "onFailed", "onCancelled", "onActivated", "onEnded", "onGestureEvent", "onHandlerStateChange"];
+export declare const baseGestureHandlerWithMonitorProps: string[];
+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 declare type 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>;
+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 TouchData = {
+    id: number;
+    x: number;
+    y: number;
+    absoluteX: number;
+    absoluteY: number;
+};
+export declare type GestureTouchEvent = {
+    handlerTag: number;
+    numberOfTouches: number;
+    state: ValueOf<typeof State>;
+    eventType: EventType;
+    allTouches: TouchData[];
+    changedTouches: TouchData[];
+};
+export declare type GestureUpdateEvent<GestureEventPayloadT = Record<string, unknown>> = GestureEventPayload & GestureEventPayloadT;
+export declare type GestureStateChangeEvent<GestureStateChangeEventPayloadT = Record<string, unknown>> = HandlerStateChangeEventPayload & GestureStateChangeEventPayloadT;
+export declare type CommonGestureConfig = {
+    enabled?: boolean;
+    shouldCancelWhenOutside?: boolean;
+    hitSlop?: HitSlop;
+};
+export declare 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>[];
+    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 function filterConfig(props: Record<string, unknown>, validProps: string[], defaults?: Record<string, unknown>): {
+    [x: string]: unknown;
+};
+export declare function findNodeHandle(node: null | number | React.Component<any, any> | React.ComponentClass<any>): null | number | React.Component<any, any> | React.ComponentClass<any>;

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

@@ -1,5 +1,12 @@
 import { BaseButtonProps, BorderlessButtonProps, RawButtonProps, RectButtonProps } from '../components/GestureButtons';
-import { FlingGestureHandlerEventPayload, FlingGestureHandlerProps, ForceTouchGestureHandlerEventPayload, ForceTouchGestureHandlerProps, GestureEvent, GestureEventPayload, HandlerStateChangeEvent, HandlerStateChangeEventPayload, LongPressGestureHandlerEventPayload, LongPressGestureHandlerProps, PanGestureHandlerEventPayload, PanGestureHandlerProps, PinchGestureHandlerEventPayload, PinchGestureHandlerProps, RotationGestureHandlerEventPayload, RotationGestureHandlerProps, TapGestureHandlerEventPayload, TapGestureHandlerProps } from './gestureHandlers';
+import { GestureEvent, GestureEventPayload, HandlerStateChangeEvent, HandlerStateChangeEventPayload } from './gestureHandlerCommon';
+import { FlingGestureHandlerEventPayload, FlingGestureHandlerProps } from './FlingGestureHandler';
+import { ForceTouchGestureHandlerEventPayload, ForceTouchGestureHandlerProps } from './ForceTouchGestureHandler';
+import { LongPressGestureHandlerEventPayload, LongPressGestureHandlerProps } from './LongPressGestureHandler';
+import { PanGestureHandlerEventPayload, PanGestureHandlerProps } from './PanGestureHandler';
+import { PinchGestureHandlerEventPayload, PinchGestureHandlerProps } from './PinchGestureHandler';
+import { RotationGestureHandlerEventPayload, RotationGestureHandlerProps } from './RotationGestureHandler';
+import { TapGestureHandlerEventPayload, TapGestureHandlerProps } from './TapGestureHandler';
 import { NativeViewGestureHandlerPayload, NativeViewGestureHandlerProps } from './NativeViewGestureHandler';
 export declare type GestureHandlerGestureEventNativeEvent = GestureEventPayload;
 export declare type GestureHandlerStateChangeNativeEvent = HandlerStateChangeEventPayload;

package/lib/typescript/handlers/gestures/GestureDetector.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+import { GestureType, HandlerCallbacks } from './gesture';
+import { SharedValue } from './reanimatedWrapper';
+import { ComposedGesture } from './gestureComposition';
+export declare type GestureConfigReference = {
+    config: GestureType[];
+    animatedEventHandler: unknown;
+    animatedHandlers: SharedValue<HandlerCallbacks<Record<string, unknown>>[] | null> | null;
+    firstExecution: boolean;
+    useAnimated: boolean;
+};
+interface GestureDetectorProps {
+    gesture?: ComposedGesture | GestureType;
+}
+export declare const GestureDetector: React.FunctionComponent<GestureDetectorProps>;
+export {};

package/lib/typescript/handlers/gestures/eventReceiver.d.ts

@@ -0,0 +1,2 @@
+export declare function startListening(): void;
+export declare function stopListening(): void;

package/lib/typescript/handlers/gestures/flingGesture.d.ts

@@ -0,0 +1,9 @@
+import { BaseGesture, BaseGestureConfig } from './gesture';
+import { FlingGestureConfig, FlingGestureHandlerEventPayload } from '../FlingGestureHandler';
+export declare class FlingGesture extends BaseGesture<FlingGestureHandlerEventPayload> {
+    config: BaseGestureConfig & FlingGestureConfig;
+    constructor();
+    numberOfPointers(pointers: number): this;
+    direction(direction: number): this;
+}
+export declare type FlingGestureType = InstanceType<typeof FlingGesture>;

package/lib/typescript/handlers/gestures/forceTouchGesture.d.ts

@@ -0,0 +1,16 @@
+import { BaseGestureConfig, ContinousBaseGesture } from './gesture';
+import { ForceTouchGestureConfig, ForceTouchGestureHandlerEventPayload } from '../ForceTouchGestureHandler';
+import { GestureUpdateEvent } from '../gestureHandlerCommon';
+declare type ForceTouchGestureChangeEventPayload = {
+    forceChange: number;
+};
+export declare class ForceTouchGesture extends ContinousBaseGesture<ForceTouchGestureHandlerEventPayload, ForceTouchGestureChangeEventPayload> {
+    config: BaseGestureConfig & ForceTouchGestureConfig;
+    constructor();
+    minForce(force: number): this;
+    maxForce(force: number): this;
+    feedbackOnActivation(value: boolean): this;
+    onChange(callback: (event: GestureUpdateEvent<GestureUpdateEvent<ForceTouchGestureHandlerEventPayload & ForceTouchGestureChangeEventPayload>>) => void): this;
+}
+export declare type ForceTouchGestureType = InstanceType<typeof ForceTouchGesture>;
+export {};

package/lib/typescript/handlers/gestures/gesture.d.ts

@@ -0,0 +1,97 @@
+import { FlingGestureHandlerEventPayload } from '../FlingGestureHandler';
+import { ForceTouchGestureHandlerEventPayload } from '../ForceTouchGestureHandler';
+import { HitSlop, CommonGestureConfig, GestureTouchEvent, GestureStateChangeEvent, GestureUpdateEvent } from '../gestureHandlerCommon';
+import { GestureStateManagerType } from './gestureStateManager';
+import { LongPressGestureHandlerEventPayload } from '../LongPressGestureHandler';
+import { PanGestureHandlerEventPayload } from '../PanGestureHandler';
+import { PinchGestureHandlerEventPayload } from '../PinchGestureHandler';
+import { RotationGestureHandlerEventPayload } from '../RotationGestureHandler';
+import { TapGestureHandlerEventPayload } from '../TapGestureHandler';
+import { NativeViewGestureHandlerPayload } from '../NativeViewGestureHandler';
+export declare type GestureType = BaseGesture<Record<string, unknown>> | BaseGesture<Record<string, never>> | BaseGesture<TapGestureHandlerEventPayload> | BaseGesture<PanGestureHandlerEventPayload> | BaseGesture<LongPressGestureHandlerEventPayload> | BaseGesture<RotationGestureHandlerEventPayload> | BaseGesture<PinchGestureHandlerEventPayload> | BaseGesture<FlingGestureHandlerEventPayload> | BaseGesture<ForceTouchGestureHandlerEventPayload> | BaseGesture<NativeViewGestureHandlerPayload>;
+export declare type GestureRef = number | GestureType | React.RefObject<GestureType | undefined> | React.RefObject<React.ComponentType | undefined>;
+export interface BaseGestureConfig extends CommonGestureConfig, Record<string, unknown> {
+    ref?: React.MutableRefObject<GestureType | undefined>;
+    requireToFail?: GestureRef[];
+    simultaneousWith?: GestureRef[];
+    needsPointerData?: boolean;
+    manualActivation?: boolean;
+}
+declare type TouchEventHandlerType = (event: GestureTouchEvent, stateManager: GestureStateManagerType) => void;
+export declare type HandlerCallbacks<EventPayloadT extends Record<string, unknown>> = {
+    handlerTag: number;
+    onBegin?: (event: GestureStateChangeEvent<EventPayloadT>) => void;
+    onStart?: (event: GestureStateChangeEvent<EventPayloadT>) => void;
+    onEnd?: (event: GestureStateChangeEvent<EventPayloadT>, success: boolean) => void;
+    onFinalize?: (event: GestureStateChangeEvent<EventPayloadT>, success: boolean) => void;
+    onUpdate?: (event: GestureUpdateEvent<EventPayloadT>) => void;
+    onChange?: (event: any) => void;
+    onTouchesDown?: TouchEventHandlerType;
+    onTouchesMove?: TouchEventHandlerType;
+    onTouchesUp?: TouchEventHandlerType;
+    onTouchesCancelled?: TouchEventHandlerType;
+    changeEventCalculator?: (current: GestureUpdateEvent<Record<string, unknown>>, previous?: GestureUpdateEvent<Record<string, unknown>>) => GestureUpdateEvent<Record<string, unknown>>;
+    isWorklet: boolean[];
+};
+export declare const CALLBACK_TYPE: {
+    readonly UNDEFINED: 0;
+    readonly BEGAN: 1;
+    readonly START: 2;
+    readonly UPDATE: 3;
+    readonly CHANGE: 4;
+    readonly END: 5;
+    readonly FINALIZE: 6;
+    readonly TOUCHES_DOWN: 7;
+    readonly TOUCHES_MOVE: 8;
+    readonly TOUCHES_UP: 9;
+    readonly TOUCHES_CANCELLED: 10;
+};
+export declare type CALLBACK_TYPE = typeof CALLBACK_TYPE[keyof typeof CALLBACK_TYPE];
+export declare abstract class Gesture {
+    /**
+     * Return array of gestures, providing the same interface for creating and updating
+     * handlers, no matter which object was used to create gesture instance.
+     */
+    abstract toGestureArray(): GestureType[];
+    /**
+     * Assign handlerTag to the gesture instance and set ref.current (if a ref is set)
+     */
+    abstract initialize(): void;
+    /**
+     * Make sure that values of properties defining relations are arrays. Do any necessary
+     * preprocessing required to configure relations between handlers. Called just before
+     * updating the handler on the native side.
+     */
+    abstract prepare(): void;
+}
+export declare abstract class BaseGesture<EventPayloadT extends Record<string, unknown>> extends Gesture {
+    handlerTag: number;
+    handlerName: string;
+    config: BaseGestureConfig;
+    handlers: HandlerCallbacks<EventPayloadT>;
+    private addDependency;
+    withRef(ref: React.MutableRefObject<GestureType | undefined>): this;
+    protected isWorklet(callback: Function): boolean;
+    onBegin(callback: (event: GestureStateChangeEvent<EventPayloadT>) => void): this;
+    onStart(callback: (event: GestureStateChangeEvent<EventPayloadT>) => void): this;
+    onEnd(callback: (event: GestureStateChangeEvent<EventPayloadT>, success: boolean) => void): this;
+    onFinalize(callback: (event: GestureStateChangeEvent<EventPayloadT>, success: boolean) => void): this;
+    onTouchesDown(callback: TouchEventHandlerType): this;
+    onTouchesMove(callback: TouchEventHandlerType): this;
+    onTouchesUp(callback: TouchEventHandlerType): this;
+    onTouchesCancelled(callback: TouchEventHandlerType): this;
+    enabled(enabled: boolean): this;
+    shouldCancelWhenOutside(value: boolean): this;
+    hitSlop(hitSlop: HitSlop): this;
+    simultaneousWithExternalGesture(...gestures: Exclude<GestureRef, number>[]): this;
+    requireExternalGestureToFail(...gestures: Exclude<GestureRef, number>[]): this;
+    initialize(): void;
+    toGestureArray(): GestureType[];
+    prepare(): void;
+}
+export declare abstract class ContinousBaseGesture<EventPayloadT extends Record<string, unknown>, EventChangePayloadT extends Record<string, unknown>> extends BaseGesture<EventPayloadT> {
+    onUpdate(callback: (event: GestureUpdateEvent<EventPayloadT>) => void): this;
+    onChange(callback: (event: GestureUpdateEvent<EventPayloadT & EventChangePayloadT>) => void): this;
+    manualActivation(manualActivation: boolean): this;
+}
+export {};

package/lib/typescript/handlers/gestures/gestureComposition.d.ts

@@ -0,0 +1,21 @@
+import { Gesture, GestureType } from './gesture';
+export declare class ComposedGesture extends Gesture {
+    protected gestures: Gesture[];
+    protected simultaneousGestures: GestureType[];
+    protected requireGesturesToFail: GestureType[];
+    constructor(...gestures: Gesture[]);
+    protected prepareSingleGesture(gesture: Gesture, simultaneousGestures: GestureType[], requireGesturesToFail: GestureType[]): void;
+    prepare(): void;
+    initialize(): void;
+    toGestureArray(): GestureType[];
+}
+export declare class SimultaneousGesture extends ComposedGesture {
+    prepare(): void;
+}
+export declare class ExclusiveGesture extends ComposedGesture {
+    prepare(): void;
+}
+export declare type ComposedGestureType = InstanceType<typeof ComposedGesture>;
+export declare type RaceGestureType = ComposedGestureType;
+export declare type SimultaneousGestureType = InstanceType<typeof SimultaneousGesture>;
+export declare type ExclusiveGestureType = InstanceType<typeof ExclusiveGesture>;