@souscheflabs/reanimated-flashlist 0.1.7

package/lib/hooks/drag/useDragShift.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useDragShift = useDragShift;
+const react_native_reanimated_1 = require("react-native-reanimated");
+const DragStateContext_1 = require("../../contexts/DragStateContext");
+/**
+ * Hook that calculates shift animation for non-dragged items.
+ *
+ * When an item is being dragged, other items need to shift up or down
+ * to make room for the dragged item at its new position. This hook
+ * calculates the target shift based on:
+ * - The current drag position (from context)
+ * - The scroll delta (accounting for autoscroll)
+ * - The item's index relative to the dragged item
+ *
+ * The shift is animated with timing for smooth transitions.
+ *
+ * @example
+ * ```tsx
+ * const { shiftY } = useDragShift({ itemId: item.id, index });
+ * // Use shiftY.value in animated style
+ * ```
+ */
+function useDragShift(config) {
+    const { itemId, index } = config;
+    // Global drag state for coordinating animations across all items
+    const { isDragging: globalIsDragging, draggedIndex, draggedItemId, currentTranslateY, scrollOffset, dragStartScrollOffset, dragUpdateTrigger, measuredItemHeight, isDropping, config: dragConfig, } = (0, DragStateContext_1.useDragState)();
+    // Shift animation SharedValue
+    const shiftY = (0, react_native_reanimated_1.useSharedValue)(0);
+    // Calculate target shift using useDerivedValue
+    const targetShiftY = (0, react_native_reanimated_1.useDerivedValue)(() => {
+        'worklet';
+        // Force re-evaluation on every drag state change
+        // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+        dragUpdateTrigger.value;
+        // During drop transition, freeze shift values
+        if (isDropping.value) {
+            return shiftY.value;
+        }
+        const currentDraggedIndex = draggedIndex.value;
+        const isDraggingNow = globalIsDragging.value;
+        const translateYNow = currentTranslateY.value;
+        const currentDraggedItemId = draggedItemId.value;
+        // If I'm the dragged item, no shift needed
+        if (currentDraggedItemId === itemId)
+            return 0;
+        // If not dragging, reset to 0
+        if (!isDraggingNow)
+            return 0;
+        // Use dynamically measured height + margins, or fall back to config
+        const itemHeight = measuredItemHeight.value > 0
+            ? measuredItemHeight.value + dragConfig.itemVerticalMargin
+            : dragConfig.itemHeight;
+        // Calculate effective translateY including scroll delta
+        const scrollDelta = scrollOffset.value - dragStartScrollOffset.value;
+        const effectiveTranslateY = translateYNow + scrollDelta;
+        // Calculate which index the dragged item is hovering over
+        const offset = effectiveTranslateY > 0 ? 0.2 : effectiveTranslateY < 0 ? -0.2 : 0;
+        const hoveredIndex = currentDraggedIndex + Math.round(effectiveTranslateY / itemHeight + offset);
+        // Moving DOWN: items between original and hovered positions shift UP
+        if (hoveredIndex > currentDraggedIndex) {
+            if (index > currentDraggedIndex && index <= hoveredIndex) {
+                return -itemHeight;
+            }
+        }
+        // Moving UP: items between hovered and original positions shift DOWN
+        else if (hoveredIndex < currentDraggedIndex) {
+            if (index < currentDraggedIndex && index >= hoveredIndex) {
+                return itemHeight;
+            }
+        }
+        return 0;
+    }, [index, itemId]);
+    // Animate shift when target changes
+    (0, react_native_reanimated_1.useAnimatedReaction)(() => targetShiftY.value, (target, prev) => {
+        'worklet';
+        if (target !== prev) {
+            shiftY.value = (0, react_native_reanimated_1.withTiming)(target, {
+                duration: 100,
+                easing: react_native_reanimated_1.Easing.out(react_native_reanimated_1.Easing.ease),
+            });
+        }
+    });
+    return { shiftY };
+}

package/lib/hooks/drag/useDropCompensation.d.ts

