react-native-gesture-handler 2.26.0 → 2.27.1

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

@@ -23,4 +23,3 @@ export declare class LongPressGesture extends BaseGesture<LongPressGestureHandle
     numberOfPointers(pointers: number): this;
 }
 export type LongPressGestureType = InstanceType<typeof LongPressGesture>;
-//# sourceMappingURL=longPressGesture.d.ts.map

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

@@ -5,4 +5,3 @@ export declare class ManualGesture extends ContinousBaseGesture<Record<string, n
     onChange(callback: (event: GestureUpdateEvent<Record<string, never>>) => void): this;
 }
 export type ManualGestureType = InstanceType<typeof ManualGesture>;
-//# sourceMappingURL=manualGesture.d.ts.map

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

@@ -16,4 +16,3 @@ export declare class NativeGesture extends BaseGesture<NativeViewGestureHandlerP
     disallowInterruption(value: boolean): this;
 }
 export type NativeGestureType = InstanceType<typeof NativeGesture>;
-//# sourceMappingURL=nativeGesture.d.ts.map

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;
+    }
+}

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

@@ -88,4 +88,3 @@ export declare class PanGesture extends ContinousBaseGesture<PanGestureHandlerEv
     onChange(callback: (event: GestureUpdateEvent<PanGestureHandlerEventPayload & PanGestureChangeEventPayload>) => void): this;
 }
 export type PanGestureType = InstanceType<typeof PanGesture>;
-//# sourceMappingURL=panGesture.d.ts.map

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

@@ -0,0 +1,181 @@
+import { ContinousBaseGesture } from './gesture';
+function changeEventCalculator(current, previous) {
+    'worklet';
+    let changePayload;
+    if (previous === undefined) {
+        changePayload = {
+            changeX: current.translationX,
+            changeY: current.translationY,
+        };
+    }
+    else {
+        changePayload = {
+            changeX: current.translationX - previous.translationX,
+            changeY: current.translationY - previous.translationY,
+        };
+    }
+    return { ...current, ...changePayload };
+}
+export class PanGesture extends ContinousBaseGesture {
+    config = {};
+    constructor() {
+        super();
+        this.handlerName = 'PanGestureHandler';
+    }
+    /**
+     * 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) {
+        if (Array.isArray(offset)) {
+            this.config.activeOffsetYStart = offset[0];
+            this.config.activeOffsetYEnd = offset[1];
+        }
+        else if (offset < 0) {
+            this.config.activeOffsetYStart = offset;
+        }
+        else {
+            this.config.activeOffsetYEnd = offset;
+        }
+        return 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) {
+        if (Array.isArray(offset)) {
+            this.config.activeOffsetXStart = offset[0];
+            this.config.activeOffsetXEnd = offset[1];
+        }
+        else if (offset < 0) {
+            this.config.activeOffsetXStart = offset;
+        }
+        else {
+            this.config.activeOffsetXEnd = offset;
+        }
+        return 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) {
+        if (Array.isArray(offset)) {
+            this.config.failOffsetYStart = offset[0];
+            this.config.failOffsetYEnd = offset[1];
+        }
+        else if (offset < 0) {
+            this.config.failOffsetYStart = offset;
+        }
+        else {
+            this.config.failOffsetYEnd = offset;
+        }
+        return 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) {
+        if (Array.isArray(offset)) {
+            this.config.failOffsetXStart = offset[0];
+            this.config.failOffsetXEnd = offset[1];
+        }
+        else if (offset < 0) {
+            this.config.failOffsetXStart = offset;
+        }
+        else {
+            this.config.failOffsetXEnd = offset;
+        }
+        return 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) {
+        this.config.minPointers = minPointers;
+        return 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) {
+        this.config.maxPointers = maxPointers;
+        return this;
+    }
+    /**
+     * Minimum distance the finger (or multiple finger) need to travel before the gesture activates.
+     * Expressed in points.
+     * @param distance
+     */
+    minDistance(distance) {
+        this.config.minDist = distance;
+        return this;
+    }
+    /**
+     * Minimum velocity the finger has to reach in order to activate handler.
+     * @param velocity
+     */
+    minVelocity(velocity) {
+        this.config.minVelocity = velocity;
+        return this;
+    }
+    /**
+     * Minimum velocity along X axis the finger has to reach in order to activate handler.
+     * @param velocity
+     */
+    minVelocityX(velocity) {
+        this.config.minVelocityX = velocity;
+        return this;
+    }
+    /**
+     * Minimum velocity along Y axis the finger has to reach in order to activate handler.
+     * @param velocity
+     */
+    minVelocityY(velocity) {
+        this.config.minVelocityY = velocity;
+        return 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) {
+        this.config.avgTouches = value;
+        return 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) {
+        this.config.enableTrackpadTwoFingerGesture = value;
+        return 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) {
+        this.config.activateAfterLongPress = duration;
+        return this;
+    }
+    onChange(callback) {
+        // @ts-ignore TS being overprotective, PanGestureHandlerEventPayload is Record
+        this.handlers.changeEventCalculator = changeEventCalculator;
+        return super.onChange(callback);
+    }
+}

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

