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

package/react-native.web.mjs

@@ -716,6 +716,7 @@ function getContainerPositionStyle({
 }
 var Container = typedMemo(function Container2({
   id,
+  itemKey,
   recycleItems,
   horizontal,
   getRenderedItem: getRenderedItem2,
@@ -727,11 +728,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}`
@@ -849,6 +849,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__ */ React3.createElement(
+    ContainerComponent,
+    {
+      getRenderedItem: getRenderedItem2,
+      horizontal,
+      ItemSeparatorComponent,
+      id,
+      itemKey,
+      recycleItems,
+      stickyHeaderConfig,
+      updateItemSize: updateItemSize2
+    }
+  );
+}
+var ContainerSlot = typedMemo(function ContainerSlot2(props) {
+  return /* @__PURE__ */ React3.createElement(ContainerSlotBase, { ...props });
+});
+
 // src/utils/reordering.ts
 var mapFn = (element) => {
   const indexStr = element.getAttribute("data-index");
@@ -968,9 +1001,12 @@ var ContainersInner = typedMemo(function ContainersInner2({ horizontal, numColum
   const ref = useRef(null);
   const ctx = useStateContext();
   const columnWrapperStyle = ctx.columnWrapperStyle;
-  const [otherAxisSize, totalSize] = useArr$(["otherAxisSize", "totalSize"]);
+  const [otherAxisSize, readyToRender, totalSize] = useArr$(["otherAxisSize", "readyToRender", "totalSize"]);
   useDOMOrder(ref);
-  const style = horizontal ? { minHeight: otherAxisSize, position: "relative", width: totalSize } : { height: totalSize, minWidth: otherAxisSize, position: "relative" };
+  const style = horizontal ? { minHeight: otherAxisSize, opacity: readyToRender ? 1 : 0, position: "relative", width: totalSize } : { height: totalSize, minWidth: otherAxisSize, opacity: readyToRender ? 1 : 0, position: "relative" };
+  if (!readyToRender) {
+    style.pointerEvents = "none";
+  }
   if (columnWrapperStyle && numColumns > 1) {
     const { columnGap, rowGap, gap } = columnWrapperStyle;
     const gapX = columnGap || gap || 0;
@@ -998,12 +1034,12 @@ var Containers = typedMemo(function Containers2({
   getRenderedItem: getRenderedItem2,
   stickyHeaderConfig
 }) {
-  const [numContainers, numColumns] = useArr$(["numContainersPooled", "numColumns"]);
+  const [numContainersPooled, numColumns] = useArr$(["numContainersPooled", "numColumns"]);
   const containers = [];
-  for (let i = 0; i < numContainers; i++) {
+  for (let i = 0; i < numContainersPooled; i++) {
     containers.push(
       /* @__PURE__ */ React3.createElement(
-        Container,
+        ContainerSlot,
         {
           getRenderedItem: getRenderedItem2,
           horizontal,
@@ -1075,6 +1111,8 @@ function useRafCoalescer(callback) {
 
 // src/components/webConstants.ts
 var LEGEND_LIST_CONTENT_CONTAINER_CLASS = "legend-list-content-container";
+var LEGEND_LIST_SCROLLBAR_X_HIDDEN_CLASS = "legend-list-scrollbar-x-hidden";
+var LEGEND_LIST_SCROLLBAR_Y_HIDDEN_CLASS = "legend-list-scrollbar-y-hidden";
 
 // src/components/webScrollUtils.ts
 function getDocumentScrollerNode() {
@@ -1160,6 +1198,17 @@ function resolveWindowScrollTarget({ clampedOffset, horizontal, listPos, scroll
 }
 
 // src/components/ListComponentScrollView.tsx
+var SCROLLBAR_HIDDEN_STYLE_ID = "legend-list-scrollbar-axis-hidden-style";
+var SCROLLBAR_HIDDEN_STYLE = `.${LEGEND_LIST_SCROLLBAR_Y_HIDDEN_CLASS}::-webkit-scrollbar:vertical{width:0;display:none;}.${LEGEND_LIST_SCROLLBAR_X_HIDDEN_CLASS}::-webkit-scrollbar:horizontal{height:0;display:none;}`;
+function ensureScrollbarHiddenStyle() {
+  if (typeof document === "undefined" || document.getElementById(SCROLLBAR_HIDDEN_STYLE_ID)) {
+    return;
+  }
+  const styleElement = document.createElement("style");
+  styleElement.id = SCROLLBAR_HIDDEN_STYLE_ID;
+  styleElement.textContent = SCROLLBAR_HIDDEN_STYLE;
+  document.head.appendChild(styleElement);
+}
 function getContentInsetEndAdjustmentEnd2(ctx) {
   var _a3, _b;
   const adjustment = (_b = (_a3 = ctx.state) == null ? void 0 : _a3.props) == null ? void 0 : _b.contentInsetEndAdjustment;
@@ -1364,6 +1413,12 @@ var ListComponentScrollView = forwardRef(function ListComponentScrollView2({
       }
     };
   }, [isWindowScroll, onLayout]);
+  const hiddenScrollIndicatorClassName = !isWindowScroll && (horizontal ? !showsHorizontalScrollIndicator && LEGEND_LIST_SCROLLBAR_X_HIDDEN_CLASS : !showsVerticalScrollIndicator && LEGEND_LIST_SCROLLBAR_Y_HIDDEN_CLASS);
+  useLayoutEffect(() => {
+    if (hiddenScrollIndicatorClassName) {
+      ensureScrollbarHiddenStyle();
+    }
+  }, [hiddenScrollIndicatorClassName]);
   const scrollViewStyle = {
     ...isWindowScroll ? {} : {
       overflow: "auto",
@@ -1392,9 +1447,31 @@ var ListComponentScrollView = forwardRef(function ListComponentScrollView2({
     scrollEventThrottle: _scrollEventThrottle,
     ScrollComponent: _ScrollComponent,
     useWindowScroll: _useWindowScroll,
+    className: scrollViewClassNameProp,
     ...webProps
   } = props;
-  return /* @__PURE__ */ React3.createElement("div", { ref: scrollRef, ...webProps, style: scrollViewStyle }, refreshControl, /* @__PURE__ */ React3.createElement("div", { className, ref: contentRef, style: contentStyle }, children, contentInsetEndAdjustmentSpacerStyle ? /* @__PURE__ */ React3.createElement("div", { "aria-hidden": true, style: contentInsetEndAdjustmentSpacerStyle }) : null));
+  const scrollViewClassName = hiddenScrollIndicatorClassName ? scrollViewClassNameProp ? `${scrollViewClassNameProp} ${hiddenScrollIndicatorClassName}` : hiddenScrollIndicatorClassName : scrollViewClassNameProp;
+  if (IS_DEV) {
+    if (/(?:^|\s)(?:[a-z0-9_-]+:)*gap(?:-[xy])?-(?:\[[^\]]+\]|[^\s]+)/.test(
+      `${contentContainerClassName != null ? contentContainerClassName : ""} ${scrollViewClassNameProp != null ? scrollViewClassNameProp : ""}`
+    )) {
+      warnDevOnce(
+        "className-gap",
+        "className/contentContainerClassName gap classes are not supported in LegendList because it needs to use exact values internally. Use contentContainerStyle={{ gap: ... }} or columnWrapperStyle instead."
+      );
+    }
+  }
+  return /* @__PURE__ */ React3.createElement(
+    "div",
+    {
+      className: scrollViewClassName,
+      ref: scrollRef,
+      ...webProps,
+      style: scrollViewStyle
+    },
+    refreshControl,
+    /* @__PURE__ */ React3.createElement("div", { className, ref: contentRef, style: contentStyle }, children, contentInsetEndAdjustmentSpacerStyle ? /* @__PURE__ */ React3.createElement("div", { "aria-hidden": true, style: contentInsetEndAdjustmentSpacerStyle }) : null)
+  );
 });
 function useValueListener$(key, callback) {
   const ctx = useStateContext();
@@ -1422,11 +1499,18 @@ function getScrollAdjustAxis(horizontal) {
     y: 1
   };
 }
-function resolveScrollAdjustContentNode(el, contentNode) {
-  if ((contentNode == null ? void 0 : contentNode.isConnected) && contentNode.parentElement === el) {
-    return contentNode;
+function getScrollAdjustTarget(ctx, contentNode) {
+  var _a3, _b, _c;
+  const scrollView = (_a3 = ctx.state) == null ? void 0 : _a3.refScroller.current;
+  const scrollElement = (_c = (_b = scrollView == null ? void 0 : scrollView.getScrollableNode) == null ? void 0 : _b.call(scrollView)) != null ? _c : null;
+  let resolvedContentNode = null;
+  if (scrollElement) {
+    resolvedContentNode = (contentNode == null ? void 0 : contentNode.isConnected) && contentNode.parentElement === scrollElement ? contentNode : scrollElement.querySelector(`:scope > .${LEGEND_LIST_CONTENT_CONTAINER_CLASS}`);
   }
-  return el.querySelector(`:scope > .${LEGEND_LIST_CONTENT_CONTAINER_CLASS}`);
+  return scrollElement ? { contentNode: resolvedContentNode, scrollElement } : null;
+}
+function scrollAdjustBy(el, left, top) {
+  el.scrollBy({ behavior: "auto", left, top });
 }
 function ScrollAdjust() {
   const ctx = useStateContext();
@@ -1435,43 +1519,43 @@ function ScrollAdjust() {
   const resetPaddingBaselineRef = React3.useRef(void 0);
   const contentNodeRef = React3.useRef(null);
   const callback = React3.useCallback(() => {
-    var _a3, _b;
+    var _a3;
     const scrollAdjust = peek$(ctx, "scrollAdjust");
     const scrollAdjustUserOffset = peek$(ctx, "scrollAdjustUserOffset");
     const scrollOffset = (scrollAdjust || 0) + (scrollAdjustUserOffset || 0);
-    const scrollView = (_a3 = ctx.state) == null ? void 0 : _a3.refScroller.current;
-    if (scrollView && scrollOffset !== lastScrollOffsetRef.current) {
-      const scrollDelta = scrollOffset - lastScrollOffsetRef.current;
-      if (scrollDelta !== 0) {
-        const axis = getScrollAdjustAxis(!!ctx.state.props.horizontal);
-        const prevScroll = scrollView.getCurrentScrollOffset();
-        const el = scrollView.getScrollableNode();
-        const contentNode = resolveScrollAdjustContentNode(el, contentNodeRef.current);
+    const scrollDelta = scrollOffset - lastScrollOffsetRef.current;
+    if (scrollDelta !== 0) {
+      const target = getScrollAdjustTarget(ctx, contentNodeRef.current);
+      if (target) {
+        const horizontal = !!ctx.state.props.horizontal;
+        const axis = getScrollAdjustAxis(horizontal);
+        const { contentNode, scrollElement: el } = target;
+        const scrollBy = () => scrollAdjustBy(el, axis.x * scrollDelta, axis.y * scrollDelta);
         contentNodeRef.current = contentNode;
-        const scrollBy = () => scrollView.scrollBy(axis.x * scrollDelta, axis.y * scrollDelta);
-        if (!contentNode) {
-          scrollBy();
-          lastScrollOffsetRef.current = scrollOffset;
-          return;
-        }
-        const totalSize = contentNode[axis.contentSizeKey];
-        const viewportSize = el[axis.viewportSizeKey];
-        const nextScroll = prevScroll + scrollDelta;
-        if (scrollDelta > 0 && !ctx.state.adjustingFromInitialMount && totalSize < nextScroll + viewportSize) {
-          const previousPaddingEnd = (_b = resetPaddingBaselineRef.current) != null ? _b : contentNode.style[axis.paddingEndProp];
-          resetPaddingBaselineRef.current = previousPaddingEnd;
-          const pad = (nextScroll + viewportSize - totalSize) * 2;
-          contentNode.style[axis.paddingEndProp] = `${pad}px`;
-          void contentNode.offsetHeight;
-          scrollBy();
-          if (resetPaddingRafRef.current !== void 0) {
-            cancelAnimationFrame(resetPaddingRafRef.current);
+        if (contentNode) {
+          const prevScroll = horizontal ? el.scrollLeft : el.scrollTop;
+          const totalSize = contentNode[axis.contentSizeKey];
+          const viewportSize = el[axis.viewportSizeKey];
+          const nextScroll = prevScroll + scrollDelta;
+          const needsTemporaryPadding = scrollDelta > 0 && !ctx.state.adjustingFromInitialMount && totalSize < nextScroll + viewportSize;
+          if (needsTemporaryPadding) {
+            const previousPaddingEnd = (_a3 = resetPaddingBaselineRef.current) != null ? _a3 : contentNode.style[axis.paddingEndProp];
+            resetPaddingBaselineRef.current = previousPaddingEnd;
+            const pad = (nextScroll + viewportSize - totalSize) * 2;
+            contentNode.style[axis.paddingEndProp] = `${pad}px`;
+            void contentNode.offsetHeight;
+            scrollBy();
+            if (resetPaddingRafRef.current !== void 0) {
+              cancelAnimationFrame(resetPaddingRafRef.current);
+            }
+            resetPaddingRafRef.current = requestAnimationFrame(() => {
+              resetPaddingRafRef.current = void 0;
+              resetPaddingBaselineRef.current = void 0;
+              contentNode.style[axis.paddingEndProp] = previousPaddingEnd;
+            });
+          } else {
+            scrollBy();
           }
-          resetPaddingRafRef.current = requestAnimationFrame(() => {
-            resetPaddingRafRef.current = void 0;
-            resetPaddingBaselineRef.current = void 0;
-            contentNode.style[axis.paddingEndProp] = previousPaddingEnd;
-          });
         } else {
           scrollBy();
         }
@@ -1782,10 +1866,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;
@@ -1810,19 +1893,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,
@@ -2574,7 +2657,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;
   }
@@ -2646,6 +2729,30 @@ function checkAllSizesKnown(state, indices) {
   });
 }
 
+// src/utils/requestAdjust.ts
+function requestAdjust(ctx, positionDiff, dataChanged) {
+  const state = ctx.state;
+  if (Math.abs(positionDiff) > 0.1) {
+    const doit = () => {
+      {
+        state.scrollAdjustHandler.requestAdjust(positionDiff);
+        if (state.adjustingFromInitialMount) {
+          state.adjustingFromInitialMount--;
+        }
+      }
+    };
+    state.scroll += positionDiff;
+    state.scrollForNextCalculateItemsInView = void 0;
+    const readyToRender = peek$(ctx, "readyToRender");
+    if (readyToRender) {
+      doit();
+    } 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;
@@ -2739,7 +2846,7 @@ function clearBootstrapInitialScrollSession(state) {
     bootstrapInitialScroll.frameHandle = void 0;
   }
   setInitialScrollSession(state, {
-    bootstrap: void 0,
+    bootstrap: null,
     kind: (_a3 = state.initialScrollSession) == null ? void 0 : _a3.kind
   });
 }
@@ -2895,15 +3002,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) {
@@ -2942,7 +3052,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;
@@ -3045,27 +3155,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;
@@ -3272,7 +3401,7 @@ function checkFinishedScrollFallback(ctx) {
       state.timeoutCheckFinishedScrollFallback = setTimeout(checkHasScrolled, delay);
     };
     const checkHasScrolled = () => {
-      var _c;
+      var _c, _d;
       state.timeoutCheckFinishedScrollFallback = void 0;
       const isStillScrollingTo = state.scrollingTo;
       if (isStillScrollingTo) {
@@ -3285,11 +3414,13 @@ function checkFinishedScrollFallback(ctx) {
           isStillScrollingTo
         );
         const completionState = getResolvedScrollCompletionState(ctx, isStillScrollingTo);
-        const canFinishAfterSilentNativeDispatch = silentInitialDispatch && completionState.isAtResolvedTarget && numChecks >= 1;
-        if (shouldFinishZeroTarget || state.hasScrolled || canFinishInitialScrollWithoutNativeProgress || canFinishAfterSilentNativeDispatch || numChecks > maxChecks) {
+        const canFinishAfterSilentNativeDispatch = Platform.OS === "android";
+        const shouldFinishAfterObservedScroll = state.hasScrolled && (!isStillScrollingTo.isInitialScroll || completionState.isAtResolvedTarget);
+        const shouldRetryUnalignedInitialScroll = isStillScrollingTo.isInitialScroll && !completionState.isAtResolvedTarget && numChecks <= maxChecks;
+        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 {
@@ -3384,30 +3515,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 doit = () => {
-      {
-        state.scrollAdjustHandler.requestAdjust(positionDiff);
-        if (state.adjustingFromInitialMount) {
-          state.adjustingFromInitialMount--;
-        }
-      }
-    };
-    state.scroll += positionDiff;
-    state.scrollForNextCalculateItemsInView = void 0;
-    const readyToRender = peek$(ctx, "readyToRender");
-    if (readyToRender) {
-      doit();
-    } 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;
@@ -3681,7 +3788,10 @@ function prepareMVCP(ctx, dataChanged) {
         return;
       }
       if (Math.abs(positionDiff) > MVCP_POSITION_EPSILON) {
-        requestAdjust(ctx, positionDiff);
+        const shouldSkipAdjustForMaintainedEnd = state.maintainingScrollAtEnd && peek$(ctx, "isWithinMaintainScrollAtEndThreshold");
+        if (!shouldSkipAdjustForMaintainedEnd) {
+          requestAdjust(ctx, positionDiff);
+        }
       }
     };
   }
@@ -4300,6 +4410,30 @@ function maybeUpdateViewabilityCallback(ctx, configId, containerId, viewToken) {
 var unstableBatchedUpdates = ReactDOM.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");
@@ -4505,7 +4639,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,
@@ -4552,12 +4686,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;
@@ -4573,9 +4717,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) {
@@ -4594,7 +4741,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,
@@ -4619,21 +4766,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;
@@ -4662,8 +4813,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) {
@@ -4702,7 +4853,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);
       }
     }
@@ -4735,7 +4886,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);
@@ -4744,7 +4895,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);
@@ -4783,7 +4934,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);
@@ -4794,7 +4945,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);
@@ -4818,17 +4969,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);
@@ -4932,21 +5083,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;
@@ -5058,14 +5213,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 (state.lastLayout) {
       if (state.initialScroll) {
         requestAnimationFrame(() => {
@@ -5216,8 +5378,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;
   }
@@ -5355,16 +5517,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) {
@@ -5436,15 +5602,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);
@@ -5495,18 +5653,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);
@@ -5611,12 +5757,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;
@@ -5638,11 +5819,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) {
@@ -5717,6 +5897,7 @@ function createImperativeHandle(ctx) {
       },
       end: state.endNoBuffer,
       endBuffered: state.endBuffered,
+      getAverageItemSizes: () => getAverageItemSizes(state),
       isAtEnd: peek$(ctx, "isAtEnd"),
       isAtStart: peek$(ctx, "isAtStart"),
       isEndReached: state.isEndReached,
@@ -5759,40 +5940,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;
@@ -6056,7 +6231,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     getFixedItemSize,
     getItemType,
     horizontal,
-    initialContainerPoolRatio = 2,
+    initialContainerPoolRatio = 3,
     initialScrollAtEnd = false,
     initialScrollIndex: initialScrollIndexProp,
     initialScrollOffset: initialScrollOffsetProp,
@@ -6097,7 +6272,6 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     stickyIndices: stickyIndicesDeprecated,
     // TODOV3: Remove from v3 release
     style: styleProp,
-    suggestEstimatedItemSize,
     useWindowScroll = false,
     viewabilityConfig,
     viewabilityConfigCallbackPairs,
@@ -6238,7 +6412,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
@@ -6258,7 +6431,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) {
@@ -6313,7 +6486,6 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     stickyPositionComponentInternal,
     stylePaddingBottom: stylePaddingBottomState,
     stylePaddingTop: stylePaddingTopState,
-    suggestEstimatedItemSize: !!suggestEstimatedItemSize,
     useWindowScroll: useWindowScrollResolved
   };
   state.refScroller = refScroller;