react-native-gesture-handler 2.16.0-rc.0 → 2.16.1

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

@@ -1,6 +1,6 @@
 import { FlingGestureHandlerEventPayload } from '../FlingGestureHandler';
 import { ForceTouchGestureHandlerEventPayload } from '../ForceTouchGestureHandler';
-import { HitSlop, CommonGestureConfig, GestureTouchEvent, GestureStateChangeEvent, GestureUpdateEvent, ActiveCursor } from '../gestureHandlerCommon';
+import { HitSlop, CommonGestureConfig, GestureTouchEvent, GestureStateChangeEvent, GestureUpdateEvent, ActiveCursor, MouseButton } from '../gestureHandlerCommon';
 import { GestureStateManagerType } from './gestureStateManager';
 import { LongPressGestureHandlerEventPayload } from '../LongPressGestureHandler';
 import { PanGestureHandlerEventPayload } from '../PanGestureHandler';
@@ -8,7 +8,6 @@ import { PinchGestureHandlerEventPayload } from '../PinchGestureHandler';
 import { RotationGestureHandlerEventPayload } from '../RotationGestureHandler';
 import { TapGestureHandlerEventPayload } from '../TapGestureHandler';
 import { NativeViewGestureHandlerPayload } from '../NativeViewGestureHandler';
