react-native-gesture-handler 2.27.0 → 2.27.1

package/lib/typescript/handlers/gestures/gestureComposition.js

@@ -0,0 +1,78 @@
+import { BaseGesture, Gesture } from './gesture';
+function extendRelation(currentRelation, extendWith) {
+    if (currentRelation === undefined) {
+        return [...extendWith];
+    }
+    else {
+        return [...currentRelation, ...extendWith];
+    }
+}
+export class ComposedGesture extends Gesture {
+    gestures = [];
+    simultaneousGestures = [];
+    requireGesturesToFail = [];
+    constructor(...gestures) {
+        super();
+        this.gestures = gestures;
+    }
+    prepareSingleGesture(gesture, simultaneousGestures, requireGesturesToFail) {
+        if (gesture instanceof BaseGesture) {
+            const newConfig = { ...gesture.config };
+            // No need to extend `blocksHandlers` here, because it's not changed in composition.
+            // The same effect is achieved by reversing the order of 2 gestures in `Exclusive`
+            newConfig.simultaneousWith = extendRelation(newConfig.simultaneousWith, simultaneousGestures);
+            newConfig.requireToFail = extendRelation(newConfig.requireToFail, requireGesturesToFail);
+            gesture.config = newConfig;
+        }
+        else if (gesture instanceof ComposedGesture) {
+            gesture.simultaneousGestures = simultaneousGestures;
+            gesture.requireGesturesToFail = requireGesturesToFail;
+            gesture.prepare();
+        }
+    }
+    prepare() {
+        for (const gesture of this.gestures) {
+            this.prepareSingleGesture(gesture, this.simultaneousGestures, this.requireGesturesToFail);
+        }
+    }
+    initialize() {
+        for (const gesture of this.gestures) {
+            gesture.initialize();
+        }
+    }
+    toGestureArray() {
+        return this.gestures.flatMap((gesture) => gesture.toGestureArray());
+    }
+}
+export class SimultaneousGesture extends ComposedGesture {
+    prepare() {
+        // This piece of magic works something like this:
+        // for every gesture in the array
+        const simultaneousArrays = this.gestures.map((gesture) => 
+        // we take the array it's in
+        this.gestures
+            // and make a copy without it
+            .filter((x) => x !== gesture)
+            // then we flatmap the result to get list of raw (not composed) gestures
+            // this way we don't make the gestures simultaneous with themselves, which is
+            // important when the gesture is `ExclusiveGesture` - we don't want to make
+            // exclusive gestures simultaneous
+            .flatMap((x) => x.toGestureArray()));
+        for (let i = 0; i < this.gestures.length; i++) {
+            this.prepareSingleGesture(this.gestures[i], simultaneousArrays[i], this.requireGesturesToFail);
+        }
+    }
+}
+export class ExclusiveGesture extends ComposedGesture {
+    prepare() {
+        // Transforms the array of gestures into array of grouped raw (not composed) gestures
+        // i.e. [gesture1, gesture2, ComposedGesture(gesture3, gesture4)] -> [[gesture1], [gesture2], [gesture3, gesture4]]
+        const gestureArrays = this.gestures.map((gesture) => gesture.toGestureArray());
+        let requireToFail = [];
+        for (let i = 0; i < this.gestures.length; i++) {
+            this.prepareSingleGesture(this.gestures[i], this.simultaneousGestures, this.requireGesturesToFail.concat(requireToFail));
+            // Every group gets to wait for all groups before it
+            requireToFail = requireToFail.concat(gestureArrays[i]);
+        }
+    }
+}

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

