@onlynative/inertia-gestures 0.0.1-alpha.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 OnlyNative
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.mts

@@ -0,0 +1,207 @@
+import { PanGesture } from 'react-native-gesture-handler';
+import { useAnimatedStyle, SharedValue } from 'react-native-reanimated';
+
+/**
+ * Public types for `@onlynative/inertia-gestures`.
+ */
+/**
+ * Bounds the dragged value can reach. Each side is optional — omit to leave
+ * that direction unbounded. Coordinates are in the same space the drag
+ * publishes (pixels of translation from the dragged element's resting
+ * position), so `{ left: -100, right: 100 }` allows ±100 px of horizontal
+ * travel.
+ */
+interface DragConstraints {
+    left?: number;
+    right?: number;
+    top?: number;
+    bottom?: number;
+}
+/**
+ * Configuration for `useDrag`. All fields are optional; the defaults give an
+ * unconstrained two-axis drag with no elasticity.
+ */
+interface DragOptions {
+    /**
+     * Restrict the drag to one axis. Defaults to `'both'`. When `'x'` is set
+     * the y-axis shared value never updates (and vice versa); the gesture
+     * still tracks both for velocity reporting on `onDragEnd`.
+     */
+    axis?: 'x' | 'y' | 'both';
+    /**
+     * Travel bounds. Out-of-bounds values clamp to the limit unless `elastic`
+     * is non-zero, in which case overshoot is dampened (rubber-band feel).
+     */
+    constraints?: DragConstraints;
+    /**
+     * Rubber-band coefficient applied to overshoot past `constraints`. `0`
+     * (default) hard-clamps; `1` is fully elastic (no resistance). Typical
+     * Framer-Motion-style feel sits around `0.2`–`0.4`.
+     */
+    elastic?: number;
+    /**
+     * Fired on the JS thread when the drag begins.
+     */
+    onDragStart?: () => void;
+    /**
+     * Fired on the JS thread when the drag finishes (release or cancel). The
+     * payload is the final translation and the release velocity in px/sec.
+     */
+    onDragEnd?: (info: {
+        x: number;
+        y: number;
+        velocity: {
+            x: number;
+            y: number;
+        };
+    }) => void;
+}
+
+interface UseDragResult {
+    /** Pan gesture to pass to a `<GestureDetector>`. */
+    gesture: PanGesture;
+    /**
+     * Animated style fragment (a single `transform` entry) to stack onto the
+     * dragged Motion primitive's `style` prop. Stable across renders.
+     */
+    animatedStyle: ReturnType<typeof useAnimatedStyle>;
+    /** Current x translation in pixels. UI-thread shared value. */
+    dragX: SharedValue<number>;
+    /** Current y translation in pixels. UI-thread shared value. */
+    dragY: SharedValue<number>;
+    /** True while the gesture is active. */
+    isDragging: SharedValue<boolean>;
+}
+/**
+ * Drag a Motion primitive with `react-native-gesture-handler`'s pan gesture.
+ *
+ * The hook owns a pair of shared values (`dragX`, `dragY`) and a `Pan`
+ * gesture that updates them on the UI thread. The returned `animatedStyle`
+ * is a self-contained `transform: [{ translateX }, { translateY }]` fragment;
+ * stack it onto the dragged component without colliding with Motion's own
+ * `animate` transforms.
+ *
+ * Usage:
+ * ```tsx
+ * const drag = useDrag({ axis: 'x', constraints: { left: -100, right: 100 } })
+ * return (
+ *   <GestureDetector gesture={drag.gesture}>
+ *     <Motion.View style={drag.animatedStyle} />
+ *   </GestureDetector>
+ * )
+ * ```
+ */
+declare function useDrag(options?: DragOptions): UseDragResult;
+
+type SwipeDirection = 'left' | 'right' | 'up' | 'down';
+interface SwipeOptions {
+    /**
+     * Allowed swipe directions. Defaults to all four. The gesture only commits
+     * for directions in this list — a horizontal swipe with `directions:
+     * ['up', 'down']` will not fire `onSwipe`.
+     */
+    directions?: SwipeDirection[];
+    /**
+     * Pixel distance threshold past which a release commits the swipe. Defaults
+     * to `80`.
+     */
+    distanceThreshold?: number;
+    /**
+     * Velocity threshold (px/sec) past which a release commits the swipe even
+     * before the distance threshold is reached — flick-style gestures. Defaults
+     * to `800`.
+     */
+    velocityThreshold?: number;
+    /**
+     * Fired on the JS thread when the gesture commits in an allowed direction.
+     */
+    onSwipe?: (direction: SwipeDirection, info: {
+        distance: number;
+        velocity: number;
+    }) => void;
+}
+interface UseSwipeResult {
+    /** Pan gesture to pass to a `<GestureDetector>`. */
+    gesture: PanGesture;
+    /**
+     * Animated style fragment exposing live translation while the gesture is
+     * active. Snaps back to `{ 0, 0 }` after release (whether or not the swipe
+     * committed) via a default spring.
+     */
+    animatedStyle: ReturnType<typeof useAnimatedStyle>;
+    /** Live x translation. */
+    swipeX: SharedValue<number>;
+    /** Live y translation. */
+    swipeY: SharedValue<number>;
+    /** True while the user is actively swiping. */
+    isActive: SharedValue<boolean>;
+}
+/**
+ * Directional commit-or-snap-back gesture. Tracks live translation while the
+ * user drags and fires `onSwipe(direction)` on release if either the distance
+ * or velocity threshold is exceeded in an allowed direction. The position
+ * shared values always animate back to zero — the consumer is responsible
+ * for whatever side effect the commit drives (delete a row, dismiss a sheet,
+ * etc.).
+ *
+ * Usage:
+ * ```tsx
+ * const swipe = useSwipe({
+ *   directions: ['left'],
+ *   onSwipe: (dir) => deleteRow(),
+ * })
+ * return (
+ *   <GestureDetector gesture={swipe.gesture}>
+ *     <Motion.View style={swipe.animatedStyle}>...</Motion.View>
+ *   </GestureDetector>
+ * )
+ * ```
+ */
+declare function useSwipe(options?: SwipeOptions): UseSwipeResult;
+
+interface PanOptions {
+    /**
+     * Translation bounds. Each side is optional; out-of-bounds motion during
+     * the active gesture and during the post-release decay is hard-clamped
+     * (Reanimated's `withDecay` `clamp` param). Decay-style overshoot is not
+     * supported here — for rubber-banded bounds, prefer `useDrag` with
+     * `elastic`.
+     */
+    constraints?: DragConstraints;
+    /**
+     * Deceleration applied to the post-release momentum. Higher = momentum
+     * dies faster. Reanimated default is `0.998`; lower values feel more
+     * "slippy". Range: roughly `0.99` (slow) to `0.999` (long glide).
+     */
+    deceleration?: number;
+    /**
+     * Disable the post-release momentum entirely. Defaults to `false` — pan
+     * coasts after release. Set to `true` for a hard stop on release (drag-like
+     * behavior).
+     */
+    disableMomentum?: boolean;
+}
+interface UsePanResult {
+    /** Pan gesture to pass to a `<GestureDetector>`. */
+    gesture: PanGesture;
+    /** Stable animated `transform` style. */
+    animatedStyle: ReturnType<typeof useAnimatedStyle>;
+    /** Live x translation, persistent across gestures. */
+    panX: SharedValue<number>;
+    /** Live y translation, persistent across gestures. */
+    panY: SharedValue<number>;
+    /** True while the user is actively panning. Decay phase reads `false`. */
+    isPanning: SharedValue<boolean>;
+}
+/**
+ * Camera-pan-style drag with momentum on release. Translation persists
+ * across separate pan gestures (the next pan starts from the current
+ * position, not zero), and on release the translation continues to glide
+ * via Reanimated's `withDecay` until friction stops it.
+ *
+ * Use for map / zoom-canvas / large-image navigation. For dragging an
+ * element to a position with no momentum, use `useDrag` instead.
+ */
+declare function usePan(options?: PanOptions): UsePanResult;
+
+export { type DragConstraints, type DragOptions, type PanOptions, type SwipeDirection, type SwipeOptions, type UseDragResult, type UsePanResult, type UseSwipeResult, useDrag, usePan, useSwipe };

