react-native-reorderable-list 0.7.0 → 0.8.0

package/src/components/ReorderableListCore/animationDefaults.ts

@@ -0,0 +1,35 @@
+import {Easing, WithTimingConfig} from 'react-native-reanimated';
+
+const DURATION_START = 150;
+const DURATION_END = 200;
+
+interface AnimationConfig {
+  start: WithTimingConfig & {toValue: number};
+  end: WithTimingConfig & {toValue: number};
+}
+
+export const SCALE_ANIMATION_CONFIG_DEFAULT: AnimationConfig = {
+  start: {
+    toValue: 1.025,
+    easing: Easing.in(Easing.ease),
+    duration: DURATION_START,
+  },
+  end: {
+    toValue: 1,
+    easing: Easing.out(Easing.ease),
+    duration: DURATION_END,
+  },
+};
+
+export const OPACITY_ANIMATION_CONFIG_DEFAULT: AnimationConfig = {
+  start: {
+    toValue: 0.75,
+    easing: Easing.in(Easing.ease),
+    duration: DURATION_START,
+  },
+  end: {
+    toValue: 1,
+    easing: Easing.out(Easing.ease),
+    duration: DURATION_END,
+  },
+};

package/src/components/ReorderableListCore/autoscrollConfig.ts

@@ -0,0 +1,31 @@
+import {Platform} from 'react-native';
+
+const IOS_CONFIG = {
+  delay: 80,
+  increment: 100,
+};
+
+const ANDROID_FABRIC_CONFIG = {
+  delay: 50,
+  increment: 80,
+};
+
+const ANDROID_PAPER_CONFIG = {
+  delay: 10,
+  increment: 4,
+};
+
+export const IS_FABRIC =
+  global && typeof global === 'object' && 'nativeFabricUIManager' in global;
+
+export const AUTOSCROLL_CONFIG = Platform.select({
+  // autoscroll behaves differently with Fabric and Paper on Android
+  android: IS_FABRIC ? ANDROID_FABRIC_CONFIG : ANDROID_PAPER_CONFIG,
+  ios: IOS_CONFIG,
+
+  // unsupported platforms
+  web: IOS_CONFIG,
+  macos: IOS_CONFIG,
+  windows: IOS_CONFIG,
+  native: IOS_CONFIG,
+});

package/src/components/ReorderableListCore/useReorderableListCore.ts

@@ -1,8 +1,7 @@
-import React, {useCallback, useMemo} from 'react';
+import React, {useCallback, useEffect, useMemo} from 'react';
 import {
   FlatList,
   LayoutChangeEvent,
-  NativeScrollEvent,
   ScrollView,
   unstable_batchedUpdates,
 } from 'react-native';