@@ -0,0 +1,100 @@
+import { FlingGesture } from './flingGesture';
+import { ForceTouchGesture } from './forceTouchGesture';
+import { Gesture } from './gesture';
+import { ComposedGesture, ExclusiveGesture, SimultaneousGesture } from './gestureComposition';
+import { LongPressGesture } from './longPressGesture';
+import { PanGesture } from './panGesture';
+import { PinchGesture } from './pinchGesture';
+import { RotationGesture } from './rotationGesture';
+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;
+    /**
+     * @deprecated ForceTouch gesture is deprecated and will be removed in the future.
+     *
+     *  #### 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;
+    /**
+     * Builds a composed gesture where only one of the provided gestures can become active.
+     * Priority is decided through the order of gestures: the first one has higher priority
+     * 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/gestureObjects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gestureObjects.d.ts","sourceRoot":"","sources":["../../../../src/handlers/gestures/gestureObjects.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EACL,eAAe,EACf,gBAAgB,EAChB,mBAAmB,EACpB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE9C;;;;;;;GAOG;AACH,eAAO,MAAM,cAAc;IACzB;;;OAGG;;IAKH;;;OAGG;;IAKH;;;OAGG;;IAKH;;;OAGG;;IAKH;;;OAGG;;IAKH;;;OAGG;;IAKH;;;;;;OAMG;;IAKH;;;;OAIG;;IAKH;;;;;OAKG;;IAKH;;;;;OAKG;;IAKH;;;;OAIG;wBACiB,OAAO,EAAE;IAI7B;;;OAGG;8BACuB,OAAO,EAAE;IAInC;;;;;;;OAOG;2BACoB,OAAO,EAAE;CAGjC,CAAC"}

package/lib/typescript/handlers/gestures/gestureObjects.js

@@ -0,0 +1,125 @@
+import { FlingGesture } from './flingGesture';
+import { ForceTouchGesture } from './forceTouchGesture';
+import { ComposedGesture, ExclusiveGesture, SimultaneousGesture, } from './gestureComposition';
+import { LongPressGesture } from './longPressGesture';
+import { PanGesture } from './panGesture';
+import { PinchGesture } from './pinchGesture';
+import { RotationGesture } from './rotationGesture';
+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 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: () => {
+        return new 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: () => {
+        return new 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: () => {
+        return new 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: () => {
+        return new 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: () => {
+        return new 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: () => {
+        return new LongPressGesture();
+    },
+    /**
+     * @deprecated ForceTouch gesture is deprecated and will be removed in the future.
+     *
+     *  #### 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: () => {
+        return new 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: () => {
+        return new 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: () => {
+        return new 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: () => {
+        return new 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) => {
+        return new ComposedGesture(...gestures);
+    },
+    /**
+     * 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) {
+        return new SimultaneousGesture(...gestures);
+    },
+    /**
+     * Builds a composed gesture where only one of the provided gestures can become active.
+     * Priority is decided through the order of gestures: the first one has higher priority
+     * 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) {
+        return new ExclusiveGesture(...gestures);
+    },
+};

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

@@ -0,0 +1,11 @@
+export interface GestureStateManagerType {
+    begin: () => void;
+    activate: () => void;
+    fail: () => void;
+    end: () => void;
+}
+declare function create(handlerTag: number): GestureStateManagerType;
+export declare const GestureStateManager: {
+    create: typeof create;
+};
+export {};

package/lib/typescript/handlers/gestures/gestureStateManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gestureStateManager.d.ts","sourceRoot":"","sources":["../../../../src/handlers/gestures/gestureStateManager.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,uBAAuB;IACtC,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB,QAAQ,EAAE,MAAM,IAAI,CAAC;IACrB,IAAI,EAAE,MAAM,IAAI,CAAC;IACjB,GAAG,EAAE,MAAM,IAAI,CAAC;CACjB;AAWD,iBAAS,MAAM,CAAC,UAAU,EAAE,MAAM,GAAG,uBAAuB,CA+C3D;AAED,eAAO,MAAM,mBAAmB;;CAE/B,CAAC"}

package/lib/typescript/handlers/gestures/gestureStateManager.js

@@ -0,0 +1,60 @@
+import { Reanimated } from './reanimatedWrapper';
+import { State } from '../../State';
+import { tagMessage } from '../../utils';
+const warningMessage = tagMessage('react-native-reanimated is required in order to use synchronous state management');
+// Check if reanimated module is available, but look for useSharedValue as conditional
+// require of reanimated can sometimes return content of `utils.ts` file (?)
+const REANIMATED_AVAILABLE = Reanimated?.useSharedValue !== undefined;
+const setGestureState = Reanimated?.setGestureState;
+function create(handlerTag) {
+    'worklet';
+    return {
+        begin: () => {
+            'worklet';
+            if (REANIMATED_AVAILABLE) {
+                // When Reanimated is available, setGestureState should be defined
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                setGestureState(handlerTag, State.BEGAN);
+            }
+            else {
+                console.warn(warningMessage);
+            }
+        },
+        activate: () => {
+            'worklet';
+            if (REANIMATED_AVAILABLE) {
+                // When Reanimated is available, setGestureState should be defined
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                setGestureState(handlerTag, State.ACTIVE);
+            }
+            else {
+                console.warn(warningMessage);
+            }
+        },
+        fail: () => {
+            'worklet';
+            if (REANIMATED_AVAILABLE) {
+                // When Reanimated is available, setGestureState should be defined
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                setGestureState(handlerTag, State.FAILED);
+            }
+            else {
+                console.warn(warningMessage);
+            }
+        },
+        end: () => {
+            'worklet';
+            if (REANIMATED_AVAILABLE) {
+                // When Reanimated is available, setGestureState should be defined
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                setGestureState(handlerTag, State.END);
+            }
+            else {
+                console.warn(warningMessage);
+            }
+        },
+    };
+}
+export const GestureStateManager = {
+    create,
+};

package/lib/typescript/handlers/gestures/gestureStateManager.web.d.ts

@@ -0,0 +1,4 @@
+import { GestureStateManagerType } from './gestureStateManager';
+export declare const GestureStateManager: {
+    create(handlerTag: number): GestureStateManagerType;
+};

package/lib/typescript/handlers/gestures/gestureStateManager.web.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gestureStateManager.web.d.ts","sourceRoot":"","sources":["../../../../src/handlers/gestures/gestureStateManager.web.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAC;AAEhE,eAAO,MAAM,mBAAmB;uBACX,MAAM,GAAG,uBAAuB;CAmBpD,CAAC"}

package/lib/typescript/handlers/gestures/gestureStateManager.web.js

@@ -0,0 +1,19 @@
+import NodeManager from '../../web/tools/NodeManager';
+export const GestureStateManager = {
+    create(handlerTag) {
+        return {
+            begin: () => {
+                NodeManager.getHandler(handlerTag).begin();
+            },
+            activate: () => {
+                NodeManager.getHandler(handlerTag).activate(true);
+            },
+            fail: () => {
+                NodeManager.getHandler(handlerTag).fail();
+            },
+            end: () => {
+                NodeManager.getHandler(handlerTag).end();
+            },
+        };
+    },
+};

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

@@ -0,0 +1,27 @@
+import { BaseGestureConfig, ContinousBaseGesture } from './gesture';
+import { GestureUpdateEvent } from '../gestureHandlerCommon';
+import type { HoverGestureHandlerEventPayload } from '../GestureHandlerEventPayload';
+export type HoverGestureChangeEventPayload = {
+    changeX: number;
+    changeY: number;
+};
+export declare enum HoverEffect {
+    NONE = 0,
+    LIFT = 1,
+    HIGHLIGHT = 2
+}
+export interface HoverGestureConfig {
+    hoverEffect?: HoverEffect;
+}
+export declare const hoverGestureHandlerProps: readonly ["hoverEffect"];
+export declare class HoverGesture extends ContinousBaseGesture<HoverGestureHandlerEventPayload, HoverGestureChangeEventPayload> {
+    config: BaseGestureConfig & HoverGestureConfig;
+    constructor();
+    /**
+     * #### iOS only
+     * Sets the visual hover effect.
+     */
+    effect(effect: HoverEffect): this;
+    onChange(callback: (event: GestureUpdateEvent<HoverGestureHandlerEventPayload & HoverGestureChangeEventPayload>) => void): this;
+}
+export type HoverGestureType = InstanceType<typeof HoverGesture>;

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