-import { MouseButton } from '../../web/interfaces';
 export 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 type GestureRef = number | GestureType | React.RefObject<GestureType | undefined> | React.RefObject<React.ComponentType | undefined>;
 export interface BaseGestureConfig extends CommonGestureConfig, Record<string, unknown> {
@@ -78,26 +77,125 @@ export declare abstract class BaseGesture<EventPayloadT extends Record<string, u
     handlers: HandlerCallbacks<EventPayloadT>;
     constructor();
     private addDependency;
+    /**
+     * Sets a `ref` to the gesture object, allowing for interoperability with the old API.
+     * @param ref
+     */
     withRef(ref: React.MutableRefObject<GestureType | undefined>): this;
     protected isWorklet(callback: Function): boolean;
+    /**
+     * Set the callback that is being called when given gesture handler starts receiving touches.
+     * At the moment of this callback the handler is in `BEGAN` state and we don't know yet if it will recognize the gesture at all.
+     * @param callback
+     */
     onBegin(callback: (event: GestureStateChangeEvent<EventPayloadT>) => void): this;
+    /**
+     * Set the callback that is being called when the gesture is recognized by the handler and it transitions to the `ACTIVE` state.
+     * @param callback
+     */
     onStart(callback: (event: GestureStateChangeEvent<EventPayloadT>) => void): this;
+    /**
+     * Set the callback that is being called when the gesture that was recognized by the handler finishes and handler reaches `END` state.
+     * It will be called only if the handler was previously in the `ACTIVE` state.
+     * @param callback
+     */
     onEnd(callback: (event: GestureStateChangeEvent<EventPayloadT>, success: boolean) => void): this;
+    /**
+     * Set the callback that is being called when the handler finalizes handling gesture - the gesture was recognized and has finished or it failed to recognize.
+     * @param callback
+     */
     onFinalize(callback: (event: GestureStateChangeEvent<EventPayloadT>, success: boolean) => void): this;
+    /**
+     * Set the `onTouchesDown` callback which is called every time a pointer is placed on the screen.
+     * @param callback
+     */
     onTouchesDown(callback: TouchEventHandlerType): this;
+    /**
+     * Set the `onTouchesMove` callback which is called every time a pointer is moved on the screen.
+     * @param callback
+     */
     onTouchesMove(callback: TouchEventHandlerType): this;
+    /**
+     * Set the `onTouchesUp` callback which is called every time a pointer is lifted from the screen.
+     * @param callback
+     */
     onTouchesUp(callback: TouchEventHandlerType): this;
+    /**
+     * Set the `onTouchesCancelled` callback which is called every time a pointer stops being tracked, for example when the gesture finishes.
+     * @param callback
+     */
     onTouchesCancelled(callback: TouchEventHandlerType): this;
+    /**
+     * Indicates whether the given handler should be analyzing stream of touch events or not.
+     * @param enabled
+     * @see https://docs.swmansion.com/react-native-gesture-handler/docs/gestures/pan-gesture#enabledvalue-boolean
+     */
     enabled(enabled: boolean): this;
+    /**
+     * When true the handler will cancel or fail recognition (depending on its current state) whenever the finger leaves the area of the connected view.
+     * @param value
+     * @see https://docs.swmansion.com/react-native-gesture-handler/docs/gestures/pan-gesture#shouldcancelwhenoutsidevalue-boolean
+     */
     shouldCancelWhenOutside(value: boolean): this;
+    /**
+     * This parameter enables control over what part of the connected view area can be used to begin recognizing the gesture.
+     * When a negative number is provided the bounds of the view will reduce the area by the given number of points in each of the sides evenly.
+     * @param hitSlop
+     * @see https://docs.swmansion.com/react-native-gesture-handler/docs/gestures/pan-gesture#hitslopsettings
+     */
     hitSlop(hitSlop: HitSlop): this;
+    /**
+     * #### Web only
+     * This parameter allows to specify which `cursor` should be used when gesture activates.
+     * Supports all CSS cursor values (e.g. `"grab"`, `"zoom-in"`). Default value is set to `"auto"`.
+     * @param activeCursor
+     */
     activeCursor(activeCursor: ActiveCursor): this;
+    /**
+     * #### Web & Android only
+     * Allows users to choose which mouse button should handler respond to.
+     * Arguments can be combined using `|` operator, e.g. `mouseButton(MouseButton.LEFT | MouseButton.RIGHT)`.
+     * Default value is set to `MouseButton.LEFT`.
+     * @param mouseButton
+     * @see https://docs.swmansion.com/react-native-gesture-handler/docs/gestures/pan-gesture#mousebuttonvalue-mousebutton-web--android-only
+     */
     mouseButton(mouseButton: MouseButton): this;
+    /**
+     * When `react-native-reanimated` is installed, the callbacks passed to the gestures are automatically workletized and run on the UI thread when called.
+     * This option allows for changing this behavior: when `true`, all the callbacks will be run on the JS thread instead of the UI thread, regardless of whether they are worklets or not.
+     * Defaults to `false`.
+     * @param runOnJS
+     */
     runOnJS(runOnJS: boolean): this;
+    /**
+     * Allows gestures across different components to be recognized simultaneously.
+     * @param gestures
+     * @see https://docs.swmansion.com/react-native-gesture-handler/docs/fundamentals/gesture-composition/#simultaneouswithexternalgesture
+     */
     simultaneousWithExternalGesture(...gestures: Exclude<GestureRef, number>[]): this;
+    /**
+     * Allows to delay activation of the handler until all handlers passed as arguments to this method fail (or don't begin at all).
+     * @param gestures
+     * @see https://docs.swmansion.com/react-native-gesture-handler/docs/fundamentals/gesture-composition/#requireexternalgesturetofail
+     */
     requireExternalGestureToFail(...gestures: Exclude<GestureRef, number>[]): this;
+    /**
+     * Works similarily to `requireExternalGestureToFail` but the direction of the relation is reversed - instead of being one-to-many relation, it's many-to-one.
+     * @param gestures
+     * @see https://docs.swmansion.com/react-native-gesture-handler/docs/fundamentals/gesture-composition/#blocksexternalgesture
+     */
     blocksExternalGesture(...gestures: Exclude<GestureRef, number>[]): this;
+    /**
+     * Sets a `testID` property for gesture object, allowing for querying for it in tests.
+     * @param id
+     */
     withTestId(id: string): this;
+    /**
+     * #### iOS only
+     * When `true`, the handler will cancel touches for native UI components (`UIButton`, `UISwitch`, etc) it's attached to when it becomes `ACTIVE`.
+     * Default value is `true`.
+     * @param value
+     */
     cancelsTouchesInView(value: boolean): this;
     initialize(): void;
     toGestureArray(): GestureType[];
@@ -105,8 +203,22 @@ export declare abstract class BaseGesture<EventPayloadT extends Record<string, u
     get shouldUseReanimated(): boolean;
 }
 export declare abstract class ContinousBaseGesture<EventPayloadT extends Record<string, unknown>, EventChangePayloadT extends Record<string, unknown>> extends BaseGesture<EventPayloadT> {
+    /**
+     * Set the callback that is being called every time the gesture receives an update while it's active.
+     * @param callback
+     */
     onUpdate(callback: (event: GestureUpdateEvent<EventPayloadT>) => void): this;
+    /**
+     * Set the callback that is being called every time the gesture receives an update while it's active.
+     * This callback will receive information about change in value in relation to the last received event.
+     * @param callback
+     */
     onChange(callback: (event: GestureUpdateEvent<EventPayloadT & EventChangePayloadT>) => void): this;
+    /**
+     * When `true` the handler will not activate by itself even if its activation criteria are met.
+     * Instead you can manipulate its state using state manager.
+     * @param manualActivation
+     */
     manualActivation(manualActivation: boolean): this;
 }
 export {};

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

