@legendapp/list 3.3.4 → 3.3.6

package/react-native.js

@@ -68,10 +68,6 @@ function getStylePaddingEnd(props) {
   }
   return (isHorizontalRTLProps(props) ? props.stylePaddingLeft : props.stylePaddingRight) || 0;
 }
-function getLogicalHorizontalMaxOffset(state, contentWidth) {
-  var _a3;
-  return (_a3 = getHorizontalMaxOffset(state, contentWidth)) != null ? _a3 : 0;
-}
 function getHorizontalInsetEnd(state, inset) {
   if (!inset) {
     return 0;
@@ -457,6 +453,28 @@ var EDGE_POSITION_EPSILON = 1;
 var ENABLE_DEVMODE = IS_DEV && false;
 var ENABLE_DEBUG_VIEW = IS_DEV && false;
 
+// src/core/cancelImperativeScroll.ts
+function cancelScrollCompletionChecks({ scheduledWork }) {
+  scheduledWork.cancel("checkFinishedScrollFrame");
+  scheduledWork.cancel("checkFinishedScrollRetryFrame");
+  scheduledWork.cancel("checkFinishedScrollFallback");
+  scheduledWork.cancel("platformScrollCompletion");
+}
+function settlePendingImperativeScroll(state) {
+  var _a3, _b;
+  const resolvePendingScroll = (_b = state.pendingScrollResolve) != null ? _b : (_a3 = state.pendingScrollToEnd) == null ? void 0 : _a3.resolve;
+  state.pendingScrollResolve = void 0;
+  state.pendingScrollToEnd = void 0;
+  resolvePendingScroll == null ? void 0 : resolvePendingScroll();
+}
+function cancelImperativeScroll(state) {
+  cancelScrollCompletionChecks(state);
+  state.scheduledWork.cancel("imperativeScrollReady");
+  state.scrollingTo = void 0;
+  state.scrollTargetPinnedRange = void 0;
+  settlePendingImperativeScroll(state);
+}
+
 // src/core/deferredPublicOnScroll.ts
 function withResolvedContentOffset(state, event, resolvedOffset) {
   return {
@@ -711,6 +729,12 @@ function checkAtBottom(ctx, allowedEdge, allowGateCreatedInCurrentCheck) {
   } = state;
   const contentSize = getContentSize(ctx);
   resetSharedEdgeGateIfOutsideHysteresis(ctx);
+  if (state.props.data.length === 0 && scrollLength > 0 && contentSize <= scrollLength) {
+    set$(ctx, "isAtEnd", true);
+    set$(ctx, "isNearEnd", true);
+    set$(ctx, "isWithinMaintainScrollAtEndThreshold", true);
+    return;
+  }
   if (contentSize > 0 && queuedInitialLayout) {
     const insetEnd = getContentInsetEnd(ctx);
     const distanceFromEnd = contentSize - scroll - scrollLength - insetEnd;
@@ -720,7 +744,7 @@ function checkAtBottom(ctx, allowedEdge, allowGateCreatedInCurrentCheck) {
     set$(
       ctx,
       "isWithinMaintainScrollAtEndThreshold",
-      isContentLess || distanceFromEnd <= maintainScrollAtEndThreshold * scrollLength
+      isContentLess || distanceFromEnd <= maintainScrollAtEndThreshold * scrollLength || state.pendingMaintainScrollAtEnd || maintainingScrollAtEnd === "animated" || maintainingScrollAtEnd === "instant"
     );
     const shouldSkipThresholdChecks = hasActiveInitialScroll(state) || maintainingScrollAtEnd;
     if (!shouldSkipThresholdChecks) {
@@ -964,6 +988,24 @@ function clearPreservedInitialScrollTarget(state) {
   state.initialScroll = void 0;
   setInitialScrollSession(state);
 }
+function supersedeInitialScroll(ctx) {
+  var _a3, _b, _c;
+  const state = ctx.state;
+  const bootstrapInitialScroll = ((_a3 = state.initialScrollSession) == null ? void 0 : _a3.kind) === "bootstrap" ? state.initialScrollSession.bootstrap : void 0;
+  if (state.initialScroll || bootstrapInitialScroll || ((_b = state.scrollingTo) == null ? void 0 : _b.isInitialScroll)) {
+    if ((bootstrapInitialScroll == null ? void 0 : bootstrapInitialScroll.frameHandle) !== void 0 && typeof cancelAnimationFrame === "function") {
+      cancelAnimationFrame(bootstrapInitialScroll.frameHandle);
+    }
+    if ((_c = state.scrollingTo) == null ? void 0 : _c.isInitialScroll) {
+      cancelScrollCompletionChecks(state);
+      state.scrollingTo = void 0;
+      state.scrollTargetPinnedRange = void 0;
+    }
+    initialScrollCompletion.resetFlags(state);
+    setInitialScrollSession(state, { bootstrap: null });
+    finishInitialScroll(ctx);
+  }
+}
 function finishInitialScroll(ctx, options) {
   var _a3, _b, _c;
   const state = ctx.state;
@@ -1053,10 +1095,22 @@ function getAlignItemsAtEndPadding(ctx) {
   return shouldPad ? Math.max(0, state.scrollLength - getRawContentLength(ctx) - getContentInsetEnd(ctx)) : 0;
 }
 function updateContentMetricsState(ctx) {
+  var _a3;
+  const { state } = ctx;
   const previousPadding = peek$(ctx, "alignItemsAtEndPadding") || 0;
   const nextPadding = getAlignItemsAtEndPadding(ctx);
   if (previousPadding !== nextPadding) {
-    set$(ctx, "alignItemsAtEndPadding", nextPadding);
+    const isAnimatedMaintainActive = state.maintainingScrollAtEnd === "pending-animated" || state.maintainingScrollAtEnd === "animated";
+    const isMaintainExpected = state.didContainersLayout && ((_a3 = state.props.maintainScrollAtEnd) == null ? void 0 : _a3.animated) && (isAnimatedMaintainActive || previousPadding > nextPadding && peek$(ctx, "isWithinMaintainScrollAtEndThreshold"));
+    if (isMaintainExpected && !isAnimatedMaintainActive && !state.pendingMaintainScrollAtEnd) {
+      state.scheduledWork.microtask(() => {
+        if (!state.maintainingScrollAtEnd && !state.pendingMaintainScrollAtEnd) {
+          set$(ctx, "alignItemsAtEndPadding", getAlignItemsAtEndPadding(ctx));
+        }
+      }, "alignItemsAtEndPaddingFallback");
+    } else if (!isMaintainExpected) {
+      set$(ctx, "alignItemsAtEndPadding", nextPadding);
+    }
   }
 }
 
@@ -1279,29 +1333,6 @@ function clampScrollOffset(ctx, offset, scrollTarget) {
   return clampedOffset;
 }
 
-// src/core/cancelImperativeScroll.ts
-function cancelScrollCompletionChecks({ scheduledWork }) {
-  scheduledWork.cancel("checkFinishedScrollFrame");
-  scheduledWork.cancel("checkFinishedScrollRetryFrame");
-  scheduledWork.cancel("checkFinishedScrollFallback");
-  scheduledWork.cancel("platformScrollCompletion");
-}
-function settlePendingImperativeScroll(state) {
-  var _a3, _b;
-  const resolvePendingScroll = (_b = state.pendingScrollResolve) != null ? _b : (_a3 = state.pendingScrollToEnd) == null ? void 0 : _a3.resolve;
-  state.pendingScrollResolve = void 0;
-  state.pendingScrollToEnd = void 0;
-  resolvePendingScroll == null ? void 0 : resolvePendingScroll();
-}
-function cancelImperativeScroll(state) {
-  cancelScrollCompletionChecks(state);
-  state.scheduledWork.cancel("imperativeScrollReady");
-  state.runPendingScrollToEnd = void 0;
-  state.scrollingTo = void 0;
-  state.scrollTargetPinnedRange = void 0;
-  settlePendingImperativeScroll(state);
-}
-
 // src/core/finishScrollTo.ts
 function finishScrollTo(ctx) {
   var _a3, _b;
@@ -1532,81 +1563,55 @@ function doScrollTo(ctx, params) {
   }
 }
 
-// src/core/doMaintainScrollAtEnd.ts
-function doMaintainScrollAtEnd(ctx) {
-  const state = ctx.state;
-  const {
-    didContainersLayout,
-    pendingNativeMVCPAdjust,
-    refScroller,
-    props: { maintainScrollAtEnd }
-  } = state;
-  const isWithinMaintainScrollAtEndThreshold = peek$(ctx, "isWithinMaintainScrollAtEndThreshold");
-  const shouldMaintainScrollAtEnd = !!(isWithinMaintainScrollAtEndThreshold && maintainScrollAtEnd && didContainersLayout);
-  if (pendingNativeMVCPAdjust) {
-    state.pendingMaintainScrollAtEnd = shouldMaintainScrollAtEnd;
-    return false;
-  }
-  if (shouldMaintainScrollAtEnd) {
-    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(() => {
-        const isStillWithinThreshold = peek$(ctx, "isWithinMaintainScrollAtEndThreshold");
-        const didScrollSinceRequest = state.scroll !== scrollAtRequest;
-        if (isStillWithinThreshold || !didScrollSinceRequest) {
-          state.maintainingScrollAtEnd = activeState;
-          const scroller = refScroller.current;
-          if (state.props.horizontal && isHorizontalRTL(state)) {
-            const currentContentSize = getContentSize(ctx);
-            const logicalEndOffset = getLogicalHorizontalMaxOffset(state, currentContentSize);
-            const nativeOffset = toNativeHorizontalOffset(state, logicalEndOffset, currentContentSize);
-            scroller == null ? void 0 : scroller.scrollTo({
-              animated: maintainScrollAtEnd.animated,
-              x: nativeOffset,
-              y: 0
-            });
-          } else {
-            scroller == null ? void 0 : scroller.scrollToEnd({
-              animated: maintainScrollAtEnd.animated
-            });
-          }
-          setTimeout(
-            () => {
-              if (state.maintainingScrollAtEnd === activeState) {
-                state.maintainingScrollAtEnd = void 0;
-                if (state.pendingMaintainScrollAtEnd) {
-                  doMaintainScrollAtEnd(ctx);
-                }
-              }
-            },
-            maintainScrollAtEnd.animated ? 500 : 0
-          );
-        } else if (state.maintainingScrollAtEnd === pendingState) {
-          state.maintainingScrollAtEnd = void 0;
-          state.pendingMaintainScrollAtEnd = false;
+// src/core/scrollRequestTracker.ts
+function getScrollRequestTracker(ctx) {
+  if (!ctx.scrollRequestTracker) {
+    let currentToken = 0;
+    const start = (resolve) => {
+      const state = ctx.state;
+      state.scheduledWork.cancel("imperativeScrollReady");
+      const token = ++currentToken;
+      settlePendingImperativeScroll(state);
+      state.pendingScrollResolve = resolve;
+      return token;
+    };
+    const runNow = (token, resolve, run) => {
+      const state = ctx.state;
+      if (token !== currentToken) {
+        return;
+      }
+      const didStartScroll = run();
+      if (!didStartScroll || !state.scrollingTo) {
+        if (state.pendingScrollResolve === resolve) {
+          state.pendingScrollResolve = void 0;
         }
-      });
-    } else {
-      state.pendingMaintainScrollAtEnd = true;
-    }
-    return true;
+        resolve();
+      }
+    };
+    ctx.scrollRequestTracker = {
+      isCurrent: (token) => token === currentToken,
+      runNow,
+      runNowIfIdle: (run) => {
+        const state = ctx.state;
+        if (state.pendingScrollResolve || state.scrollingTo) {
+          return Promise.resolve();
+        }
+        return new Promise((resolve) => {
+          const token = start(resolve);
+          runNow(token, resolve, run);
+        });
+      },
+      start
+    };
   }
-  state.pendingMaintainScrollAtEnd = false;
-  return false;
+  return ctx.scrollRequestTracker;
 }
 
 // src/utils/requestAdjust.ts
-function requestAdjust(ctx, positionDiff, dataChanged) {
+function requestAdjust(ctx, positionDiff, source) {
   const state = ctx.state;
   if (Math.abs(positionDiff) > 0.1) {
+    const dataChanged = source === "data";
     const needsScrollWorkaround = Platform.OS === "android" && !IsNewArchitecture && dataChanged && state.scroll <= positionDiff;
     const doit = () => {
       if (needsScrollWorkaround) {
@@ -1623,7 +1628,7 @@ function requestAdjust(ctx, positionDiff, dataChanged) {
     const readyToRender = peek$(ctx, "readyToRender");
     if (readyToRender) {
       doit();
-      if (Platform.OS !== "web") {
+      if (Platform.OS !== "web" && source !== "item-size") {
         const threshold = state.scroll - positionDiff / 2;
         if (!state.ignoreScrollFromMVCP) {
           state.ignoreScrollFromMVCP = {};
@@ -1656,6 +1661,87 @@ function requestAdjust(ctx, positionDiff, dataChanged) {
   }
 }
 
+// src/core/doMaintainScrollAtEnd.ts
+function finishMaintainScrollAtEnd(ctx) {
+  var _a3;
+  const { state } = ctx;
+  const currentPadding = peek$(ctx, "alignItemsAtEndPadding") || 0;
+  const nextPadding = getAlignItemsAtEndPadding(ctx);
+  state.maintainingScrollAtEnd = void 0;
+  state.pendingMaintainScrollAtEnd = false;
+  if (currentPadding !== nextPadding) {
+    set$(ctx, "alignItemsAtEndPadding", nextPadding);
+    state.scrollForNextCalculateItemsInView = void 0;
+    (_a3 = state.triggerCalculateItemsInView) == null ? void 0 : _a3.call(state, { forceFullItemPositions: true });
+    const nextScroll = clampScrollOffset(ctx, state.scroll + nextPadding - currentPadding);
+    requestAdjust(ctx, nextScroll - state.scroll);
+  }
+}
+function doMaintainScrollAtEnd(ctx) {
+  const state = ctx.state;
+  const {
+    didContainersLayout,
+    didFinishInitialScroll,
+    pendingNativeMVCPAdjust,
+    props: { maintainScrollAtEnd }
+  } = state;
+  const isWithinMaintainScrollAtEndThreshold = peek$(ctx, "isWithinMaintainScrollAtEndThreshold");
+  const isReplayingPendingMaintain = !!state.pendingMaintainScrollAtEnd;
+  const shouldMaintainScrollAtEnd = !!((isWithinMaintainScrollAtEndThreshold || isReplayingPendingMaintain) && maintainScrollAtEnd && didFinishInitialScroll);
+  if (shouldMaintainScrollAtEnd && !didContainersLayout) {
+    state.pendingMaintainScrollAtEnd = true;
+    return false;
+  }
+  if (pendingNativeMVCPAdjust) {
+    state.pendingMaintainScrollAtEnd = shouldMaintainScrollAtEnd;
+    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) {
+          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 {
+              finishMaintainScrollAtEnd(ctx);
+            }
+          });
+        } else if (state.maintainingScrollAtEnd === pendingState) {
+          finishMaintainScrollAtEnd(ctx);
+        }
+      });
+    } else {
+      state.pendingMaintainScrollAtEnd = true;
+    }
+    return true;
+  }
+  finishMaintainScrollAtEnd(ctx);
+  return false;
+}
+
 // src/core/mvcp.ts
 var MVCP_POSITION_EPSILON = 0.1;
 var MVCP_ANCHOR_LOCK_TTL_MS = 300;
@@ -1729,7 +1815,7 @@ function settlePendingNativeMVCPAdjust(ctx, remainingAfterManual, nativeDelta) {
   state.pendingNativeMVCPAdjust = void 0;
   const remaining = remainingAfterManual - nativeDelta;
   if (Math.abs(remaining) > MVCP_POSITION_EPSILON) {
-    requestAdjust(ctx, remaining, true);
+    requestAdjust(ctx, remaining, "data");
   }
 }
 function maybeApplyPredictedNativeMVCPAdjust(ctx) {
@@ -1748,7 +1834,7 @@ function maybeApplyPredictedNativeMVCPAdjust(ctx) {
     return;
   }
   pending.manualApplied = manualDesired;
-  requestAdjust(ctx, manualDesired, true);
+  requestAdjust(ctx, manualDesired, "data");
   pending.furthestProgressTowardAmount = 0;
 }
 function resolvePendingNativeMVCPAdjust(ctx, newScroll) {
@@ -1794,7 +1880,7 @@ function resolvePendingNativeMVCPAdjust(ctx, newScroll) {
   }
   return false;
 }
-function prepareMVCP(ctx, dataChanged) {
+function prepareMVCP(ctx, dataChanged, adjustmentSource) {
   const state = ctx.state;
   const { idsInView, positions, props } = state;
   const {
@@ -1948,7 +2034,7 @@ function prepareMVCP(ctx, dataChanged) {
       if (Math.abs(positionDiff) > MVCP_POSITION_EPSILON) {
         const shouldSkipAdjustForMaintainedEnd = (state.maintainingScrollAtEnd === "pending-animated" || state.maintainingScrollAtEnd === "animated") && peek$(ctx, "isWithinMaintainScrollAtEndThreshold");
         if (!shouldSkipAdjustForMaintainedEnd) {
-          requestAdjust(ctx, positionDiff, dataChanged && mvcpData);
+          requestAdjust(ctx, positionDiff, dataChanged && mvcpData ? "data" : adjustmentSource);
         }
       }
     };
@@ -2046,6 +2132,10 @@ 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);
+  if (didCancelMaintainScrollAtEnd) {
+    finishMaintainScrollAtEnd(ctx);
+  }
   const allowedEdge = isUserScrollEvent ? beginReachedEdgeUserScroll(ctx, newScroll - prevScroll) : void 0;
   const didResolvePendingNativeMVCPAdjust = resolvePendingNativeMVCPAdjust(ctx, newScroll);
   const scrollLength = state.scrollLength;
@@ -2054,7 +2144,7 @@ function updateScroll(ctx, newScroll, forceUpdate, options) {
   updateAdaptiveRender(ctx, scrollVelocity, { forceLight: isLargeUserScrollJump });
   const lastCalculated = state.scrollLastCalculate;
   const useAggressiveItemRecalculation = isInMVCPActiveMode(state);
-  const shouldUpdate = useAggressiveItemRecalculation || didResolvePendingNativeMVCPAdjust || allowedEdge !== void 0 || forceUpdate || lastCalculated === void 0 || Math.abs(state.scroll - lastCalculated) > 2;
+  const shouldUpdate = useAggressiveItemRecalculation || didResolvePendingNativeMVCPAdjust || didCancelMaintainScrollAtEnd || allowedEdge !== void 0 || forceUpdate || lastCalculated === void 0 || Math.abs(state.scroll - lastCalculated) > 2;
   if (shouldUpdate) {
     state.scrollLastCalculate = state.scroll;
     state.ignoreScrollFromMVCPIgnored = false;
@@ -2883,7 +2973,7 @@ function handleBootstrapInitialScrollFooterLayout(ctx, options) {
   }
 }
 function handleBootstrapInitialScrollLayoutChange(ctx) {
-  var _a3, _b, _c;
+  var _a3, _b;
   const state = ctx.state;
   const initialScroll = state.initialScroll;
   const bootstrapInitialScroll = getBootstrapInitialScrollSession(state);
@@ -2897,19 +2987,15 @@ function handleBootstrapInitialScrollLayoutChange(ctx) {
         if (state.didFinishInitialScroll) {
           schedulePreservedEndAnchorCorrection(ctx);
         } else if (scrollingTo) {
-          const existingWatchdog = initialScrollWatchdog.get(state);
-          scrollingTo.offset = resolvedOffset;
-          scrollingTo.targetOffset = resolvedOffset;
           state.initialScroll = {
             ...initialScroll,
             contentOffset: resolvedOffset
           };
-          state.hasScrolled = false;
-          initialScrollWatchdog.set(state, {
-            startScroll: (_c = existingWatchdog == null ? void 0 : existingWatchdog.startScroll) != null ? _c : state.scroll,
-            targetOffset: resolvedOffset
+          dispatchInitialScroll(ctx, {
+            forceScroll: true,
+            resolvedOffset,
+            target: state.initialScroll
           });
-          requestAdjust(ctx, offsetDiff);
         }
       }
     } else {
@@ -3951,6 +4037,9 @@ function setDidLayout(ctx) {
   state.queuedInitialLayout = true;
   checkAtBottom(ctx);
   setInitialRenderState(ctx, { didLayout: true });
+  if (state.pendingMaintainScrollAtEnd) {
+    doMaintainScrollAtEnd(ctx);
+  }
 }
 
 // src/core/calculateItemsInView.ts
@@ -4187,7 +4276,7 @@ function calculateItemsInView(ctx, params = {}) {
     const stickyHeaderIndicesArr = state.props.stickyHeaderIndicesArr || [];
     const stickyHeaderIndicesSet = state.props.stickyHeaderIndicesSet || /* @__PURE__ */ new Set();
     const drawDistance = getEffectiveDrawDistance(ctx, params.drawDistanceMode);
-    const { dataChanged, doMVCP, forceFullItemPositions } = params;
+    const { dataChanged, doMVCP, forceFullItemPositions, mvcpAdjustmentSource } = params;
     const bootstrapInitialScrollState = ((_a3 = state.initialScrollSession) == null ? void 0 : _a3.kind) === "bootstrap" ? state.initialScrollSession.bootstrap : void 0;
     const suppressInitialScrollSideEffects = !!bootstrapInitialScrollState;
     const prevNumContainers = peek$(ctx, "numContainers");
@@ -4288,7 +4377,7 @@ function calculateItemsInView(ctx, params = {}) {
         }
       }
     }
-    const checkMVCP = doMVCP && !suppressInitialScrollSideEffects ? prepareMVCP(ctx, dataChanged) : void 0;
+    const checkMVCP = doMVCP && !suppressInitialScrollSideEffects ? prepareMVCP(ctx, dataChanged, mvcpAdjustmentSource) : void 0;
     if (dataChanged) {
       resetLayoutCachesForDataChange(state);
     }
@@ -4702,12 +4791,15 @@ function runOrScheduleMVCPRecalculate(ctx) {
   } else if (Platform.OS === "web") {
     if (!state.mvcpAnchorLock) {
       state.scheduledWork.cancel("mvcpRecalculate");
-      calculateItemsInView(ctx, { doMVCP: true });
+      calculateItemsInView(ctx, { doMVCP: true, mvcpAdjustmentSource: "item-size" });
     } else if (!state.scheduledWork.has("mvcpRecalculate")) {
-      state.scheduledWork.frame(() => calculateItemsInView(ctx, { doMVCP: true }), "mvcpRecalculate");
+      state.scheduledWork.frame(
+        () => calculateItemsInView(ctx, { doMVCP: true, mvcpAdjustmentSource: "item-size" }),
+        "mvcpRecalculate"
+      );
     }
   } else {
-    calculateItemsInView(ctx, { doMVCP: true });
+    calculateItemsInView(ctx, { doMVCP: true, mvcpAdjustmentSource: "item-size" });
   }
 }
 function updateOtherAxisSizeIfNeeded(ctx, sizeObj, horizontal) {
@@ -4833,7 +4925,7 @@ function applyItemSize(ctx, itemKey, sizeObj, resolvedMeasurementItem) {
     if (!needsRecalculate && state.containerItemKeys.has(itemKey)) {
       needsRecalculate = true;
     }
-    if (prevSizeKnown !== void 0 && Math.abs(prevSizeKnown - size) > 5) {
+    if (prevSizeKnown === void 0 || Math.abs(prevSizeKnown - size) > 5) {
       shouldMaintainScrollAtEnd = true;
     }
     onItemSizeChanged == null ? void 0 : onItemSizeChanged({
@@ -5196,6 +5288,30 @@ function useContainerItemSignals(containerContext) {
     itemKey
   };
 }
+function scheduleViewabilityConfigWarning(ctx, hookName, configId) {
+  let cancelled = false;
+  Promise.resolve().then(() => {
+    var _a3;
+    const viewabilityConfigCallbackPairs = (_a3 = ctx.state) == null ? void 0 : _a3.viewabilityConfigCallbackPairs;
+    if (!cancelled && ctx.state) {
+      if (!(viewabilityConfigCallbackPairs == null ? void 0 : viewabilityConfigCallbackPairs.length)) {
+        warnDevOnce(
+          `${hookName}-missing-viewability-config`,
+          `${hookName} requires viewability to be configured on the owning LegendList. Add viewabilityConfig with a visibility threshold.`
+        );
+      } else if (hookName === "useViewability" && !viewabilityConfigCallbackPairs.some((pair) => pair.viewabilityConfig.id === (configId != null ? configId : ""))) {
+        const configDescription = configId ? ` for configId "${configId}"` : "";
+        warnDevOnce(
+          `${hookName}-missing-viewability-config-${configId != null ? configId : "default"}`,
+          `${hookName}${configDescription} requires a matching viewabilityConfig.id on the owning LegendList. Add an id to viewabilityConfig and pass the same id to useViewability.`
+        );
+      }
+    }
+  });
+  return () => {
+    cancelled = true;
+  };
+}
 function useAdaptiveRender() {
   const [mode] = useArr$(["adaptiveRender"]);
   return mode;
@@ -5235,7 +5351,9 @@ function useViewability(callback, configId) {
     const { containerId } = containerContext;
     const key = containerId + (configId != null ? configId : "");
     ctx.mapViewabilityCallbacks.set(key, callback);
+    const cancelConfigWarning = IS_DEV ? scheduleViewabilityConfigWarning(ctx, "useViewability", configId) : void 0;
     return () => {
+      cancelConfigWarning == null ? void 0 : cancelConfigWarning();
       ctx.mapViewabilityCallbacks.delete(key);
     };
   }, [ctx, callback, configId, containerContext]);
@@ -5259,7 +5377,9 @@ function useViewabilityAmount(callback) {
     }
     const { containerId } = containerContext;
     ctx.mapViewabilityAmountCallbacks.set(containerId, callback);
+    const cancelConfigWarning = IS_DEV ? scheduleViewabilityConfigWarning(ctx, "useViewabilityAmount") : void 0;
     return () => {
+      cancelConfigWarning == null ? void 0 : cancelConfigWarning();
       ctx.mapViewabilityAmountCallbacks.delete(containerId);
     };
   }, [ctx, callback, containerContext]);
@@ -5683,13 +5803,11 @@ var ContainerSlot = typedMemo(function ContainerSlot2(props) {
   return /* @__PURE__ */ React2__namespace.createElement(ContainerSlotBase, { ...props });
 });
 function useFreshDataTransitionVisibility(readyToRender, transitionEpoch) {
-  const completedTransitionEpoch = React2.useRef(transitionEpoch);
-  const isTransitionPending = completedTransitionEpoch.current !== transitionEpoch;
+  const [completedTransitionEpoch, setCompletedTransitionEpoch] = React2.useState(transitionEpoch);
+  const isTransitionPending = completedTransitionEpoch !== transitionEpoch;
   React2.useLayoutEffect(() => {
-    if (!readyToRender) {
-      completedTransitionEpoch.current = transitionEpoch;
-    }
-  }, [readyToRender, transitionEpoch]);
+    setCompletedTransitionEpoch(transitionEpoch);
+  }, [transitionEpoch]);
   return readyToRender && !isTransitionPending;
 }
 
@@ -6368,11 +6486,29 @@ var ScheduledWork = class {
   constructor() {
     this.work = /* @__PURE__ */ new Map();
   }
+  microtask(callback, key) {
+    const pendingWork = this.work.get(key);
+    if (pendingWork == null ? void 0 : pendingWork.callback) {
+      pendingWork.callback = callback;
+    } else {
+      this.cancel(key);
+      const work = { callback, cancel: () => {
+      } };
+      this.work.set(key, work);
+      queueMicrotask(() => {
+        var _a3;
+        if (this.work.get(key) === work) {
+          this.work.delete(key);
+          (_a3 = work.callback) == null ? void 0 : _a3.call(work);
+        }
+      });
+    }
+  }
   timeout(callback, delay, key) {
     if (key) {
       this.cancel(key);
     }
-    const work = [void 0, clearTimeout];
+    const work = { cancel: () => clearTimeout(handle) };
     const handle = setTimeout(() => {
       const workKey = key != null ? key : handle;
       if (this.work.get(workKey) === work) {
@@ -6380,14 +6516,13 @@ var ScheduledWork = class {
         callback();
       }
     }, delay);
-    work[0] = handle;
     this.work.set(key != null ? key : handle, work);
   }
   frame(callback, key) {
     this.cancel(key);
-    const work = [void 0, cancelAnimationFrame];
+    const work = { cancel: () => cancelAnimationFrame(handle) };
     this.work.set(key, work);
-    work[0] = requestAnimationFrame(() => {
+    const handle = requestAnimationFrame(() => {
       if (this.work.get(key) === work) {
         this.work.delete(key);
         callback();
@@ -6396,21 +6531,21 @@ var ScheduledWork = class {
   }
   register(key, cancel) {
     this.cancel(key);
-    this.work.set(key, [void 0, cancel]);
+    this.work.set(key, { cancel });
   }
   cancel(key) {
     const work = this.work.get(key);
     if (work) {
       this.work.delete(key);
-      work[1](work[0]);
+      work.cancel();
     }
   }
   has(key) {
     return this.work.has(key);
   }
   dispose() {
-    for (const [handle, cancel] of this.work.values()) {
-      cancel(handle);
+    for (const work of this.work.values()) {
+      work.cancel();
     }
     this.work.clear();
   }
@@ -6467,6 +6602,25 @@ var ScrollAdjustHandler = class {
   }
 };
 
+// src/core/scrollToEnd.ts
+function scrollToEnd(ctx, options) {
+  const state = ctx.state;
+  const data = state.props.data;
+  const index = data.length - 1;
+  if (index === -1) {
+    return false;
+  }
+  const paddingBottom = state.props.stylePaddingBottom || 0;
+  const footerSize = peek$(ctx, "footerSize") || 0;
+  scrollToIndex(ctx, {
+    ...options,
+    index,
+    viewOffset: -paddingBottom - footerSize + ((options == null ? void 0 : options.viewOffset) || 0),
+    viewPosition: 1
+  });
+  return true;
+}
+
 // src/core/updateContentInsetEndAdjustment.ts
 function updateContentInsetEndAdjustment(ctx, previousContentInsetEndAdjustment) {
   const state = ctx.state;
@@ -6541,25 +6695,6 @@ function createColumnWrapperStyle(contentContainerStyle) {
   }
 }
 
-// src/core/scrollToEnd.ts
-function scrollToEnd(ctx, options) {
-  const state = ctx.state;
-  const data = state.props.data;
-  const index = data.length - 1;
-  if (index === -1) {
-    return false;
-  }
-  const paddingBottom = state.props.stylePaddingBottom || 0;
-  const footerSize = peek$(ctx, "footerSize") || 0;
-  scrollToIndex(ctx, {
-    ...options,
-    index,
-    viewOffset: -paddingBottom - footerSize + ((options == null ? void 0 : options.viewOffset) || 0),
-    viewPosition: 1
-  });
-  return true;
-}
-
 // src/utils/createImperativeHandle.ts
 var DEFAULT_AVERAGE_ITEM_SIZE_TYPE = "default";
 function getAverageItemSizes(state) {
@@ -6586,9 +6721,9 @@ function triggerMountedContainerLayouts(ctx) {
 }
 function createImperativeHandle(ctx, scheduleImperativeScrollCommit) {
   const state = ctx.state;
+  const scrollRequestTracker = getScrollRequestTracker(ctx);
   const IMPERATIVE_SCROLL_SETTLE_MAX_WAIT_MS = 800;
   const IMPERATIVE_SCROLL_SETTLE_STABLE_FRAMES = 2;
-  let imperativeScrollToken = 0;
   const isSettlingAfterDataChange = () => !!state.didDataChange || !!state.didColumnsChange || state.scheduledWork.has("mvcpRecalculate") || state.ignoreScrollFromMVCP !== void 0;
   const isScrollToIndexReady = (targetIndex, allowEmpty = false) => {
     var _a3;
@@ -6610,7 +6745,7 @@ function createImperativeHandle(ctx, scheduleImperativeScrollCommit) {
     const startedAt = Date.now();
     let stableFrames = 0;
     const check = () => {
-      if (token !== imperativeScrollToken) {
+      if (!scrollRequestTracker.isCurrent(token)) {
         return;
       }
       if (isSettlingAfterDataChange() || !isReady()) {
@@ -6628,40 +6763,23 @@ function createImperativeHandle(ctx, scheduleImperativeScrollCommit) {
     state.scheduledWork.frame(check, "imperativeScrollReady");
   };
   const runScrollRequest = (token, resolve, run, isReady = () => true) => {
-    const runNow = () => {
-      if (token !== imperativeScrollToken) {
-        return;
-      }
-      const didStartScroll = run();
-      if (!didStartScroll || !state.scrollingTo) {
-        if (state.pendingScrollResolve === resolve) {
-          state.pendingScrollResolve = void 0;
-        }
-        resolve();
-      }
-    };
+    const runNow = () => scrollRequestTracker.runNow(token, resolve, run);
     if (isSettlingAfterDataChange() || !isReady()) {
       runWhenReady(token, runNow, isReady);
     } else {
       runNow();
     }
   };
-  const startImperativeScroll = (resolve) => {
-    state.scheduledWork.cancel("imperativeScrollReady");
-    const token = ++imperativeScrollToken;
-    settlePendingImperativeScroll(state);
-    state.pendingScrollResolve = resolve;
-    return token;
-  };
   const runScrollWithPromise = (run, isReady = () => true) => new Promise((resolve) => {
-    const token = startImperativeScroll(resolve);
+    const token = scrollRequestTracker.start(resolve);
+    supersedeInitialScroll(ctx);
     runScrollRequest(token, resolve, run, isReady);
   });
   state.runPendingScrollToEnd = () => {
     const pendingScroll = state.pendingScrollToEnd;
     if (pendingScroll) {
       state.pendingScrollToEnd = void 0;
-      if (pendingScroll.token === imperativeScrollToken) {
+      if (scrollRequestTracker.isCurrent(pendingScroll.token)) {
         runScrollRequest(
           pendingScroll.token,
           pendingScroll.resolve,
@@ -6775,15 +6893,15 @@ function createImperativeHandle(ctx, scheduleImperativeScrollCommit) {
     }),
     scrollToEnd: (options) => new Promise((resolve) => {
       var _a3;
-      const token = startImperativeScroll(resolve);
+      const token = scrollRequestTracker.start(resolve);
       state.pendingScrollToEnd = {
         options,
         resolve,
         token
       };
-      if (scheduleImperativeScrollCommit) {
-        scheduleImperativeScrollCommit();
-      } else {
+      scheduleImperativeScrollCommit == null ? void 0 : scheduleImperativeScrollCommit();
+      supersedeInitialScroll(ctx);
+      if (!scheduleImperativeScrollCommit) {
         (_a3 = state.runPendingScrollToEnd) == null ? void 0 : _a3.call(state);
       }
     }),
@@ -7155,6 +7273,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
   const shouldInitializeHorizontalRTL = !initialScrollAtEnd && !hasInitialScrollIndex && !hasInitialScrollOffset && isHorizontalRTLProps({ horizontal, rtl });
   const initialScrollUsesOffsetOnly = !initialScrollAtEnd && !hasInitialScrollIndex && (hasInitialScrollOffset || shouldInitializeHorizontalRTL);
   const usesBootstrapInitialScroll = initialScrollAtEnd || hasInitialScrollIndex;
+  const shouldBottomAlignNumericInitialScrollIndex = typeof initialScrollIndexProp === "number" && !hasInitialScrollOffset && dataProp.length > 1 && initialScrollIndexProp >= dataProp.length - 1;
   const initialScrollProp = initialScrollAtEnd ? {
     index: Math.max(0, dataProp.length - 1),
     preserveForBottomPadding: true,
@@ -7167,7 +7286,9 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     viewPosition: (_d = initialScrollIndexProp.viewPosition) != null ? _d : 0
   } : {
     index: initialScrollIndexProp != null ? initialScrollIndexProp : 0,
-    viewOffset: initialScrollOffsetProp != null ? initialScrollOffsetProp : 0
+    preserveForBottomPadding: shouldBottomAlignNumericInitialScrollIndex ? true : void 0,
+    viewOffset: initialScrollOffsetProp != null ? initialScrollOffsetProp : shouldBottomAlignNumericInitialScrollIndex ? -stylePaddingEndState : 0,
+    viewPosition: shouldBottomAlignNumericInitialScrollIndex ? 1 : void 0
   } : initialScrollUsesOffsetOnly ? {
     contentOffset: initialScrollOffsetProp != null ? initialScrollOffsetProp : 0,
     index: 0,
@@ -7273,6 +7394,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
         viewabilityConfigCallbackPairs: void 0
       };
       const internalState = ctx.state;
+      ctx.scrollToEnd = (options) => scrollToEnd(ctx, options);
       internalState.triggerCalculateItemsInView = (params) => calculateItemsInView(ctx, params);
       internalState.reprocessCurrentScroll = () => updateScroll(ctx, internalState.scroll, true);
       set$(ctx, "maintainVisibleContentPosition", maintainVisibleContentPositionConfig);
@@ -7634,6 +7756,13 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       onScroll: (event) => onScroll(ctx, event),
       onScrollBeginDrag: (event) => {
         var _a4, _b2;
+        const maintainingScrollAtEnd = state.maintainingScrollAtEnd;
+        if (maintainingScrollAtEnd === "animated" || maintainingScrollAtEnd === "instant") {
+          cancelImperativeScroll(state);
+        }
+        if (maintainingScrollAtEnd) {
+          finishMaintainScrollAtEnd(ctx);
+        }
         prepareReachedEdgeForNextUserScroll(ctx);
         (_b2 = (_a4 = state.props).onScrollBeginDrag) == null ? void 0 : _b2.call(_a4, event);
       },