@@ -12,7 +11,6 @@ import Animated, {
   AnimatedRef,
   Easing,
   SharedValue,
-  cancelAnimation,
   runOnJS,
   runOnUI,
   scrollTo,
@@ -24,8 +22,17 @@ import Animated, {
   withTiming,
 } from 'react-native-reanimated';
 
-import {AUTOSCROLL_INCREMENT} from './constants';
-import {ReorderableListDragEndEvent, ReorderableListState} from '../../types';
+import {
+  OPACITY_ANIMATION_CONFIG_DEFAULT,
+  SCALE_ANIMATION_CONFIG_DEFAULT,
+} from './animationDefaults';
+import {AUTOSCROLL_CONFIG} from './autoscrollConfig';
+import {
+  ReorderableListCellAnimations,
+  ReorderableListDragEndEvent,
+  ReorderableListDragStartEvent,
+  ReorderableListState,
+} from '../../types';
 import type {ReorderableListReorderEvent} from '../../types';
 
 const version = React.version.split('.');
@@ -41,8 +48,8 @@ interface UseReorderableListCoreArgs<T> {
   animationDuration: number;
   dragReorderThreshold: number;
   onReorder: (event: ReorderableListReorderEvent) => void;
+  onDragStart?: (event: ReorderableListDragStartEvent) => void;
   onDragEnd?: (event: ReorderableListDragEndEvent) => void;
-  onScroll?: (event: NativeScrollEvent) => void;
   onLayout?: (event: LayoutChangeEvent) => void;
   scrollViewContainerRef: React.RefObject<ScrollView> | undefined;
   scrollViewHeightY: SharedValue<number> | undefined;
@@ -51,6 +58,7 @@ interface UseReorderableListCoreArgs<T> {
   initialScrollEnabled: boolean | undefined;
   initialScrollViewScrollEnabled: boolean | undefined;
   nestedScrollable: boolean | undefined;
+  cellAnimations: ReorderableListCellAnimations | undefined;
 }
 
 export const useReorderableListCore = <T>({
@@ -61,8 +69,8 @@ export const useReorderableListCore = <T>({
   animationDuration,
   dragReorderThreshold,
   onReorder,
+  onDragStart,
   onDragEnd,
-  onScroll,
   onLayout,
   scrollViewContainerRef,
   scrollViewHeightY,
@@ -71,6 +79,7 @@ export const useReorderableListCore = <T>({
   initialScrollEnabled,
   initialScrollViewScrollEnabled,
   nestedScrollable,
+  cellAnimations,
 }: UseReorderableListCoreArgs<T>) => {
   const flatListRef = useAnimatedRef<FlatList>();
   const scrollEnabled = useSharedValue(initialScrollEnabled);
@@ -99,12 +108,15 @@ export const useReorderableListCore = <T>({
   const dragEndHandlers = useSharedValue<
     ((from: number, to: number) => void)[][]
   >([]);
-
-  // animation duration as a shared value allows to avoid re-rendering of all cells on value change
+  const startY = useSharedValue(0);
   const duration = useSharedValue(animationDuration);
-  if (duration.value !== animationDuration) {
+  const scaleDefault = useSharedValue(1);
+  const opacityDefault = useSharedValue(1);
+  const {scale, opacity} = cellAnimations || {};
+
+  useEffect(() => {
     duration.value = animationDuration;
-  }
+  }, [duration, animationDuration]);
 
   const listContextValue = useMemo(
     () => ({
@@ -112,12 +124,21 @@ export const useReorderableListCore = <T>({
       currentIndex,
       draggedIndex,
       dragEndHandlers,
+      scale: scale || scaleDefault,
+      opacity: opacity || opacityDefault,
     }),
-    [draggedHeight, currentIndex, draggedIndex, dragEndHandlers],
+    [
+      draggedHeight,
+      currentIndex,
+      draggedIndex,
+      dragEndHandlers,
+      scale,
+      scaleDefault,
+      opacity,
+      opacityDefault,
+    ],
   );
 
-  const startY = useSharedValue(0);
-
   const panGestureHandler = useMemo(
     () =>
       Gesture.Pan()
@@ -127,22 +148,18 @@ export const useReorderableListCore = <T>({
             startY.value = e.y;
             currentY.value = e.y;
             currentTranslationY.value = e.translationY;
-            if (draggedIndex.value >= 0) {
-              dragY.value = e.translationY;
-            }
+            dragY.value = e.translationY;
             gestureState.value = e.state;
           }
         })
         .onUpdate(e => {
-          if (state.value !== ReorderableListState.RELEASING) {
+          if (state.value !== ReorderableListState.RELEASED) {
             currentY.value = startY.value + e.translationY;
             currentTranslationY.value = e.translationY;
-            if (draggedIndex.value >= 0) {
-              dragY.value =
-                e.translationY +
-                dragScrollTranslationY.value +
-                scrollViewDragScrollTranslationY.value;
-            }
+            dragY.value =
+              e.translationY +
+              dragScrollTranslationY.value +
+              scrollViewDragScrollTranslationY.value;
             gestureState.value = e.state;
           }
         })
@@ -153,7 +170,6 @@ export const useReorderableListCore = <T>({
       currentY,
       dragScrollTranslationY,
       scrollViewDragScrollTranslationY,
-      draggedIndex,
       gestureState,
       dragY,
       startY,
@@ -198,21 +214,23 @@ export const useReorderableListCore = <T>({
   const resetSharedValues = useCallback(() => {
     'worklet';
 
-    // current index is reset on item render for the on end event
-    draggedIndex.value = -1;
-    // released flag is reset after release is triggered in the item
     state.value = ReorderableListState.IDLE;
+    draggedIndex.value = -1;
     dragY.value = 0;
     dragScrollTranslationY.value = 0;
     scrollViewDragScrollTranslationY.value = 0;
   }, [
+    draggedIndex,
     dragY,
     dragScrollTranslationY,
     scrollViewDragScrollTranslationY,
-    draggedIndex,
     state,
   ]);
 
+  const resetSharedValuesAfterAnimations = useCallback(() => {
+    setTimeout(runOnUI(resetSharedValues), duration.value);
+  }, [resetSharedValues, duration]);
+
   const reorder = (fromIndex: number, toIndex: number) => {
     runOnUI(resetSharedValues)();
 
@@ -316,19 +334,39 @@ export const useReorderableListCore = <T>({
     ],
   );
 
+  const runDefaultDragAnimations = useCallback(
+    (type: 'start' | 'end') => {
+      'worklet';
+
+      // if animation is not disabled and not custom run the default
+      if (scale !== false && !scale) {
+        const scaleConfig = SCALE_ANIMATION_CONFIG_DEFAULT[type];
+        scaleDefault.value = withTiming(scaleConfig.toValue, scaleConfig);
+      }
+
+      // if animation is not disabled and not custom run the default
+      if (opacity !== false && !opacity) {
+        const opacityConfig = OPACITY_ANIMATION_CONFIG_DEFAULT[type];
+        opacityDefault.value = withTiming(opacityConfig.toValue, opacityConfig);
+      }
+    },
+    [scale, scaleDefault, opacity, opacityDefault],
+  );
+
   useAnimatedReaction(
     () => gestureState.value,
     () => {
       if (
         gestureState.value !== State.ACTIVE &&
         gestureState.value !== State.BEGAN &&
-        (state.value === ReorderableListState.DRAGGING ||
-          state.value === ReorderableListState.AUTO_SCROLL)
+        (state.value === ReorderableListState.DRAGGED ||
+          state.value === ReorderableListState.AUTOSCROLL)
       ) {
-        state.value = ReorderableListState.RELEASING;
+        state.value = ReorderableListState.RELEASED;
 
         // enable back scroll on releasing
         runOnJS(setScrollEnabled)(true);
+
         // trigger onDragEnd event
         let e = {from: draggedIndex.value, to: currentIndex.value};
         onDragEnd?.(e);
@@ -351,6 +389,8 @@ export const useReorderableListCore = <T>({
               currentItemOffset +
               (draggedItemHeight - currentItemHeight);
 
+        runDefaultDragAnimations('end');
+
         if (dragY.value !== newTopPosition) {
           // animate dragged item to its new position on release
           dragY.value = withTiming(
@@ -367,7 +407,7 @@ export const useReorderableListCore = <T>({
           // user might drag and release the item without moving it so,
           // since the animation end callback is not executed in that case
           // we need to reset values as the reorder function would do
-          resetSharedValues();
+          runOnJS(resetSharedValuesAfterAnimations)();
         }
       }
     },
@@ -488,20 +528,20 @@ export const useReorderableListCore = <T>({
     () => currentY.value + scrollViewDragScrollTranslationY.value,
     y => {
       if (
-        state.value === ReorderableListState.DRAGGING ||
-        state.value === ReorderableListState.AUTO_SCROLL
+        state.value === ReorderableListState.DRAGGED ||
+        state.value === ReorderableListState.AUTOSCROLL
       ) {
         setCurrentIndex(y);
 
-        if (scrollDirection(y)) {
-          if (state.value !== ReorderableListState.AUTO_SCROLL) {
+        if (scrollDirection(y) !== 0) {
+          if (state.value !== ReorderableListState.AUTOSCROLL) {
             // trigger autoscroll
             lastAutoscrollTrigger.value = autoscrollTrigger.value;
             autoscrollTrigger.value *= -1;
+            state.value = ReorderableListState.AUTOSCROLL;
           }
-          state.value = ReorderableListState.AUTO_SCROLL;
-        } else {
-          state.value = ReorderableListState.DRAGGING;
+        } else if (state.value === ReorderableListState.AUTOSCROLL) {
+          state.value = ReorderableListState.DRAGGED;
         }
       }
     },
@@ -512,11 +552,13 @@ export const useReorderableListCore = <T>({
     () => {
       if (
         autoscrollTrigger.value !== lastAutoscrollTrigger.value &&
-        state.value === ReorderableListState.AUTO_SCROLL
+        state.value === ReorderableListState.AUTOSCROLL
       ) {
         let y = currentY.value + scrollViewDragScrollTranslationY.value;
         const autoscrollIncrement =
-          scrollDirection(y) * AUTOSCROLL_INCREMENT * autoscrollSpeedScale;
+          scrollDirection(y) *
+          AUTOSCROLL_CONFIG.increment *
+          autoscrollSpeedScale;
 
         if (autoscrollIncrement !== 0) {
           let scrollOffset = flatListScrollOffsetY.value;
@@ -545,28 +587,24 @@ export const useReorderableListCore = <T>({
 
     // checking if the list is not scrollable instead of the scrolling state
     // fixes a bug on iOS where the item is shifted after autoscrolling and then
-    // moving await from autoscroll area
+    // moving away from autoscroll area
     if (!scrollEnabled.value) {
       dragScrollTranslationY.value =
         flatListScrollOffsetY.value - dragInitialScrollOffsetY.value;
     }
 
-    if (state.value === ReorderableListState.AUTO_SCROLL) {
+    if (state.value === ReorderableListState.AUTOSCROLL) {
       dragY.value =
         currentTranslationY.value +
         dragScrollTranslationY.value +
         scrollViewDragScrollTranslationY.value;
 
-      cancelAnimation(autoscrollTrigger);
-
       lastAutoscrollTrigger.value = autoscrollTrigger.value;
       autoscrollTrigger.value = withDelay(
         autoscrollDelay,
         withTiming(autoscrollTrigger.value * -1, {duration: 0}),
       );
     }
-
-    onScroll?.(e);
   });
 
   // parent scroll handler
@@ -582,12 +620,10 @@ export const useReorderableListCore = <T>({
             value - scrollViewDragInitialScrollOffsetY.value;
         }
 
-        if (state.value === ReorderableListState.AUTO_SCROLL) {
+        if (state.value === ReorderableListState.AUTOSCROLL) {
           dragY.value =
             currentTranslationY.value + scrollViewDragScrollTranslationY.value;
 
-          cancelAnimation(autoscrollTrigger);
-
           lastAutoscrollTrigger.value = autoscrollTrigger.value;
           autoscrollTrigger.value = withDelay(
             autoscrollDelay,
@@ -617,9 +653,13 @@ export const useReorderableListCore = <T>({
         draggedIndex.value = index;
         previousIndex.value = -1;
         currentIndex.value = index;
-        state.value = ReorderableListState.DRAGGING;
+        state.value = ReorderableListState.DRAGGED;
 
         runOnJS(setScrollEnabled)(false);
+
+        // run animation before onDragStart to avoid potentially waiting for it
+        runDefaultDragAnimations('start');
+        onDragStart?.({index});
       }
     },
     [
@@ -635,6 +675,8 @@ export const useReorderableListCore = <T>({
       state,
       flatListScrollOffsetY,
       itemHeight,
+      onDragStart,
+      runDefaultDragAnimations,
     ],
   );
 

package/src/components/ScrollViewContainer.tsx

@@ -5,6 +5,7 @@ import {Gesture, GestureDetector} from 'react-native-gesture-handler';
 import Animated, {
   useAnimatedRef,
   useAnimatedScrollHandler,
+  useComposedEventHandler,
   useSharedValue,
 } from 'react-native-reanimated';
 
@@ -27,12 +28,15 @@ export const ScrollViewContainer: React.FC<ScrollViewContainerProps> = ({
   const handleScroll = useAnimatedScrollHandler(
     e => {
       scrollViewScrollOffsetY.value = e.contentOffset.y;
-
-      onScroll?.(e);
     },
     [scrollViewScrollOffsetY],
   );
 
+  const composedScrollHandler = useComposedEventHandler([
+    handleScroll,
+    onScroll || null,
+  ]);
+
   const contextValue = useMemo(
     () => ({
       scrollViewContainerRef,
@@ -64,7 +68,7 @@ export const ScrollViewContainer: React.FC<ScrollViewContainerProps> = ({
         <Animated.ScrollView
           {...rest}
           ref={scrollViewContainerRef}
-          onScroll={handleScroll}
+          onScroll={composedScrollHandler}
           onLayout={handleLayout}
           scrollEnabled={scrollEnabled}
         />

package/src/components/index.ts

@@ -1,5 +1,4 @@
 export * from './ReorderableList';
 export * from './NestedReorderableList';
 export * from './ReorderableListCell';
-export * from './ReorderableListItem';
 export * from './ScrollViewContainer';

package/src/contexts/ReorderableListContext.ts

@@ -6,6 +6,8 @@ interface ReorderableListContextData {
   currentIndex: SharedValue<number>;
   draggedHeight: SharedValue<number>;
   dragEndHandlers: SharedValue<((from: number, to: number) => void)[][]>;
+  scale: SharedValue<number>;
+  opacity: SharedValue<number>;
 }
 
 export const ReorderableListContext = React.createContext<

package/src/index.ts

@@ -1,7 +1,6 @@
 import {
   NestedReorderableList,
   ReorderableList,
-  ReorderableListItem,
   ScrollViewContainer,
 } from './components';
 import {
@@ -10,9 +9,9 @@ import {
   useReorderableDragStart,
 } from './hooks';
 import type {
+  ReorderableListCellAnimations,
   ReorderableListDragEndEvent,
-  ReorderableListItemConfig,
-  ReorderableListItemProps,
+  ReorderableListDragStartEvent,
   ReorderableListProps,
   ReorderableListReorderEvent,
   ScrollViewContainerProps,
@@ -25,10 +24,9 @@ export {
   useReorderableDragEnd,
   ReorderableListProps,
   ReorderableListReorderEvent,
+  ReorderableListCellAnimations,
+  ReorderableListDragStartEvent,
   ReorderableListDragEndEvent,
-  ReorderableListItem,
-  ReorderableListItemConfig,
-  ReorderableListItemProps,
   ScrollViewContainer,
   ScrollViewContainerProps,
   NestedReorderableList,

package/src/types/misc.ts

@@ -1,6 +1,6 @@
 export enum ReorderableListState {
   IDLE = 0,
-  DRAGGING,
-  RELEASING,
-  AUTO_SCROLL,
+  DRAGGED,
+  RELEASED,
+  AUTOSCROLL,
 }

package/src/types/props.ts

@@ -1,11 +1,6 @@
-import type {
-  FlatListProps,
-  NativeScrollEvent,
-  ScrollViewProps,
-  ViewProps,
-} from 'react-native';
+import type {FlatListProps, ScrollViewProps} from 'react-native';
 
-import {EasingFunction} from 'react-native-reanimated';
+import {SharedValue, useAnimatedScrollHandler} from 'react-native-reanimated';
 
 export interface ReorderableListReorderEvent {
   /**
@@ -18,6 +13,13 @@ export interface ReorderableListReorderEvent {
   to: number;
 }
 
+export interface ReorderableListDragStartEvent {
+  /**
+   * Index of the dragged item.
+   */
+  index: number;
+}
+
 export interface ReorderableListDragEndEvent {
   /**
    * Index of the dragged item.
@@ -69,63 +71,44 @@ export interface ReorderableListProps<T>
    */
   animationDuration?: number;
   /**
-   * Event fired after an item is released and the list is reordered.
-   */
-  onReorder: (event: ReorderableListReorderEvent) => void;
-  /**
-   * Event fired at most once per frame during scrolling. Needs to be a `worklet`. See [Reanimated docs](https://docs.swmansion.com/react-native-reanimated) for further info.
+   * Allows passing an object with shared values that can animate a cell by using the `onDragStart` and `onDragEnd` events.
    */
-  onScroll?: (event: NativeScrollEvent) => void;
+  cellAnimations?: ReorderableListCellAnimations;
   /**
-   * Event fired when the dragged item is released. Needs to be a `worklet`. See [Reanimated docs](https://docs.swmansion.com/react-native-reanimated) for further info.
-   */
-  onDragEnd?: (event: ReorderableListDragEndEvent) => void;
-}
-
-export interface ReorderableListItemConfig {
-  /**
-   * Value of the animated style on drag end.
-   */
-  enabled?: boolean;
-  /**
-   * Value of the animated style on drag end.
-   */
-  valueEnd?: number;
-  /**
-   * Value of the animated style on drag start.
+   * Event fired after an item is released and the list is reordered.
    */
-  valueStart?: number;
+  onReorder: (event: ReorderableListReorderEvent) => void;
   /**
-   * Easing function for the animation to the end value. Default: `Easing.in(Easing.ease)`.
+   * An animated scroll handler created with useAnimatedScrollHandler. See [Reanimated docs](https://docs.swmansion.com/react-native-reanimated) for further info.
    */
-  easingEnd?: EasingFunction;
+  onScroll?: ReturnType<typeof useAnimatedScrollHandler>;
   /**
-   * Easing function for the animation to the start value. Default: `Easing.out(Easing.ease)`.
+   * Event fired when an item is dragged. Needs to be a `worklet`. See [Reanimated docs](https://docs.swmansion.com/react-native-reanimated) for further info.
    */
-  easingStart?: EasingFunction;
+  onDragStart?: (event: ReorderableListDragStartEvent) => void;
   /**
-   * Duration of the animations in milliseconds. Default: `200`.
+   * Event fired when the dragged item is released. Needs to be a `worklet`. See [Reanimated docs](https://docs.swmansion.com/react-native-reanimated) for further info.
    */
-  duration?: number;
+  onDragEnd?: (event: ReorderableListDragEndEvent) => void;
 }
 
-export interface ReorderableListItemProps extends ViewProps {
+export interface ReorderableListCellAnimations {
   /**
-   * Config for the `opacity` animation. Enabled by default with custom default options.
+   * Shared value to animate the opacity of a dragged item. Set to false to disable default opacity animations.
    */
-  opacityAnimationConfig?: ReorderableListItemConfig;
+  opacity?: SharedValue<number> | false;
   /**
-   * Config for the `scale` animation. Enabled by default with custom default options.
+   * Shared value to animate the scale of a dragged item. Set to false to disable default scale animations.
    */
-  scaleAnimationConfig?: ReorderableListItemConfig;
+  scale?: SharedValue<number> | false;
 }
 
 export interface ScrollViewContainerProps
   extends Omit<ScrollViewProps, 'onScroll'> {
   /**
-   * Event fired at most once per frame during scrolling. Needs to be a `worklet`. See [Reanimated docs](https://docs.swmansion.com/react-native-reanimated) for further info.
+   * An animated scroll handler created with useAnimatedScrollHandler. See [Reanimated docs](https://docs.swmansion.com/react-native-reanimated) for further info.
    */
-  onScroll?: (event: NativeScrollEvent) => void;
+  onScroll?: ReturnType<typeof useAnimatedScrollHandler>;
 }
 
 export interface NestedReorderableListProps<T> extends ReorderableListProps<T> {

package/lib/commonjs/components/ReorderableListCore/constants.ios.js

@@ -1,10 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.AUTOSCROLL_INCREMENT = exports.AUTOSCROLL_DELAY = void 0;
-// iOS specific constants
-const AUTOSCROLL_INCREMENT = exports.AUTOSCROLL_INCREMENT = 80;
-const AUTOSCROLL_DELAY = exports.AUTOSCROLL_DELAY = 100;
-//# sourceMappingURL=constants.ios.js.map

package/lib/commonjs/components/ReorderableListCore/constants.ios.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["AUTOSCROLL_INCREMENT","exports","AUTOSCROLL_DELAY"],"sourceRoot":"../../../../src","sources":["components/ReorderableListCore/constants.ios.ts"],"mappings":";;;;;;AAAA;AACO,MAAMA,oBAAoB,GAAAC,OAAA,CAAAD,oBAAA,GAAG,EAAE;AAC/B,MAAME,gBAAgB,GAAAD,OAAA,CAAAC,gBAAA,GAAG,GAAG","ignoreList":[]}

package/lib/commonjs/components/ReorderableListCore/constants.js

@@ -1,10 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.AUTOSCROLL_INCREMENT = exports.AUTOSCROLL_DELAY = void 0;
-// Default constants
-const AUTOSCROLL_INCREMENT = exports.AUTOSCROLL_INCREMENT = 5;
-const AUTOSCROLL_DELAY = exports.AUTOSCROLL_DELAY = 0;
-//# sourceMappingURL=constants.js.map

package/lib/commonjs/components/ReorderableListCore/constants.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["AUTOSCROLL_INCREMENT","exports","AUTOSCROLL_DELAY"],"sourceRoot":"../../../../src","sources":["components/ReorderableListCore/constants.ts"],"mappings":";;;;;;AAAA;AACO,MAAMA,oBAAoB,GAAAC,OAAA,CAAAD,oBAAA,GAAG,CAAC;AAC9B,MAAME,gBAAgB,GAAAD,OAAA,CAAAC,gBAAA,GAAG,CAAC","ignoreList":[]}