@@ -10,24 +10,80 @@ import { TapGesture } from './tapGesture';
 import { NativeGesture } from './nativeGesture';
 import { ManualGesture } from './manualGesture';
 import { HoverGesture } from './hoverGesture';
+/**
+ * `Gesture` is the object that allows you to create and compose gestures.
+ *
+ * ### Remarks
+ * - Consider wrapping your gesture configurations with `useMemo`, as it will reduce the amount of work Gesture Handler has to do under the hood when updating gestures.
+ *
+ * @see https://docs.swmansion.com/react-native-gesture-handler/docs/gestures/gesture
+ */
 export declare const GestureObjects: {
+    /**
+     * A discrete gesture that recognizes one or many taps.
+     * @see https://docs.swmansion.com/react-native-gesture-handler/docs/gestures/tap-gesture
+     */
     Tap: () => TapGesture;
+    /**
+     * A continuous gesture that can recognize a panning (dragging) gesture and track its movement.
+     * @see https://docs.swmansion.com/react-native-gesture-handler/docs/gestures/pan-gesture
+     */
     Pan: () => PanGesture;
+    /**
+     * A continuous gesture that recognizes pinch gesture. It allows for tracking the distance between two fingers and use that information to scale or zoom your content.
+     * @see https://docs.swmansion.com/react-native-gesture-handler/docs/gestures/pinch-gesture
+     */
     Pinch: () => PinchGesture;
+    /**
+     * A continuous gesture that can recognize rotation and track its movement.
+     * @see https://docs.swmansion.com/react-native-gesture-handler/docs/gestures/rotation-gesture
+     */
     Rotation: () => RotationGesture;
+    /**
+     * A discrete gesture that activates when the movement is sufficiently fast.
+     * @see https://docs.swmansion.com/react-native-gesture-handler/docs/gestures/fling-gesture
+     */
     Fling: () => FlingGesture;
+    /**
+     * A discrete gesture that activates when the corresponding view is pressed for a sufficiently long time.
+     * @see https://docs.swmansion.com/react-native-gesture-handler/docs/gestures/long-press-gesture
+     */
     LongPress: () => LongPressGesture;
+    /**
+     * #### iOS only
+     * A continuous gesture that recognizes force of a touch. It allows for tracking pressure of touch on some iOS devices.
+     * @see https://docs.swmansion.com/react-native-gesture-handler/docs/gestures/force-touch-gesture
+     */
     ForceTouch: () => ForceTouchGesture;
+    /**
+     * A gesture that allows other touch handling components to participate in RNGH's gesture system.
+     * When used, the other component should be the direct child of a `GestureDetector`.
+     * @see https://docs.swmansion.com/react-native-gesture-handler/docs/gestures/native-gesture
+     */
     Native: () => NativeGesture;
+    /**
+     * A plain gesture that has no specific activation criteria nor event data set.
+     * Its state has to be controlled manually using a state manager.
+     * It will not fail when all the pointers are lifted from the screen.
+     * @see https://docs.swmansion.com/react-native-gesture-handler/docs/gestures/manual-gesture
+     */
     Manual: () => ManualGesture;
+    /**
+     * A continuous gesture that can recognize hovering above the view it's attached to.
+     * The hover effect may be activated by moving a mouse or a stylus over the view.
+     *
+     * @see https://docs.swmansion.com/react-native-gesture-handler/docs/gestures/hover-gesture
+     */
     Hover: () => HoverGesture;
     /**
      * Builds a composed gesture consisting of gestures provided as parameters.
      * The first one that becomes active cancels the rest of gestures.
+     * @see https://docs.swmansion.com/react-native-gesture-handler/docs/fundamentals/gesture-composition/#race
      */
     Race: (...gestures: Gesture[]) => ComposedGesture;
     /**
      * Builds a composed gesture that allows all base gestures to run simultaneously.
+     * @see https://docs.swmansion.com/react-native-gesture-handler/docs/fundamentals/gesture-composition/#simultaneous
      */
     Simultaneous(...gestures: Gesture[]): SimultaneousGesture;
     /**
@@ -36,6 +92,7 @@ export declare const GestureObjects: {
      * than the second one, second one has higher priority than the third one, and so on.
      * For example, to make a gesture that recognizes both single and double tap you need
      * to call Exclusive(doubleTap, singleTap).
+     * @see https://docs.swmansion.com/react-native-gesture-handler/docs/fundamentals/gesture-composition/#exclusive
      */
     Exclusive(...gestures: Gesture[]): ExclusiveGesture;
 };

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

