react-native-reorderable-list 0.16.2 → 0.17.0

package/lib/module/components/ReorderableListCore.js

@@ -23,9 +23,9 @@ const ReorderableListCore = ({
   onDragEnd,
   onIndexChange,
   scrollViewContainerRef,
-  scrollViewPageY,
-  scrollViewHeightY,
-  scrollViewScrollOffsetY,
+  scrollViewPageXY,
+  scrollViewSize,
+  scrollViewScrollOffsetXY,
   scrollViewScrollEnabledProp,
   setScrollViewForceDisableScroll,
   scrollable,
@@ -50,35 +50,35 @@ const ReorderableListCore = ({
   const scrollEnabledProp = usePropAsSharedValue(scrollEnabled);
   const currentScrollEnabled = useSharedValue(scrollEnabled);
   const gestureState = useSharedValue(State.UNDETERMINED);
-  const currentY = useSharedValue(0);
-  const currentTranslationY = useSharedValue(0);
-  const currentItemDragCenterY = useSharedValue(null);
-  const startItemDragCenterY = useSharedValue(0);
-  const flatListScrollOffsetY = useSharedValue(0);
-  const flatListHeightY = useSharedValue(0);
-  const flatListPageY = useSharedValue(0);
-  // The scroll y translation of the list since drag start
-  const dragScrollTranslationY = useSharedValue(0);
-  // The initial scroll offset y of the list on drag start
-  const dragInitialScrollOffsetY = useSharedValue(0);
-  // The scroll y translation of the ScrollViewContainer since drag start
-  const scrollViewDragScrollTranslationY = useSharedValue(0);
-  // The initial scroll offset y of the ScrollViewContainer on drag start
-  const scrollViewDragInitialScrollOffsetY = useSharedValue(0);
-  const draggedHeight = useSharedValue(0);
+  const currentXY = useSharedValue(0);
+  const currentTranslationXY = useSharedValue(0);
+  const currentItemDragCenterXY = useSharedValue(null);
+  const startItemDragCenterXY = useSharedValue(0);
+  const flatListScrollOffsetXY = useSharedValue(0);
+  const flatListSize = useSharedValue(0);
+  const flatListPageXY = useSharedValue(0);
+  // The scroll x or y translation of the list since drag start
+  const dragScrollTranslationXY = useSharedValue(0);
+  // The initial scroll offset x or y of the list on drag start
+  const dragInitialScrollOffsetXY = useSharedValue(0);
+  // The scroll x or y translation of the ScrollViewContainer since drag start
+  const scrollViewDragScrollTranslationXY = useSharedValue(0);
+  // The initial scroll offset x or y of the ScrollViewContainer on drag start
+  const scrollViewDragInitialScrollOffsetXY = useSharedValue(0);
+  const draggedSize = useSharedValue(0);
   const itemOffset = useSharedValue([]);
-  const itemHeight = useSharedValue([]);
-  // We need to track data length since itemOffset and itemHeight might contain more data than we need.
+  const itemSize = useSharedValue([]);
+  // We need to track data length since itemOffset and itemSize might contain more data than we need.
   // e.g. items are removed from the list, in which case layout data for those items is set to 0.
   const itemCount = useSharedValue(data.length);
   const autoscrollTrigger = useSharedValue(-1);
   const lastAutoscrollTrigger = useSharedValue(-1);
-  const dragY = useSharedValue(0);
+  const dragXY = useSharedValue(0);
   const currentIndex = useSharedValue(-1);
   const draggedIndex = useSharedValue(-1);
   const state = useSharedValue(ReorderableListState.IDLE);
   const dragEndHandlers = useSharedValue([]);
-  const startY = useSharedValue(0);
+  const startXY = useSharedValue(0);
   const scaleDefault = useSharedValue(1);
   const opacityDefault = useSharedValue(1);
   const dragDirection = useSharedValue(0);
@@ -90,9 +90,10 @@ const ReorderableListCore = ({
   const animationDurationProp = usePropAsSharedValue(animationDuration);
   const autoscrollActivationDeltaProp = usePropAsSharedValue(autoscrollActivationDelta);
   const dragEnabledProp = usePropAsSharedValue(dragEnabled ?? true);
+  const horizontalProp = usePropAsSharedValue(!!rest.horizontal);
 
   // Position of the list relative to the scroll container
-  const nestedFlatListPositionY = useDerivedValue(() => flatListPageY.value - ((scrollViewPageY === null || scrollViewPageY === void 0 ? void 0 : scrollViewPageY.value) || 0));
+  const nestedFlatListPositionXY = useDerivedValue(() => flatListPageXY.value - ((scrollViewPageXY === null || scrollViewPageXY === void 0 ? void 0 : scrollViewPageXY.value) || 0));
   useEffect(() => {
     itemCount.value = data.length;
 
@@ -102,13 +103,13 @@ const ReorderableListCore = ({
     if (data.length < prevItemCount.current) {
       for (let i = data.length; i < prevItemCount.current; i++) {
         runOnUI(() => {
-          itemHeight.value[i] = 0;
+          itemSize.value[i] = 0;
           itemOffset.value[i] = 0;
         })();
       }
     }
     prevItemCount.current = data.length;
-  }, [data.length, itemHeight, itemOffset, itemCount]);
+  }, [data.length, itemSize, itemOffset, itemCount]);
   useEffect(() => {
     if (!markedCellsRef.current ||
     // Clean keys once they surpass by 10% the size of the list itself.
@@ -141,12 +142,13 @@ const ReorderableListCore = ({
     return `${cellKey}#${mark}`;
   }, []);
   const listContextValue = useMemo(() => ({
-    draggedHeight,
+    draggedSize,
     currentIndex,
     draggedIndex,
     dragEndHandlers,
     activeIndex,
     itemLayoutAnimation: itemLayoutAnimationPropRef,
+    horizontal: horizontalProp,
     cellAnimations: {
       ...cellAnimations,
       transform: cellAnimations && 'transform' in cellAnimations ? cellAnimations.transform : [{
@@ -154,7 +156,7 @@ const ReorderableListCore = ({
       }],
       opacity: cellAnimations && 'opacity' in cellAnimations ? cellAnimations.opacity : opacityDefault
     }
-  }), [draggedHeight, currentIndex, draggedIndex, dragEndHandlers, activeIndex, cellAnimations, itemLayoutAnimationPropRef, scaleDefault, opacityDefault]);
+  }), [draggedSize, currentIndex, draggedIndex, dragEndHandlers, activeIndex, cellAnimations, itemLayoutAnimationPropRef, scaleDefault, opacityDefault, horizontalProp]);
 
   /**
    * Decides the intended drag direction of the user.
@@ -166,41 +168,46 @@ const ReorderableListCore = ({
   const setDragDirection = useCallback(e => {
     'worklet';
 
-    const direction = e.velocityY > 0 ? 1 : -1;
+    const absoluteXY = horizontalProp.value ? e.absoluteX : e.absoluteY;
+    const velocityXY = horizontalProp.value ? e.velocityX : e.velocityY;
+    const direction = velocityXY > 0 ? 1 : -1;
     if (direction !== dragDirection.value) {
       if (lastDragDirectionPivot.value === null) {
-        lastDragDirectionPivot.value = e.absoluteY;
-      } else if (Math.abs(e.absoluteY - lastDragDirectionPivot.value) >= autoscrollActivationDeltaProp.value) {
+        lastDragDirectionPivot.value = absoluteXY;
+      } else if (Math.abs(absoluteXY - lastDragDirectionPivot.value) >= autoscrollActivationDeltaProp.value) {
         dragDirection.value = direction;
-        lastDragDirectionPivot.value = e.absoluteY;
+        lastDragDirectionPivot.value = absoluteXY;
       }
     }
-  }, [dragDirection, lastDragDirectionPivot, autoscrollActivationDeltaProp]);
-  const setCurrentItemDragCenterY = useCallback(e => {
+  }, [dragDirection, lastDragDirectionPivot, autoscrollActivationDeltaProp, horizontalProp]);
+  const setCurrentItemDragCenterXY = useCallback(e => {
     'worklet';
 
-    if (currentItemDragCenterY.value === null) {
+    const translationXY = horizontalProp.value ? e.translationX : e.translationY;
+    if (currentItemDragCenterXY.value === null) {
       if (currentIndex.value >= 0) {
-        const itemCenter = itemHeight.value[currentIndex.value] * 0.5;
-        // the y coordinate of the item relative to the list
-        const itemY = itemOffset.value[currentIndex.value] - (flatListScrollOffsetY.value + scrollViewDragScrollTranslationY.value);
-        const value = itemY + itemCenter + e.translationY;
-        startItemDragCenterY.value = value;
-        currentItemDragCenterY.value = value;
+        const itemCenter = itemSize.value[currentIndex.value] * 0.5;
+        // the x or y coordinate of the item relative to the list
+        const itemXY = itemOffset.value[currentIndex.value] - (flatListScrollOffsetXY.value + scrollViewDragScrollTranslationXY.value);
+        const value = itemXY + itemCenter + translationXY;
+        startItemDragCenterXY.value = value;
+        currentItemDragCenterXY.value = value;
       }
     } else {
-      currentItemDragCenterY.value = startItemDragCenterY.value + e.translationY;
+      currentItemDragCenterXY.value = startItemDragCenterXY.value + translationXY;
     }
-  }, [currentItemDragCenterY, currentIndex, startItemDragCenterY, itemOffset, itemHeight, flatListScrollOffsetY, scrollViewDragScrollTranslationY]);
+  }, [horizontalProp, currentItemDragCenterXY, currentIndex, startItemDragCenterXY, itemOffset, itemSize, flatListScrollOffsetXY, scrollViewDragScrollTranslationXY]);
   const panGestureHandler = useMemo(() => (panGesture || Gesture.Pan()).onBegin(e => {
     'worklet';
 
     // prevent new dragging until item is completely released
     if (state.value === ReorderableListState.IDLE) {
-      startY.value = e.y;
-      currentY.value = e.y;
-      currentTranslationY.value = e.translationY;
-      dragY.value = e.translationY;
+      const xy = horizontalProp.value ? e.x : e.y;
+      const translationXY = horizontalProp.value ? e.translationX : e.translationY;
+      startXY.value = xy;
+      currentXY.value = xy;
+      currentTranslationXY.value = translationXY;
+      dragXY.value = translationXY;
       gestureState.value = e.state;
     }
   }).onUpdate(e => {
@@ -210,10 +217,11 @@ const ReorderableListCore = ({
       setDragDirection(e);
     }
     if (state.value !== ReorderableListState.RELEASED) {
-      setCurrentItemDragCenterY(e);
-      currentY.value = startY.value + e.translationY;
-      currentTranslationY.value = e.translationY;
-      dragY.value = e.translationY + dragScrollTranslationY.value + scrollViewDragScrollTranslationY.value;
+      setCurrentItemDragCenterXY(e);
+      const translationXY = horizontalProp.value ? e.translationX : e.translationY;
+      currentXY.value = startXY.value + translationXY;
+      currentTranslationXY.value = translationXY;
+      dragXY.value = translationXY + dragScrollTranslationXY.value + scrollViewDragScrollTranslationXY.value;
       gestureState.value = e.state;
     }
   }).onEnd(e => {
@@ -224,7 +232,7 @@ const ReorderableListCore = ({
     'worklet';
 
     gestureState.value = e.state;
-  }), [panGesture, state, startY, currentY, currentTranslationY, dragY, gestureState, dragScrollTranslationY, scrollViewDragScrollTranslationY, setDragDirection, setCurrentItemDragCenterY]);
+  }), [panGesture, state, startXY, currentXY, currentTranslationXY, dragXY, gestureState, dragScrollTranslationXY, scrollViewDragScrollTranslationXY, setDragDirection, setCurrentItemDragCenterXY, horizontalProp]);
   const panGestureHandlerWithPropOptions = useMemo(() => {
     if (typeof panActivateAfterLongPress === 'number') {
       panGestureHandler.activateAfterLongPress(panActivateAfterLongPress);
@@ -268,13 +276,13 @@ const ReorderableListCore = ({
 
     state.value = ReorderableListState.IDLE;
     draggedIndex.value = -1;
-    dragY.value = 0;
-    dragScrollTranslationY.value = 0;
-    scrollViewDragScrollTranslationY.value = 0;
+    dragXY.value = 0;
+    dragScrollTranslationXY.value = 0;
+    scrollViewDragScrollTranslationXY.value = 0;
     dragDirection.value = 0;
     lastDragDirectionPivot.value = null;
-    currentItemDragCenterY.value = null;
-  }, [state, draggedIndex, dragY, dragScrollTranslationY, scrollViewDragScrollTranslationY, dragDirection, lastDragDirectionPivot, currentItemDragCenterY]);
+    currentItemDragCenterXY.value = null;
+  }, [state, draggedIndex, dragXY, dragScrollTranslationXY, scrollViewDragScrollTranslationXY, dragDirection, lastDragDirectionPivot, currentItemDragCenterXY]);
   const resetSharedValuesAfterAnimations = useCallback(() => {
     setTimeout(runOnUI(resetSharedValues), animationDurationProp.value);
   }, [resetSharedValues, animationDurationProp]);
@@ -311,14 +319,14 @@ const ReorderableListCore = ({
     const index1 = itemDirection ? from : to;
     const index2 = itemDirection ? to : from;
     const newOffset1 = itemOffset.value[index1];
-    const newHeight1 = itemHeight.value[index2];
-    const newOffset2 = itemOffset.value[index2] + itemHeight.value[index2] - itemHeight.value[index1];
-    const newHeight2 = itemHeight.value[index1];
+    const newSize1 = itemSize.value[index2];
+    const newOffset2 = itemOffset.value[index2] + itemSize.value[index2] - itemSize.value[index1];
+    const newSize2 = itemSize.value[index1];
     itemOffset.value[index1] = newOffset1;
-    itemHeight.value[index1] = newHeight1;
+    itemSize.value[index1] = newSize1;
     itemOffset.value[index2] = newOffset2;
-    itemHeight.value[index2] = newHeight2;
-  }, [itemOffset, itemHeight]);
+    itemSize.value[index2] = newSize2;
+  }, [itemOffset, itemSize]);
 
   /**
    * Computes a potential new drop container for the current dragged item and evaluates
@@ -330,29 +338,29 @@ const ReorderableListCore = ({
   const computeCurrentIndex = useCallback(() => {
     'worklet';
 
-    if (currentItemDragCenterY.value === null) {
+    if (currentItemDragCenterXY.value === null) {
       return currentIndex.value;
     }
 
-    // apply scroll offset and scroll container translation
-    const relativeDragCenterY = flatListScrollOffsetY.value + scrollViewDragScrollTranslationY.value + currentItemDragCenterY.value;
+    // Apply scroll offset and scroll container translation.
+    const relativeDragCenterXY = flatListScrollOffsetXY.value + scrollViewDragScrollTranslationXY.value + currentItemDragCenterXY.value;
     const currentOffset = itemOffset.value[currentIndex.value];
-    const currentHeight = itemHeight.value[currentIndex.value];
-    const currentCenter = currentOffset + currentHeight * 0.5;
+    const currentSize = itemSize.value[currentIndex.value];
+    const currentCenter = currentOffset + currentSize * 0.5;
     const max = itemCount.value;
-    const possibleIndex = relativeDragCenterY < currentCenter ? Math.max(0, currentIndex.value - 1) : Math.min(max - 1, currentIndex.value + 1);
+    const possibleIndex = relativeDragCenterXY < currentCenter ? Math.max(0, currentIndex.value - 1) : Math.min(max - 1, currentIndex.value + 1);
     if (currentIndex.value !== possibleIndex) {
       let possibleOffset = itemOffset.value[possibleIndex];
       if (possibleIndex > currentIndex.value) {
-        possibleOffset += itemHeight.value[possibleIndex] - currentHeight;
+        possibleOffset += itemSize.value[possibleIndex] - currentSize;
       }
-      const possibleCenter = possibleOffset + currentHeight * 0.5;
-      const distanceFromCurrent = Math.abs(relativeDragCenterY - currentCenter);
-      const distanceFromPossible = Math.abs(relativeDragCenterY - possibleCenter);
+      const possibleCenter = possibleOffset + currentSize * 0.5;
+      const distanceFromCurrent = Math.abs(relativeDragCenterXY - currentCenter);
+      const distanceFromPossible = Math.abs(relativeDragCenterXY - possibleCenter);
       return distanceFromCurrent <= distanceFromPossible ? currentIndex.value : possibleIndex;
     }
     return currentIndex.value;
-  }, [currentIndex, currentItemDragCenterY, itemCount, itemOffset, itemHeight, flatListScrollOffsetY, scrollViewDragScrollTranslationY]);
+  }, [currentIndex, currentItemDragCenterXY, itemCount, itemOffset, itemSize, flatListScrollOffsetXY, scrollViewDragScrollTranslationXY]);
   const setCurrentIndex = useCallback(() => {
     'worklet';
 
@@ -374,7 +382,7 @@ const ReorderableListCore = ({
       scaleDefault.value = withTiming(scaleConfig.toValue, scaleConfig);
     }
 
-    // if no custom opacity run the default
+    // If no custom opacity run the default.
     if (!(cellAnimations && 'opacity' in cellAnimations)) {
       const opacityConfig = OPACITY_ANIMATION_CONFIG_DEFAULT[type];
       opacityDefault.value = withTiming(opacityConfig.toValue, opacityConfig);
@@ -390,7 +398,7 @@ const ReorderableListCore = ({
         runOnJS(setActiveIndex)(-1);
       }
 
-      // trigger onDragEnd event
+      // Trigger onDragEnd event.
       let e = {
         from: draggedIndex.value,
         to: currentIndex.value
@@ -403,23 +411,23 @@ const ReorderableListCore = ({
 
       // they are actually swapped on drag translation
       const currentItemOffset = itemOffset.value[draggedIndex.value];
-      const currentItemHeight = itemHeight.value[draggedIndex.value];
+      const currentItemSize = itemSize.value[draggedIndex.value];
       const draggedItemOffset = itemOffset.value[currentIndex.value];
-      const draggedItemHeight = itemHeight.value[currentIndex.value];
-      const newTopPosition = currentIndex.value > draggedIndex.value ? draggedItemOffset - currentItemOffset : draggedItemOffset - currentItemOffset + (draggedItemHeight - currentItemHeight);
+      const draggedItemSize = itemSize.value[currentIndex.value];
+      const newPositionXY = currentIndex.value > draggedIndex.value ? draggedItemOffset - currentItemOffset : draggedItemOffset - currentItemOffset + (draggedItemSize - currentItemSize);
       runDefaultDragAnimations('end');
-      if (dragY.value !== newTopPosition) {
-        // animate dragged item to its new position on release
-        dragY.value = withTiming(newTopPosition, {
+      if (dragXY.value !== newPositionXY) {
+        // Animate dragged item to its new position on release.
+        dragXY.value = withTiming(newPositionXY, {
           duration: animationDurationProp.value,
           easing: Easing.out(Easing.ease)
         }, () => {
           runOnJS(reorder)(draggedIndex.value, currentIndex.value);
         });
       } else {
-        // user might drag and release the item without moving it so,
+        // 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
+        // we need to reset values as the reorder function would do.
         runOnJS(resetSharedValuesAfterAnimations)();
       }
     }
@@ -427,58 +435,58 @@ const ReorderableListCore = ({
   const computeHiddenArea = useCallback(() => {
     'worklet';
 
-    if (!scrollViewScrollOffsetY || !scrollViewHeightY) {
+    if (!scrollViewScrollOffsetXY || !scrollViewSize) {
       return {
-        top: 0,
-        bottom: 0
+        start: 0,
+        end: 0
       };
     }
 
     // hidden area cannot be negative
-    const top = Math.max(0, scrollViewScrollOffsetY.value - nestedFlatListPositionY.value);
-    const bottom = Math.max(0, nestedFlatListPositionY.value + flatListHeightY.value - (scrollViewScrollOffsetY.value + scrollViewHeightY.value));
+    const start = Math.max(0, scrollViewScrollOffsetXY.value - nestedFlatListPositionXY.value);
+    const end = Math.max(0, nestedFlatListPositionXY.value + flatListSize.value - (scrollViewScrollOffsetXY.value + scrollViewSize.value));
     return {
-      top,
-      bottom
+      start,
+      end
     };
-  }, [scrollViewScrollOffsetY, scrollViewHeightY, nestedFlatListPositionY, flatListHeightY]);
+  }, [scrollViewScrollOffsetXY, scrollViewSize, nestedFlatListPositionXY, flatListSize]);
   const computeThresholdArea = useCallback(() => {
     'worklet';
 
     const hiddenArea = computeHiddenArea();
-    const offsetTop = Math.max(0, (autoscrollThresholdOffset === null || autoscrollThresholdOffset === void 0 ? void 0 : autoscrollThresholdOffset.top) || 0);
-    const offsetBottom = Math.max(0, (autoscrollThresholdOffset === null || autoscrollThresholdOffset === void 0 ? void 0 : autoscrollThresholdOffset.bottom) || 0);
+    const offsetStart = Math.max(0, (autoscrollThresholdOffset === null || autoscrollThresholdOffset === void 0 ? void 0 : autoscrollThresholdOffset.start) || (autoscrollThresholdOffset === null || autoscrollThresholdOffset === void 0 ? void 0 : autoscrollThresholdOffset.top) || 0);
+    const offsetEnd = Math.max(0, (autoscrollThresholdOffset === null || autoscrollThresholdOffset === void 0 ? void 0 : autoscrollThresholdOffset.end) || (autoscrollThresholdOffset === null || autoscrollThresholdOffset === void 0 ? void 0 : autoscrollThresholdOffset.bottom) || 0);
     const threshold = Math.max(0, Math.min(autoscrollThreshold, 0.4));
-    const visibleHeight = flatListHeightY.value - (hiddenArea.top + hiddenArea.bottom) - (offsetTop + offsetBottom);
-    const area = visibleHeight * threshold;
-    const top = area + offsetTop;
-    const bottom = flatListHeightY.value - area - offsetBottom;
+    const visibleSize = flatListSize.value - (hiddenArea.start + hiddenArea.end) - (offsetStart + offsetEnd);
+    const area = visibleSize * threshold;
+    const start = area + offsetStart;
+    const end = flatListSize.value - area - offsetEnd;
     return {
-      top,
-      bottom
+      start,
+      end
     };
-  }, [computeHiddenArea, autoscrollThreshold, autoscrollThresholdOffset, flatListHeightY]);
+  }, [computeHiddenArea, autoscrollThreshold, autoscrollThresholdOffset, flatListSize]);
   const computeContainerThresholdArea = useCallback(() => {
     'worklet';
 
-    if (!scrollViewHeightY) {
+    if (!scrollViewSize) {
       return {
-        top: -Infinity,
-        bottom: Infinity
+        start: -Infinity,
+        end: Infinity
       };
     }
-    const offsetTop = Math.max(0, (autoscrollThresholdOffset === null || autoscrollThresholdOffset === void 0 ? void 0 : autoscrollThresholdOffset.top) || 0);
-    const offsetBottom = Math.max(0, (autoscrollThresholdOffset === null || autoscrollThresholdOffset === void 0 ? void 0 : autoscrollThresholdOffset.bottom) || 0);
+    const offsetStart = Math.max(0, (autoscrollThresholdOffset === null || autoscrollThresholdOffset === void 0 ? void 0 : autoscrollThresholdOffset.start) || (autoscrollThresholdOffset === null || autoscrollThresholdOffset === void 0 ? void 0 : autoscrollThresholdOffset.top) || 0);
+    const offsetEnd = Math.max(0, (autoscrollThresholdOffset === null || autoscrollThresholdOffset === void 0 ? void 0 : autoscrollThresholdOffset.end) || (autoscrollThresholdOffset === null || autoscrollThresholdOffset === void 0 ? void 0 : autoscrollThresholdOffset.bottom) || 0);
     const threshold = Math.max(0, Math.min(autoscrollThreshold, 0.4));
-    const visibleHeight = scrollViewHeightY.value - (offsetTop + offsetBottom);
-    const area = visibleHeight * threshold;
-    const top = area + offsetTop;
-    const bottom = visibleHeight - area - offsetBottom;
+    const visibleSize = scrollViewSize.value - (offsetStart + offsetEnd);
+    const area = visibleSize * threshold;
+    const start = area + offsetStart;
+    const end = visibleSize - area - offsetEnd;
     return {
-      top,
-      bottom
+      start,
+      end
     };
-  }, [autoscrollThreshold, autoscrollThresholdOffset, scrollViewHeightY]);
+  }, [autoscrollThreshold, autoscrollThresholdOffset, scrollViewSize]);
   const shouldScrollContainer = useCallback(y => {
     'worklet';
 
@@ -487,52 +495,53 @@ const ReorderableListCore = ({
 
     // We should scroll the container if there's a hidden part of the nested list.
     // We might have floating errors like 0.0001 which we should ignore.
-    return nestedListHiddenArea.top > 0.01 && y <= containerThresholdArea.top || nestedListHiddenArea.bottom > 0.01 && y >= containerThresholdArea.bottom;
+    return nestedListHiddenArea.start > 0.01 && y <= containerThresholdArea.start || nestedListHiddenArea.end > 0.01 && y >= containerThresholdArea.end;
   }, [computeHiddenArea, computeContainerThresholdArea]);
-  const getRelativeContainerY = useCallback(() => {
+  const getRelativeContainerXY = useCallback(() => {
     'worklet';
 
-    return currentY.value + nestedFlatListPositionY.value - scrollViewDragInitialScrollOffsetY.value;
-  }, [currentY, nestedFlatListPositionY, scrollViewDragInitialScrollOffsetY]);
-  const getRelativeListY = useCallback(() => {
+    return currentXY.value + nestedFlatListPositionXY.value - scrollViewDragInitialScrollOffsetXY.value;
+  }, [currentXY, nestedFlatListPositionXY, scrollViewDragInitialScrollOffsetXY]);
+  const getRelativeListXY = useCallback(() => {
     'worklet';
 
-    return currentY.value + scrollViewDragScrollTranslationY.value;
-  }, [currentY, scrollViewDragScrollTranslationY]);
+    return currentXY.value + scrollViewDragScrollTranslationXY.value;
+  }, [currentXY, scrollViewDragScrollTranslationXY]);
   const scrollDirection = useCallback(() => {
     'worklet';
 
-    const relativeContainerY = getRelativeContainerY();
-    if (shouldScrollContainer(relativeContainerY)) {
+    const relativeContainerXY = getRelativeContainerXY();
+    if (shouldScrollContainer(relativeContainerXY)) {
       const containerThresholdArea = computeContainerThresholdArea();
-      if (relativeContainerY <= containerThresholdArea.top) {
+      if (relativeContainerXY <= containerThresholdArea.start) {
         return -1;
       }
-      if (relativeContainerY >= containerThresholdArea.bottom) {
+      if (relativeContainerXY >= containerThresholdArea.end) {
         return 1;
       }
     } else if (scrollable) {
-      const relativeListY = getRelativeListY();
+      const relativeListXY = getRelativeListXY();
       const thresholdArea = computeThresholdArea();
-      if (relativeListY <= thresholdArea.top) {
+      if (relativeListXY <= thresholdArea.start) {
         return -1;
       }
-      if (relativeListY >= thresholdArea.bottom) {
+      if (relativeListXY >= thresholdArea.end) {
         return 1;
       }
     }
     return 0;
-  }, [shouldScrollContainer, computeThresholdArea, computeContainerThresholdArea, getRelativeContainerY, getRelativeListY, scrollable]);
-  useAnimatedReaction(() => currentY.value, () => {
+  }, [shouldScrollContainer, computeThresholdArea, computeContainerThresholdArea, getRelativeContainerXY, getRelativeListXY, scrollable]);
+  useAnimatedReaction(() => currentXY.value, () => {
     if (state.value === ReorderableListState.DRAGGED || state.value === ReorderableListState.AUTOSCROLL) {
       setCurrentIndex();
 
       // Trigger autoscroll when:
-      // 1. Within the threshold area (top or bottom of list)
+      // 1. Within the threshold area (start or end of list)
       // 2. Have dragged in the same direction as the scroll
       // 3. Not already in autoscroll mode
       if (dragDirection.value === scrollDirection()) {
-        // When the first two conditions are met and it's already in autoscroll mode, we let it continue (no-op)
+        // When the first two conditions are met and it's already in autoscroll mode,
+        // we let it continue (no-op).
         if (state.value !== ReorderableListState.AUTOSCROLL) {
           state.value = ReorderableListState.AUTOSCROLL;
           lastAutoscrollTrigger.value = autoscrollTrigger.value;
@@ -547,17 +556,18 @@ const ReorderableListCore = ({
     if (autoscrollTrigger.value !== lastAutoscrollTrigger.value && state.value === ReorderableListState.AUTOSCROLL) {
       const autoscrollIncrement = dragDirection.value * AUTOSCROLL_CONFIG.increment * autoscrollSpeedScale;
       if (autoscrollIncrement !== 0) {
-        let scrollOffset = flatListScrollOffsetY.value;
+        let scrollOffset = flatListScrollOffsetXY.value;
         let listRef = flatListRef;
 
         // Checking on every autoscroll whether to scroll the container,
         // this allows to smoothly pass the scroll from the container to the nested list
         // without any gesture input.
-        if (scrollViewScrollOffsetY && shouldScrollContainer(getRelativeContainerY())) {
-          scrollOffset = scrollViewScrollOffsetY.value;
+        if (scrollViewScrollOffsetXY && shouldScrollContainer(getRelativeContainerXY())) {
+          scrollOffset = scrollViewScrollOffsetXY.value;
           listRef = scrollViewContainerRef;
         }
-        scrollTo(listRef, 0, scrollOffset + autoscrollIncrement, true);
+        const scrollToValue = scrollOffset + autoscrollIncrement;
+        scrollTo(listRef, horizontalProp.value ? scrollToValue : 0, horizontalProp.value ? 0 : scrollToValue, true);
       }
 
       // when autoscrolling user may not be moving his finger so we need
@@ -568,16 +578,16 @@ const ReorderableListCore = ({
 
   // flatlist scroll handler
   const handleScroll = useAnimatedScrollHandler(e => {
-    flatListScrollOffsetY.value = e.contentOffset.y;
+    flatListScrollOffsetXY.value = horizontalProp.value ? e.contentOffset.x : e.contentOffset.y;
 
     // 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 away from the area.
     if (!currentScrollEnabled.value) {
-      dragScrollTranslationY.value = flatListScrollOffsetY.value - dragInitialScrollOffsetY.value;
+      dragScrollTranslationXY.value = flatListScrollOffsetXY.value - dragInitialScrollOffsetXY.value;
     }
     if (state.value === ReorderableListState.AUTOSCROLL) {
-      dragY.value = currentTranslationY.value + dragScrollTranslationY.value + scrollViewDragScrollTranslationY.value;
+      dragXY.value = currentTranslationXY.value + dragScrollTranslationXY.value + scrollViewDragScrollTranslationXY.value;
       lastAutoscrollTrigger.value = autoscrollTrigger.value;
       autoscrollTrigger.value = withDelay(autoscrollDelay, withTiming(autoscrollTrigger.value * -1, {
         duration: 0
@@ -586,16 +596,16 @@ const ReorderableListCore = ({
   });
 
   // container scroll handler
-  useAnimatedReaction(() => scrollViewScrollOffsetY === null || scrollViewScrollOffsetY === void 0 ? void 0 : scrollViewScrollOffsetY.value, value => {
+  useAnimatedReaction(() => scrollViewScrollOffsetXY === null || scrollViewScrollOffsetXY === void 0 ? void 0 : scrollViewScrollOffsetXY.value, value => {
     if (value) {
       // 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
+      // Fixes a bug on iOS where the item is shifted, after autoscrolling and then
       // moving away from the area.
       if (!currentScrollEnabled.value) {
-        scrollViewDragScrollTranslationY.value = value - scrollViewDragInitialScrollOffsetY.value;
+        scrollViewDragScrollTranslationXY.value = value - scrollViewDragInitialScrollOffsetXY.value;
       }
       if (state.value === ReorderableListState.AUTOSCROLL) {
-        dragY.value = currentTranslationY.value + scrollViewDragScrollTranslationY.value;
+        dragXY.value = currentTranslationXY.value + scrollViewDragScrollTranslationXY.value;
         lastAutoscrollTrigger.value = autoscrollTrigger.value;
         autoscrollTrigger.value = withDelay(autoscrollDelay, withTiming(autoscrollTrigger.value * -1, {
           duration: 0
@@ -610,17 +620,17 @@ const ReorderableListCore = ({
       return;
     }
 
-    // allow new drag when item is completely released
+    // Allow new drag when item is completely released.
     if (state.value === ReorderableListState.IDLE) {
-      // resetting shared values again fixes a flickeing bug in nested lists where
-      // after scrolling the parent list it would offset the new dragged item in another nested list
+      // Resetting shared values again fixes a flickeing bug in nested lists where
+      // after scrolling the parent list it would offset the new dragged item in another nested list.
       resetSharedValues();
       if (shouldUpdateActiveItem) {
         runOnJS(setActiveIndex)(index);
       }
-      dragInitialScrollOffsetY.value = flatListScrollOffsetY.value;
-      scrollViewDragInitialScrollOffsetY.value = (scrollViewScrollOffsetY === null || scrollViewScrollOffsetY === void 0 ? void 0 : scrollViewScrollOffsetY.value) || 0;
-      draggedHeight.value = itemHeight.value[index];
+      dragInitialScrollOffsetXY.value = flatListScrollOffsetXY.value;
+      scrollViewDragInitialScrollOffsetXY.value = (scrollViewScrollOffsetXY === null || scrollViewScrollOffsetXY === void 0 ? void 0 : scrollViewScrollOffsetXY.value) || 0;
+      draggedSize.value = itemSize.value[index];
       draggedIndex.value = index;
       currentIndex.value = index;
       state.value = ReorderableListState.DRAGGED;
@@ -632,29 +642,30 @@ const ReorderableListCore = ({
         index
       });
     }
-  }, [dragEnabledProp, resetSharedValues, shouldUpdateActiveItem, dragInitialScrollOffsetY, scrollViewScrollOffsetY, scrollViewDragInitialScrollOffsetY, setScrollEnabled, currentIndex, draggedHeight, draggedIndex, state, flatListScrollOffsetY, itemHeight, onDragStart, runDefaultDragAnimations]);
+  }, [dragEnabledProp, resetSharedValues, shouldUpdateActiveItem, dragInitialScrollOffsetXY, scrollViewScrollOffsetXY, scrollViewDragInitialScrollOffsetXY, setScrollEnabled, currentIndex, draggedSize, draggedIndex, state, flatListScrollOffsetXY, itemSize, onDragStart, runDefaultDragAnimations]);
   const handleFlatListLayout = useCallback(e => {
-    flatListHeightY.value = e.nativeEvent.layout.height;
+    flatListSize.value = horizontalProp.value ? e.nativeEvent.layout.width : e.nativeEvent.layout.height;
 
     // If nested in a scroll container.
-    if (scrollViewScrollOffsetY) {
-      // Timeout fixes a bug where measure returns height 0.
+    if (scrollViewScrollOffsetXY) {
+      // Timeout fixes a bug where measure returns width or height 0.
       setTimeout(() => {
         runOnUI(() => {
           const measurement = measure(flatListRef);
           if (!measurement) {
             return;
           }
+          const pageXY = horizontalProp.value ? measurement.pageX : measurement.pageY;
 
           // We need to use pageY because the list might be nested into other views,
           // It's important that we take the measurement of the list without any scroll offset
           // from the scroll container.
-          flatListPageY.value = measurement.pageY + ((scrollViewScrollOffsetY === null || scrollViewScrollOffsetY === void 0 ? void 0 : scrollViewScrollOffsetY.value) || 0);
+          flatListPageXY.value = pageXY + ((scrollViewScrollOffsetXY === null || scrollViewScrollOffsetXY === void 0 ? void 0 : scrollViewScrollOffsetXY.value) || 0);
         })();
       }, 100);
     }
     onLayout === null || onLayout === void 0 || onLayout(e);
-  }, [flatListRef, flatListPageY, flatListHeightY, scrollViewScrollOffsetY, onLayout]);
+  }, [flatListRef, flatListPageXY, flatListSize, horizontalProp, scrollViewScrollOffsetXY, onLayout]);
   const handleRef = useCallback(value => {
     flatListRef(value);
     if (typeof ref === 'function') {
@@ -664,7 +675,7 @@ const ReorderableListCore = ({
     }
   }, [flatListRef, ref]);
   const combinedGesture = useMemo(() => {
-    // android is able to handle nested scroll view, but not the full height ones like iOS
+    // Android is able to handle nested scroll view, but not the full size ones like iOS.
     if (outerScrollGesture && !(Platform.OS === 'android' && scrollable)) {
       return Gesture.Simultaneous(outerScrollGesture, gestureHandler);
     }
@@ -678,8 +689,8 @@ const ReorderableListCore = ({
     // forces remount with key change on reorder
     key: createCellKey(cellKey),
     itemOffset: itemOffset,
-    itemHeight: itemHeight,
-    dragY: dragY,
+    itemSize: itemSize,
+    dragXY: dragXY,
     draggedIndex: draggedIndex,
     animationDuration: animationDurationProp,
     startDrag: startDrag
@@ -696,7 +707,6 @@ const ReorderableListCore = ({
     onLayout: handleFlatListLayout,
     onScroll: composedScrollHandler,
     scrollEventThrottle: 1,
-    horizontal: false,
     removeClippedSubviews: false,
     numColumns: 1
     // We force disable scroll or let the component prop control it.