@legendapp/list 3.3.11 → 3.4.0

package/react-native.mjs

@@ -437,6 +437,14 @@ var EDGE_POSITION_EPSILON = 1;
 var ENABLE_DEVMODE = IS_DEV && false;
 var ENABLE_DEBUG_VIEW = IS_DEV && false;
 
+// src/core/endOfContentTarget.ts
+function getEndAlignedViewOffset(stylePaddingEnd, footerSize = 0) {
+  return -stylePaddingEnd - footerSize;
+}
+function isEndOfContentTarget(target, dataLength) {
+  return !!target && dataLength > 0 && target.viewPosition === 1 && !!target.preserveForBottomPadding && target.index !== void 0 && target.index >= dataLength - 1;
+}
+
 // src/core/cancelImperativeScroll.ts
 function cancelScrollCompletionChecks({ scheduledWork }) {
   scheduledWork.cancel("checkFinishedScrollFrame");
@@ -621,26 +629,25 @@ var checkThreshold = (distance, atThreshold, threshold, wasReached, snapshot, co
       scrollPosition: context.scrollPosition
     });
   };
+  let reached = !!wasReached;
   if (!wasReached) {
-    if (!within) {
-      return false;
-    }
-    onReached(distance);
-    updateSnapshot();
-    return true;
-  }
-  const reset = isOutsideThresholdHysteresis(distance, atThreshold, threshold);
-  if (reset) {
-    setSnapshot(void 0);
-    return false;
-  }
-  if (within) {
-    const changed = !snapshot || snapshot.atThreshold !== atThreshold || snapshot.contentSize !== context.contentSize || snapshot.dataLength !== context.dataLength;
-    if (changed) {
+    if (within && onReached(distance)) {
       updateSnapshot();
+      reached = true;
+    }
+  } else {
+    const reset = isOutsideThresholdHysteresis(distance, atThreshold, threshold);
+    if (reset) {
+      setSnapshot(void 0);
+      reached = false;
+    } else if (within) {
+      const changed = !snapshot || snapshot.atThreshold !== atThreshold || snapshot.contentSize !== context.contentSize || snapshot.dataLength !== context.dataLength;
+      if (changed) {
+        updateSnapshot();
+      }
     }
   }
-  return true;
+  return reached;
 };
 
 // src/utils/edgeReachedGate.ts
@@ -687,7 +694,6 @@ function beginReachedEdgeUserScroll(ctx, scrollDelta) {
     return void 0;
   }
   const allowedEdge = scrollDelta < 0 ? "start" : "end";
-  state.edgeReachedGate = "closed";
   resetEdgeLatch(ctx, allowedEdge);
   return allowedEdge;
 }