@@ -9,4 +9,3 @@ export declare class PinchGesture extends ContinousBaseGesture<PinchGestureHandl
     onChange(callback: (event: GestureUpdateEvent<PinchGestureHandlerEventPayload & PinchGestureChangeEventPayload>) => void): this;
 }
 export type PinchGestureType = InstanceType<typeof PinchGesture>;
-//# sourceMappingURL=pinchGesture.d.ts.map

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

@@ -0,0 +1,27 @@
+import { ContinousBaseGesture } from './gesture';
+function changeEventCalculator(current, previous) {
+    'worklet';
+    let changePayload;
+    if (previous === undefined) {
+        changePayload = {
+            scaleChange: current.scale,
+        };
+    }
+    else {
+        changePayload = {
+            scaleChange: current.scale / previous.scale,
+        };
+    }
+    return { ...current, ...changePayload };
+}
+export class PinchGesture extends ContinousBaseGesture {
+    constructor() {
+        super();
+        this.handlerName = 'PinchGestureHandler';
+    }
+    onChange(callback) {
+        // @ts-ignore TS being overprotective, PinchGestureHandlerEventPayload is Record
+        this.handlers.changeEventCalculator = changeEventCalculator;
+        return super.onChange(callback);
+    }
+}

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

@@ -12,4 +12,3 @@ declare let Reanimated: {
     setGestureState: (handlerTag: number, newState: number) => void;
 } | undefined;
 export { Reanimated };
-//# sourceMappingURL=reanimatedWrapper.d.ts.map

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

@@ -0,0 +1,23 @@
+import { tagMessage } from '../../utils';
+let Reanimated;
+try {
+    Reanimated = require('react-native-reanimated');
+}
+catch (e) {
+    // When 'react-native-reanimated' is not available we want to quietly continue
+    // @ts-ignore TS demands the variable to be initialized
+    Reanimated = undefined;
+}
+if (!Reanimated?.useSharedValue) {
+    // @ts-ignore Make sure the loaded module is actually Reanimated, if it's not
+    // reset the module to undefined so we can fallback to the default implementation
+    Reanimated = undefined;
+}
+if (Reanimated !== undefined && !Reanimated.setGestureState) {
+    // The loaded module is Reanimated but it doesn't have the setGestureState defined
+    Reanimated.setGestureState = () => {
+        'worklet';
+        console.warn(tagMessage('Please use newer version of react-native-reanimated in order to control state of the gestures.'));
+    };
+}
+export { Reanimated };

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

@@ -10,4 +10,3 @@ export declare class RotationGesture extends ContinousBaseGesture<RotationGestur
 }
 export type RotationGestureType = InstanceType<typeof RotationGesture>;
 export {};
-//# sourceMappingURL=rotationGesture.d.ts.map

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