package/dist/index.d.ts

@@ -0,0 +1,207 @@
+import { PanGesture } from 'react-native-gesture-handler';
+import { useAnimatedStyle, SharedValue } from 'react-native-reanimated';
+
+/**
+ * Public types for `@onlynative/inertia-gestures`.
+ */
+/**
+ * Bounds the dragged value can reach. Each side is optional — omit to leave
+ * that direction unbounded. Coordinates are in the same space the drag
+ * publishes (pixels of translation from the dragged element's resting
+ * position), so `{ left: -100, right: 100 }` allows ±100 px of horizontal
+ * travel.
+ */
+interface DragConstraints {
+    left?: number;
+    right?: number;
+    top?: number;
+    bottom?: number;
+}
+/**
+ * Configuration for `useDrag`. All fields are optional; the defaults give an
+ * unconstrained two-axis drag with no elasticity.
+ */
+interface DragOptions {
+    /**
+     * Restrict the drag to one axis. Defaults to `'both'`. When `'x'` is set
+     * the y-axis shared value never updates (and vice versa); the gesture
+     * still tracks both for velocity reporting on `onDragEnd`.
+     */
+    axis?: 'x' | 'y' | 'both';
+    /**
+     * Travel bounds. Out-of-bounds values clamp to the limit unless `elastic`
+     * is non-zero, in which case overshoot is dampened (rubber-band feel).
+     */
+    constraints?: DragConstraints;
+    /**
+     * Rubber-band coefficient applied to overshoot past `constraints`. `0`
+     * (default) hard-clamps; `1` is fully elastic (no resistance). Typical
+     * Framer-Motion-style feel sits around `0.2`–`0.4`.
+     */
+    elastic?: number;
+    /**
+     * Fired on the JS thread when the drag begins.
+     */
+    onDragStart?: () => void;
+    /**
+     * Fired on the JS thread when the drag finishes (release or cancel). The
+     * payload is the final translation and the release velocity in px/sec.
+     */
+    onDragEnd?: (info: {
+        x: number;
+        y: number;
+        velocity: {
+            x: number;
+            y: number;
+        };
+    }) => void;
+}
+
+interface UseDragResult {
+    /** Pan gesture to pass to a `<GestureDetector>`. */
+    gesture: PanGesture;
+    /**
+     * Animated style fragment (a single `transform` entry) to stack onto the
+     * dragged Motion primitive's `style` prop. Stable across renders.
+     */
+    animatedStyle: ReturnType<typeof useAnimatedStyle>;
+    /** Current x translation in pixels. UI-thread shared value. */
+    dragX: SharedValue<number>;
+    /** Current y translation in pixels. UI-thread shared value. */
+    dragY: SharedValue<number>;
+    /** True while the gesture is active. */
+    isDragging: SharedValue<boolean>;
+}
+/**
+ * Drag a Motion primitive with `react-native-gesture-handler`'s pan gesture.
+ *
+ * The hook owns a pair of shared values (`dragX`, `dragY`) and a `Pan`
+ * gesture that updates them on the UI thread. The returned `animatedStyle`
+ * is a self-contained `transform: [{ translateX }, { translateY }]` fragment;
+ * stack it onto the dragged component without colliding with Motion's own
+ * `animate` transforms.
+ *
+ * Usage:
+ * ```tsx
+ * const drag = useDrag({ axis: 'x', constraints: { left: -100, right: 100 } })
+ * return (
+ *   <GestureDetector gesture={drag.gesture}>
+ *     <Motion.View style={drag.animatedStyle} />
+ *   </GestureDetector>
+ * )
+ * ```
+ */
+declare function useDrag(options?: DragOptions): UseDragResult;
+
+type SwipeDirection = 'left' | 'right' | 'up' | 'down';
+interface SwipeOptions {
+    /**
+     * Allowed swipe directions. Defaults to all four. The gesture only commits
+     * for directions in this list — a horizontal swipe with `directions:
+     * ['up', 'down']` will not fire `onSwipe`.
+     */
+    directions?: SwipeDirection[];
+    /**
+     * Pixel distance threshold past which a release commits the swipe. Defaults
+     * to `80`.
+     */
+    distanceThreshold?: number;
+    /**
+     * Velocity threshold (px/sec) past which a release commits the swipe even
+     * before the distance threshold is reached — flick-style gestures. Defaults
+     * to `800`.
+     */
+    velocityThreshold?: number;
+    /**
+     * Fired on the JS thread when the gesture commits in an allowed direction.
+     */
+    onSwipe?: (direction: SwipeDirection, info: {
+        distance: number;
+        velocity: number;
+    }) => void;
+}
+interface UseSwipeResult {
+    /** Pan gesture to pass to a `<GestureDetector>`. */
+    gesture: PanGesture;
+    /**
+     * Animated style fragment exposing live translation while the gesture is
+     * active. Snaps back to `{ 0, 0 }` after release (whether or not the swipe
+     * committed) via a default spring.
+     */
+    animatedStyle: ReturnType<typeof useAnimatedStyle>;
+    /** Live x translation. */
+    swipeX: SharedValue<number>;
+    /** Live y translation. */
+    swipeY: SharedValue<number>;
+    /** True while the user is actively swiping. */
+    isActive: SharedValue<boolean>;
+}
+/**
+ * Directional commit-or-snap-back gesture. Tracks live translation while the
+ * user drags and fires `onSwipe(direction)` on release if either the distance
+ * or velocity threshold is exceeded in an allowed direction. The position
+ * shared values always animate back to zero — the consumer is responsible
+ * for whatever side effect the commit drives (delete a row, dismiss a sheet,
+ * etc.).
+ *
+ * Usage:
+ * ```tsx
+ * const swipe = useSwipe({
+ *   directions: ['left'],
+ *   onSwipe: (dir) => deleteRow(),
+ * })
+ * return (
+ *   <GestureDetector gesture={swipe.gesture}>
+ *     <Motion.View style={swipe.animatedStyle}>...</Motion.View>
+ *   </GestureDetector>
+ * )
+ * ```
+ */
+declare function useSwipe(options?: SwipeOptions): UseSwipeResult;
+
+interface PanOptions {
+    /**
+     * Translation bounds. Each side is optional; out-of-bounds motion during
+     * the active gesture and during the post-release decay is hard-clamped
+     * (Reanimated's `withDecay` `clamp` param). Decay-style overshoot is not
+     * supported here — for rubber-banded bounds, prefer `useDrag` with
+     * `elastic`.
+     */
+    constraints?: DragConstraints;
+    /**
+     * Deceleration applied to the post-release momentum. Higher = momentum
+     * dies faster. Reanimated default is `0.998`; lower values feel more
+     * "slippy". Range: roughly `0.99` (slow) to `0.999` (long glide).
+     */
+    deceleration?: number;
+    /**
+     * Disable the post-release momentum entirely. Defaults to `false` — pan
+     * coasts after release. Set to `true` for a hard stop on release (drag-like
+     * behavior).
+     */
+    disableMomentum?: boolean;
+}
+interface UsePanResult {
+    /** Pan gesture to pass to a `<GestureDetector>`. */
+    gesture: PanGesture;
+    /** Stable animated `transform` style. */
+    animatedStyle: ReturnType<typeof useAnimatedStyle>;
+    /** Live x translation, persistent across gestures. */
+    panX: SharedValue<number>;
+    /** Live y translation, persistent across gestures. */
+    panY: SharedValue<number>;
+    /** True while the user is actively panning. Decay phase reads `false`. */
+    isPanning: SharedValue<boolean>;
+}
+/**
+ * Camera-pan-style drag with momentum on release. Translation persists
+ * across separate pan gestures (the next pan starts from the current
+ * position, not zero), and on release the translation continues to glide
+ * via Reanimated's `withDecay` until friction stops it.
+ *
+ * Use for map / zoom-canvas / large-image navigation. For dragging an
+ * element to a position with no momentum, use `useDrag` instead.
+ */
+declare function usePan(options?: PanOptions): UsePanResult;
+
+export { type DragConstraints, type DragOptions, type PanOptions, type SwipeDirection, type SwipeOptions, type UseDragResult, type UsePanResult, type UseSwipeResult, useDrag, usePan, useSwipe };