@@ -728,7 +734,7 @@ function checkAtBottom(ctx, allowedEdge, allowGateCreatedInCurrentCheck) {
     set$(
       ctx,
       "isWithinMaintainScrollAtEndThreshold",
-      isContentLess || distanceFromEnd <= maintainScrollAtEndThreshold * scrollLength || state.pendingMaintainScrollAtEnd || maintainingScrollAtEnd === "animated" || maintainingScrollAtEnd === "instant"
+      isContentLess || distanceFromEnd <= maintainScrollAtEndThreshold * scrollLength || state.pendingMaintainScrollAtEnd || !!maintainingScrollAtEnd
     );
     const shouldSkipThresholdChecks = hasActiveInitialScroll(state) || maintainingScrollAtEnd;
     if (!shouldSkipThresholdChecks) {
@@ -744,11 +750,13 @@ function checkAtBottom(ctx, allowedEdge, allowGateCreatedInCurrentCheck) {
           scrollPosition: scroll
         },
         (distance) => {
-          var _a4, _b;
-          if (canDispatchReachedEdge(ctx, "end", allowedEdge, allowGateCreatedInCurrentCheck)) {
+          let dispatched = false;
+          if (state.props.onEndReached && canDispatchReachedEdge(ctx, "end", allowedEdge, allowGateCreatedInCurrentCheck)) {
             markReachedEdge(ctx);
-            (_b = (_a4 = state.props).onEndReached) == null ? void 0 : _b.call(_a4, { distanceFromEnd: distance });
+            state.props.onEndReached({ distanceFromEnd: distance });
+            dispatched = true;
           }
+          return dispatched;
         },
         (snapshot) => {
           state.endReachedSnapshot = snapshot;
@@ -781,7 +789,7 @@ function checkAtTop(ctx, allowedEdge, allowGateCreatedInCurrentCheck) {
   }
   set$(ctx, "isAtStart", scroll <= EDGE_POSITION_EPSILON);
   set$(ctx, "isNearStart", scroll <= threshold);
-  const shouldSkipThresholdChecks = hasActiveInitialScroll(state) || !!state.scrollingTo;
+  const shouldSkipThresholdChecks = !state.queuedInitialLayout || hasActiveInitialScroll(state) || !!state.scrollingTo;
   if (!shouldSkipThresholdChecks) {
     state.isStartReached = checkThreshold(
       scroll,
@@ -795,11 +803,13 @@ function checkAtTop(ctx, allowedEdge, allowGateCreatedInCurrentCheck) {
         scrollPosition: scroll
       },
       (distance) => {
-        var _a3, _b;
-        if (canDispatchReachedEdge(ctx, "start", allowedEdge, allowGateCreatedInCurrentCheck)) {
+        let dispatched = false;
+        if (state.props.onStartReached && canDispatchReachedEdge(ctx, "start", allowedEdge, allowGateCreatedInCurrentCheck)) {
           markReachedEdge(ctx);
-          (_b = (_a3 = state.props).onStartReached) == null ? void 0 : _b.call(_a3, { distanceFromStart: distance });
+          state.props.onStartReached({ distanceFromStart: distance });
+          dispatched = true;
         }
+        return dispatched;
       },
       (snapshot) => {
         state.startReachedSnapshot = snapshot;
@@ -918,6 +928,11 @@ function resetInitialRenderState(ctx, {
   if (resetLayout) {
     state.didContainersLayout = false;
     state.queuedInitialLayout = false;
+    state.edgeReachedGate = void 0;
+    state.isStartReached = null;
+    state.isEndReached = null;
+    state.startReachedSnapshot = void 0;
+    state.endReachedSnapshot = void 0;
   }
   if (resetInitialScroll) {
     state.didFinishInitialScroll = false;
@@ -932,7 +947,7 @@ function setInitialRenderState(ctx, {
   const { state } = ctx;
   const {
     loadStartTime,
-    props: { onLoad }
+    props: { onLoad, onReady }
   } = state;
   if (didLayout) {
     state.didContainersLayout = true;
@@ -953,6 +968,7 @@ function setInitialRenderState(ctx, {
         onLoad({ elapsedTimeInMs: Date.now() - loadStartTime });
       }
     }
+    onReady == null ? void 0 : onReady();
   }
 }
 
@@ -1298,10 +1314,6 @@ function calculateOffsetWithOffsetPosition(ctx, offsetParam, params) {
     const itemSize = Math.max(0, measuredItemSize - (isOutOfBounds ? 0 : ctx.scrollAxisGap));
     const trailingInset = getContentInsetEnd(ctx);
     offset -= viewPosition * (state.scrollLength - trailingInset - itemSize);
-    if (!isOutOfBounds && index === state.props.data.length - 1) {
-      const footerSize = peek$(ctx, "footerSize") || 0;
-      offset += footerSize;
-    }
   }
   return offset;
 }
@@ -1817,7 +1829,7 @@ function updateScroll(ctx, newScroll, forceUpdate, options) {
   state.scrollTime = currentTime;
   const scrollDelta = Math.abs(newScroll - prevScroll);
   const isUserScrollEvent = !!(options == null ? void 0 : options.fromNativeScrollEvent) && scrollDelta > 0.1 && !adjustChanged && scrollingTo === void 0 && !state.pendingNativeMVCPAdjust;
-  const didCancelMaintainScrollAtEnd = isUserScrollEvent && newScroll < prevScroll && !!(state.maintainingScrollAtEnd || state.pendingMaintainScrollAtEnd);
+  const didCancelMaintainScrollAtEnd = Platform.OS === "web" && isUserScrollEvent && newScroll < prevScroll && !!(state.maintainingScrollAtEnd || state.pendingMaintainScrollAtEnd);
   if (didCancelMaintainScrollAtEnd) {
     finishMaintainScrollAtEnd(ctx);
   }
@@ -1895,89 +1907,103 @@ function finishMaintainScrollAtEnd(ctx) {
     requestAdjust(ctx, nextScroll - state.scroll);
   }
 }
-function doMaintainScrollAtEnd(ctx) {
-  var _a3, _b, _c, _d, _e;
+function doMaintainScrollAtEnd(ctx, options) {
+  var _a3, _b, _c, _d, _e, _f;
   const state = ctx.state;
-  const {
-    didContainersLayout,
-    didFinishInitialScroll,
-    pendingNativeMVCPAdjust,
-    props: { maintainScrollAtEnd }
-  } = state;
-  const isWithinMaintainScrollAtEndThreshold = peek$(ctx, "isWithinMaintainScrollAtEndThreshold");
-  const isReplayingPendingMaintain = !!state.pendingMaintainScrollAtEnd;
-  const shouldMaintainScrollAtEnd = !!(!((_a3 = ctx.scrollRequestTracker) == null ? void 0 : _a3.isWaitingToRun()) && (!state.scrollingTo || state.scrollingTo.isScrollToEnd) && (isWithinMaintainScrollAtEndThreshold || isReplayingPendingMaintain || ((_b = state.scrollingTo) == null ? void 0 : _b.isScrollToEnd)) && maintainScrollAtEnd && didFinishInitialScroll);
-  if (shouldMaintainScrollAtEnd && !state.scrollingTo) {
-    const scroller = state.refScroller.current;
-    const nativeMax = (_c = scroller == null ? void 0 : scroller.getMaxScrollOffset) == null ? void 0 : _c.call(scroller);
-    const observed = (_d = scroller == null ? void 0 : scroller.getCurrentScrollOffset) == null ? void 0 : _d.call(scroller);
-    if (nativeMax !== void 0 && observed !== void 0 && nativeMax < state.scroll - 1 && Math.abs(observed - nativeMax) <= 1) {
-      state.pendingMaintainScrollAtEnd = true;
-      state.scrollPending = observed;
-      updateScroll(ctx, observed, true, { markHasScrolled: false });
+  let didMaintain = false;
+  if (state.isDragging) {
+    finishMaintainScrollAtEnd(ctx);
+  } else {
+    const {
+      didContainersLayout,
+      didFinishInitialScroll,
+      pendingNativeMVCPAdjust,
+      props: { maintainScrollAtEnd }
+    } = state;
+    const immediate = (options == null ? void 0 : options.immediate) && Platform.OS === "web" && !(maintainScrollAtEnd == null ? void 0 : maintainScrollAtEnd.animated);
+    const isWithinMaintainScrollAtEndThreshold = peek$(ctx, "isWithinMaintainScrollAtEndThreshold");
+    const isReplayingPendingMaintain = !!state.pendingMaintainScrollAtEnd;
+    const shouldMaintainScrollAtEnd = !!(!((_a3 = ctx.scrollRequestTracker) == null ? void 0 : _a3.isWaitingToRun()) && (!state.scrollingTo || state.scrollingTo.isScrollToEnd) && (isWithinMaintainScrollAtEndThreshold || isReplayingPendingMaintain || ((_b = state.scrollingTo) == null ? void 0 : _b.isScrollToEnd)) && maintainScrollAtEnd && didFinishInitialScroll);
+    if (shouldMaintainScrollAtEnd && !state.scrollingTo) {
+      const scroller = state.refScroller.current;
+      const nativeMax = (_c = scroller == null ? void 0 : scroller.getMaxScrollOffset) == null ? void 0 : _c.call(scroller);
+      const observed = (_d = scroller == null ? void 0 : scroller.getCurrentScrollOffset) == null ? void 0 : _d.call(scroller);
+      if (nativeMax !== void 0 && observed !== void 0 && nativeMax < state.scroll - 1 && Math.abs(observed - nativeMax) <= 1) {
+        state.pendingMaintainScrollAtEnd = true;
+        state.scrollPending = observed;
+        updateScroll(ctx, observed, true, { markHasScrolled: false });
+      }
     }
-  }
-  if (shouldMaintainScrollAtEnd && !didContainersLayout) {
-    state.pendingMaintainScrollAtEnd = true;
-    return false;
-  }
-  if (pendingNativeMVCPAdjust) {
-    state.pendingMaintainScrollAtEnd = shouldMaintainScrollAtEnd;
-    return false;
-  }
-  if (shouldMaintainScrollAtEnd && (state.scrollingTo || state.pendingScrollResolve)) {
-    state.pendingMaintainScrollAtEnd = true;
-    (_e = state.maintainingScrollAtEnd) != null ? _e : state.maintainingScrollAtEnd = maintainScrollAtEnd.animated ? "pending-animated" : "pending-instant";
-    return false;
-  }
-  if (shouldMaintainScrollAtEnd && didContainersLayout) {
-    state.pendingMaintainScrollAtEnd = false;
-    const contentSize = getContentSize(ctx);
-    if (contentSize < state.scrollLength) {
-      state.scroll = 0;
-    }
-    if (!state.maintainingScrollAtEnd) {
-      const pendingState = maintainScrollAtEnd.animated ? "pending-animated" : "pending-instant";
-      const activeState = maintainScrollAtEnd.animated ? "animated" : "instant";
-      const scrollAtRequest = state.scroll;
-      state.maintainingScrollAtEnd = pendingState;
-      requestAnimationFrame(() => {
-        if (state.maintainingScrollAtEnd !== pendingState) {
-          return;
-        }
-        const isStillWithinThreshold = peek$(ctx, "isWithinMaintainScrollAtEndThreshold");
-        const didScrollSinceRequest = state.scroll !== scrollAtRequest;
-        if (isReplayingPendingMaintain || isStillWithinThreshold || !didScrollSinceRequest) {
-          if (state.scrollingTo || state.pendingScrollResolve) {
-            state.pendingMaintainScrollAtEnd = true;
-            return;
-          }
-          state.maintainingScrollAtEnd = activeState;
-          const scrollPromise = getScrollRequestTracker(ctx).runNowIfIdle(
-            () => ctx.scrollToEnd({ animated: maintainScrollAtEnd.animated })
-          );
-          void scrollPromise.then(() => {
-            if (state.maintainingScrollAtEnd !== activeState) {
-              return;
-            }
-            if (state.pendingMaintainScrollAtEnd) {
-              state.maintainingScrollAtEnd = void 0;
-              doMaintainScrollAtEnd(ctx);
-            } else {
+    if (shouldMaintainScrollAtEnd && !didContainersLayout) {
+      state.pendingMaintainScrollAtEnd = true;
+    } else if (pendingNativeMVCPAdjust) {
+      state.pendingMaintainScrollAtEnd = shouldMaintainScrollAtEnd;
+    } else if (shouldMaintainScrollAtEnd && (state.scrollingTo || state.pendingScrollResolve)) {
+      if (immediate && ((_e = state.scrollingTo) == null ? void 0 : _e.isScrollToEnd) && !state.scrollingTo.animated) {
+        state.pendingMaintainScrollAtEnd = false;
+        ctx.scrollToEnd({ animated: false });
+        didMaintain = true;
+      } else {
+        state.pendingMaintainScrollAtEnd = true;
+        (_f = state.maintainingScrollAtEnd) != null ? _f : state.maintainingScrollAtEnd = maintainScrollAtEnd.animated ? "pending-animated" : "pending-instant";
+      }
+    } else if (shouldMaintainScrollAtEnd && didContainersLayout) {
+      state.pendingMaintainScrollAtEnd = false;
+      const contentSize = getContentSize(ctx);
+      if (contentSize < state.scrollLength) {
+        state.scroll = 0;
+      }
+      if (!state.maintainingScrollAtEnd || immediate && state.maintainingScrollAtEnd === "pending-instant") {
+        const pendingState = maintainScrollAtEnd.animated ? "pending-animated" : "pending-instant";
+        const activeState = maintainScrollAtEnd.animated ? "animated" : "instant";
+        const scrollAtRequest = state.scroll;
+        state.maintainingScrollAtEnd = pendingState;
+        const run = () => {
+          if (state.maintainingScrollAtEnd === pendingState) {
+            if (state.isDragging) {
               finishMaintainScrollAtEnd(ctx);
+            } else {
+              const isStillWithinThreshold = peek$(ctx, "isWithinMaintainScrollAtEndThreshold");
+              const didScrollSinceRequest = Platform.OS === "web" && state.scroll !== scrollAtRequest;
+              if (isReplayingPendingMaintain || isStillWithinThreshold || !didScrollSinceRequest) {
+                if (state.scrollingTo || state.pendingScrollResolve) {
+                  state.pendingMaintainScrollAtEnd = true;
+                } else {
+                  state.maintainingScrollAtEnd = activeState;
+                  const scrollPromise = getScrollRequestTracker(ctx).runNowIfIdle(
+                    () => ctx.scrollToEnd({ animated: maintainScrollAtEnd.animated })
+                  );
+                  void scrollPromise.then(() => {
+                    if (state.maintainingScrollAtEnd === activeState) {
+                      if (state.pendingMaintainScrollAtEnd) {
+                        state.maintainingScrollAtEnd = void 0;
+                        doMaintainScrollAtEnd(ctx);
+                      } else {
+                        finishMaintainScrollAtEnd(ctx);
+                      }
+                    }
+                  });
+                }
+              } else if (state.maintainingScrollAtEnd === pendingState) {
+                finishMaintainScrollAtEnd(ctx);
+              }
             }
-          });
-        } else if (state.maintainingScrollAtEnd === pendingState) {
-          finishMaintainScrollAtEnd(ctx);
+          }
+        };
+        if (immediate) {
+          run();
+        } else {
+          requestAnimationFrame(run);
         }
-      });
+      } else {
+        state.pendingMaintainScrollAtEnd = true;
+      }
+      didMaintain = true;
     } else {
-      state.pendingMaintainScrollAtEnd = true;
+      finishMaintainScrollAtEnd(ctx);
     }
-    return true;
   }
-  finishMaintainScrollAtEnd(ctx);
-  return false;
+  return didMaintain;
 }
 
 // src/core/finishScrollTo.ts
@@ -2366,7 +2392,9 @@ function scrollTo(ctx, params) {
       pinScrollTargetRenderRange(ctx, targetOffset, scrollTarget.index);
     }
   }
-  state.scrollPending = targetOffset;
+  if (!animated || isInitialScroll) {
+    state.scrollPending = targetOffset;
+  }
   syncInitialScrollNativeWatchdog(state, { isInitialScroll, requestedOffset: offset, targetOffset });
   if (!isInitialScroll && !noScrollingTo && Math.abs(state.scroll - targetOffset) > 1) {
     if (animated) {
@@ -2743,13 +2771,13 @@ function rearmBootstrapInitialScroll(ctx, options) {
   queueBootstrapInitialScrollReevaluation(ctx.state);
 }
 function createInitialScrollAtEndTarget(options) {
-  const { dataLength, footerSize, preserveForFooterLayout, stylePaddingEnd } = options;
+  const { dataLength, footerSize, index, preserveForFooterLayout, stylePaddingEnd } = options;
   return {
     contentOffset: void 0,
-    index: Math.max(0, dataLength - 1),
+    index: index != null ? index : Math.max(0, dataLength - 1),
     preserveForBottomPadding: true,
     preserveForFooterLayout,
-    viewOffset: -stylePaddingEnd - footerSize,
+    viewOffset: getEndAlignedViewOffset(stylePaddingEnd, footerSize),
     viewPosition: 1
   };
 }
@@ -2765,13 +2793,14 @@ function isRetargetableBottomAlignedInitialScrollTarget(target) {
 function createRetargetedBottomAlignedInitialScroll(options) {
   const { dataLength, footerSize, initialScrollAtEnd, stylePaddingEnd, target } = options;
   const preserveForFooterLayout = shouldPreserveInitialScrollForFooterLayout(target);
+  const alignsToContentEnd = initialScrollAtEnd || isEndOfContentTarget(target, dataLength);
   return {
     ...target,
     contentOffset: void 0,
     index: initialScrollAtEnd ? Math.max(0, dataLength - 1) : target.index,
     preserveForBottomPadding: true,
     preserveForFooterLayout,
-    viewOffset: -stylePaddingEnd - (preserveForFooterLayout ? footerSize : 0),
+    viewOffset: getEndAlignedViewOffset(stylePaddingEnd, alignsToContentEnd ? footerSize : 0),
     viewPosition: 1
   };
 }
@@ -2785,7 +2814,7 @@ function clearPendingInitialScrollFooterLayout(ctx, options) {
   }
   const clearedFooterTarget = createInitialScrollAtEndTarget({
     dataLength,
-    footerSize: 0,
+    footerSize: peek$(ctx, "footerSize") || 0,
     preserveForFooterLayout: void 0,
     stylePaddingEnd
   });
@@ -2808,13 +2837,12 @@ function getObservedBootstrapInitialScrollOffset(state) {
   return typeof observedOffset === "number" && Number.isFinite(observedOffset) ? observedOffset : (_d = (_c = state.scrollPending) != null ? _c : state.scroll) != null ? _d : 0;
 }
 function getPreservedEndAnchorOffsetDiff(ctx) {
-  var _a3;
   const state = ctx.state;
   const initialScroll = state.initialScroll;
-  if (!state.didFinishInitialScroll || ((_a3 = state.scrollingTo) == null ? void 0 : _a3.isInitialScroll) || !initialScroll || initialScroll.viewPosition !== 1 || state.props.data.length === 0 || isOffsetInitialScrollSession(state)) {
+  if (!state.didFinishInitialScroll || state.scrollingTo || state.pendingScrollResolve || state.maintainingScrollAtEnd || state.isDragging || !initialScroll || initialScroll.viewPosition !== 1 || state.props.data.length === 0 || isOffsetInitialScrollSession(state)) {
     return;
   }
-  const currentOffset = typeof state.lastNativeScroll === "number" && Number.isFinite(state.lastNativeScroll) ? state.lastNativeScroll : getObservedBootstrapInitialScrollOffset(state);
+  const currentOffset = Platform.OS !== "web" && typeof state.lastNativeScroll === "number" && Number.isFinite(state.lastNativeScroll) ? state.lastNativeScroll : getObservedBootstrapInitialScrollOffset(state);
   return resolveInitialScrollOffset(ctx, initialScroll) - currentOffset;
 }
 function schedulePreservedEndAnchorCorrection(ctx) {
@@ -2842,6 +2870,9 @@ function schedulePreservedEndAnchorCorrectionFrame(ctx, correction) {
     const hasObservedNativeScrollAfterRequest = !activeCorrection.lastRequestTime || ((_a3 = state.lastNativeScrollTime) != null ? _a3 : 0) > activeCorrection.lastRequestTime;
     if (hasObservedNativeScrollAfterRequest) {
       activeCorrection.lastRequestTime = Date.now();
+      if (Platform.OS === "web") {
+        state.scroll = getObservedBootstrapInitialScrollOffset(state);
+      }
       requestAdjust(ctx, offsetDiff);
     }
     schedulePreservedEndAnchorCorrectionFrame(ctx, correction);
@@ -2964,10 +2995,10 @@ function handleBootstrapInitialScrollDataChange(ctx, options) {
 function handleBootstrapInitialScrollFooterLayout(ctx, options) {
   const { dataLength, footerSize, initialScrollAtEnd, stylePaddingEnd } = options;
   const state = ctx.state;
-  if (!initialScrollAtEnd) {
+  const initialScroll = state.initialScroll;
+  if (!initialScrollAtEnd && !isEndOfContentTarget(initialScroll, dataLength)) {
     return;
   }
-  const initialScroll = state.initialScroll;
   if (isOffsetInitialScrollSession(state) || dataLength === 0 || !initialScroll) {
     return;
   }
@@ -2985,6 +3016,7 @@ function handleBootstrapInitialScrollFooterLayout(ctx, options) {
     const updatedInitialScroll = createInitialScrollAtEndTarget({
       dataLength,
       footerSize,
+      index: initialScrollAtEnd ? void 0 : initialScroll.index,
       preserveForFooterLayout: shouldPreserveInitialScrollForFooterLayout(initialScroll),
       stylePaddingEnd
     });
@@ -3944,7 +3976,7 @@ function getExpandedContainerPoolSize(dataLength, numContainers) {
 }
 
 // src/utils/findAvailableContainers.ts
-function findAvailableContainers(ctx, needNewContainers, startBuffered, endBuffered, pendingRemoval, getRequiredItemType, protectedKeys) {
+function findAvailableContainers(ctx, needNewContainers, startBuffered, endBuffered, pendingRemoval, protectedKeys, reverseItemOrder = false) {
   var _a3;
   const numNeeded = needNewContainers.length;
   if (numNeeded === 0) {
@@ -3953,16 +3985,27 @@ function findAvailableContainers(ctx, needNewContainers, startBuffered, endBuffe
   const numContainers = peek$(ctx, "numContainers");
   const state = ctx.state;
   const { containerItemMetadata, stickyContainerPool } = state;
+  const { data, getItemType } = state.props;
+  const hasItemTypes = !!getItemType;
   const shouldAvoidAssignedContainerReuse = state.props.recycleItems && !!state.props.positionComponentInternal;
   const pendingRemovalSet = pendingRemoval.length > 0 ? new Set(pendingRemoval) : void 0;
-  const requests = needNewContainers.map((itemIndex, order) => ({
-    isSticky: state.props.stickyHeaderIndicesSet.has(itemIndex),
-    itemIndex,
-    itemType: getRequiredItemType == null ? void 0 : getRequiredItemType(itemIndex),
-    order
-  }));
-  const normalRequests = requests.filter((request) => !request.isSticky);
-  const stickyRequests = requests.filter((request) => request.isSticky);
+  const requests = new Array(numNeeded);
+  const normalRequests = [];
+  const stickyRequests = [];
+  for (let order = 0; order < numNeeded; order++) {
+    const itemIndex = needNewContainers[order];
+    const itemType = getItemType == null ? void 0 : getItemType(data[itemIndex], itemIndex);
+    const request = {
+      isBuffered: itemIndex >= startBuffered && itemIndex <= endBuffered,
+      isSticky: state.props.stickyHeaderIndicesSet.has(itemIndex),
+      itemIndex,
+      itemType: hasItemTypes ? itemType !== void 0 ? String(itemType) : "" : void 0,
+      order,
+      renderPriority: reverseItemOrder ? -itemIndex : itemIndex
+    };
+    requests[order] = request;
+    (request.isSticky ? stickyRequests : normalRequests).push(request);
+  }
   const normalCandidates = [];
   const stickyCandidates = [];
   for (let containerIndex = 0; containerIndex < numContainers; containerIndex++) {
@@ -4018,7 +4061,7 @@ function findAvailableContainers(ctx, needNewContainers, startBuffered, endBuffe
     }
   };
   const assignFromPool = (pendingRequests, candidates, allowCrossType) => {
-    if (getRequiredItemType) {
+    if (hasItemTypes) {
       assignMatching(
         pendingRequests,
         candidates,
@@ -4042,6 +4085,11 @@ function findAvailableContainers(ctx, needNewContainers, startBuffered, endBuffe
     }
     assign(request, containerIndex);
   }
+  if (normalRequests.length > 1 || stickyRequests.length > 1) {
+    const containerIndices = [];
+    reorderPoolAssignments(normalRequests, allocations, containerIndices, hasItemTypes);
+    reorderPoolAssignments(stickyRequests, allocations, containerIndices, hasItemTypes);
+  }
   if (pendingRemovalChanged) {
     pendingRemoval.length = 0;
     if (pendingRemovalSet) {
@@ -4071,12 +4119,53 @@ function findAvailableContainers(ctx, needNewContainers, startBuffered, endBuffe
 function comparatorByDistance(a, b) {
   return b.distance - a.distance;
 }
+function comparatorByRenderPriority(a, b) {
+  return Number(b.isBuffered) - Number(a.isBuffered) || a.renderPriority - b.renderPriority;
+}
+function comparatorByIndex(a, b) {
+  return a - b;
+}
+function reorderPoolAssignments(requests, allocations, containerIndices, groupByType) {
+  if (requests.length >= 2) {
+    if (groupByType) {
+      const groups = /* @__PURE__ */ new Map();
+      for (const request of requests) {
+        const group = groups.get(request.itemType);
+        if (group) {
+          group.push(request);
+        } else {
+          groups.set(request.itemType, [request]);
+        }
+      }
+      for (const group of groups.values()) {
+        reorderPoolAssignments(group, allocations, containerIndices, false);
+      }
+    } else {
+      containerIndices.length = 0;
+      let indicesSorted = true;
+      for (let i = 0; i < requests.length; i++) {
+        const containerIndex = allocations[requests[i].order].containerIndex;
+        if (i > 0 && containerIndex < containerIndices[i - 1]) {
+          indicesSorted = false;
+        }
+        containerIndices.push(containerIndex);
+      }
+      if (!indicesSorted) {
+        containerIndices.sort(comparatorByIndex);
+      }
+      requests.sort(comparatorByRenderPriority);
+      for (let i = 0; i < requests.length; i++) {
+        allocations[requests[i].order].containerIndex = containerIndices[i];
+      }
+    }
+  }
+}
 
 // src/utils/setDidLayout.ts
 function setDidLayout(ctx) {
   const state = ctx.state;
   state.queuedInitialLayout = true;
-  checkAtBottom(ctx);
+  checkThresholds(ctx);
   setInitialRenderState(ctx, { didLayout: true });
   if (state.pendingMaintainScrollAtEnd) {
     doMaintainScrollAtEnd(ctx);
@@ -4304,9 +4393,9 @@ function calculateItemsInView(ctx, params = {}) {
       enableScrollForNextCalculateItemsInView,
       idCache,
       indexByKey,
-      minIndexSizeChanged,
+      positionRecalculationStartIndex,
       positions,
-      props: { alwaysRenderIndicesArr, alwaysRenderIndicesSet, getItemType, keyExtractor, onStickyHeaderChange },
+      props: { alwaysRenderIndicesArr, alwaysRenderIndicesSet, keyExtractor, onStickyHeaderChange },
       scrollForNextCalculateItemsInView,
       scrollLength,
       sizes,
@@ -4422,21 +4511,21 @@ function calculateItemsInView(ctx, params = {}) {
     if (dataChanged) {
       resetLayoutCachesForDataChange(state);
     }
-    const startIndex = forceFullItemPositions || dataChanged ? 0 : (_e = minIndexSizeChanged != null ? minIndexSizeChanged : state.startBuffered) != null ? _e : 0;
-    const optimizeForVisibleWindow = !forceFullItemPositions && !dataChanged && numColumns > 1 && minIndexSizeChanged !== void 0;
+    const startIndex = forceFullItemPositions || dataChanged ? 0 : (_e = positionRecalculationStartIndex != null ? positionRecalculationStartIndex : state.startBuffered) != null ? _e : 0;
+    const optimizeForVisibleWindow = !forceFullItemPositions && !dataChanged && numColumns > 1 && positionRecalculationStartIndex !== void 0;
     updateItemPositions(ctx, dataChanged, {
       doMVCP,
       // A changed size shifts every following position. The scrolling early-exit
       // would leave the untouched suffix in the old coordinate space.
-      forceFullUpdate: !!forceFullItemPositions || minIndexSizeChanged !== void 0,
+      forceFullUpdate: !!forceFullItemPositions || positionRecalculationStartIndex !== void 0,
       optimizeForVisibleWindow,
       scrollBottomBuffered,
       scrollVelocity: speed,
       startIndex
     });
     totalSize = getContentSize(ctx);
-    if (minIndexSizeChanged !== void 0) {
-      state.minIndexSizeChanged = void 0;
+    if (positionRecalculationStartIndex !== void 0) {
+      state.positionRecalculationStartIndex = void 0;
     }
     let protectedContainerKeys;
     if (dataChanged && doMVCP && state.props.maintainVisibleContentPosition.data && state.didContainersLayout && state.idsInView.length > 0) {
@@ -4612,18 +4701,18 @@ function calculateItemsInView(ctx, params = {}) {
         set$(ctx, "activeStickyIndex", -1);
       }
       if (needNewContainers.length > 0) {
-        const getRequiredItemType = getItemType ? (i) => {
-          const itemType = getItemType(data[i], i);
-          return itemType !== void 0 ? String(itemType) : "";
-        } : void 0;
         const availableContainerAllocations = findAvailableContainers(
           ctx,
           needNewContainers,
           startBuffered,
           endBuffered,
           pendingRemoval,
-          getRequiredItemType,
-          protectedContainerKeys
+          protectedContainerKeys,
+          // Initial end alignment has no scroll velocity yet. Keep its
+          // target-side rows first until the initial scroll settles.
+          // After a pause velocity can be zero on the first movement;
+          // use its displacement without treating initial insets as motion.
+          hasActiveInitialScroll(state) ? (initialScroll == null ? void 0 : initialScroll.viewPosition) === 1 : (speed || (state.hasScrolled ? state.scroll - state.scrollPrev : 0)) < 0
         );
         for (const allocation of availableContainerAllocations) {
           const i = allocation.itemIndex;
@@ -4919,6 +5008,7 @@ function updateItemSizesBatch(ctx, measurements) {
   var _a3;
   const state = ctx.state;
   const result = {};
+  const previousTotalSize = state.totalSize;
   for (const measurement of measurements) {
     const ownsMeasuredItem = measurement.containerId === void 0 || peek$(ctx, `containerItemKey${measurement.containerId}`) === measurement.itemKey;
     if (ownsMeasuredItem) {
@@ -4929,6 +5019,9 @@ function updateItemSizesBatch(ctx, measurements) {
       mergeItemSizeUpdateResult(result, nextResult);
     }
   }
+  if (state.totalSize !== previousTotalSize) {
+    set$(ctx, "totalSize", state.totalSize);
+  }
   flushItemSizeUpdates(ctx, result);
 }
 function applyItemSize(ctx, itemKey, sizeObj, resolvedMeasurementItem) {
@@ -4967,12 +5060,12 @@ function applyItemSize(ctx, itemKey, sizeObj, resolvedMeasurementItem) {
   }
   let needsRecalculate = !didContainersLayout;
   let shouldMaintainScrollAtEnd = false;
-  let minIndexSizeChanged;
+  let positionRecalculationStartIndex;
   const prevSizeKnown = state.sizesKnown.get(itemKey);
-  const diff = updateOneItemSize(ctx, itemKey, sizeObj, resolvedMeasurementItem);
+  const diff = updateOneItemSize(ctx, itemKey, sizeObj, resolvedMeasurementItem, false);
   const size = roundSize(horizontal ? sizeObj.width : sizeObj.height);
   if (diff !== 0) {
-    minIndexSizeChanged = minIndexSizeChanged !== void 0 ? Math.min(minIndexSizeChanged, index) : index;
+    positionRecalculationStartIndex = positionRecalculationStartIndex !== void 0 ? Math.min(positionRecalculationStartIndex, index) : index;
     const { startBuffered, endBuffered } = state;
     needsRecalculate || (needsRecalculate = index >= startBuffered && index <= endBuffered);
     if (!needsRecalculate && state.containerItemKeys.has(itemKey)) {
@@ -4989,8 +5082,8 @@ function applyItemSize(ctx, itemKey, sizeObj, resolvedMeasurementItem) {
       size
     });
   }
-  if (minIndexSizeChanged !== void 0) {
-    state.minIndexSizeChanged = state.minIndexSizeChanged !== void 0 ? Math.min(state.minIndexSizeChanged, minIndexSizeChanged) : minIndexSizeChanged;
+  if (positionRecalculationStartIndex !== void 0) {
+    state.positionRecalculationStartIndex = state.positionRecalculationStartIndex !== void 0 ? Math.min(state.positionRecalculationStartIndex, positionRecalculationStartIndex) : positionRecalculationStartIndex;
   }
   updateOtherAxisSizeIfNeeded(ctx, sizeObj, horizontal);
   if (didContainersLayout || checkAllSizesKnown(state, state.startBuffered, state.endBuffered)) {
@@ -5007,7 +5100,7 @@ function applyItemSize(ctx, itemKey, sizeObj, resolvedMeasurementItem) {
     didMeasureUserScrollAnchorResetItem
   };
 }
-function updateOneItemSize(ctx, itemKey, sizeObj, resolvedMeasurementItem) {
+function updateOneItemSize(ctx, itemKey, sizeObj, resolvedMeasurementItem, notifyTotalSize = true) {
   var _a3, _b;
   const state = ctx.state;
   const {
@@ -5030,7 +5123,16 @@ function updateOneItemSize(ctx, itemKey, sizeObj, resolvedMeasurementItem) {
     fixedItemSize,
     itemType
   } : void 0;
-  const prevSize = getItemSize(ctx, itemKey, index, itemData, void 0, void 0, void 0, resolvedItemSize);
+  const prevSize = getItemSize(
+    ctx,
+    itemKey,
+    index,
+    itemData,
+    void 0,
+    void 0,
+    notifyTotalSize,
+    resolvedItemSize
+  );
   const rawSize = horizontal ? sizeObj.width : sizeObj.height;
   const prevSizeKnown = sizesKnown.get(itemKey);
   if (Platform.OS !== "web" && prevSizeKnown !== void 0 && isNativeLayoutNoise(rawSize - prevSizeKnown)) {
@@ -5055,7 +5157,7 @@ function updateOneItemSize(ctx, itemKey, sizeObj, resolvedMeasurementItem) {
     }
   }
   if (!prevSize || Math.abs(prevSize - size) > 0.1) {
-    setSize(ctx, itemKey, size);
+    setSize(ctx, itemKey, size, notifyTotalSize);
     return size - prevSize;
   }
   return 0;
@@ -5206,10 +5308,16 @@ function useValue$(key, params) {
     var _a3;
     return (_a3 = getValue ? getValue(peek$(ctx, key)) : peek$(ctx, key)) != null ? _a3 : 0;
   };
-  const animValue = useAnimatedValue(getNewValue());
+  const initialValue = getNewValue();
+  const animValue = useAnimatedValue(initialValue);
+  const lastValue = useRef(initialValue);
   useLayoutEffect(() => {
     const syncCurrentValue = () => {
-      animValue.setValue(getNewValue());
+      const nextValue = getNewValue();
+      if (lastValue.current !== nextValue) {
+        lastValue.current = nextValue;
+        animValue.setValue(nextValue);
+      }
     };
     const unsubscribe = listen$(ctx, key, syncCurrentValue);
     syncCurrentValue();
@@ -6124,6 +6232,7 @@ var ListComponent = typedMemo(function ListComponent2({
   renderScrollComponent,
   onLayoutFooter,
   onInternalScrollBeginDrag,
+  onInternalScrollEndDrag,
   onInternalScrollEnd,
   scrollAdjustHandler,
   snapToIndices,
@@ -6195,7 +6304,7 @@ var ListComponent = typedMemo(function ListComponent2({
     SnapOrScroll,
     {
       ...rest,
-      ...Platform.OS === "web" ? ScrollComponent === ListComponentScrollView ? { onInternalScrollEnd, useWindowScroll } : {} : { onScrollBeginDrag: onInternalScrollBeginDrag },
+      ...Platform.OS === "web" ? ScrollComponent === ListComponentScrollView ? { onInternalScrollEnd, useWindowScroll } : {} : { onScrollBeginDrag: onInternalScrollBeginDrag, onScrollEndDrag: onInternalScrollEndDrag },
       contentContainerStyle: [
         horizontal ? { height: "100%" } : {},
         contentContainerStyle,
@@ -6314,7 +6423,7 @@ function checkResetContainers(ctx, dataProp, { didColumnsChange = false } = {})
     for (const key in state.averageSizes) {
       delete state.averageSizes[key];
     }
-    state.minIndexSizeChanged = 0;
+    state.positionRecalculationStartIndex = 0;
     state.scrollForNextCalculateItemsInView = void 0;
   }
   calculateItemsInView(ctx, { dataChanged: true, doMVCP: true });
@@ -6478,7 +6587,7 @@ function handleLayout(ctx, layoutParam, setCanRender) {
       set$(ctx, "scrollSize", { height: layout.height, width: layout.width });
     }
     if (maintainScrollAtEnd == null ? void 0 : maintainScrollAtEnd.onLayout) {
-      doMaintainScrollAtEnd(ctx);
+      doMaintainScrollAtEnd(ctx, { immediate: true });
     }
     checkThresholds(ctx);
     if (state) {
@@ -6711,12 +6820,12 @@ function scrollToEnd(ctx, options) {
   if (index === -1) {
     return false;
   }
-  const paddingBottom = state.props.stylePaddingBottom || 0;
+  const paddingBottom = getStylePaddingEnd(state.props);
   const footerSize = peek$(ctx, "footerSize") || 0;
   scrollToIndex(ctx, {
     ...options,
     index,
-    viewOffset: -paddingBottom - footerSize + ((options == null ? void 0 : options.viewOffset) || 0),
+    viewOffset: getEndAlignedViewOffset(paddingBottom, footerSize) + ((options == null ? void 0 : options.viewOffset) || 0),
     viewPosition: 1
   });
   if (state.scrollingTo) {
@@ -6919,7 +7028,7 @@ function createImperativeHandle(ctx, scheduleImperativeScrollCommit) {
     for (const key in state.averageSizes) {
       delete state.averageSizes[key];
     }
-    state.minIndexSizeChanged = 0;
+    state.positionRecalculationStartIndex = 0;
     state.scrollForNextCalculateItemsInView = void 0;
     state.pendingTotalSize = void 0;
     state.totalSize = 0;
@@ -7313,10 +7422,12 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     onMetricsChange,
     onLayout: onLayoutProp,
     onLoad,
+    onReady,
     onMomentumScrollEnd,
     onRefresh,
     onScroll: onScrollProp,
     onScrollBeginDrag,
+    onScrollEndDrag,
     onStartReached,
     onStartReachedThreshold = 0.5,
     onStickyHeaderChange,
@@ -7385,17 +7496,17 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
   const initialScrollProp = initialScrollAtEnd ? {
     index: Math.max(0, dataProp.length - 1),
     preserveForBottomPadding: true,
-    viewOffset: -stylePaddingEndState,
+    viewOffset: getEndAlignedViewOffset(stylePaddingEndState),
     viewPosition: 1
   } : hasInitialScrollIndex ? typeof initialScrollIndexProp === "object" ? {
     index: (_b = initialScrollIndexProp.index) != null ? _b : 0,
     preserveForBottomPadding: initialScrollIndexProp.viewOffset === void 0 && initialScrollIndexProp.viewPosition === 1 ? true : void 0,
-    viewOffset: (_c = initialScrollIndexProp.viewOffset) != null ? _c : initialScrollIndexProp.viewPosition === 1 ? -stylePaddingEndState : 0,
+    viewOffset: (_c = initialScrollIndexProp.viewOffset) != null ? _c : initialScrollIndexProp.viewPosition === 1 ? getEndAlignedViewOffset(stylePaddingEndState) : 0,
     viewPosition: (_d = initialScrollIndexProp.viewPosition) != null ? _d : 0
   } : {
     index: initialScrollIndexProp != null ? initialScrollIndexProp : 0,
     preserveForBottomPadding: shouldBottomAlignNumericInitialScrollIndex ? true : void 0,
-    viewOffset: initialScrollOffsetProp != null ? initialScrollOffsetProp : shouldBottomAlignNumericInitialScrollIndex ? -stylePaddingEndState : 0,
+    viewOffset: initialScrollOffsetProp != null ? initialScrollOffsetProp : shouldBottomAlignNumericInitialScrollIndex ? getEndAlignedViewOffset(stylePaddingEndState) : 0,
     viewPosition: shouldBottomAlignNumericInitialScrollIndex ? 1 : void 0
   } : initialScrollUsesOffsetOnly ? {
     contentOffset: initialScrollOffsetProp != null ? initialScrollOffsetProp : 0,
@@ -7473,11 +7584,11 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
         lastLayout: void 0,
         lastScrollDelta: 0,
         loadStartTime: Date.now(),
-        minIndexSizeChanged: 0,
         nativeContentInset: void 0,
         nativeMarginTop: 0,
         pendingDataComparison: void 0,
         pendingNativeMVCPAdjust: void 0,
+        positionRecalculationStartIndex: 0,
         positions: [],
         props: {},
         queuedCalculateItemsInView: 0,
@@ -7580,8 +7691,10 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     onItemSizeChanged,
     onLoad,
     onMomentumScrollEnd,
+    onReady,
     onScroll: throttleScrollFn,
     onScrollBeginDrag,
+    onScrollEndDrag,
     onStartReached,
     onStartReachedThreshold,
     onStickyHeaderChange,
@@ -7877,11 +7990,17 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       onScroll: (event) => onScroll(ctx, event),
       onScrollBeginDrag: (event) => {
         var _a4, _b2;
+        state.isDragging = true;
         interruptMaintainScrollAtEnd(ctx);
         prepareReachedEdgeForNextUserScroll(ctx);
         (_b2 = (_a4 = state.props).onScrollBeginDrag) == null ? void 0 : _b2.call(_a4, event);
       },
-      onScrollEnd: () => prepareReachedEdgeForNextUserScroll(ctx)
+      onScrollEnd: () => prepareReachedEdgeForNextUserScroll(ctx),
+      onScrollEndDrag: (event) => {
+        var _a4, _b2;
+        state.isDragging = false;
+        (_b2 = (_a4 = state.props).onScrollEndDrag) == null ? void 0 : _b2.call(_a4, event);
+      }
     }),
     []
   );
@@ -7905,6 +8024,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       ListHeaderComponent,
       onInternalScrollBeginDrag: fns.onScrollBeginDrag,
       onInternalScrollEnd: fns.onScrollEnd,
+      onInternalScrollEndDrag: fns.onScrollEndDrag,
       onLayout,
       onLayoutFooter,
       onMomentumScrollEnd: fns.onMomentumScrollEnd,