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

package/react-native.web.js

@@ -166,7 +166,10 @@ function useSelector$(signalName, selector) {
 }
 
 // src/state/getContentInsetEnd.ts
-function getContentInsetEnd(ctx) {
+function getContentInsetEndAdjustmentEnd(adjustment) {
+  return Math.max(0, adjustment != null ? adjustment : 0);
+}
+function getContentInsetEnd(ctx, contentInsetEndAdjustmentOverride) {
   var _a3, _b;
   const state = ctx.state;
   const { props } = state;
@@ -174,14 +177,21 @@ function getContentInsetEnd(ctx) {
   const contentInset = props.contentInset;
   const baseInset = contentInset != null ? contentInset : state.nativeContentInset;
   const baseEndInset = (horizontal ? baseInset == null ? void 0 : baseInset.right : baseInset == null ? void 0 : baseInset.bottom) || 0;
+  const contentInsetEndAdjustment = getContentInsetEndAdjustmentEnd(
+    contentInsetEndAdjustmentOverride != null ? contentInsetEndAdjustmentOverride : props.contentInsetEndAdjustment
+  );
   const anchoredEndSpaceSize = peek$(ctx, "anchoredEndSpaceSize");
   const anchoredEndInset = ((_a3 = props.anchoredEndSpace) == null ? void 0 : _a3.includeInEndInset) && anchoredEndSpaceSize ? anchoredEndSpaceSize : 0;
   const overrideInset = (_b = state.contentInsetOverride) != null ? _b : void 0;
+  const adjustedBaseEndInset = baseEndInset + contentInsetEndAdjustment;
   if (overrideInset) {
     const mergedInset = { bottom: 0, right: 0, ...baseInset, ...overrideInset };
-    return Math.max((horizontal ? mergedInset.right : mergedInset.bottom) || 0, anchoredEndInset);
+    return Math.max(
+      ((horizontal ? mergedInset.right : mergedInset.bottom) || 0) + contentInsetEndAdjustment,
+      anchoredEndInset
+    );
   }
-  return Math.max(baseEndInset, anchoredEndInset);
+  return Math.max(adjustedBaseEndInset, anchoredEndInset);
 }
 
 // src/state/getContentSize.ts
@@ -682,8 +692,52 @@ function isInMVCPActiveMode(state) {
 }
 
 // src/components/Container.tsx
+function getContainerPositionStyle({
+  columnWrapperStyle,
+  horizontal,
+  hasItemSeparator,
+  numColumns,
+  otherAxisPos,
+  otherAxisSize
+}) {
+  let paddingStyles;
+  if (columnWrapperStyle) {
+    const { columnGap, rowGap, gap } = columnWrapperStyle;
+    if (horizontal) {
+      paddingStyles = {
+        paddingBottom: numColumns > 1 ? (rowGap || gap || 0) / 2 : void 0,
+        paddingRight: columnGap || gap || void 0,
+        paddingTop: numColumns > 1 ? (rowGap || gap || 0) / 2 : void 0
+      };
+    } else {
+      paddingStyles = {
+        paddingBottom: rowGap || gap || void 0,
+        paddingLeft: numColumns > 1 ? (columnGap || gap || 0) / 2 : void 0,
+        paddingRight: numColumns > 1 ? (columnGap || gap || 0) / 2 : void 0
+      };
+    }
+  }
+  return horizontal ? {
+    boxSizing: paddingStyles ? "border-box" : void 0,
+    flexDirection: hasItemSeparator ? "row" : void 0,
+    height: otherAxisSize,
+    left: 0,
+    position: "absolute",
+    top: otherAxisPos,
+    ...paddingStyles || {}
+  } : {
+    boxSizing: paddingStyles ? "border-box" : void 0,
+    left: otherAxisPos,
+    position: "absolute",
+    right: numColumns > 1 ? null : 0,
+    top: 0,
+    width: otherAxisSize,
+    ...paddingStyles || {}
+  };
+}
 var Container = typedMemo(function Container2({
   id,
+  itemKey,
   recycleItems,
   horizontal,
   getRenderedItem: getRenderedItem2,
@@ -695,11 +749,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}`
@@ -720,42 +773,17 @@ var Container = typedMemo(function Container2({
   const resolvedSpan = Math.min(Math.max(span || 1, 1), numColumns);
   const otherAxisPos = numColumns > 1 ? `${(resolvedColumn - 1) / numColumns * 100}%` : 0;
   const otherAxisSize = numColumns > 1 ? `${resolvedSpan / numColumns * 100}%` : void 0;
-  const style = React3.useMemo(() => {
-    let paddingStyles;
-    if (columnWrapperStyle) {
-      const { columnGap, rowGap, gap } = columnWrapperStyle;
-      if (horizontal) {
-        paddingStyles = {
-          paddingBottom: numColumns > 1 ? (rowGap || gap || 0) / 2 : void 0,
-          paddingRight: columnGap || gap || void 0,
-          paddingTop: numColumns > 1 ? (rowGap || gap || 0) / 2 : void 0
-        };
-      } else {
-        paddingStyles = {
-          paddingBottom: rowGap || gap || void 0,
-          paddingLeft: numColumns > 1 ? (columnGap || gap || 0) / 2 : void 0,
-          paddingRight: numColumns > 1 ? (columnGap || gap || 0) / 2 : void 0
-        };
-      }
-    }
-    return horizontal ? {
-      boxSizing: paddingStyles ? "border-box" : void 0,
-      flexDirection: ItemSeparatorComponent ? "row" : void 0,
-      height: otherAxisSize,
-      left: 0,
-      position: "absolute",
-      top: otherAxisPos,
-      ...paddingStyles || {}
-    } : {
-      boxSizing: paddingStyles ? "border-box" : void 0,
-      left: otherAxisPos,
-      position: "absolute",
-      right: numColumns > 1 ? null : 0,
-      top: 0,
-      width: otherAxisSize,
-      ...paddingStyles || {}
-    };
-  }, [horizontal, otherAxisPos, otherAxisSize, columnWrapperStyle, numColumns]);
+  const style = React3.useMemo(
+    () => getContainerPositionStyle({
+      columnWrapperStyle,
+      hasItemSeparator: !!ItemSeparatorComponent,
+      horizontal,
+      numColumns,
+      otherAxisPos,
+      otherAxisSize
+    }),
+    [horizontal, otherAxisPos, otherAxisSize, columnWrapperStyle, numColumns, ItemSeparatorComponent]
+  );
   const renderedItemInfo = React3.useMemo(
     () => itemKey !== void 0 ? getRenderedItem2(itemKey) : null,
     [itemKey, data, extraData]
@@ -842,6 +870,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__namespace.createElement(
+    ContainerComponent,
+    {
+      getRenderedItem: getRenderedItem2,
+      horizontal,
+      ItemSeparatorComponent,
+      id,
+      itemKey,
+      recycleItems,
+      stickyHeaderConfig,
+      updateItemSize: updateItemSize2
+    }
+  );
+}
+var ContainerSlot = typedMemo(function ContainerSlot2(props) {
+  return /* @__PURE__ */ React3__namespace.createElement(ContainerSlotBase, { ...props });
+});
+
 // src/utils/reordering.ts
 var mapFn = (element) => {
   const indexStr = element.getAttribute("data-index");
@@ -961,9 +1022,12 @@ var ContainersInner = typedMemo(function ContainersInner2({ horizontal, numColum
   const ref = React3.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;
@@ -991,12 +1055,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__namespace.createElement(
-        Container,
+        ContainerSlot,
         {
           getRenderedItem: getRenderedItem2,
           horizontal,
@@ -1066,6 +1130,11 @@ function useRafCoalescer(callback) {
   return coalescer;
 }
 
+// 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() {
   if (typeof document === "undefined") {
@@ -1150,6 +1219,22 @@ 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;
+  return Math.max(0, adjustment != null ? adjustment : 0);
+}
 var ListComponentScrollView = React3.forwardRef(function ListComponentScrollView2({
   children,
   style,
@@ -1167,7 +1252,9 @@ var ListComponentScrollView = React3.forwardRef(function ListComponentScrollView
   onLayout,
   ...props
 }, ref) {
+  var _a3, _b, _c;
   const ctx = useStateContext();
+  const [anchoredEndSpaceSize] = useArr$(["anchoredEndSpaceSize"]);
   const scrollRef = React3.useRef(null);
   const contentRef = React3.useRef(null);
   const isWindowScroll = useWindowScroll;
@@ -1229,10 +1316,9 @@ var ListComponentScrollView = React3.forwardRef(function ListComponentScrollView
   React3.useImperativeHandle(ref, () => {
     const api = {
       getBoundingClientRect: () => {
-        var _a3;
-        return (_a3 = scrollRef.current) == null ? void 0 : _a3.getBoundingClientRect();
+        var _a4;
+        return (_a4 = scrollRef.current) == null ? void 0 : _a4.getBoundingClientRect();
       },
-      getContentNode: () => contentRef.current,
       getCurrentScrollOffset,
       getScrollableNode: () => resolveScrollableNode(scrollRef.current, isWindowScroll),
       getScrollEventTarget: () => getScrollTarget(),
@@ -1348,6 +1434,12 @@ var ListComponentScrollView = React3.forwardRef(function ListComponentScrollView
       }
     };
   }, [isWindowScroll, onLayout]);
+  const hiddenScrollIndicatorClassName = !isWindowScroll && (horizontal ? !showsHorizontalScrollIndicator && LEGEND_LIST_SCROLLBAR_X_HIDDEN_CLASS : !showsVerticalScrollIndicator && LEGEND_LIST_SCROLLBAR_Y_HIDDEN_CLASS);
+  React3.useLayoutEffect(() => {
+    if (hiddenScrollIndicatorClassName) {
+      ensureScrollbarHiddenStyle();
+    }
+  }, [hiddenScrollIndicatorClassName]);
   const scrollViewStyle = {
     ...isWindowScroll ? {} : {
       overflow: "auto",
@@ -1358,6 +1450,10 @@ var ListComponentScrollView = React3.forwardRef(function ListComponentScrollView
     },
     ...StyleSheet.flatten(style)
   };
+  const contentInsetEndAdjustment = getContentInsetEndAdjustmentEnd2(ctx);
+  const anchoredEndInset = ((_c = (_b = (_a3 = ctx.state) == null ? void 0 : _a3.props) == null ? void 0 : _b.anchoredEndSpace) == null ? void 0 : _c.includeInEndInset) && anchoredEndSpaceSize ? anchoredEndSpaceSize : 0;
+  const renderedContentInsetEndAdjustment = Math.max(0, contentInsetEndAdjustment - anchoredEndInset);
+  const contentInsetEndAdjustmentSpacerStyle = renderedContentInsetEndAdjustment ? horizontal ? { flexShrink: 0, width: renderedContentInsetEndAdjustment } : { height: renderedContentInsetEndAdjustment } : void 0;
   const contentStyle = {
     display: horizontal ? "flex" : "block",
     flexDirection: horizontal ? "row" : void 0,
@@ -1365,15 +1461,38 @@ var ListComponentScrollView = React3.forwardRef(function ListComponentScrollView
     minWidth: horizontal ? "100%" : void 0,
     ...StyleSheet.flatten(contentContainerStyle)
   };
+  const className = contentContainerClassName ? `${LEGEND_LIST_CONTENT_CONTAINER_CLASS} ${contentContainerClassName}` : LEGEND_LIST_CONTENT_CONTAINER_CLASS;
   const {
     contentContainerClassName: _contentContainerClassName,
     contentInset: _contentInset,
     scrollEventThrottle: _scrollEventThrottle,
     ScrollComponent: _ScrollComponent,
     useWindowScroll: _useWindowScroll,
+    className: scrollViewClassNameProp,
     ...webProps
   } = props;
-  return /* @__PURE__ */ React3__namespace.createElement("div", { ref: scrollRef, ...webProps, style: scrollViewStyle }, refreshControl, /* @__PURE__ */ React3__namespace.createElement("div", { className: contentContainerClassName, ref: contentRef, style: contentStyle }, children));
+  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__namespace.createElement(
+    "div",
+    {
+      className: scrollViewClassName,
+      ref: scrollRef,
+      ...webProps,
+      style: scrollViewStyle
+    },
+    refreshControl,
+    /* @__PURE__ */ React3__namespace.createElement("div", { className, ref: contentRef, style: contentStyle }, children, contentInsetEndAdjustmentSpacerStyle ? /* @__PURE__ */ React3__namespace.createElement("div", { "aria-hidden": true, style: contentInsetEndAdjustmentSpacerStyle }) : null)
+  );
 });
 function useValueListener$(key, callback) {
   const ctx = useStateContext();
@@ -1401,48 +1520,63 @@ function getScrollAdjustAxis(horizontal) {
     y: 1
   };
 }
+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 scrollElement ? { contentNode: resolvedContentNode, scrollElement } : null;
+}
+function scrollAdjustBy(el, left, top) {
+  el.scrollBy({ behavior: "auto", left, top });
+}
 function ScrollAdjust() {
   const ctx = useStateContext();
   const lastScrollOffsetRef = React3__namespace.useRef(0);
   const resetPaddingRafRef = React3__namespace.useRef(void 0);
   const resetPaddingBaselineRef = React3__namespace.useRef(void 0);
+  const contentNodeRef = React3__namespace.useRef(null);
   const callback = React3__namespace.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 contentNode = scrollView.getContentNode();
-        const prevScroll = scrollView.getCurrentScrollOffset();
-        const el = scrollView.getScrollableNode();
-        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);
+    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;
+        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();
         }
@@ -1753,10 +1887,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;
@@ -1781,19 +1914,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,
@@ -2545,7 +2678,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;
   }
@@ -2617,6 +2750,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;
@@ -2710,7 +2867,7 @@ function clearBootstrapInitialScrollSession(state) {
     bootstrapInitialScroll.frameHandle = void 0;
   }
   setInitialScrollSession(state, {
-    bootstrap: void 0,
+    bootstrap: null,
     kind: (_a3 = state.initialScrollSession) == null ? void 0 : _a3.kind
   });
 }
@@ -2866,15 +3023,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) {
@@ -2913,7 +3073,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;
@@ -3016,27 +3176,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;
@@ -3243,7 +3422,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) {
@@ -3256,11 +3435,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 {
@@ -3273,6 +3454,15 @@ function checkFinishedScrollFallback(ctx) {
 }
 
 // src/core/initialScrollLifecycle.ts
+function retargetActiveInitialScrollAtEnd(ctx) {
+  var _a3;
+  const state = ctx.state;
+  const initialScroll = state.initialScroll;
+  if (!initialScroll || state.didFinishInitialScroll || ((_a3 = state.initialScrollSession) == null ? void 0 : _a3.kind) === "offset" || initialScroll.viewPosition !== 1 || state.props.data.length === 0) {
+    return false;
+  }
+  return advanceCurrentInitialScrollSession(ctx, { forceScroll: true });
+}
 function handleInitialScrollLayoutReady(ctx) {
   var _a3;
   if (!ctx.state.initialScroll) {
@@ -3346,30 +3536,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;
@@ -3643,7 +3809,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);
+        }
       }
     };
   }
@@ -4262,6 +4431,30 @@ function maybeUpdateViewabilityCallback(ctx, configId, containerId, viewToken) {
 var unstableBatchedUpdates = ReactDOM__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");
@@ -4467,7 +4660,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,
@@ -4514,12 +4707,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;
@@ -4535,9 +4738,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) {
@@ -4556,7 +4762,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,
@@ -4581,21 +4787,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;
@@ -4624,8 +4834,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) {
@@ -4664,7 +4874,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);
       }
     }
@@ -4697,7 +4907,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);
@@ -4706,7 +4916,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);
@@ -4745,7 +4955,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);
@@ -4756,7 +4966,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);
@@ -4780,17 +4990,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);
@@ -4894,21 +5104,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;
@@ -5020,14 +5234,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(() => {
@@ -5178,8 +5399,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;
   }
@@ -5317,16 +5538,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) {
@@ -5339,6 +5564,22 @@ function maybeUpdateAnchoredEndSpace(ctx) {
   return nextSize;
 }
 
+// src/core/updateContentInsetEndAdjustment.ts
+function updateContentInsetEndAdjustment(ctx, previousContentInsetEndAdjustment) {
+  const state = ctx.state;
+  const previousContentInsetEnd = getContentInsetEnd(ctx, previousContentInsetEndAdjustment);
+  const nextContentInsetEnd = getContentInsetEnd(ctx);
+  const insetDiff = nextContentInsetEnd - previousContentInsetEnd;
+  if (insetDiff !== 0) {
+    const wasWithinEndThreshold = !!peek$(ctx, "isWithinMaintainScrollAtEndThreshold");
+    updateScroll(ctx, state.scroll, true, { markHasScrolled: false });
+    const didRetargetInitialScroll = retargetActiveInitialScrollAtEnd(ctx);
+    if (!didRetargetInitialScroll && wasWithinEndThreshold && (insetDiff > 0)) {
+      requestAdjust(ctx, insetDiff);
+    }
+  }
+}
+
 // src/core/updateItemSize.ts
 function runOrScheduleMVCPRecalculate(ctx) {
   const state = ctx.state;
@@ -5382,15 +5623,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);
@@ -5441,18 +5674,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);
@@ -5557,12 +5778,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;
@@ -5584,11 +5840,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) {
@@ -5663,6 +5918,7 @@ function createImperativeHandle(ctx) {
       },
       end: state.endNoBuffer,
       endBuffered: state.endBuffered,
+      getAverageItemSizes: () => getAverageItemSizes(state),
       isAtEnd: peek$(ctx, "isAtEnd"),
       isAtStart: peek$(ctx, "isAtStart"),
       isEndReached: state.isEndReached,
@@ -5686,8 +5942,14 @@ function createImperativeHandle(ctx) {
       startBuffered: state.startBuffered
     }),
     reportContentInset: (inset) => {
+      var _a3, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
+      const previousInset = state.contentInsetOverride;
       state.contentInsetOverride = inset != null ? inset : void 0;
+      const didChange = ((_a3 = previousInset == null ? void 0 : previousInset.top) != null ? _a3 : 0) !== ((_c = (_b = state.contentInsetOverride) == null ? void 0 : _b.top) != null ? _c : 0) || ((_d = previousInset == null ? void 0 : previousInset.bottom) != null ? _d : 0) !== ((_f = (_e = state.contentInsetOverride) == null ? void 0 : _e.bottom) != null ? _f : 0) || ((_g = previousInset == null ? void 0 : previousInset.left) != null ? _g : 0) !== ((_i = (_h = state.contentInsetOverride) == null ? void 0 : _h.left) != null ? _i : 0) || ((_j = previousInset == null ? void 0 : previousInset.right) != null ? _j : 0) !== ((_l = (_k = state.contentInsetOverride) == null ? void 0 : _k.right) != null ? _l : 0);
       updateScroll(ctx, state.scroll, true, { markHasScrolled: false });
+      if (didChange) {
+        retargetActiveInitialScrollAtEnd(ctx);
+      }
     },
     scrollIndexIntoView: (options) => runScrollWithPromise(() => scrollIndexIntoView(options)),
     scrollItemIntoView: ({ item, ...props }) => runScrollWithPromise(() => {
@@ -5699,40 +5961,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;
@@ -5988,6 +6244,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     data: dataProp = [],
     dataVersion,
     drawDistance = 250,
+    contentInsetEndAdjustment,
     estimatedItemSize = 100,
     estimatedListSize,
     extraData,
@@ -5995,7 +6252,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     getFixedItemSize,
     getItemType,
     horizontal,
-    initialContainerPoolRatio = 2,
+    initialContainerPoolRatio = 3,
     initialScrollAtEnd = false,
     initialScrollIndex: initialScrollIndexProp,
     initialScrollOffset: initialScrollOffsetProp,
@@ -6036,7 +6293,6 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     stickyIndices: stickyIndicesDeprecated,
     // TODOV3: Remove from v3 release
     style: styleProp,
-    suggestEstimatedItemSize,
     useWindowScroll = false,
     viewabilityConfig,
     viewabilityConfigCallbackPairs,
@@ -6097,6 +6353,8 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
   const combinedRef = useCombinedRef(refScroller, refScrollView);
   const keyExtractor = keyExtractorProp != null ? keyExtractorProp : ((_item, index) => index.toString());
   const stickyHeaderIndices = stickyHeaderIndicesProp != null ? stickyHeaderIndicesProp : stickyIndicesDeprecated;
+  const contentInsetEndAdjustmentResolved = contentInsetEndAdjustment ;
+  const previousContentInsetEndAdjustmentRef = React3.useRef(contentInsetEndAdjustmentResolved);
   const alwaysRenderIndices = React3.useMemo(() => {
     const indices = getAlwaysRenderIndices(alwaysRender, dataProp, keyExtractor, anchoredEndSpace == null ? void 0 : anchoredEndSpace.anchorIndex);
     return { arr: indices, set: new Set(indices) };
@@ -6175,7 +6433,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
@@ -6195,7 +6452,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) {
@@ -6216,6 +6473,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     anchoredEndSpace: anchoredEndSpaceResolved,
     animatedProps: animatedPropsInternal,
     contentInset,
+    contentInsetEndAdjustment: contentInsetEndAdjustmentResolved,
     data: dataProp,
     dataVersion,
     drawDistance,
@@ -6249,7 +6507,6 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     stickyPositionComponentInternal,
     stylePaddingBottom: stylePaddingBottomState,
     stylePaddingTop: stylePaddingTopState,
-    suggestEstimatedItemSize: !!suggestEstimatedItemSize,
     useWindowScroll: useWindowScrollResolved
   };
   state.refScroller = refScroller;
@@ -6333,6 +6590,11 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     didAnchoredEndSpaceAnchorIndexChange,
     numColumnsProp
   ]);
+  React3.useLayoutEffect(() => {
+    const previousContentInsetEndAdjustment = previousContentInsetEndAdjustmentRef.current;
+    previousContentInsetEndAdjustmentRef.current = contentInsetEndAdjustmentResolved;
+    updateContentInsetEndAdjustment(ctx, previousContentInsetEndAdjustment);
+  }, [ctx, contentInsetEndAdjustmentResolved]);
   const onLayoutFooter = React3.useCallback(
     (layout) => {
       if (!usesBootstrapInitialScroll) {