@@ -0,0 +1,27 @@
+import { ContinousBaseGesture } from './gesture';
+function changeEventCalculator(current, previous) {
+    'worklet';
+    let changePayload;
+    if (previous === undefined) {
+        changePayload = {
+            rotationChange: current.rotation,
+        };
+    }
+    else {
+        changePayload = {
+            rotationChange: current.rotation - previous.rotation,
+        };
+    }
+    return { ...current, ...changePayload };
+}
+export class RotationGesture extends ContinousBaseGesture {
+    constructor() {
+        super();
+        this.handlerName = 'RotationGestureHandler';
+    }
+    onChange(callback) {
+        // @ts-ignore TS being overprotective, RotationGestureHandlerEventPayload is Record
+        this.handlers.changeEventCalculator = changeEventCalculator;
+        return super.onChange(callback);
+    }
+}

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

@@ -48,4 +48,3 @@ export declare class TapGesture extends BaseGesture<TapGestureHandlerEventPayloa
     maxDeltaY(delta: number): this;
 }
 export type TapGestureType = InstanceType<typeof TapGesture>;
-//# sourceMappingURL=tapGesture.d.ts.map

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

@@ -0,0 +1,72 @@
+import { BaseGesture } from './gesture';
+export class TapGesture extends BaseGesture {
+    config = {};
+    constructor() {
+        super();
+        this.handlerName = 'TapGestureHandler';
+        this.shouldCancelWhenOutside(true);
+    }
+    /**
+     * 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) {
+        this.config.minPointers = minPointers;
+        return this;
+    }
+    /**
+     * Number of tap gestures required to activate the gesture.
+     * The default value is 1.
+     * @param count
+     */
+    numberOfTaps(count) {
+        this.config.numberOfTaps = count;
+        return 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) {
+        this.config.maxDist = maxDist;
+        return 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) {
+        this.config.maxDurationMs = duration;
+        return 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) {
+        this.config.maxDelayMs = delay;
+        return 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) {
+        this.config.maxDeltaX = delta;
+        return 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) {
+        this.config.maxDeltaY = delta;
+        return this;
+    }
+}

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

@@ -1,2 +1 @@
 export declare function getNextHandlerTag(): number;
-//# sourceMappingURL=getNextHandlerTag.d.ts.map

package/lib/typescript/handlers/getNextHandlerTag.js

@@ -0,0 +1,4 @@
+let handlerTag = 1;
+export function getNextHandlerTag() {
+    return handlerTag++;
+}

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

@@ -12,4 +12,3 @@ export interface GestureHandlerCallbacks {
     onGestureEvent: (event: GestureEvent<any>) => void;
     onGestureStateChange: (event: HandlerStateChangeEvent<any>) => void;
 }
-//# sourceMappingURL=handlersRegistry.d.ts.map

package/lib/typescript/handlers/handlersRegistry.js

@@ -0,0 +1,36 @@
+import { isTestEnv } from '../utils';
+export const handlerIDToTag = {};
+const gestures = new Map();
+const oldHandlers = new Map();
+const testIDs = new Map();
+export function registerHandler(handlerTag, handler, testID) {
+    gestures.set(handlerTag, handler);
+    if (isTestEnv() && testID) {
+        testIDs.set(testID, handlerTag);
+    }
+}
+export function registerOldGestureHandler(handlerTag, handler) {
+    oldHandlers.set(handlerTag, handler);
+}
+export function unregisterOldGestureHandler(handlerTag) {
+    oldHandlers.delete(handlerTag);
+}
+export function unregisterHandler(handlerTag, testID) {
+    gestures.delete(handlerTag);
+    if (isTestEnv() && testID) {
+        testIDs.delete(testID);
+    }
+}
+export function findHandler(handlerTag) {
+    return gestures.get(handlerTag);
+}
+export function findOldGestureHandler(handlerTag) {
+    return oldHandlers.get(handlerTag);
+}
+export function findHandlerByTestID(testID) {
+    const handlerTag = testIDs.get(testID);
+    if (handlerTag !== undefined) {
+        return findHandler(handlerTag) ?? null;
+    }
+    return null;
+}

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