@@ -0,0 +1 @@
+{"version":3,"file":"hoverGesture.d.ts","sourceRoot":"","sources":["../../../../src/handlers/gestures/hoverGesture.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,MAAM,WAAW,CAAC;AACpE,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,+BAA+B,CAAC;AAErF,MAAM,MAAM,8BAA8B,GAAG;IAC3C,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,oBAAY,WAAW;IACrB,IAAI,IAAI;IACR,IAAI,IAAI;IACR,SAAS,IAAI;CACd;AAED,MAAM,WAAW,kBAAkB;IACjC,WAAW,CAAC,EAAE,WAAW,CAAC;CAC3B;AAED,eAAO,MAAM,wBAAwB,0BAA2B,CAAC;AAuBjE,qBAAa,YAAa,SAAQ,oBAAoB,CACpD,+BAA+B,EAC/B,8BAA8B,CAC/B;IACQ,MAAM,EAAE,iBAAiB,GAAG,kBAAkB,CAAM;;IAQ3D;;;OAGG;IACH,MAAM,CAAC,MAAM,EAAE,WAAW;IAK1B,QAAQ,CACN,QAAQ,EAAE,CACR,KAAK,EAAE,kBAAkB,CACvB,+BAA+B,GAAG,8BAA8B,CACjE,KACE,IAAI;CAMZ;AAED,MAAM,MAAM,gBAAgB,GAAG,YAAY,CAAC,OAAO,YAAY,CAAC,CAAC"}

package/lib/typescript/handlers/gestures/hoverGesture.js

@@ -0,0 +1,45 @@
+import { ContinousBaseGesture } from './gesture';
+export var HoverEffect;
+(function (HoverEffect) {
+    HoverEffect[HoverEffect["NONE"] = 0] = "NONE";
+    HoverEffect[HoverEffect["LIFT"] = 1] = "LIFT";
+    HoverEffect[HoverEffect["HIGHLIGHT"] = 2] = "HIGHLIGHT";
+})(HoverEffect || (HoverEffect = {}));
+export const hoverGestureHandlerProps = ['hoverEffect'];
+function changeEventCalculator(current, previous) {
+    'worklet';
+    let changePayload;
+    if (previous === undefined) {
+        changePayload = {
+            changeX: current.x,
+            changeY: current.y,
+        };
+    }
+    else {
+        changePayload = {
+            changeX: current.x - previous.x,
+            changeY: current.y - previous.y,
+        };
+    }
+    return { ...current, ...changePayload };
+}
+export class HoverGesture extends ContinousBaseGesture {
+    config = {};
+    constructor() {
+        super();
+        this.handlerName = 'HoverGestureHandler';
+    }
+    /**
+     * #### iOS only
+     * Sets the visual hover effect.
+     */
+    effect(effect) {
+        this.config.hoverEffect = effect;
+        return this;
+    }
+    onChange(callback) {
+        // @ts-ignore TS being overprotective, HoverGestureHandlerEventPayload is Record
+        this.handlers.changeEventCalculator = changeEventCalculator;
+        return super.onChange(callback);
+    }
+}

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

@@ -0,0 +1,25 @@
+import { BaseGesture, BaseGestureConfig } from './gesture';
+import { LongPressGestureConfig } from '../LongPressGestureHandler';
+import type { LongPressGestureHandlerEventPayload } from '../GestureHandlerEventPayload';
+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;
+    /**
+     * Determine exact number of points required to handle the long press gesture.
+     * @param pointers
+     */
+    numberOfPointers(pointers: number): this;
+}
+export type LongPressGestureType = InstanceType<typeof LongPressGesture>;

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