@@ -23,8 +23,8 @@ export declare class HoverGesture extends ContinousBaseGesture<HoverGestureHandl
     config: BaseGestureConfig & HoverGestureConfig;
     constructor();
     /**
+     * #### iOS only
      * Sets the visual hover effect.
-     * iOS only
      */
     effect(effect: HoverEffect): this;
     onChange(callback: (event: GestureUpdateEvent<HoverGestureHandlerEventPayload & HoverGestureChangeEventPayload>) => void): this;

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

@@ -3,7 +3,17 @@ import { LongPressGestureConfig, LongPressGestureHandlerEventPayload } from '../
 export declare class LongPressGesture extends BaseGesture<LongPressGestureHandlerEventPayload> {
     config: BaseGestureConfig & LongPressGestureConfig;
     constructor();
+    /**
+     * Minimum time, expressed in milliseconds, that a finger must remain pressed on the corresponding view.
+     * The default value is 500.
+     * @param duration
+     */
     minDuration(duration: number): this;
+    /**
+     * Maximum distance, expressed in points, that defines how far the finger is allowed to travel during a long press gesture.
+     * @param distance
+     * @see https://docs.swmansion.com/react-native-gesture-handler/docs/gestures/long-press-gesture#maxdistancevalue-number
+     */
     maxDistance(distance: number): this;
 }
 export type LongPressGestureType = InstanceType<typeof LongPressGesture>;

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

@@ -3,7 +3,15 @@ import { NativeViewGestureConfig, NativeViewGestureHandlerPayload } from '../Nat
 export declare class NativeGesture extends BaseGesture<NativeViewGestureHandlerPayload> {
     config: BaseGestureConfig & NativeViewGestureConfig;
     constructor();
+    /**
+     * When true, underlying handler will activate unconditionally when in `BEGAN` or `UNDETERMINED` state.
+     * @param value
+     */
     shouldActivateOnStart(value: boolean): this;
+    /**
+     * When true, cancels all other gesture handlers when this `NativeViewGestureHandler` receives an `ACTIVE` state event.
+     * @param value
+     */
     disallowInterruption(value: boolean): this;
 }
 export type NativeGestureType = InstanceType<typeof NativeGesture>;

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