package/dist/index.js

@@ -0,0 +1,259 @@
+'use strict';
+
+var react = require('react');
+var reactNativeGestureHandler = require('react-native-gesture-handler');
+var reactNativeReanimated = require('react-native-reanimated');
+
+// src/useDrag.ts
+function useDrag(options = {}) {
+  const {
+    axis = "both",
+    constraints,
+    elastic = 0,
+    onDragStart,
+    onDragEnd
+  } = options;
+  const dragX = reactNativeReanimated.useSharedValue(0);
+  const dragY = reactNativeReanimated.useSharedValue(0);
+  const startX = reactNativeReanimated.useSharedValue(0);
+  const startY = reactNativeReanimated.useSharedValue(0);
+  const isDragging = reactNativeReanimated.useSharedValue(false);
+  const lockX = axis !== "y";
+  const lockY = axis !== "x";
+  const left = constraints?.left;
+  const right = constraints?.right;
+  const top = constraints?.top;
+  const bottom = constraints?.bottom;
+  const elasticCoef = elastic;
+  const gesture = react.useMemo(() => {
+    const pan = reactNativeGestureHandler.Gesture.Pan().onStart(() => {
+      "worklet";
+      startX.value = dragX.value;
+      startY.value = dragY.value;
+      isDragging.value = true;
+      if (onDragStart) reactNativeReanimated.runOnJS(onDragStart)();
+    }).onUpdate((e) => {
+      "worklet";
+      if (lockX) {
+        dragX.value = applyBounds(
+          startX.value + e.translationX,
+          left,
+          right,
+          elasticCoef
+        );
+      }
+      if (lockY) {
+        dragY.value = applyBounds(
+          startY.value + e.translationY,
+          top,
+          bottom,
+          elasticCoef
+        );
+      }
+    }).onEnd((e) => {
+      "worklet";
+      isDragging.value = false;
+      if (onDragEnd) {
+        const x = dragX.value;
+        const y = dragY.value;
+        const vx = e.velocityX;
+        const vy = e.velocityY;
+        reactNativeReanimated.runOnJS(onDragEnd)({ x, y, velocity: { x: vx, y: vy } });
+      }
+    });
+    return pan;
+  }, [
+    lockX,
+    lockY,
+    left,
+    right,
+    top,
+    bottom,
+    elasticCoef,
+    onDragStart,
+    onDragEnd,
+    dragX,
+    dragY,
+    startX,
+    startY,
+    isDragging
+  ]);
+  const animatedStyle = reactNativeReanimated.useAnimatedStyle(() => ({
+    transform: [{ translateX: dragX.value }, { translateY: dragY.value }]
+  }));
+  return { gesture, animatedStyle, dragX, dragY, isDragging };
+}
+function applyBounds(value, min, max, elastic) {
+  "worklet";
+  if (min !== void 0 && value < min) {
+    return elastic > 0 ? min + (value - min) * elastic : min;
+  }
+  if (max !== void 0 && value > max) {
+    return elastic > 0 ? max + (value - max) * elastic : max;
+  }
+  return value;
+}
+var DEFAULT_DIRECTIONS = ["left", "right", "up", "down"];
+function useSwipe(options = {}) {
+  const {
+    directions = DEFAULT_DIRECTIONS,
+    distanceThreshold = 80,
+    velocityThreshold = 800,
+    onSwipe
+  } = options;
+  const swipeX = reactNativeReanimated.useSharedValue(0);
+  const swipeY = reactNativeReanimated.useSharedValue(0);
+  const isActive = reactNativeReanimated.useSharedValue(false);
+  const allowLeft = directions.includes("left");
+  const allowRight = directions.includes("right");
+  const allowUp = directions.includes("up");
+  const allowDown = directions.includes("down");
+  const gesture = react.useMemo(() => {
+    const pan = reactNativeGestureHandler.Gesture.Pan().onStart(() => {
+      "worklet";
+      isActive.value = true;
+    }).onUpdate((e) => {
+      "worklet";
+      swipeX.value = e.translationX;
+      swipeY.value = e.translationY;
+    }).onEnd((e) => {
+      "worklet";
+      isActive.value = false;
+      const direction = pickDirection(
+        e.translationX,
+        e.translationY,
+        e.velocityX,
+        e.velocityY,
+        distanceThreshold,
+        velocityThreshold,
+        allowLeft,
+        allowRight,
+        allowUp,
+        allowDown
+      );
+      if (direction !== null && onSwipe) {
+        const isHoriz = direction === "left" || direction === "right";
+        const distance = isHoriz ? Math.abs(e.translationX) : Math.abs(e.translationY);
+        const velocity = isHoriz ? Math.abs(e.velocityX) : Math.abs(e.velocityY);
+        reactNativeReanimated.runOnJS(onSwipe)(direction, { distance, velocity });
+      }
+      swipeX.value = reactNativeReanimated.withSpring(0);
+      swipeY.value = reactNativeReanimated.withSpring(0);
+    }).onFinalize(() => {
+      "worklet";
+      isActive.value = false;
+    });
+    return pan;
+  }, [
+    distanceThreshold,
+    velocityThreshold,
+    allowLeft,
+    allowRight,
+    allowUp,
+    allowDown,
+    onSwipe,
+    swipeX,
+    swipeY,
+    isActive
+  ]);
+  const animatedStyle = reactNativeReanimated.useAnimatedStyle(() => ({
+    transform: [{ translateX: swipeX.value }, { translateY: swipeY.value }]
+  }));
+  return { gesture, animatedStyle, swipeX, swipeY, isActive };
+}
+function pickDirection(tx, ty, vx, vy, distanceThreshold, velocityThreshold, allowLeft, allowRight, allowUp, allowDown) {
+  "worklet";
+  const absX = Math.abs(tx);
+  const absY = Math.abs(ty);
+  if (absX >= absY) {
+    const meets2 = absX >= distanceThreshold || Math.abs(vx) >= velocityThreshold;
+    if (!meets2) return null;
+    if (tx < 0 && allowLeft) return "left";
+    if (tx > 0 && allowRight) return "right";
+    return null;
+  }
+  const meets = absY >= distanceThreshold || Math.abs(vy) >= velocityThreshold;
+  if (!meets) return null;
+  if (ty < 0 && allowUp) return "up";
+  if (ty > 0 && allowDown) return "down";
+  return null;
+}
+function usePan(options = {}) {
+  const { constraints, deceleration, disableMomentum = false } = options;
+  const panX = reactNativeReanimated.useSharedValue(0);
+  const panY = reactNativeReanimated.useSharedValue(0);
+  const startX = reactNativeReanimated.useSharedValue(0);
+  const startY = reactNativeReanimated.useSharedValue(0);
+  const isPanning = reactNativeReanimated.useSharedValue(false);
+  const left = constraints?.left;
+  const right = constraints?.right;
+  const top = constraints?.top;
+  const bottom = constraints?.bottom;
+  const decel = deceleration;
+  const gesture = react.useMemo(() => {
+    const pan = reactNativeGestureHandler.Gesture.Pan().onStart(() => {
+      "worklet";
+      startX.value = panX.value;
+      startY.value = panY.value;
+      isPanning.value = true;
+    }).onUpdate((e) => {
+      "worklet";
+      panX.value = clamp(startX.value + e.translationX, left, right);
+      panY.value = clamp(startY.value + e.translationY, top, bottom);
+    }).onEnd((e) => {
+      "worklet";
+      isPanning.value = false;
+      if (disableMomentum) return;
+      const clampX = boundsTuple(left, right);
+      const clampY = boundsTuple(top, bottom);
+      panX.value = reactNativeReanimated.withDecay(decayConfig(e.velocityX, decel, clampX));
+      panY.value = reactNativeReanimated.withDecay(decayConfig(e.velocityY, decel, clampY));
+    }).onFinalize(() => {
+      "worklet";
+      isPanning.value = false;
+    });
+    return pan;
+  }, [
+    left,
+    right,
+    top,
+    bottom,
+    decel,
+    disableMomentum,
+    panX,
+    panY,
+    startX,
+    startY,
+    isPanning
+  ]);
+  const animatedStyle = reactNativeReanimated.useAnimatedStyle(() => ({
+    transform: [{ translateX: panX.value }, { translateY: panY.value }]
+  }));
+  return { gesture, animatedStyle, panX, panY, isPanning };
+}
+function clamp(value, min, max) {
+  "worklet";
+  if (min !== void 0 && value < min) return min;
+  if (max !== void 0 && value > max) return max;
+  return value;
+}
+function boundsTuple(min, max) {
+  "worklet";
+  if (min === void 0 && max === void 0) return void 0;
+  return [min ?? Number.NEGATIVE_INFINITY, max ?? Number.POSITIVE_INFINITY];
+}
+function decayConfig(velocity, deceleration, clamp2) {
+  "worklet";
+  const cfg = {
+    velocity
+  };
+  if (deceleration !== void 0) cfg.deceleration = deceleration;
+  if (clamp2 !== void 0) cfg.clamp = clamp2;
+  return cfg;
+}
+
+exports.useDrag = useDrag;
+exports.usePan = usePan;
+exports.useSwipe = useSwipe;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map