@@ -0,0 +1,27 @@
+import type { UseDropCompensationConfig } from '../../types';
+/**
+ * Hook that handles index change compensation after drag reorder.
+ *
+ * When an item is dropped and the data updates, React re-renders with new indices.
+ * This causes a visual jump because items suddenly have different positions.
+ * This hook compensates by:
+ * 1. Detecting index changes (via useRecyclingState for FlashList recycling)
+ * 2. Adjusting translateY to compensate for the position delta
+ * 3. Animating the dragged item back to 0 (settle animation)
+ * 4. Resetting global drag state after animation completes
+ * 5. Resetting shiftY on UI thread via useAnimatedReaction
+ *
+ * useLayoutEffect runs synchronously before paint to prevent visual flash.
+ *
+ * @example
+ * ```tsx
+ * useDropCompensation({
+ *   itemId: item.id,
+ *   index,
+ *   translateY,
+ *   shiftY,
+ * });
+ * ```
+ */
+export declare function useDropCompensation(config: UseDropCompensationConfig): void;
+//# sourceMappingURL=useDropCompensation.d.ts.map

package/lib/hooks/drag/useDropCompensation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDropCompensation.d.ts","sourceRoot":"","sources":["../../../src/hooks/drag/useDropCompensation.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,aAAa,CAAC;AAE7D;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,yBAAyB,GAAG,IAAI,CAoF3E"}