@@ -8,18 +8,81 @@ export type PanGestureChangeEventPayload = {
 export declare class PanGesture extends ContinousBaseGesture<PanGestureHandlerEventPayload, PanGestureChangeEventPayload> {
     config: BaseGestureConfig & PanGestureConfig;
     constructor();
-    activeOffsetY(offset: number | number[]): this;
-    activeOffsetX(offset: number | number[]): this;
-    failOffsetY(offset: number | number[]): this;
-    failOffsetX(offset: number | number[]): this;
+    /**
+     * Range along Y axis (in points) where fingers travels without activation of gesture.
+     * @param offset
+     * @see https://docs.swmansion.com/react-native-gesture-handler/docs/gestures/pan-gesture#activeoffsetyvalue-number--number
+     */
+    activeOffsetY(offset: number | [activeOffsetYStart: number, activeOffsetYEnd: number]): this;
+    /**
+     * Range along X axis (in points) where fingers travels without activation of gesture.
+     * @param offset
+     * @see https://docs.swmansion.com/react-native-gesture-handler/docs/gestures/pan-gesture#activeoffsetxvalue-number--number
+     */
+    activeOffsetX(offset: number | [activeOffsetXStart: number, activeOffsetXEnd: number]): this;
+    /**
+     * When the finger moves outside this range (in points) along Y axis and gesture hasn't yet activated it will fail recognizing the gesture.
+     * @param offset
+     * @see https://docs.swmansion.com/react-native-gesture-handler/docs/gestures/pan-gesture#failoffsetyvalue-number--number
+     */
+    failOffsetY(offset: number | [failOffsetYStart: number, failOffsetYEnd: number]): this;
+    /**
+     * When the finger moves outside this range (in points) along X axis and gesture hasn't yet activated it will fail recognizing the gesture.
+     * @param offset
+     * @see https://docs.swmansion.com/react-native-gesture-handler/docs/gestures/pan-gesture#failoffsetxvalue-number--number
+     */
+    failOffsetX(offset: number | [failOffsetXStart: number, failOffsetXEnd: number]): this;
+    /**
+     * A number of fingers that is required to be placed before gesture can activate. Should be a higher or equal to 0 integer.
+     * @param minPointers
+     */
     minPointers(minPointers: number): this;
+    /**
+     * When the given number of fingers is placed on the screen and gesture hasn't yet activated it will fail recognizing the gesture.
+     * Should be a higher or equal to 0 integer.
+     * @param maxPointers
+     */
     maxPointers(maxPointers: number): this;
+    /**
+     * Minimum distance the finger (or multiple finger) need to travel before the gesture activates.
+     * Expressed in points.
+     * @param distance
+     */
     minDistance(distance: number): this;
+    /**
+     * Minimum velocity the finger has to reach in order to activate handler.
+     * @param velocity
+     */
     minVelocity(velocity: number): this;
+    /**
+     * Minimum velocity along X axis the finger has to reach in order to activate handler.
+     * @param velocity
+     */
     minVelocityX(velocity: number): this;
+    /**
+     * Minimum velocity along Y axis the finger has to reach in order to activate handler.
+     * @param velocity
+     */
     minVelocityY(velocity: number): this;
+    /**
+     * #### Android only
+     * Android, by default, will calculate translation values based on the position of the leading pointer (the first one that was placed on the screen).
+     * This modifier allows that behavior to be changed to the one that is default on iOS - the averaged position of all active pointers will be used to calculate the translation values.
+     * @param value
+     */
     averageTouches(value: boolean): this;
+    /**
+     * #### iOS only
+     * Enables two-finger gestures on supported devices, for example iPads with trackpads.
+     * @param value
+     * @see https://docs.swmansion.com/react-native-gesture-handler/docs/gestures/pan-gesture/#enabletrackpadtwofingergesturevalue-boolean-ios-only
+     */
     enableTrackpadTwoFingerGesture(value: boolean): this;
+    /**
+     * Duration in milliseconds of the LongPress gesture before Pan is allowed to activate.
+     * @param duration
+     * @see https://docs.swmansion.com/react-native-gesture-handler/docs/gestures/pan-gesture/#activateafterlongpressduration-number
+     */
     activateAfterLongPress(duration: number): this;
     onChange(callback: (event: GestureUpdateEvent<PanGestureHandlerEventPayload & PanGestureChangeEventPayload>) => void): this;
 }

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

@@ -3,12 +3,47 @@ import { TapGestureConfig, TapGestureHandlerEventPayload } from '../TapGestureHa
 export declare class TapGesture extends BaseGesture<TapGestureHandlerEventPayload> {
     config: BaseGestureConfig & TapGestureConfig;
     constructor();
+    /**
+     * Minimum number of pointers (fingers) required to be placed before the gesture activates.
+     * Should be a positive integer. The default value is 1.
+     * @param minPointers
+     */
     minPointers(minPointers: number): this;
+    /**
+     * Number of tap gestures required to activate the gesture.
+     * The default value is 1.
+     * @param count
+     */
     numberOfTaps(count: number): this;
+    /**
+     * Maximum distance, expressed in points, that defines how far the finger is allowed to travel during a tap gesture.
+     * @param maxDist
+     * @see https://docs.swmansion.com/react-native-gesture-handler/docs/gestures/tap-gesture#maxdistancevalue-number
+     */
     maxDistance(maxDist: number): this;
+    /**
+     * Maximum time, expressed in milliseconds, that defines how fast a finger must be released after a touch.
+     * The default value is 500.
+     * @param duration
+     */
     maxDuration(duration: number): this;
+    /**
+     * Maximum time, expressed in milliseconds, that can pass before the next tap — if many taps are required.
+     * The default value is 500.
+     * @param delay
+     */
     maxDelay(delay: number): this;
+    /**
+     * Maximum distance, expressed in points, that defines how far the finger is allowed to travel along the X axis during a tap gesture.
+     * @param delta
+     * @see https://docs.swmansion.com/react-native-gesture-handler/docs/gestures/tap-gesture#maxdeltaxvalue-number
+     */
     maxDeltaX(delta: number): this;
+    /**
+     * Maximum distance, expressed in points, that defines how far the finger is allowed to travel along the Y axis during a tap gesture.
+     * @param delta
+     * @see https://docs.swmansion.com/react-native-gesture-handler/docs/gestures/tap-gesture#maxdeltayvalue-number
+     */
     maxDeltaY(delta: number): this;
 }
 export type TapGestureType = InstanceType<typeof TapGesture>;

package/lib/typescript/index.d.ts

@@ -1,10 +1,10 @@
 export { Directions } from './Directions';
 export { State } from './State';
-export { MouseButton } from './web/interfaces';
 export { PointerType } from './PointerType';
 export { default as gestureHandlerRootHOC } from './components/gestureHandlerRootHOC';
 export { default as GestureHandlerRootView } from './components/GestureHandlerRootView';
 export type { GestureEvent, HandlerStateChangeEvent, GestureEventPayload, HandlerStateChangeEventPayload, GestureTouchEvent, TouchData, GestureUpdateEvent, GestureStateChangeEvent, } from './handlers/gestureHandlerCommon';
+export { MouseButton } from './handlers/gestureHandlerCommon';
 export type { GestureType } from './handlers/gestures/gesture';
 export type { TapGestureHandlerEventPayload, TapGestureHandlerProps, } from './handlers/TapGestureHandler';
 export type { ForceTouchGestureHandlerEventPayload, ForceTouchGestureHandlerProps, } from './handlers/ForceTouchGestureHandler';

package/lib/typescript/mocks.d.ts

@@ -26,6 +26,7 @@ declare const _default: {
     readonly dropGestureHandler: () => void;
     readonly updateGestureHandler: () => void;
     readonly flushOperations: () => void;
+    readonly install: () => void;
     readonly Directions: {
         readonly RIGHT: 1;
         readonly LEFT: 2;

package/lib/typescript/specs/RNGestureHandlerButtonNativeComponent.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="react-native/types/modules/codegen" />
-import type { Int32, WithDefault } from 'react-native/Libraries/Types/CodegenTypes';
+import type { Int32, WithDefault, Float } from 'react-native/Libraries/Types/CodegenTypes';
 import type { ViewProps, ColorValue } from 'react-native';
 interface NativeProps extends ViewProps {
     exclusive?: WithDefault<boolean, true>;
@@ -9,6 +9,9 @@ interface NativeProps extends ViewProps {
     rippleColor?: ColorValue;
     rippleRadius?: Int32;
     touchSoundDisabled?: WithDefault<boolean, false>;
+    borderWidth?: Float;
+    borderColor?: ColorValue;
+    borderStyle?: WithDefault<string, 'solid'>;
 }
 declare const _default: import("react-native/Libraries/Utilities/codegenNativeComponent").NativeComponentType<NativeProps>;
 export default _default;

package/lib/typescript/web/Gestures.d.ts

@@ -0,0 +1,36 @@
+import PanGestureHandler from './handlers/PanGestureHandler';
+import TapGestureHandler from './handlers/TapGestureHandler';
+import LongPressGestureHandler from './handlers/LongPressGestureHandler';
+import PinchGestureHandler from './handlers/PinchGestureHandler';
+import RotationGestureHandler from './handlers/RotationGestureHandler';
+import FlingGestureHandler from './handlers/FlingGestureHandler';
+import NativeViewGestureHandler from './handlers/NativeViewGestureHandler';
+import ManualGestureHandler from './handlers/ManualGestureHandler';
+import HoverGestureHandler from './handlers/HoverGestureHandler';
+import HammerNativeViewGestureHandler from '../web_hammer/NativeViewGestureHandler';
+import HammerPanGestureHandler from '../web_hammer/PanGestureHandler';
+import HammerTapGestureHandler from '../web_hammer/TapGestureHandler';
+import HammerLongPressGestureHandler from '../web_hammer/LongPressGestureHandler';
+import HammerPinchGestureHandler from '../web_hammer/PinchGestureHandler';
+import HammerRotationGestureHandler from '../web_hammer/RotationGestureHandler';
+import HammerFlingGestureHandler from '../web_hammer/FlingGestureHandler';
+export declare const Gestures: {
+    NativeViewGestureHandler: typeof NativeViewGestureHandler;
+    PanGestureHandler: typeof PanGestureHandler;
+    TapGestureHandler: typeof TapGestureHandler;
+    LongPressGestureHandler: typeof LongPressGestureHandler;
+    PinchGestureHandler: typeof PinchGestureHandler;
+    RotationGestureHandler: typeof RotationGestureHandler;
+    FlingGestureHandler: typeof FlingGestureHandler;
+    ManualGestureHandler: typeof ManualGestureHandler;
+    HoverGestureHandler: typeof HoverGestureHandler;
+};
+export declare const HammerGestures: {
+    NativeViewGestureHandler: typeof HammerNativeViewGestureHandler;
+    PanGestureHandler: typeof HammerPanGestureHandler;
+    TapGestureHandler: typeof HammerTapGestureHandler;
+    LongPressGestureHandler: typeof HammerLongPressGestureHandler;
+    PinchGestureHandler: typeof HammerPinchGestureHandler;
+    RotationGestureHandler: typeof HammerRotationGestureHandler;
+    FlingGestureHandler: typeof HammerFlingGestureHandler;
+};

package/lib/typescript/web/constants.d.ts

@@ -1,7 +1,2 @@
 export declare const DEFAULT_TOUCH_SLOP = 15;
-export declare const Direction: {
-    RIGHT: number;
-    LEFT: number;
-    UP: number;
-    DOWN: number;
-};
+export declare const MINIMAL_FLING_VELOCITY = 0.1;

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

@@ -4,10 +4,8 @@ export default class FlingGestureHandler extends GestureHandler {
     private numberOfPointersRequired;
     private direction;
     private maxDurationMs;
-    private minAcceptableDelta;
+    private minVelocity;
     private delayTimeout;
-    private startX;
-    private startY;
     private maxNumberOfPointersSimultaneously;
     private keyPointer;
     init(ref: number, propsRef: React.RefObject<unknown>): void;
@@ -18,7 +16,9 @@ export default class FlingGestureHandler extends GestureHandler {
     protected onPointerDown(event: AdaptedEvent): void;
     protected onPointerAdd(event: AdaptedEvent): void;
     private newPointerAction;
+    private pointerMoveAction;
     protected onPointerMove(event: AdaptedEvent): void;
+    protected onPointerOutOfBounds(event: AdaptedEvent): void;
     protected onPointerUp(event: AdaptedEvent): void;
     protected onPointerRemove(event: AdaptedEvent): void;
     private onUp;

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

@@ -1,13 +1,15 @@
 import { State } from '../../State';
-import { Config, AdaptedEvent, MouseButton } from '../interfaces';
+import { Config, AdaptedEvent } from '../interfaces';
 import EventManager from '../tools/EventManager';
 import PointerTracker from '../tools/PointerTracker';
 import { GestureHandlerDelegate } from '../tools/GestureHandlerDelegate';
+import IGestureHandler from './IGestureHandler';
+import { MouseButton } from '../../handlers/gestureHandlerCommon';
 import { PointerType } from '../../PointerType';
-export default abstract class GestureHandler {
+export default abstract class GestureHandler implements IGestureHandler {
     private lastSentState;
     protected currentState: State;
-    protected shouldCancellWhenOutside: boolean;
+    protected shouldCancelWhenOutside: boolean;
     protected hasCustomActivationCriteria: boolean;
     protected enabled: boolean;
     private viewRef;
@@ -20,8 +22,8 @@ export default abstract class GestureHandler {
     protected active: boolean;
     protected shouldResetProgress: boolean;
     protected pointerType: PointerType;
-    protected delegate: GestureHandlerDelegate<unknown>;
-    constructor(delegate: GestureHandlerDelegate<unknown>);
+    protected delegate: GestureHandlerDelegate<unknown, IGestureHandler>;
+    constructor(delegate: GestureHandlerDelegate<unknown, IGestureHandler>);
     protected init(viewRef: number, propsRef: React.RefObject<unknown>): void;
     attachEventManager(manager: EventManager<unknown>): void;
     protected onCancel(): void;
@@ -39,7 +41,7 @@ export default abstract class GestureHandler {
      * @param {boolean} sendIfDisabled - Used when handler becomes disabled. With this flag orchestrator will be forced to send cancel event
      */
     cancel(sendIfDisabled?: boolean): void;
-    activate(_force?: boolean): void;
+    activate(force?: boolean): void;
     end(): void;
     isAwaiting(): boolean;
     setAwaiting(value: boolean): void;
@@ -49,10 +51,10 @@ export default abstract class GestureHandler {
     setShouldResetProgress(value: boolean): void;
     getActivationIndex(): number;
     setActivationIndex(value: number): void;
-    shouldWaitForHandlerFailure(handler: GestureHandler): boolean;
-    shouldRequireToWaitForFailure(handler: GestureHandler): boolean;
-    shouldRecognizeSimultaneously(handler: GestureHandler): boolean;
-    shouldBeCancelledByOther(handler: GestureHandler): boolean;
+    shouldWaitForHandlerFailure(handler: IGestureHandler): boolean;
+    shouldRequireToWaitForFailure(handler: IGestureHandler): boolean;
+    shouldRecognizeSimultaneously(handler: IGestureHandler): boolean;
+    shouldBeCancelledByOther(handler: IGestureHandler): boolean;
     protected onPointerDown(event: AdaptedEvent): void;
     protected onPointerAdd(event: AdaptedEvent): void;
     protected onPointerUp(event: AdaptedEvent): void;
@@ -81,7 +83,7 @@ export default abstract class GestureHandler {
     getTag(): number;
     setTag(tag: number): void;
     getConfig(): Config;
-    getDelegate(): GestureHandlerDelegate<unknown>;
+    getDelegate(): GestureHandlerDelegate<unknown, IGestureHandler>;
     getTracker(): PointerTracker;
     getTrackedPointersID(): number[];
     getState(): State;

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

@@ -0,0 +1,38 @@
+import type { PointerType } from '../../PointerType';
+import type { MouseButton } from '../../handlers/gestureHandlerCommon';
+import type { State } from '../../State';
+import type { Config } from '../interfaces';
+import type EventManager from '../tools/EventManager';
+import type { GestureHandlerDelegate } from '../tools/GestureHandlerDelegate';
+import type PointerTracker from '../tools/PointerTracker';
+export default interface IGestureHandler {
+    getTag: () => number;
+    getState: () => State;
+    getConfig: () => Config;
+    getDelegate: () => GestureHandlerDelegate<unknown, this>;
+    attachEventManager: (manager: EventManager<unknown>) => void;
+    isButtonInConfig: (mouseButton: MouseButton | undefined) => boolean | number | undefined;
+    getPointerType: () => PointerType;
+    getTracker: () => PointerTracker;
+    getTrackedPointersID: () => number[];
+    begin: () => void;
+    activate: (force: boolean) => void;
+    end: () => void;
+    fail: () => void;
+    cancel: () => void;
+    reset: () => void;
+    isEnabled: () => boolean;
+    isActive: () => boolean;
+    setActive: (value: boolean) => void;
+    isAwaiting: () => boolean;
+    setAwaiting: (value: boolean) => void;
+    setActivationIndex: (value: number) => void;
+    setShouldResetProgress: (value: boolean) => void;
+    shouldWaitForHandlerFailure: (handler: IGestureHandler) => boolean;
+    shouldRequireToWaitForFailure: (handler: IGestureHandler) => boolean;
+    shouldRecognizeSimultaneously: (handler: IGestureHandler) => boolean;
+    shouldBeCancelledByOther: (handler: IGestureHandler) => boolean;
+    sendEvent: (newState: State, oldState: State) => void;
+    updateGestureConfig: (config: Config) => void;
+    isButton?: () => boolean;
+}

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

@@ -21,4 +21,5 @@ export default class NativeViewGestureHandler extends GestureHandler {
     shouldRecognizeSimultaneously(handler: GestureHandler): boolean;
     shouldBeCancelledByOther(_handler: GestureHandler): boolean;
     disallowsInterruption(): boolean;
+    isButton(): boolean;
 }