@legendapp/list 3.0.0-beta.53 → 3.0.0-beta.54

package/index.native.js

@@ -722,6 +722,7 @@ function getContainerPositionStyle({
 }
 var Container = typedMemo(function Container2({
   id,
+  itemKey,
   recycleItems,
   horizontal,
   getRenderedItem: getRenderedItem2,
@@ -733,11 +734,10 @@ var Container = typedMemo(function Container2({
   const { columnWrapperStyle, animatedScrollY } = ctx;
   const positionComponentInternal = ctx.state.props.positionComponentInternal;
   const stickyPositionComponentInternal = ctx.state.props.stickyPositionComponentInternal;
-  const [column = 0, span = 1, data, itemKey, numColumns = 1, extraData, isSticky] = useArr$([
+  const [column = 0, span = 1, data, numColumns = 1, extraData, isSticky] = useArr$([
     `containerColumn${id}`,
     `containerSpan${id}`,
     `containerItemData${id}`,
-    `containerItemKey${id}`,
     "numColumns",
     "extraData",
     `containerSticky${id}`
@@ -882,6 +882,39 @@ var Container = typedMemo(function Container2({
   );
 });
 
+// src/components/ContainerSlot.tsx
+function ContainerSlotBase({
+  id,
+  horizontal,
+  recycleItems,
+  ItemSeparatorComponent,
+  updateItemSize: updateItemSize2,
+  getRenderedItem: getRenderedItem2,
+  stickyHeaderConfig,
+  ContainerComponent = Container
+}) {
+  const [itemKey] = useArr$([`containerItemKey${id}`]);
+  if (itemKey === void 0) {
+    return null;
+  }
+  return /* @__PURE__ */ React2__namespace.createElement(
+    ContainerComponent,
+    {
+      getRenderedItem: getRenderedItem2,
+      horizontal,
+      ItemSeparatorComponent,
+      id,
+      itemKey,
+      recycleItems,
+      stickyHeaderConfig,
+      updateItemSize: updateItemSize2
+    }
+  );
+}
+var ContainerSlot = typedMemo(function ContainerSlot2(props) {
+  return /* @__PURE__ */ React2__namespace.createElement(ContainerSlotBase, { ...props });
+});
+
 // src/components/Containers.native.tsx
 var ContainersLayer = typedMemo(function ContainersLayer2({ children, horizontal }) {
   const ctx = useStateContext();
@@ -920,12 +953,12 @@ var Containers = typedMemo(function Containers2({
   updateItemSize: updateItemSize2,
   getRenderedItem: getRenderedItem2
 }) {
-  const [numContainers] = useArr$(["numContainersPooled"]);
+  const [numContainersPooled] = useArr$(["numContainersPooled"]);
   const containers = [];
-  for (let i = 0; i < numContainers; i++) {
+  for (let i = 0; i < numContainersPooled; i++) {
     containers.push(
       /* @__PURE__ */ React2__namespace.createElement(
-        Container,
+        ContainerSlot,
         {
           getRenderedItem: getRenderedItem2,
           horizontal,
@@ -1252,10 +1285,9 @@ var initialScrollWatchdog = {
   clear(state) {
     initialScrollWatchdog.set(state, void 0);
   },
-  didObserveProgress(newScroll, watchdog) {
-    const previousDistance = Math.abs(watchdog.startScroll - watchdog.targetOffset);
+  didReachTarget(newScroll, watchdog) {
     const nextDistance = Math.abs(newScroll - watchdog.targetOffset);
-    return nextDistance <= INITIAL_SCROLL_MIN_TARGET_OFFSET || nextDistance + INITIAL_SCROLL_MIN_TARGET_OFFSET < previousDistance;
+    return nextDistance <= INITIAL_SCROLL_MIN_TARGET_OFFSET;
   },
   get(state) {
     var _a3, _b;
@@ -1280,19 +1312,19 @@ var initialScrollWatchdog = {
   }
 };
 function setInitialScrollSession(state, options = {}) {
-  var _a3, _b, _c;
+  var _a3, _b, _c, _d;
   const existingSession = state.initialScrollSession;
   const kind = (_a3 = options.kind) != null ? _a3 : existingSession == null ? void 0 : existingSession.kind;
   const completion = existingSession == null ? void 0 : existingSession.completion;
-  const hasBootstrapOverride = Object.hasOwn(options, "bootstrap");
-  const bootstrap = kind === "bootstrap" ? hasBootstrapOverride ? options.bootstrap : (existingSession == null ? void 0 : existingSession.kind) === "bootstrap" ? existingSession.bootstrap : void 0 : void 0;
+  const existingBootstrap = (existingSession == null ? void 0 : existingSession.kind) === "bootstrap" ? existingSession.bootstrap : void 0;
+  const bootstrap = kind === "bootstrap" ? options.bootstrap === null ? void 0 : (_b = options.bootstrap) != null ? _b : existingBootstrap : void 0;
   if (!kind) {
     return clearInitialScrollSession(state);
   }
   if (!state.initialScroll && !bootstrap && !hasInitialScrollSessionCompletion(completion)) {
     return clearInitialScrollSession(state);
   }
-  const previousDataLength = (_c = (_b = options.previousDataLength) != null ? _b : existingSession == null ? void 0 : existingSession.previousDataLength) != null ? _c : 0;
+  const previousDataLength = (_d = (_c = options.previousDataLength) != null ? _c : existingSession == null ? void 0 : existingSession.previousDataLength) != null ? _d : 0;
   state.initialScrollSession = createInitialScrollSession({
     bootstrap,
     completion,
@@ -1874,7 +1906,7 @@ function checkFinishedScrollFallback(ctx) {
       state.timeoutCheckFinishedScrollFallback = setTimeout(checkHasScrolled, delay);
     };
     const checkHasScrolled = () => {
-      var _a3, _b, _c;
+      var _a3, _b, _c, _d;
       state.timeoutCheckFinishedScrollFallback = void 0;
       const isStillScrollingTo = state.scrollingTo;
       if (isStillScrollingTo) {
@@ -1887,8 +1919,10 @@ function checkFinishedScrollFallback(ctx) {
           isStillScrollingTo
         );
         const completionState = getResolvedScrollCompletionState(ctx, isStillScrollingTo);
-        const canFinishAfterSilentNativeDispatch = silentInitialDispatch && completionState.isAtResolvedTarget && numChecks >= 1;
+        const canFinishAfterSilentNativeDispatch = Platform.OS === "android" && silentInitialDispatch && completionState.isAtResolvedTarget && numChecks >= 1;
         const shouldRetrySilentInitialNativeScroll = Platform.OS === "android" && canFinishAfterSilentNativeDispatch && !initialScrollCompletion.didRetrySilentInitialScroll(state);
+        const shouldFinishAfterObservedScroll = state.hasScrolled && (!isStillScrollingTo.isInitialScroll || completionState.isAtResolvedTarget);
+        const shouldRetryUnalignedInitialScroll = isStillScrollingTo.isInitialScroll && !completionState.isAtResolvedTarget && numChecks <= maxChecks;
         if (shouldRetrySilentInitialNativeScroll) {
           const targetOffset = (_b = (_a3 = getInitialScrollWatchdogTargetOffset(state)) != null ? _a3 : isStillScrollingTo.targetOffset) != null ? _b : 0;
           const jiggleOffset = targetOffset >= SILENT_INITIAL_SCROLL_TARGET_EPSILON ? targetOffset - SILENT_INITIAL_SCROLL_TARGET_EPSILON : targetOffset + SILENT_INITIAL_SCROLL_TARGET_EPSILON;
@@ -1898,10 +1932,10 @@ function checkFinishedScrollFallback(ctx) {
             scrollToFallbackOffset(ctx, targetOffset);
           });
           scheduleFallbackCheck(SILENT_INITIAL_SCROLL_RETRY_DELAY_MS);
-        } else if (shouldFinishZeroTarget || state.hasScrolled || canFinishInitialScrollWithoutNativeProgress || canFinishAfterSilentNativeDispatch || numChecks > maxChecks) {
+        } else if (shouldFinishZeroTarget || shouldFinishAfterObservedScroll || canFinishInitialScrollWithoutNativeProgress || canFinishAfterSilentNativeDispatch || numChecks > maxChecks) {
           finishScrollTo(ctx);
-        } else if (isNativeInitialPending && numChecks <= maxChecks) {
-          const targetOffset = (_c = getInitialScrollWatchdogTargetOffset(state)) != null ? _c : state.scrollPending;
+        } else if ((isNativeInitialPending || shouldRetryUnalignedInitialScroll) && numChecks <= maxChecks) {
+          const targetOffset = (_d = (_c = getInitialScrollWatchdogTargetOffset(state)) != null ? _c : isStillScrollingTo.targetOffset) != null ? _d : state.scrollPending;
           scrollToFallbackOffset(ctx, targetOffset);
           scheduleFallbackCheck(silentInitialDispatch ? SILENT_INITIAL_SCROLL_RETRY_DELAY_MS : 100);
         } else {
@@ -2130,7 +2164,7 @@ function advanceMeasuredInitialScroll(ctx, options) {
   const activeInitialTargetOffset = scrollingTo ? (_a3 = scrollingTo.targetOffset) != null ? _a3 : scrollingTo.offset : void 0;
   const didOffsetChange = initialScroll.contentOffset === void 0 || Math.abs(initialScroll.contentOffset - resolvedOffset) > 1;
   const didActiveInitialTargetChange = activeInitialTargetOffset !== void 0 && Math.abs(activeInitialTargetOffset - resolvedOffset) > 1;
-  const isAlreadyAtDesiredInitialTarget = activeInitialTargetOffset !== void 0 && Math.abs(state.scroll - activeInitialTargetOffset) <= 1 && Math.abs(state.scrollPending - activeInitialTargetOffset) <= 1;
+  const isAlreadyAtDesiredInitialTarget = activeInitialTargetOffset !== void 0 && Math.abs(state.scroll - resolvedOffset) <= 1 && Math.abs(state.scrollPending - resolvedOffset) <= 1;
   if (!(options == null ? void 0 : options.forceScroll) && !didOffsetChange && isInitialScrollInProgress && !didActiveInitialTargetChange) {
     return false;
   }
@@ -2202,6 +2236,61 @@ function checkAllSizesKnown(state, indices) {
   });
 }
 
+// src/utils/requestAdjust.ts
+function requestAdjust(ctx, positionDiff, dataChanged) {
+  const state = ctx.state;
+  if (Math.abs(positionDiff) > 0.1) {
+    const needsScrollWorkaround = Platform.OS === "android" && !IsNewArchitecture && dataChanged && state.scroll <= positionDiff;
+    const doit = () => {
+      if (needsScrollWorkaround) {
+        scrollTo(ctx, {
+          noScrollingTo: true,
+          offset: state.scroll
+        });
+      } else {
+        state.scrollAdjustHandler.requestAdjust(positionDiff);
+        if (state.adjustingFromInitialMount) {
+          state.adjustingFromInitialMount--;
+        }
+      }
+    };
+    state.scroll += positionDiff;
+    state.scrollForNextCalculateItemsInView = void 0;
+    const readyToRender = peek$(ctx, "readyToRender");
+    if (readyToRender) {
+      doit();
+      if (Platform.OS !== "web") {
+        const threshold = state.scroll - positionDiff / 2;
+        if (!state.ignoreScrollFromMVCP) {
+          state.ignoreScrollFromMVCP = {};
+        }
+        if (positionDiff > 0) {
+          state.ignoreScrollFromMVCP.lt = threshold;
+        } else {
+          state.ignoreScrollFromMVCP.gt = threshold;
+        }
+        if (state.ignoreScrollFromMVCPTimeout) {
+          clearTimeout(state.ignoreScrollFromMVCPTimeout);
+        }
+        const delay = needsScrollWorkaround ? 250 : 100;
+        state.ignoreScrollFromMVCPTimeout = setTimeout(() => {
+          var _a3;
+          state.ignoreScrollFromMVCP = void 0;
+          const shouldForceUpdate = state.ignoreScrollFromMVCPIgnored && state.scrollProcessingEnabled !== false;
+          if (shouldForceUpdate) {
+            state.ignoreScrollFromMVCPIgnored = false;
+            state.scrollPending = state.scroll;
+            (_a3 = state.reprocessCurrentScroll) == null ? void 0 : _a3.call(state);
+          }
+        }, delay);
+      }
+    } else {
+      state.adjustingFromInitialMount = (state.adjustingFromInitialMount || 0) + 1;
+      requestAnimationFrame(doit);
+    }
+  }
+}
+
 // src/core/bootstrapInitialScroll.ts
 var DEFAULT_BOOTSTRAP_REVEAL_EPSILON = 1;
 var DEFAULT_BOOTSTRAP_REVEAL_MAX_FRAMES = 8;
@@ -2295,7 +2384,7 @@ function clearBootstrapInitialScrollSession(state) {
     bootstrapInitialScroll.frameHandle = void 0;
   }
   setInitialScrollSession(state, {
-    bootstrap: void 0,
+    bootstrap: null,
     kind: (_a3 = state.initialScrollSession) == null ? void 0 : _a3.kind
   });
 }
@@ -2451,15 +2540,18 @@ function clearFinishedBootstrapInitialScrollTargetIfMovedAway(ctx) {
     return;
   }
   if (didFinishedInitialScrollMoveAwayFromTarget(ctx, initialScroll)) {
-    if (shouldPreserveInitialScrollForFooterLayout(initialScroll)) {
-      clearPendingInitialScrollFooterLayout(ctx, {
-        dataLength: state.props.data.length,
-        stylePaddingBottom: (_b = state.props.stylePaddingBottom) != null ? _b : 0,
-        target: initialScroll
-      });
-      return;
+    const shouldKeepEndTargetAlive = isRetargetableBottomAlignedInitialScrollTarget(initialScroll) && peek$(ctx, "isAtEnd");
+    if (!shouldKeepEndTargetAlive) {
+      if (shouldPreserveInitialScrollForFooterLayout(initialScroll)) {
+        clearPendingInitialScrollFooterLayout(ctx, {
+          dataLength: state.props.data.length,
+          stylePaddingBottom: (_b = state.props.stylePaddingBottom) != null ? _b : 0,
+          target: initialScroll
+        });
+      } else {
+        clearFinishedViewportRetargetableInitialScroll(state);
+      }
     }
-    clearFinishedViewportRetargetableInitialScroll(state);
   }
 }
 function startBootstrapInitialScrollOnMount(ctx, options) {
@@ -2498,7 +2590,7 @@ function handleBootstrapInitialScrollDataChange(ctx, options) {
   }
   const shouldResetDidFinish = !!(state.didFinishInitialScroll && previousDataLength === 0 && dataLength > 0 && initialScroll.index !== void 0);
   const bootstrapInitialScroll = getBootstrapInitialScrollSession(state);
-  const shouldClearFinishedResizePreservation = didDataChange && dataLength > 0 && state.didFinishInitialScroll && !bootstrapInitialScroll && !shouldResetDidFinish;
+  const shouldClearFinishedResizePreservation = !initialScrollAtEnd && didDataChange && dataLength > 0 && state.didFinishInitialScroll && !bootstrapInitialScroll && !shouldResetDidFinish;
   if (shouldClearFinishedResizePreservation) {
     clearPreservedInitialScrollTarget(state);
     return;
@@ -2601,27 +2693,46 @@ function handleBootstrapInitialScrollFooterLayout(ctx, options) {
   }
 }
 function handleBootstrapInitialScrollLayoutChange(ctx) {
+  var _a3, _b, _c, _d;
   const state = ctx.state;
   const initialScroll = state.initialScroll;
-  if (isOffsetInitialScrollSession(state) || state.props.data.length === 0 || !initialScroll) {
-    return;
-  }
   const bootstrapInitialScroll = getBootstrapInitialScrollSession(state);
-  if (!bootstrapInitialScroll && initialScroll.viewPosition !== 1) {
-    return;
-  }
-  const didFinishInitialScroll = state.didFinishInitialScroll;
-  if (didFinishInitialScroll) {
-    setInitialScrollTarget(state, initialScroll, {
-      resetDidFinish: true
-    });
-    state.clearPreservedInitialScrollOnNextFinish = true;
+  if (initialScroll && state.props.data.length > 0 && !isOffsetInitialScrollSession(state) && (bootstrapInitialScroll || initialScroll.viewPosition === 1)) {
+    const resolvedOffset = resolveInitialScrollOffset(ctx, initialScroll);
+    const scrollingTo = ((_a3 = state.scrollingTo) == null ? void 0 : _a3.isInitialScroll) ? state.scrollingTo : void 0;
+    if (!bootstrapInitialScroll && (scrollingTo || state.didFinishInitialScroll)) {
+      const currentOffset = scrollingTo ? (_b = scrollingTo.targetOffset) != null ? _b : scrollingTo.offset : getObservedBootstrapInitialScrollOffset(state);
+      const offsetDiff = resolvedOffset - currentOffset;
+      if (Math.abs(offsetDiff) > DEFAULT_BOOTSTRAP_REVEAL_EPSILON) {
+        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
+          });
+        }
+        requestAdjust(ctx, offsetDiff);
+        if (state.didFinishInitialScroll) {
+          (_d = state.triggerCalculateItemsInView) == null ? void 0 : _d.call(state, { forceFullItemPositions: true });
+        }
+      }
+      if (state.didFinishInitialScroll) {
+        clearFinishedViewportRetargetableInitialScroll(state);
+      }
+    } else {
+      rearmBootstrapInitialScroll(ctx, {
+        scroll: resolvedOffset,
+        targetIndexSeed: initialScroll.index
+      });
+    }
   }
-  rearmBootstrapInitialScroll(ctx, {
-    scroll: resolveInitialScrollOffset(ctx, initialScroll),
-    seedContentOffset: didFinishInitialScroll && !bootstrapInitialScroll ? getObservedBootstrapInitialScrollOffset(state) : void 0,
-    targetIndexSeed: initialScroll.index
-  });
 }
 function evaluateBootstrapInitialScroll(ctx) {
   var _a3, _b;
@@ -2808,61 +2919,6 @@ function handleInitialScrollDataChange(ctx, options) {
   advanceCurrentInitialScrollSession(ctx);
 }
 
-// src/utils/requestAdjust.ts
-function requestAdjust(ctx, positionDiff, dataChanged) {
-  const state = ctx.state;
-  if (Math.abs(positionDiff) > 0.1) {
-    const needsScrollWorkaround = Platform.OS === "android" && !IsNewArchitecture && dataChanged && state.scroll <= positionDiff;
-    const doit = () => {
-      if (needsScrollWorkaround) {
-        scrollTo(ctx, {
-          noScrollingTo: true,
-          offset: state.scroll
-        });
-      } else {
-        state.scrollAdjustHandler.requestAdjust(positionDiff);
-        if (state.adjustingFromInitialMount) {
-          state.adjustingFromInitialMount--;
-        }
-      }
-    };
-    state.scroll += positionDiff;
-    state.scrollForNextCalculateItemsInView = void 0;
-    const readyToRender = peek$(ctx, "readyToRender");
-    if (readyToRender) {
-      doit();
-      if (Platform.OS !== "web") {
-        const threshold = state.scroll - positionDiff / 2;
-        if (!state.ignoreScrollFromMVCP) {
-          state.ignoreScrollFromMVCP = {};
-        }
-        if (positionDiff > 0) {
-          state.ignoreScrollFromMVCP.lt = threshold;
-        } else {
-          state.ignoreScrollFromMVCP.gt = threshold;
-        }
-        if (state.ignoreScrollFromMVCPTimeout) {
-          clearTimeout(state.ignoreScrollFromMVCPTimeout);
-        }
-        const delay = needsScrollWorkaround ? 250 : 100;
-        state.ignoreScrollFromMVCPTimeout = setTimeout(() => {
-          var _a3;
-          state.ignoreScrollFromMVCP = void 0;
-          const shouldForceUpdate = state.ignoreScrollFromMVCPIgnored && state.scrollProcessingEnabled !== false;
-          if (shouldForceUpdate) {
-            state.ignoreScrollFromMVCPIgnored = false;
-            state.scrollPending = state.scroll;
-            (_a3 = state.reprocessCurrentScroll) == null ? void 0 : _a3.call(state);
-          }
-        }, delay);
-      }
-    } else {
-      state.adjustingFromInitialMount = (state.adjustingFromInitialMount || 0) + 1;
-      requestAnimationFrame(doit);
-    }
-  }
-}
-
 // src/core/mvcp.ts
 var MVCP_POSITION_EPSILON = 0.1;
 var MVCP_ANCHOR_LOCK_TTL_MS = 300;
@@ -3146,7 +3202,10 @@ function prepareMVCP(ctx, dataChanged) {
         return;
       }
       if (Math.abs(positionDiff) > MVCP_POSITION_EPSILON) {
-        requestAdjust(ctx, positionDiff, dataChanged && mvcpData);
+        const shouldSkipAdjustForMaintainedEnd = state.maintainingScrollAtEnd && peek$(ctx, "isWithinMaintainScrollAtEndThreshold");
+        if (!shouldSkipAdjustForMaintainedEnd) {
+          requestAdjust(ctx, positionDiff, dataChanged && mvcpData);
+        }
       }
     };
   }
@@ -3765,6 +3824,30 @@ function maybeUpdateViewabilityCallback(ctx, configId, containerId, viewToken) {
 var unstableBatchedUpdates = ReactNative__namespace.unstable_batchedUpdates;
 var batchedUpdates = typeof unstableBatchedUpdates === "function" ? unstableBatchedUpdates : (fn) => fn();
 
+// src/utils/containerPool.ts
+var MIN_INITIAL_CONTAINER_POOL_SIZE = 32;
+var MAX_INITIAL_SPARE_CONTAINERS = 64;
+function getInitialContainerPoolSize(dataLength, numContainers, initialContainerPoolRatio) {
+  if (dataLength <= 0 || numContainers <= 0) {
+    return 0;
+  }
+  const ratioPoolSize = Math.ceil(numContainers * initialContainerPoolRatio);
+  const cappedSparePoolSize = numContainers + MAX_INITIAL_SPARE_CONTAINERS;
+  const targetPoolSize = Math.max(
+    numContainers,
+    Math.min(ratioPoolSize, cappedSparePoolSize),
+    Math.min(dataLength, MIN_INITIAL_CONTAINER_POOL_SIZE)
+  );
+  const maxUsefulPoolSize = Math.max(dataLength, numContainers);
+  return Math.min(maxUsefulPoolSize, targetPoolSize);
+}
+function getExpandedContainerPoolSize(dataLength, numContainers) {
+  if (dataLength <= 0 || numContainers <= 0) {
+    return 0;
+  }
+  return Math.min(Math.max(dataLength, numContainers), Math.max(numContainers, Math.ceil(numContainers * 1.5)));
+}
+
 // src/utils/findAvailableContainers.ts
 function findAvailableContainers(ctx, numNeeded, startBuffered, endBuffered, pendingRemoval, requiredItemTypes, needNewContainers, protectedKeys) {
   const numContainers = peek$(ctx, "numContainers");
@@ -3970,7 +4053,7 @@ function handleStickyRecycling(ctx, stickyArray, scroll, drawDistance, currentSt
 function calculateItemsInView(ctx, params = {}) {
   const state = ctx.state;
   batchedUpdates(() => {
-    var _a3, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r;
+    var _a3, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q;
     const {
       columns,
       columnSpans,
@@ -4017,12 +4100,22 @@ function calculateItemsInView(ctx, params = {}) {
       // current initial-scroll target instead of transient native adjustments.
       resolveInitialScrollOffset(ctx, initialScroll)
     ) : state.scroll;
-    const scrollAdjustPending = (_c = peek$(ctx, "scrollAdjustPending")) != null ? _c : 0;
-    const scrollAdjustPad = scrollAdjustPending - topPad;
-    let scroll = Math.round(scrollState + scrollExtra + scrollAdjustPad);
-    if (scroll + scrollLength > totalSize) {
-      scroll = Math.max(0, totalSize - scrollLength);
-    }
+    let scrollAdjustPending = 0;
+    let scrollAdjustPad = 0;
+    let scroll = 0;
+    let scrollTopBuffered = 0;
+    let scrollBottom = 0;
+    let scrollBottomBuffered = 0;
+    const updateScroll2 = (nextScrollState) => {
+      var _a4;
+      scrollAdjustPending = (_a4 = peek$(ctx, "scrollAdjustPending")) != null ? _a4 : 0;
+      scrollAdjustPad = scrollAdjustPending - topPad;
+      scroll = Math.round(nextScrollState + scrollExtra + scrollAdjustPad);
+      if (scroll + scrollLength > totalSize) {
+        scroll = Math.max(0, totalSize - scrollLength);
+      }
+    };
+    updateScroll2(scrollState);
     const previousStickyIndex = peek$(ctx, "activeStickyIndex");
     const currentStickyIdx = stickyIndicesArr.length > 0 ? findCurrentStickyIndex(stickyIndicesArr, scroll, state) : -1;
     const nextActiveStickyIndex = currentStickyIdx >= 0 ? stickyIndicesArr[currentStickyIdx] : -1;
@@ -4038,9 +4131,12 @@ function calculateItemsInView(ctx, params = {}) {
       scrollBufferTop = drawDistance * 1.5;
       scrollBufferBottom = drawDistance * 0.5;
     }
-    const scrollTopBuffered = scroll - scrollBufferTop;
-    const scrollBottom = scroll + scrollLength + (scroll < 0 ? -scroll : 0);
-    const scrollBottomBuffered = scrollBottom + scrollBufferBottom;
+    const updateScrollRange = () => {
+      scrollTopBuffered = scroll - scrollBufferTop;
+      scrollBottom = scroll + scrollLength + (scroll < 0 ? -scroll : 0);
+      scrollBottomBuffered = scrollBottom + scrollBufferBottom;
+    };
+    updateScrollRange();
     if (!suppressInitialScrollSideEffects && !dataChanged && !forceFullItemPositions && scrollForNextCalculateItemsInView) {
       const { top, bottom } = scrollForNextCalculateItemsInView;
       if (top === null && bottom === null) {
@@ -4059,7 +4155,7 @@ function calculateItemsInView(ctx, params = {}) {
       columns.length = 0;
       columnSpans.length = 0;
     }
-    const startIndex = forceFullItemPositions || dataChanged ? 0 : (_d = minIndexSizeChanged != null ? minIndexSizeChanged : state.startBuffered) != null ? _d : 0;
+    const startIndex = forceFullItemPositions || dataChanged ? 0 : (_c = minIndexSizeChanged != null ? minIndexSizeChanged : state.startBuffered) != null ? _c : 0;
     const optimizeForVisibleWindow = !forceFullItemPositions && !dataChanged && numColumns > 1 && minIndexSizeChanged !== void 0;
     updateItemPositions(ctx, dataChanged, {
       doMVCP,
@@ -4084,21 +4180,25 @@ function calculateItemsInView(ctx, params = {}) {
       }
     }
     const scrollBeforeMVCP = state.scroll;
-    const scrollAdjustPendingBeforeMVCP = (_e = peek$(ctx, "scrollAdjustPending")) != null ? _e : 0;
+    const scrollAdjustPendingBeforeMVCP = (_d = peek$(ctx, "scrollAdjustPending")) != null ? _d : 0;
     checkMVCP == null ? void 0 : checkMVCP();
-    const didMVCPAdjustScroll = !!checkMVCP && (state.scroll !== scrollBeforeMVCP || ((_f = peek$(ctx, "scrollAdjustPending")) != null ? _f : 0) !== scrollAdjustPendingBeforeMVCP);
+    const didMVCPAdjustScroll = !!checkMVCP && (state.scroll !== scrollBeforeMVCP || ((_e = peek$(ctx, "scrollAdjustPending")) != null ? _e : 0) !== scrollAdjustPendingBeforeMVCP);
+    if (didMVCPAdjustScroll && initialScroll) {
+      updateScroll2(state.scroll);
+      updateScrollRange();
+    }
     let startNoBuffer = null;
     let startBuffered = null;
     let startBufferedId = null;
     let endNoBuffer = null;
     let endBuffered = null;
-    let loopStart = (_g = suppressInitialScrollSideEffects ? bootstrapInitialScrollState == null ? void 0 : bootstrapInitialScrollState.targetIndexSeed : void 0) != null ? _g : !dataChanged && startBufferedIdOrig ? indexByKey.get(startBufferedIdOrig) || 0 : 0;
+    let loopStart = (_f = suppressInitialScrollSideEffects ? bootstrapInitialScrollState == null ? void 0 : bootstrapInitialScrollState.targetIndexSeed : void 0) != null ? _f : !dataChanged && startBufferedIdOrig ? indexByKey.get(startBufferedIdOrig) || 0 : 0;
     for (let i = loopStart; i >= 0; i--) {
-      const id = (_h = idCache[i]) != null ? _h : getId(state, i);
+      const id = (_g = idCache[i]) != null ? _g : getId(state, i);
       const top = positions[i];
-      const size = (_i = sizes.get(id)) != null ? _i : getItemSize(ctx, id, i, data[i]);
+      const size = (_h = sizes.get(id)) != null ? _h : getItemSize(ctx, id, i, data[i]);
       const bottom = top + size;
-      if (bottom > scroll - scrollBufferTop) {
+      if (bottom > scrollTopBuffered) {
         loopStart = i;
       } else {
         break;
@@ -4127,8 +4227,8 @@ function calculateItemsInView(ctx, params = {}) {
     let firstFullyOnScreenIndex;
     const dataLength = data.length;
     for (let i = Math.max(0, loopStart); i < dataLength && (!foundEnd || i <= maxIndexRendered); i++) {
-      const id = (_j = idCache[i]) != null ? _j : getId(state, i);
-      const size = (_k = sizes.get(id)) != null ? _k : getItemSize(ctx, id, i, data[i]);
+      const id = (_i = idCache[i]) != null ? _i : getId(state, i);
+      const size = (_j = sizes.get(id)) != null ? _j : getItemSize(ctx, id, i, data[i]);
       const top = positions[i];
       if (!foundEnd) {
         if (startNoBuffer === null && top + size > scroll) {
@@ -4167,7 +4267,7 @@ function calculateItemsInView(ctx, params = {}) {
     const firstVisibleAnchorIndex = firstFullyOnScreenIndex != null ? firstFullyOnScreenIndex : startNoBuffer;
     if (firstVisibleAnchorIndex !== null && firstVisibleAnchorIndex !== void 0 && endNoBuffer !== null) {
       for (let i = firstVisibleAnchorIndex; i <= endNoBuffer; i++) {
-        const id = (_l = idCache[i]) != null ? _l : getId(state, i);
+        const id = (_k = idCache[i]) != null ? _k : getId(state, i);
         idsInView.push(id);
       }
     }
@@ -4200,7 +4300,7 @@ function calculateItemsInView(ctx, params = {}) {
       const needNewContainers = [];
       const needNewContainersSet = /* @__PURE__ */ new Set();
       for (let i = startBuffered; i <= endBuffered; i++) {
-        const id = (_m = idCache[i]) != null ? _m : getId(state, i);
+        const id = (_l = idCache[i]) != null ? _l : getId(state, i);
         if (!containerItemKeys.has(id)) {
           needNewContainersSet.add(i);
           needNewContainers.push(i);
@@ -4209,7 +4309,7 @@ function calculateItemsInView(ctx, params = {}) {
       if (alwaysRenderArr.length > 0) {
         for (const index of alwaysRenderArr) {
           if (index < 0 || index >= dataLength) continue;
-          const id = (_n = idCache[index]) != null ? _n : getId(state, index);
+          const id = (_m = idCache[index]) != null ? _m : getId(state, index);
           if (id && !containerItemKeys.has(id) && !needNewContainersSet.has(index)) {
             needNewContainersSet.add(index);
             needNewContainers.push(index);
@@ -4248,7 +4348,7 @@ function calculateItemsInView(ctx, params = {}) {
         for (let idx = 0; idx < needNewContainers.length; idx++) {
           const i = needNewContainers[idx];
           const containerIndex = availableContainers[idx];
-          const id = (_o = idCache[i]) != null ? _o : getId(state, i);
+          const id = (_n = idCache[i]) != null ? _n : getId(state, i);
           const oldKey = peek$(ctx, `containerItemKey${containerIndex}`);
           if (oldKey && oldKey !== id) {
             containerItemKeys.delete(oldKey);
@@ -4259,7 +4359,7 @@ function calculateItemsInView(ctx, params = {}) {
             state.containerItemTypes.set(containerIndex, requiredItemTypes[idx]);
           }
           containerItemKeys.set(id, containerIndex);
-          (_p = state.userScrollAnchorResetKeys) == null ? void 0 : _p.add(id);
+          (_o = state.userScrollAnchorResetKeys) == null ? void 0 : _o.add(id);
           const containerSticky = `containerSticky${containerIndex}`;
           const isSticky = stickyIndicesSet.has(i);
           const isAlwaysRender = alwaysRenderSet.has(i);
@@ -4283,17 +4383,17 @@ function calculateItemsInView(ctx, params = {}) {
         if (numContainers !== prevNumContainers) {
           set$(ctx, "numContainers", numContainers);
           if (numContainers > peek$(ctx, "numContainersPooled")) {
-            set$(ctx, "numContainersPooled", Math.ceil(numContainers * 1.5));
+            set$(ctx, "numContainersPooled", getExpandedContainerPoolSize(dataLength, numContainers));
           }
         }
       }
-      if (((_q = state.userScrollAnchorResetKeys) == null ? void 0 : _q.size) === 0) {
+      if (((_p = state.userScrollAnchorResetKeys) == null ? void 0 : _p.size) === 0) {
         state.userScrollAnchorResetKeys = void 0;
       }
       if (alwaysRenderArr.length > 0) {
         for (const index of alwaysRenderArr) {
           if (index < 0 || index >= dataLength) continue;
-          const id = (_r = idCache[index]) != null ? _r : getId(state, index);
+          const id = (_q = idCache[index]) != null ? _q : getId(state, index);
           const containerIndex = containerItemKeys.get(id);
           if (containerIndex !== void 0) {
             state.stickyContainerPool.add(containerIndex);
@@ -4397,21 +4497,25 @@ function doMaintainScrollAtEnd(ctx) {
     if (contentSize < state.scrollLength) {
       state.scroll = 0;
     }
-    requestAnimationFrame(() => {
-      var _a3;
-      if (peek$(ctx, "isWithinMaintainScrollAtEndThreshold")) {
-        state.maintainingScrollAtEnd = true;
-        (_a3 = refScroller.current) == null ? void 0 : _a3.scrollToEnd({
-          animated: maintainScrollAtEnd.animated
-        });
-        setTimeout(
-          () => {
-            state.maintainingScrollAtEnd = false;
-          },
-          maintainScrollAtEnd.animated ? 500 : 0
-        );
-      }
-    });
+    if (!state.maintainingScrollAtEnd) {
+      state.maintainingScrollAtEnd = true;
+      requestAnimationFrame(() => {
+        var _a3;
+        if (peek$(ctx, "isWithinMaintainScrollAtEndThreshold")) {
+          (_a3 = refScroller.current) == null ? void 0 : _a3.scrollToEnd({
+            animated: maintainScrollAtEnd.animated
+          });
+          setTimeout(
+            () => {
+              state.maintainingScrollAtEnd = false;
+            },
+            maintainScrollAtEnd.animated ? 500 : 0
+          );
+        } else {
+          state.maintainingScrollAtEnd = false;
+        }
+      });
+    }
     return true;
   }
   return false;
@@ -4523,14 +4627,21 @@ function doInitialAllocateContainers(ctx) {
     } else {
       averageItemSize = estimatedItemSize;
     }
-    const numContainers = Math.ceil((scrollLength + drawDistance * 2) / averageItemSize * numColumns);
+    const numContainers = Math.max(
+      1,
+      Math.ceil((scrollLength + drawDistance * 2) / averageItemSize * numColumns)
+    );
     for (let i = 0; i < numContainers; i++) {
       set$(ctx, `containerPosition${i}`, POSITION_OUT_OF_VIEW);
       set$(ctx, `containerColumn${i}`, -1);
       set$(ctx, `containerSpan${i}`, 1);
     }
     set$(ctx, "numContainers", numContainers);
-    set$(ctx, "numContainersPooled", numContainers * state.props.initialContainerPoolRatio);
+    set$(
+      ctx,
+      "numContainersPooled",
+      getInitialContainerPoolSize(data.length, numContainers, state.props.initialContainerPoolRatio)
+    );
     if (!IsNewArchitecture || state.lastLayout) {
       if (state.initialScroll) {
         requestAnimationFrame(() => {
@@ -4682,8 +4793,8 @@ function updateScroll(ctx, newScroll, forceUpdate, options) {
 // src/core/onScroll.ts
 function trackInitialScrollNativeProgress(state, newScroll) {
   const initialNativeScrollWatchdog = initialScrollWatchdog.get(state);
-  const didInitialScrollProgress = !!initialNativeScrollWatchdog && initialScrollWatchdog.didObserveProgress(newScroll, initialNativeScrollWatchdog);
-  if (didInitialScrollProgress) {
+  const didInitialScrollReachTarget = !!initialNativeScrollWatchdog && initialScrollWatchdog.didReachTarget(newScroll, initialNativeScrollWatchdog);
+  if (didInitialScrollReachTarget) {
     initialScrollWatchdog.clear(state);
     return;
   }
@@ -4821,16 +4932,20 @@ function maybeUpdateAnchoredEndSpace(ctx) {
       let contentBelowAnchor = 0;
       const footerSize = ctx.values.get("footerSize") || 0;
       const stylePaddingBottom = state.props.stylePaddingBottom || 0;
+      let hasUnknownTailSize = false;
       for (let index = anchorIndex; index < data.length; index++) {
         const itemKey = getId(state, index);
         const size = itemKey ? state.sizesKnown.get(itemKey) : void 0;
         const effectiveSize = index === anchorIndex && anchorMaxSize !== void 0 ? Math.min(size || 0, Math.max(0, anchorMaxSize)) : size;
+        if (size === void 0) {
+          hasUnknownTailSize = true;
+        }
         if (effectiveSize !== null && effectiveSize !== void 0 && effectiveSize > 0) {
           contentBelowAnchor += effectiveSize;
         }
       }
       contentBelowAnchor += footerSize + stylePaddingBottom;
-      nextSize = Math.max(0, state.scrollLength - contentBelowAnchor - anchorOffset);
+      nextSize = hasUnknownTailSize ? previousSize || 0 : Math.max(0, state.scrollLength - contentBelowAnchor - anchorOffset);
     }
   }
   if (previousSize !== nextSize) {
@@ -4904,15 +5019,7 @@ function updateItemSize(ctx, itemKey, sizeObj) {
   const {
     didContainersLayout,
     sizesKnown,
-    props: {
-      getFixedItemSize,
-      getItemType,
-      horizontal,
-      suggestEstimatedItemSize,
-      onItemSizeChanged,
-      data,
-      maintainScrollAtEnd
-    }
+    props: { getFixedItemSize, getItemType, horizontal, onItemSizeChanged, data, maintainScrollAtEnd }
   } = state;
   if (!data) return;
   const index = state.indexByKey.get(itemKey);
@@ -4963,18 +5070,6 @@ function updateItemSize(ctx, itemKey, sizeObj) {
   if (minIndexSizeChanged !== void 0) {
     state.minIndexSizeChanged = state.minIndexSizeChanged !== void 0 ? Math.min(state.minIndexSizeChanged, minIndexSizeChanged) : minIndexSizeChanged;
   }
-  if (IS_DEV && suggestEstimatedItemSize && minIndexSizeChanged !== void 0) {
-    if (state.timeoutSizeMessage) clearTimeout(state.timeoutSizeMessage);
-    state.timeoutSizeMessage = setTimeout(() => {
-      var _a4;
-      state.timeoutSizeMessage = void 0;
-      const num = state.sizesKnown.size;
-      const avg = (_a4 = state.averageSizes[""]) == null ? void 0 : _a4.avg;
-      console.warn(
-        `[legend-list] Based on the ${num} items rendered so far, the optimal estimated size is ${avg}.`
-      );
-    }, 1e3);
-  }
   const cur = peek$(ctx, "otherAxisSize");
   if (!cur || maxOtherAxisSize > cur) {
     set$(ctx, "otherAxisSize", maxOtherAxisSize);
@@ -5092,12 +5187,47 @@ function createColumnWrapperStyle(contentContainerStyle) {
 }
 
 // src/utils/createImperativeHandle.ts
+var DEFAULT_AVERAGE_ITEM_SIZE_TYPE = "default";
+function getAverageItemSizes(state) {
+  const averageItemSizes = {};
+  for (const itemType in state.averageSizes) {
+    const averageSize = state.averageSizes[itemType];
+    if (averageSize) {
+      averageItemSizes[itemType || DEFAULT_AVERAGE_ITEM_SIZE_TYPE] = {
+        average: averageSize.avg,
+        count: averageSize.num
+      };
+    }
+  }
+  return averageItemSizes;
+}
 function createImperativeHandle(ctx) {
   const state = ctx.state;
   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.queuedMVCPRecalculate !== void 0 || state.ignoreScrollFromMVCP !== void 0;
+  const isScrollToIndexReady = (targetIndex, allowEmpty = false) => {
+    var _a3;
+    const props = state.props;
+    const dataLength = props.data.length;
+    const anchorIndex = (_a3 = props.anchoredEndSpace) == null ? void 0 : _a3.anchorIndex;
+    if (targetIndex < 0) {
+      return allowEmpty;
+    }
+    if (targetIndex >= dataLength) {
+      return false;
+    }
+    if (anchorIndex === void 0 || anchorIndex < 0 || anchorIndex >= dataLength || targetIndex < anchorIndex || props.getFixedItemSize) {
+      return true;
+    }
+    for (let index = anchorIndex; index < dataLength; index++) {
+      if (!state.sizesKnown.has(getId(state, index))) {
+        return false;
+      }
+    }
+    return true;
+  };
   const runWhenReady = (token, run, isReady) => {
     const startedAt = Date.now();
     let stableFrames = 0;
@@ -5119,11 +5249,10 @@ function createImperativeHandle(ctx) {
     };
     requestAnimationFrame(check);
   };
-  const runScrollWithPromise = (run, options) => new Promise((resolve) => {
-    var _a3, _b;
+  const runScrollWithPromise = (run, isReady = () => true) => new Promise((resolve) => {
+    var _a3;
     const token = ++imperativeScrollToken;
-    const isReady = (_a3 = options == null ? void 0 : options.isReady) != null ? _a3 : (() => true);
-    (_b = state.pendingScrollResolve) == null ? void 0 : _b.call(state);
+    (_a3 = state.pendingScrollResolve) == null ? void 0 : _a3.call(state);
     state.pendingScrollResolve = resolve;
     const runNow = () => {
       if (token !== imperativeScrollToken) {
@@ -5198,6 +5327,7 @@ function createImperativeHandle(ctx) {
       },
       end: state.endNoBuffer,
       endBuffered: state.endBuffered,
+      getAverageItemSizes: () => getAverageItemSizes(state),
       isAtEnd: peek$(ctx, "isAtEnd"),
       isAtStart: peek$(ctx, "isAtStart"),
       isEndReached: state.isEndReached,
@@ -5240,40 +5370,34 @@ function createImperativeHandle(ctx) {
       }
       return false;
     }),
-    scrollToEnd: (options) => runScrollWithPromise(() => {
-      const data = state.props.data;
-      const stylePaddingBottom = state.props.stylePaddingBottom;
-      const index = data.length - 1;
-      if (index !== -1) {
-        const paddingBottom = 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;
-      }
-      return false;
-    }),
-    scrollToIndex: (params) => {
-      const shouldWaitForOutOfRangeTarget = params.index >= 0 && params.index >= state.props.data.length;
-      const options = shouldWaitForOutOfRangeTarget ? {
-        isReady: () => {
-          var _a3;
-          const props = state.props;
-          const anchorIndex = (_a3 = props.anchoredEndSpace) == null ? void 0 : _a3.anchorIndex;
-          const lastIndex = props.data.length - 1;
-          const isInRange = params.index < props.data.length;
-          const shouldWaitForAnchorSize = isInRange && anchorIndex !== void 0 && anchorIndex >= 0 && params.index >= anchorIndex && !props.getFixedItemSize && !state.sizesKnown.has(getId(state, lastIndex));
-          return isInRange && !shouldWaitForAnchorSize;
+    scrollToEnd: (options) => runScrollWithPromise(
+      () => {
+        const data = state.props.data;
+        const stylePaddingBottom = state.props.stylePaddingBottom;
+        const index = data.length - 1;
+        if (index !== -1) {
+          const paddingBottom = 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;
         }
-      } : void 0;
-      return runScrollWithPromise(() => {
-        scrollToIndex(ctx, params);
-        return true;
-      }, options);
+        return false;
+      },
+      () => isScrollToIndexReady(state.props.data.length - 1, true)
+    ),
+    scrollToIndex: (params) => {
+      return runScrollWithPromise(
+        () => {
+          scrollToIndex(ctx, params);
+          return true;
+        },
+        params.index >= 0 ? () => isScrollToIndexReady(params.index) : void 0
+      );
     },
     scrollToItem: ({ item, ...props }) => runScrollWithPromise(() => {
       const data = state.props.data;
@@ -5537,7 +5661,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     getFixedItemSize,
     getItemType,
     horizontal,
-    initialContainerPoolRatio = 2,
+    initialContainerPoolRatio = 3,
     initialScrollAtEnd = false,
     initialScrollIndex: initialScrollIndexProp,
     initialScrollOffset: initialScrollOffsetProp,
@@ -5578,7 +5702,6 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     stickyIndices: stickyIndicesDeprecated,
     // TODOV3: Remove from v3 release
     style: styleProp,
-    suggestEstimatedItemSize,
     useWindowScroll = false,
     viewabilityConfig,
     viewabilityConfigCallbackPairs,
@@ -5719,7 +5842,6 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
         startReachedSnapshotDataChangeEpoch: void 0,
         stickyContainerPool: /* @__PURE__ */ new Set(),
         stickyContainers: /* @__PURE__ */ new Map(),
-        timeoutSizeMessage: 0,
         timeouts: /* @__PURE__ */ new Set(),
         totalSize: 0,
         viewabilityConfigCallbackPairs: void 0
@@ -5739,7 +5861,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
   const didDataReferenceChangeLocal = state.props.data !== dataProp;
   const didDataVersionChangeLocal = state.props.dataVersion !== dataVersion;
   const didDataChangeLocal = didDataVersionChangeLocal || didDataReferenceChangeLocal && checkStructuralDataChange(state, dataProp, state.props.data);
-  if (didDataChangeLocal && state.didFinishInitialScroll && ((_f = state.initialScroll) == null ? void 0 : _f.viewPosition) === 1 && state.props.data.length > 0) {
+  if (didDataChangeLocal && !initialScrollAtEnd && state.didFinishInitialScroll && ((_f = state.initialScroll) == null ? void 0 : _f.viewPosition) === 1 && state.props.data.length > 0) {
     clearPreservedInitialScrollTarget(state);
   }
   if (didDataChangeLocal) {
@@ -5794,7 +5916,6 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     stickyPositionComponentInternal,
     stylePaddingBottom: stylePaddingBottomState,
     stylePaddingTop: stylePaddingTopState,
-    suggestEstimatedItemSize: !!suggestEstimatedItemSize,
     useWindowScroll: useWindowScrollResolved
   };
   state.refScroller = refScroller;