@@ -0,0 +1 @@
+{"version":3,"file":"longPressGesture.d.ts","sourceRoot":"","sources":["../../../../src/handlers/gestures/longPressGesture.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAC3D,OAAO,EAAE,sBAAsB,EAAE,MAAM,4BAA4B,CAAC;AACpE,OAAO,KAAK,EAAE,mCAAmC,EAAE,MAAM,+BAA+B,CAAC;AAEzF,qBAAa,gBAAiB,SAAQ,WAAW,CAAC,mCAAmC,CAAC;IAC7E,MAAM,EAAE,iBAAiB,GAAG,sBAAsB,CAAM;;IAS/D;;;;OAIG;IACH,WAAW,CAAC,QAAQ,EAAE,MAAM;IAK5B;;;;OAIG;IACH,WAAW,CAAC,QAAQ,EAAE,MAAM;IAK5B;;;OAGG;IACH,gBAAgB,CAAC,QAAQ,EAAE,MAAM;CAIlC;AAED,MAAM,MAAM,oBAAoB,GAAG,YAAY,CAAC,OAAO,gBAAgB,CAAC,CAAC"}

package/lib/typescript/handlers/gestures/longPressGesture.js

@@ -0,0 +1,35 @@
+import { BaseGesture } from './gesture';
+export class LongPressGesture extends BaseGesture {
+    config = {};
+    constructor() {
+        super();
+        this.handlerName = 'LongPressGestureHandler';
+        this.shouldCancelWhenOutside(true);
+    }
+    /**
+     * Minimum time, expressed in milliseconds, that a finger must remain pressed on the corresponding view.
+     * The default value is 500.
+     * @param duration
+     */
+    minDuration(duration) {
+        this.config.minDurationMs = duration;
+        return 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) {
+        this.config.maxDist = distance;
+        return this;
+    }
+    /**
+     * Determine exact number of points required to handle the long press gesture.
+     * @param pointers
+     */
+    numberOfPointers(pointers) {
+        this.config.numberOfPointers = pointers;
+        return this;
+    }
+}

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

@@ -0,0 +1,7 @@
+import { GestureUpdateEvent } from '../gestureHandlerCommon';
+import { ContinousBaseGesture } from './gesture';
+export declare class ManualGesture extends ContinousBaseGesture<Record<string, never>, Record<string, never>> {
+    constructor();
+    onChange(callback: (event: GestureUpdateEvent<Record<string, never>>) => void): this;
+}
+export type ManualGestureType = InstanceType<typeof ManualGesture>;

package/lib/typescript/handlers/gestures/manualGesture.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manualGesture.d.ts","sourceRoot":"","sources":["../../../../src/handlers/gestures/manualGesture.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,EAAE,oBAAoB,EAAE,MAAM,WAAW,CAAC;AAUjD,qBAAa,aAAc,SAAQ,oBAAoB,CACrD,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,EACrB,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CACtB;;IAOC,QAAQ,CACN,QAAQ,EAAE,CAAC,KAAK,EAAE,kBAAkB,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,KAAK,IAAI;CAMvE;AAED,MAAM,MAAM,iBAAiB,GAAG,YAAY,CAAC,OAAO,aAAa,CAAC,CAAC"}

package/lib/typescript/handlers/gestures/manualGesture.js

@@ -0,0 +1,16 @@
+import { ContinousBaseGesture } from './gesture';
+function changeEventCalculator(current, _previous) {
+    'worklet';
+    return current;
+}
+export class ManualGesture extends ContinousBaseGesture {
+    constructor() {
+        super();
+        this.handlerName = 'ManualGestureHandler';
+    }
+    onChange(callback) {
+        // @ts-ignore TS being overprotective, Record<string, never> is Record
+        this.handlers.changeEventCalculator = changeEventCalculator;
+        return super.onChange(callback);
+    }
+}

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

@@ -0,0 +1,18 @@
+import { BaseGestureConfig, BaseGesture } from './gesture';
+import { NativeViewGestureConfig } from '../NativeViewGestureHandler';
+import type { NativeViewGestureHandlerPayload } from '../GestureHandlerEventPayload';
+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/nativeGesture.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nativeGesture.d.ts","sourceRoot":"","sources":["../../../../src/handlers/gestures/nativeGesture.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAC3D,OAAO,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAC;AACtE,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,+BAA+B,CAAC;AAErF,qBAAa,aAAc,SAAQ,WAAW,CAAC,+BAA+B,CAAC;IACtE,MAAM,EAAE,iBAAiB,GAAG,uBAAuB,CAAM;;IAQhE;;;OAGG;IACH,qBAAqB,CAAC,KAAK,EAAE,OAAO;IAKpC;;;OAGG;IACH,oBAAoB,CAAC,KAAK,EAAE,OAAO;CAIpC;AAED,MAAM,MAAM,iBAAiB,GAAG,YAAY,CAAC,OAAO,aAAa,CAAC,CAAC"}

package/lib/typescript/handlers/gestures/nativeGesture.js

@@ -0,0 +1,24 @@
+import { BaseGesture } from './gesture';
+export class NativeGesture extends BaseGesture {
+    config = {};
+    constructor() {
+        super();
+        this.handlerName = 'NativeViewGestureHandler';
+    }
+    /**
+     * When true, underlying handler will activate unconditionally when in `BEGAN` or `UNDETERMINED` state.
+     * @param value
+     */
+    shouldActivateOnStart(value) {
+        this.config.shouldActivateOnStart = value;
+        return this;
+    }
+    /**
+     * When true, cancels all other gesture handlers when this `NativeViewGestureHandler` receives an `ACTIVE` state event.
+     * @param value
+     */
+    disallowInterruption(value) {
+        this.config.disallowInterruption = value;
+        return this;
+    }
+}