package/lib/hooks/drag/useDropCompensation.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useDropCompensation = useDropCompensation;
+const react_1 = require("react");
+const react_native_reanimated_1 = require("react-native-reanimated");
+const flash_list_1 = require("@shopify/flash-list");
+const DragStateContext_1 = require("../../contexts/DragStateContext");
+/**
+ * Hook that handles index change compensation after drag reorder.
+ *
+ * When an item is dropped and the data updates, React re-renders with new indices.
+ * This causes a visual jump because items suddenly have different positions.
+ * This hook compensates by:
+ * 1. Detecting index changes (via useRecyclingState for FlashList recycling)
+ * 2. Adjusting translateY to compensate for the position delta
+ * 3. Animating the dragged item back to 0 (settle animation)
+ * 4. Resetting global drag state after animation completes
+ * 5. Resetting shiftY on UI thread via useAnimatedReaction
+ *
+ * useLayoutEffect runs synchronously before paint to prevent visual flash.
+ *
+ * @example
+ * ```tsx
+ * useDropCompensation({
+ *   itemId: item.id,
+ *   index,
+ *   translateY,
+ *   shiftY,
+ * });
+ * ```
+ */
+function useDropCompensation(config) {
+    const { itemId, index, translateY, shiftY } = config;
+    // Track index on UI thread for synchronized shift reset
+    const indexShared = (0, react_native_reanimated_1.useSharedValue)(index);
+    // Global drag state
+    const { isDragging: globalIsDragging, draggedIndex, draggedItemId, measuredItemHeight, isDropping, dragUpdateTrigger, config: dragConfig, } = (0, DragStateContext_1.useDragState)();
+    // Use FlashList's useRecyclingState for automatic reset on view recycling
+    const [prevIndex, setPrevIndex] = (0, flash_list_1.useRecyclingState)(index, [itemId]);
+    // Handle index changes after data updates (drop compensation)
+    (0, react_1.useLayoutEffect)(() => {
+        if (index !== prevIndex) {
+            // Compensate for index change by adjusting translateY
+            const indexDelta = index - prevIndex;
+            const heightDelta = indexDelta * dragConfig.itemHeight;
+            // Check if this is the dragged item completing its drop
+            const isTheDraggedItem = draggedItemId.value === itemId;
+            // Compensate translateY for position change
+            const compensatedY = translateY.value - heightDelta;
+            if (isTheDraggedItem) {
+                // Dragged item: animate smoothly to 0 from compensated position
+                translateY.value = compensatedY;
+                translateY.value = (0, react_native_reanimated_1.withTiming)(0, { duration: 150, easing: react_native_reanimated_1.Easing.out(react_native_reanimated_1.Easing.ease) }, finished => {
+                    'worklet';
+                    if (finished) {
+                        // Reset ALL global state after settle animation
+                        isDropping.value = false;
+                        globalIsDragging.value = false;
+                        draggedIndex.value = -1;
+                        draggedItemId.value = '';
+                        measuredItemHeight.value = 0;
+                        dragUpdateTrigger.value = (0, react_native_reanimated_1.withTiming)(dragUpdateTrigger.value + 1, {
+                            duration: 1,
+                        });
+                    }
+                });
+            }
+            else if (Math.abs(translateY.value) > 1) {
+                // Non-dragged item: just compensate without animation
+                translateY.value = compensatedY;
+            }
+            // Update tracked index
+            setPrevIndex(index);
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [index, prevIndex, translateY, setPrevIndex, itemId]);
+    // Sync JS index to SharedValue for UI thread access
+    (0, react_1.useLayoutEffect)(() => {
+        indexShared.value = index;
+    }, [index, indexShared]);
+    // Reset shiftY on UI thread when index changes
+    (0, react_native_reanimated_1.useAnimatedReaction)(() => indexShared.value, (currentIndex, prevIdx) => {
+        'worklet';
+        if (prevIdx !== null &&
+            currentIndex !== prevIdx &&
+            Math.abs(shiftY.value) > 1) {
+            shiftY.value = 0;
+        }
+    });
+}

package/lib/hooks/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Hooks for AnimatedFlashList
+ *
+ * Re-exports all hooks for both drag and animation functionality.
+ */
+export { useDragGesture, useDragShift, useDragAnimatedStyle, useDropCompensation, } from './drag';
+export { useListExitAnimation, useListEntryAnimation } from './animations';
+//# sourceMappingURL=index.d.ts.map

package/lib/hooks/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/hooks/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EACL,cAAc,EACd,YAAY,EACZ,oBAAoB,EACpB,mBAAmB,GACpB,MAAM,QAAQ,CAAC;AAGhB,OAAO,EAAE,oBAAoB,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC"}

package/lib/hooks/index.js

@@ -0,0 +1,18 @@
+"use strict";
+/**
+ * Hooks for AnimatedFlashList
+ *
+ * Re-exports all hooks for both drag and animation functionality.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useListEntryAnimation = exports.useListExitAnimation = exports.useDropCompensation = exports.useDragAnimatedStyle = exports.useDragShift = exports.useDragGesture = void 0;
+// Drag hooks
+var drag_1 = require("./drag");
+Object.defineProperty(exports, "useDragGesture", { enumerable: true, get: function () { return drag_1.useDragGesture; } });
+Object.defineProperty(exports, "useDragShift", { enumerable: true, get: function () { return drag_1.useDragShift; } });
+Object.defineProperty(exports, "useDragAnimatedStyle", { enumerable: true, get: function () { return drag_1.useDragAnimatedStyle; } });
+Object.defineProperty(exports, "useDropCompensation", { enumerable: true, get: function () { return drag_1.useDropCompensation; } });
+// Animation hooks
+var animations_1 = require("./animations");
+Object.defineProperty(exports, "useListExitAnimation", { enumerable: true, get: function () { return animations_1.useListExitAnimation; } });
+Object.defineProperty(exports, "useListEntryAnimation", { enumerable: true, get: function () { return animations_1.useListEntryAnimation; } });

package/lib/index.d.ts

@@ -0,0 +1,42 @@
+/**
+ * @souschef/reanimated-flashlist
+ *
+ * A high-performance animated FlashList with drag-to-reorder and entry/exit animations.
+ *
+ * @example
+ * ```tsx
+ * import {
+ *   AnimatedFlashList,
+ *   type AnimatedListItem,
+ * } from '@souschef/reanimated-flashlist';
+ *
+ * interface MyItem extends AnimatedListItem {
+ *   title: string;
+ * }
+ *
+ * <AnimatedFlashList<MyItem>
+ *   data={items}
+ *   keyExtractor={(item) => item.id}
+ *   renderItem={({ item, dragHandleProps, triggerExitAnimation }) => (
+ *     <View>
+ *       <Text>{item.title}</Text>
+ *       {dragHandleProps && (
+ *         <GestureDetector gesture={dragHandleProps.gesture}>
+ *           <DragIcon />
+ *         </GestureDetector>
+ *       )}
+ *     </View>
+ *   )}
+ *   dragEnabled
+ *   onReorder={(itemId, from, to) => handleReorder(itemId, from, to)}
+ * />
+ * ```
+ */
+export { AnimatedFlashList } from './AnimatedFlashList';
+export { AnimatedFlashListItem } from './AnimatedFlashListItem';
+export { DragStateProvider, useDragState, ListAnimationProvider, useListAnimation, useListAnimationOptional, } from './contexts';
+export { useDragGesture, useDragShift, useDragAnimatedStyle, useDropCompensation, useListExitAnimation, useListEntryAnimation, } from './hooks';
+export { DEFAULT_DRAG_CONFIG, createDragConfig, DEFAULT_EXIT_ANIMATION, FAST_EXIT_ANIMATION, DEFAULT_ENTRY_ANIMATION, getExitAnimationConfig, createEntryAnimationConfig, standardEasing, } from './constants';
+export type { AnimatedListItem, AnimatedFlashListProps, AnimatedFlashListRef, AnimatedFlashListConfig, AnimatedRenderItemInfo, DragHandleProps, DragConfig, UseDragGestureConfig, UseDragGestureCallbacks, UseDragGestureResult, UseDragShiftConfig, UseDragShiftResult, UseDropCompensationConfig, UseDragAnimatedStyleResult, AnimationDirection, ExitAnimationPreset, ExitAnimationConfig, EntryAnimationConfig, PendingEntryAnimation, ExitAnimationTrigger, HapticFeedbackType, } from './types';
+export type { DragStateContextValue, ListAnimationContextValue, } from './contexts';
+//# sourceMappingURL=index.d.ts.map

package/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAGH,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAGhE,OAAO,EACL,iBAAiB,EACjB,YAAY,EACZ,qBAAqB,EACrB,gBAAgB,EAChB,wBAAwB,GACzB,MAAM,YAAY,CAAC;AAGpB,OAAO,EAEL,cAAc,EACd,YAAY,EACZ,oBAAoB,EACpB,mBAAmB,EAEnB,oBAAoB,EACpB,qBAAqB,GACtB,MAAM,SAAS,CAAC;AAGjB,OAAO,EACL,mBAAmB,EACnB,gBAAgB,EAChB,sBAAsB,EACtB,mBAAmB,EACnB,uBAAuB,EACvB,sBAAsB,EACtB,0BAA0B,EAC1B,cAAc,GACf,MAAM,aAAa,CAAC;AAGrB,YAAY,EAEV,gBAAgB,EAChB,sBAAsB,EACtB,oBAAoB,EACpB,uBAAuB,EACvB,sBAAsB,EACtB,eAAe,EAEf,UAAU,EACV,oBAAoB,EACpB,uBAAuB,EACvB,oBAAoB,EACpB,kBAAkB,EAClB,kBAAkB,EAClB,yBAAyB,EACzB,0BAA0B,EAE1B,kBAAkB,EAClB,mBAAmB,EACnB,mBAAmB,EACnB,oBAAoB,EACpB,qBAAqB,EACrB,oBAAoB,EACpB,kBAAkB,GACnB,MAAM,SAAS,CAAC;AAGjB,YAAY,EACV,qBAAqB,EACrB,yBAAyB,GAC1B,MAAM,YAAY,CAAC"}

package/lib/index.js

@@ -0,0 +1,69 @@
+"use strict";
+/**
+ * @souschef/reanimated-flashlist
+ *
+ * A high-performance animated FlashList with drag-to-reorder and entry/exit animations.
+ *
+ * @example
+ * ```tsx
+ * import {
+ *   AnimatedFlashList,
+ *   type AnimatedListItem,
+ * } from '@souschef/reanimated-flashlist';
+ *
+ * interface MyItem extends AnimatedListItem {
+ *   title: string;
+ * }
+ *
+ * <AnimatedFlashList<MyItem>
+ *   data={items}
+ *   keyExtractor={(item) => item.id}
+ *   renderItem={({ item, dragHandleProps, triggerExitAnimation }) => (
+ *     <View>
+ *       <Text>{item.title}</Text>
+ *       {dragHandleProps && (
+ *         <GestureDetector gesture={dragHandleProps.gesture}>
+ *           <DragIcon />
+ *         </GestureDetector>
+ *       )}
+ *     </View>
+ *   )}
+ *   dragEnabled
+ *   onReorder={(itemId, from, to) => handleReorder(itemId, from, to)}
+ * />
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.standardEasing = exports.createEntryAnimationConfig = exports.getExitAnimationConfig = exports.DEFAULT_ENTRY_ANIMATION = exports.FAST_EXIT_ANIMATION = exports.DEFAULT_EXIT_ANIMATION = exports.createDragConfig = exports.DEFAULT_DRAG_CONFIG = exports.useListEntryAnimation = exports.useListExitAnimation = exports.useDropCompensation = exports.useDragAnimatedStyle = exports.useDragShift = exports.useDragGesture = exports.useListAnimationOptional = exports.useListAnimation = exports.ListAnimationProvider = exports.useDragState = exports.DragStateProvider = exports.AnimatedFlashListItem = exports.AnimatedFlashList = void 0;
+// Main component
+var AnimatedFlashList_1 = require("./AnimatedFlashList");
+Object.defineProperty(exports, "AnimatedFlashList", { enumerable: true, get: function () { return AnimatedFlashList_1.AnimatedFlashList; } });
+var AnimatedFlashListItem_1 = require("./AnimatedFlashListItem");
+Object.defineProperty(exports, "AnimatedFlashListItem", { enumerable: true, get: function () { return AnimatedFlashListItem_1.AnimatedFlashListItem; } });
+// Contexts (for advanced usage)
+var contexts_1 = require("./contexts");
+Object.defineProperty(exports, "DragStateProvider", { enumerable: true, get: function () { return contexts_1.DragStateProvider; } });
+Object.defineProperty(exports, "useDragState", { enumerable: true, get: function () { return contexts_1.useDragState; } });
+Object.defineProperty(exports, "ListAnimationProvider", { enumerable: true, get: function () { return contexts_1.ListAnimationProvider; } });
+Object.defineProperty(exports, "useListAnimation", { enumerable: true, get: function () { return contexts_1.useListAnimation; } });
+Object.defineProperty(exports, "useListAnimationOptional", { enumerable: true, get: function () { return contexts_1.useListAnimationOptional; } });
+// Hooks (for advanced/custom implementations)
+var hooks_1 = require("./hooks");
+// Drag hooks
+Object.defineProperty(exports, "useDragGesture", { enumerable: true, get: function () { return hooks_1.useDragGesture; } });
+Object.defineProperty(exports, "useDragShift", { enumerable: true, get: function () { return hooks_1.useDragShift; } });
+Object.defineProperty(exports, "useDragAnimatedStyle", { enumerable: true, get: function () { return hooks_1.useDragAnimatedStyle; } });
+Object.defineProperty(exports, "useDropCompensation", { enumerable: true, get: function () { return hooks_1.useDropCompensation; } });
+// Animation hooks
+Object.defineProperty(exports, "useListExitAnimation", { enumerable: true, get: function () { return hooks_1.useListExitAnimation; } });
+Object.defineProperty(exports, "useListEntryAnimation", { enumerable: true, get: function () { return hooks_1.useListEntryAnimation; } });
+// Constants (for customization)
+var constants_1 = require("./constants");
+Object.defineProperty(exports, "DEFAULT_DRAG_CONFIG", { enumerable: true, get: function () { return constants_1.DEFAULT_DRAG_CONFIG; } });
+Object.defineProperty(exports, "createDragConfig", { enumerable: true, get: function () { return constants_1.createDragConfig; } });
+Object.defineProperty(exports, "DEFAULT_EXIT_ANIMATION", { enumerable: true, get: function () { return constants_1.DEFAULT_EXIT_ANIMATION; } });
+Object.defineProperty(exports, "FAST_EXIT_ANIMATION", { enumerable: true, get: function () { return constants_1.FAST_EXIT_ANIMATION; } });
+Object.defineProperty(exports, "DEFAULT_ENTRY_ANIMATION", { enumerable: true, get: function () { return constants_1.DEFAULT_ENTRY_ANIMATION; } });
+Object.defineProperty(exports, "getExitAnimationConfig", { enumerable: true, get: function () { return constants_1.getExitAnimationConfig; } });
+Object.defineProperty(exports, "createEntryAnimationConfig", { enumerable: true, get: function () { return constants_1.createEntryAnimationConfig; } });
+Object.defineProperty(exports, "standardEasing", { enumerable: true, get: function () { return constants_1.standardEasing; } });

package/lib/types/animations.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Animation direction for entry/exit animations
+ * 1 = forward/right, -1 = backward/left
+ */
+export type AnimationDirection = 1 | -1;
+/**
+ * Animation preset type for exit animations
+ * - 'default': Standard exit animation (for swipe/delete actions)
+ * - 'fast': Quick exit animation (for checkbox toggles)
+ */
+export type ExitAnimationPreset = 'default' | 'fast';
+/**
+ * Haptic feedback types that can be triggered during animations
+ */
+export type HapticFeedbackType = 'light' | 'medium' | 'heavy' | 'selection';
+/**
+ * Configuration for exit animations
+ */
+export interface ExitAnimationConfig {
+    slide: {
+        duration: number;
+        distance: number;
+    };
+    fade: {
+        delay: number;
+        duration: number;
+    };
+    scale: {
+        delay: number;
+        duration: number;
+        toValue: number;
+    };
+    removalDelay: number;
+    layoutAnimation: {
+        duration: number;
+    };
+}
+/**
+ * Configuration for entry animations
+ */
+export interface EntryAnimationConfig {
+    fade: {
+        duration: number;
+    };
+    slide: {
+        distance: number;
+        duration: number;
+    };
+}
+/**
+ * Pending entry animation info
+ */
+export interface PendingEntryAnimation {
+    itemId: string;
+    direction: AnimationDirection;
+    timestamp: number;
+}
+/**
+ * Exit animation trigger function type
+ */
+export type ExitAnimationTrigger = (direction: AnimationDirection, onComplete: () => void, preset?: ExitAnimationPreset) => void;
+/**
+ * Info about an item currently exiting (for layout compensation)
+ */
+export interface ExitingItemInfo {
+    itemId: string;
+    index: number;
+    height: number;
+    timestamp: number;
+}
+//# sourceMappingURL=animations.d.ts.map

package/lib/types/animations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"animations.d.ts","sourceRoot":"","sources":["../../src/types/animations.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC;AAExC;;;;GAIG;AACH,MAAM,MAAM,mBAAmB,GAAG,SAAS,GAAG,MAAM,CAAC;AAErD;;GAEG;AACH,MAAM,MAAM,kBAAkB,GAAG,OAAO,GAAG,QAAQ,GAAG,OAAO,GAAG,WAAW,CAAC;AAE5E;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE;QACL,QAAQ,EAAE,MAAM,CAAC;QACjB,QAAQ,EAAE,MAAM,CAAC;KAClB,CAAC;IACF,IAAI,EAAE;QACJ,KAAK,EAAE,MAAM,CAAC;QACd,QAAQ,EAAE,MAAM,CAAC;KAClB,CAAC;IACF,KAAK,EAAE;QACL,KAAK,EAAE,MAAM,CAAC;QACd,QAAQ,EAAE,MAAM,CAAC;QACjB,OAAO,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,YAAY,EAAE,MAAM,CAAC;IACrB,eAAe,EAAE;QACf,QAAQ,EAAE,MAAM,CAAC;KAClB,CAAC;CACH;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC;IAC3B,KAAK,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC;CAC/C;AAED;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,kBAAkB,CAAC;IAC9B,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAAG,CACjC,SAAS,EAAE,kBAAkB,EAC7B,UAAU,EAAE,MAAM,IAAI,EACtB,MAAM,CAAC,EAAE,mBAAmB,KACzB,IAAI,CAAC;AAEV;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACnB"}

package/lib/types/animations.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/drag.d.ts

@@ -0,0 +1,94 @@
+import type { SharedValue, AnimatedRef } from 'react-native-reanimated';
+import type { GestureType } from 'react-native-gesture-handler';
+import type Animated from 'react-native-reanimated';
+/**
+ * Configuration for drag behavior
+ */
+export interface DragConfig {
+    /** Fixed height for list items (used for drag calculations) */
+    itemHeight: number;
+    /** Scale factor applied to dragged item */
+    dragScale: number;
+    /** Shadow opacity for dragged item */
+    dragShadowOpacity: number;
+    /** Vertical margin per item */
+    itemVerticalMargin: number;
+    /** Duration (ms) to hold drag handle before drag activates */
+    longPressDuration: number;
+    /** Pixels from viewport edge to trigger autoscroll */
+    edgeThreshold: number;
+    /** Maximum scroll speed in pixels per frame */
+    maxScrollSpeed: number;
+}
+/**
+ * Configuration for useDragGesture hook
+ */
+export interface UseDragGestureConfig {
+    /** Item ID for stable identity */
+    itemId: string;
+    /** Current index in list */
+    index: number;
+    /** Total number of items in the list */
+    totalItems: number;
+    /** Whether drag is enabled for this item */
+    enabled: boolean;
+    /** Ref to measure item container */
+    containerRef: AnimatedRef<Animated.View>;
+}
+/**
+ * Callbacks for drag gesture events
+ */
+export interface UseDragGestureCallbacks {
+    /** Called when reorder should occur (with index delta) */
+    onReorderByDelta?: (itemId: string, delta: number) => void;
+    /** Optional haptic feedback callback */
+    onHapticFeedback?: (type: 'light' | 'medium') => void;
+}
+/**
+ * Return value from useDragGesture hook
+ */
+export interface UseDragGestureResult {
+    /** The pan gesture to attach to drag handle */
+    panGesture: GestureType;
+    /** Whether this item is currently being dragged */
+    isDragging: SharedValue<boolean>;
+    /** Current translateY of this item */
+    translateY: SharedValue<number>;
+}
+/**
+ * Configuration for useDragShift hook
+ */
+export interface UseDragShiftConfig {
+    /** Item ID for identity check (to skip shift for the dragged item) */
+    itemId: string;
+    /** Current index in list */
+    index: number;
+}
+/**
+ * Return value from useDragShift hook
+ */
+export interface UseDragShiftResult {
+    /** Animated shift value for non-dragged items */
+    shiftY: SharedValue<number>;
+}
+/**
+ * Configuration for useDropCompensation hook
+ */
+export interface UseDropCompensationConfig {
+    /** Item ID for stable identity check */
+    itemId: string;
+    /** Current index in list */
+    index: number;
+    /** This item's translateY SharedValue (from useDragGesture) */
+    translateY: SharedValue<number>;
+    /** This item's shiftY SharedValue (from useDragShift) */
+    shiftY: SharedValue<number>;
+}
+/**
+ * Return value from useDragAnimatedStyle hook
+ */
+export interface UseDragAnimatedStyleResult {
+    /** Animated style for the dragged item (transform, zIndex, shadow) */
+    dragAnimatedStyle: ReturnType<typeof import('react-native-reanimated').useAnimatedStyle>;
+}
+//# sourceMappingURL=drag.d.ts.map

package/lib/types/drag.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drag.d.ts","sourceRoot":"","sources":["../../src/types/drag.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AACxE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAChE,OAAO,KAAK,QAAQ,MAAM,yBAAyB,CAAC;AAEpD;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,+DAA+D;IAC/D,UAAU,EAAE,MAAM,CAAC;IACnB,2CAA2C;IAC3C,SAAS,EAAE,MAAM,CAAC;IAClB,sCAAsC;IACtC,iBAAiB,EAAE,MAAM,CAAC;IAC1B,+BAA+B;IAC/B,kBAAkB,EAAE,MAAM,CAAC;IAC3B,8DAA8D;IAC9D,iBAAiB,EAAE,MAAM,CAAC;IAC1B,sDAAsD;IACtD,aAAa,EAAE,MAAM,CAAC;IACtB,+CAA+C;IAC/C,cAAc,EAAE,MAAM,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,kCAAkC;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,4BAA4B;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,wCAAwC;IACxC,UAAU,EAAE,MAAM,CAAC;IACnB,4CAA4C;IAC5C,OAAO,EAAE,OAAO,CAAC;IACjB,oCAAoC;IACpC,YAAY,EAAE,WAAW,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;CAC1C;AAED;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC,0DAA0D;IAC1D,gBAAgB,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAC3D,wCAAwC;IACxC,gBAAgB,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,GAAG,QAAQ,KAAK,IAAI,CAAC;CACvD;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,+CAA+C;IAC/C,UAAU,EAAE,WAAW,CAAC;IACxB,mDAAmD;IACnD,UAAU,EAAE,WAAW,CAAC,OAAO,CAAC,CAAC;IACjC,sCAAsC;IACtC,UAAU,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CACjC;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,sEAAsE;IACtE,MAAM,EAAE,MAAM,CAAC;IACf,4BAA4B;IAC5B,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,iDAAiD;IACjD,MAAM,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CAC7B;AAED;;GAEG;AACH,MAAM,WAAW,yBAAyB;IACxC,wCAAwC;IACxC,MAAM,EAAE,MAAM,CAAC;IACf,4BAA4B;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,+DAA+D;IAC/D,UAAU,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAChC,yDAAyD;IACzD,MAAM,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CAC7B;AAED;;GAEG;AACH,MAAM,WAAW,0BAA0B;IACzC,sEAAsE;IACtE,iBAAiB,EAAE,UAAU,CAAC,cAAc,yBAAyB,EAAE,gBAAgB,CAAC,CAAC;CAC1F"}

package/lib/types/drag.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/index.d.ts

@@ -0,0 +1,4 @@
+export * from './animations';
+export * from './drag';
+export * from './list';
+//# sourceMappingURL=index.d.ts.map

package/lib/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,QAAQ,CAAC;AACvB,cAAc,QAAQ,CAAC"}

package/lib/types/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./animations"), exports);
+__exportStar(require("./drag"), exports);
+__exportStar(require("./list"), exports);