@@ -5,4 +5,3 @@ export declare function filterConfig(props: Record<string, unknown>, validProps:
 export declare function transformIntoHandlerTags(handlerIDs: any): any;
 export declare function findNodeHandle(node: null | number | React.Component<any, any> | React.ComponentClass<any>): null | number | React.Component<any, any> | React.ComponentClass<any>;
 export declare function scheduleFlushOperations(): void;
-//# sourceMappingURL=utils.d.ts.map

package/lib/typescript/handlers/utils.js

@@ -0,0 +1,58 @@
+import { Platform, findNodeHandle as findNodeHandleRN } from 'react-native';
+import { handlerIDToTag } from './handlersRegistry';
+import { toArray } from '../utils';
+import RNGestureHandlerModule from '../RNGestureHandlerModule';
+import { ghQueueMicrotask } from '../ghQueueMicrotask';
+function isConfigParam(param, name) {
+    // param !== Object(param) returns false if `param` is a function
+    // or an object and returns true if `param` is null
+    return (param !== undefined &&
+        (param !== Object(param) ||
+            !('__isNative' in param)) &&
+        name !== 'onHandlerStateChange' &&
+        name !== 'onGestureEvent');
+}
+export function filterConfig(props, validProps, defaults = {}) {
+    const filteredConfig = { ...defaults };
+    for (const key of validProps) {
+        let value = props[key];
+        if (isConfigParam(value, key)) {
+            if (key === 'simultaneousHandlers' || key === 'waitFor') {
+                value = transformIntoHandlerTags(props[key]);
+            }
+            else if (key === 'hitSlop' && typeof value !== 'object') {
+                value = { top: value, left: value, bottom: value, right: value };
+            }
+            filteredConfig[key] = value;
+        }
+    }
+    return filteredConfig;
+}
+export function transformIntoHandlerTags(handlerIDs) {
+    handlerIDs = toArray(handlerIDs);
+    if (Platform.OS === 'web') {
+        return handlerIDs
+            .map(({ current }) => current)
+            .filter((handle) => handle);
+    }
+    // converts handler string IDs into their numeric tags
+    return handlerIDs
+        .map((handlerID) => handlerIDToTag[handlerID] || handlerID.current?.handlerTag || -1)
+        .filter((handlerTag) => handlerTag > 0);
+}
+export function findNodeHandle(node) {
+    if (Platform.OS === 'web') {
+        return node;
+    }
+    return findNodeHandleRN(node) ?? null;
+}
+let flushOperationsScheduled = false;
+export function scheduleFlushOperations() {
+    if (!flushOperationsScheduled) {
+        flushOperationsScheduled = true;
+        ghQueueMicrotask(() => {
+            RNGestureHandlerModule.flushOperations();
+            flushOperationsScheduled = false;
+        });
+    }
+}

package/lib/typescript/index.d.ts

@@ -56,4 +56,3 @@ export { default as Pressable } from './components/Pressable';
 export type { DrawerLayoutProps, DrawerPosition, DrawerState, DrawerType, DrawerLockMode, DrawerKeyboardDismissMode, } from './components/DrawerLayout';
 export { default as DrawerLayout } from './components/DrawerLayout';
 export { enableExperimentalWebImplementation, enableLegacyWebImplementation, } from './EnableNewWebImplementation';
-//# sourceMappingURL=index.d.ts.map

package/lib/typescript/index.js

@@ -0,0 +1,28 @@
+import { initialize } from './init';
+export { Directions } from './Directions';
+export { State } from './State';
+export { PointerType } from './PointerType';
+export { default as gestureHandlerRootHOC } from './components/gestureHandlerRootHOC';
+export { default as GestureHandlerRootView } from './components/GestureHandlerRootView';
+export { MouseButton } from './handlers/gestureHandlerCommon';
+export { TapGestureHandler } from './handlers/TapGestureHandler';
+export { ForceTouchGestureHandler } from './handlers/ForceTouchGestureHandler';
+export { LongPressGestureHandler } from './handlers/LongPressGestureHandler';
+export { PanGestureHandler } from './handlers/PanGestureHandler';
+export { PinchGestureHandler } from './handlers/PinchGestureHandler';
+export { RotationGestureHandler } from './handlers/RotationGestureHandler';
+export { FlingGestureHandler } from './handlers/FlingGestureHandler';
+export { default as createNativeWrapper } from './handlers/createNativeWrapper';
+export { GestureDetector } from './handlers/gestures/GestureDetector';
+export { GestureObjects as Gesture } from './handlers/gestures/gestureObjects';
+export { NativeViewGestureHandler } from './handlers/NativeViewGestureHandler';
+export { RawButton, BaseButton, RectButton, BorderlessButton, PureNativeButton, } from './components/GestureButtons';
+export { TouchableHighlight, TouchableNativeFeedback, TouchableOpacity, TouchableWithoutFeedback, } from './components/touchables';
+export { ScrollView, Switch, TextInput, DrawerLayoutAndroid, FlatList, RefreshControl, } from './components/GestureComponents';
+export { Text } from './components/Text';
+export { HoverEffect } from './handlers/gestures/hoverGesture';
+export { default as Swipeable } from './components/Swipeable';
+export { default as Pressable } from './components/Pressable';
+export { default as DrawerLayout } from './components/DrawerLayout';
+export { enableExperimentalWebImplementation, enableLegacyWebImplementation, } from './EnableNewWebImplementation';
+initialize();

package/lib/typescript/init.d.ts

@@ -1,3 +1,2 @@
 export declare function initialize(): void;
 export declare function maybeInitializeFabric(): void;
-//# sourceMappingURL=init.d.ts.map

package/lib/typescript/init.js

@@ -0,0 +1,15 @@
+import { startListening } from './handlers/gestures/eventReceiver';
+import RNGestureHandlerModule from './RNGestureHandlerModule';
+import { isFabric } from './utils';
+let fabricInitialized = false;
+export function initialize() {
+    startListening();
+}
+// Since isFabric() may give wrong results before the first render, we call this
+// method during render of GestureHandlerRootView
+export function maybeInitializeFabric() {
+    if (isFabric() && !fabricInitialized) {
+        RNGestureHandlerModule.install();
+        fabricInitialized = true;
+    }
+}

package/lib/typescript/jestUtils/index.d.ts

@@ -1,2 +1 @@
 export { getByGestureTestId, fireGestureHandler } from './jestUtils';
-//# sourceMappingURL=index.d.ts.map

package/lib/typescript/jestUtils/index.js

@@ -0,0 +1 @@
+export { getByGestureTestId, fireGestureHandler } from './jestUtils';

package/lib/typescript/jestUtils/jestUtils.d.ts

@@ -27,4 +27,3 @@ type ExtractConfig<T> = T extends BaseGesture<infer TGesturePayload> ? TGestureP
 export declare function fireGestureHandler<THandler extends AllGestures | AllHandlers>(componentOrGesture: ReactTestInstance | GestureType, eventList?: Partial<GestureHandlerTestEvent<ExtractConfig<THandler>>>[]): void;
 export declare function getByGestureTestId(testID: string): BaseGesture<Record<string, unknown>> | BaseGesture<Record<string, never>> | BaseGesture<TapGestureHandlerEventPayload> | BaseGesture<PanGestureHandlerEventPayload> | BaseGesture<LongPressGestureHandlerEventPayload> | BaseGesture<RotationGestureHandlerEventPayload> | BaseGesture<PinchGestureHandlerEventPayload> | BaseGesture<ForceTouchGestureHandlerEventPayload> | BaseGesture<NativeViewGestureHandlerPayload> | BaseGesture<import("../handlers/GestureHandlerEventPayload").HoverGestureHandlerEventPayload>;
 export {};
-//# sourceMappingURL=jestUtils.d.ts.map