@legendapp/list 3.0.6 → 3.1.0

package/react.js

@@ -162,6 +162,7 @@ function StateProvider({ children }) {
     mapViewabilityConfigStates: /* @__PURE__ */ new Map(),
     mapViewabilityValues: /* @__PURE__ */ new Map(),
     positionListeners: /* @__PURE__ */ new Map(),
+    scrollAxisGap: 0,
     state: void 0,
     values: /* @__PURE__ */ new Map([
       ["alignItemsAtEndPadding", 0],
@@ -174,6 +175,7 @@ function StateProvider({ children }) {
       ["isNearEnd", false],
       ["isNearStart", false],
       ["isWithinMaintainScrollAtEndThreshold", false],
+      ["adaptiveRender", "light"],
       ["totalSize", 0],
       ["scrollAdjustPending", 0]
     ]),
@@ -554,6 +556,24 @@ var ContextContainer = React3.createContext(null);
 function useContextContainer() {
   return React3.useContext(ContextContainer);
 }
+function useAdaptiveRender() {
+  const [mode] = useArr$(["adaptiveRender"]);
+  return mode;
+}
+function useAdaptiveRenderChange(callback) {
+  const ctx = useStateContext();
+  const callbackRef = React3.useRef(callback);
+  callbackRef.current = callback;
+  React3.useLayoutEffect(() => {
+    let mode = peek$(ctx, "adaptiveRender");
+    return listen$(ctx, "adaptiveRender", (nextMode) => {
+      if (mode !== nextMode) {
+        mode = nextMode;
+        callbackRef.current(nextMode);
+      }
+    });
+  }, [ctx]);
+}
 function useViewability(callback, configId) {
   const ctx = useStateContext();
   const containerContext = useContextContainer();
@@ -823,6 +843,7 @@ function isInMVCPActiveMode(state) {
 // src/components/Container.tsx
 function getContainerPositionStyle({
   columnWrapperStyle,
+  contentContainerAlignItems,
   horizontal,
   hasItemSeparator,
   isHorizontalRTLList,
@@ -848,13 +869,14 @@ function getContainerPositionStyle({
     }
   }
   return horizontal ? {
+    bottom: contentContainerAlignItems === "flex-end" && numColumns === 1 ? 0 : void 0,
     boxSizing: paddingStyles ? "border-box" : void 0,
     direction: isHorizontalRTLList && Platform.OS === "web" ? "ltr" : void 0,
     flexDirection: hasItemSeparator ? "row" : void 0,
     height: otherAxisSize,
     left: 0,
     position: "absolute",
-    top: otherAxisPos,
+    top: contentContainerAlignItems === "flex-end" && numColumns === 1 ? void 0 : otherAxisPos,
     ...paddingStyles || {}
   } : {
     boxSizing: paddingStyles ? "border-box" : void 0,
@@ -908,6 +930,7 @@ var Container = typedMemo(function Container2({
   const style = React3.useMemo(
     () => getContainerPositionStyle({
       columnWrapperStyle,
+      contentContainerAlignItems: ctx.state.props.contentContainerAlignItems,
       hasItemSeparator: !!ItemSeparatorComponent,
       horizontal,
       isHorizontalRTLList,
@@ -921,6 +944,7 @@ var Container = typedMemo(function Container2({
       otherAxisPos,
       otherAxisSize,
       columnWrapperStyle,
+      ctx.state.props.contentContainerAlignItems,
       numColumns,
       ItemSeparatorComponent
     ]
@@ -1636,7 +1660,12 @@ var ListComponentScrollView = React3.forwardRef(function ListComponentScrollView
       WebkitOverflowScrolling: "touch"
       // iOS momentum scrolling
     },
-    ...StyleSheet.flatten(style)
+    ...StyleSheet.flatten(style),
+    ...maintainVisibleContentPosition ? {
+      // Chrome's native scroll anchoring can apply after LegendList's MVCP adjustment,
+      // causing the same header/item-size delta to be compensated twice.
+      overflowAnchor: "none"
+    } : {}
   };
   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;
@@ -1647,7 +1676,10 @@ var ListComponentScrollView = React3.forwardRef(function ListComponentScrollView
     flexDirection: horizontal ? "row" : void 0,
     minHeight: horizontal ? void 0 : "100%",
     minWidth: horizontal ? "100%" : void 0,
-    ...StyleSheet.flatten(contentContainerStyle)
+    ...StyleSheet.flatten(contentContainerStyle),
+    ...maintainVisibleContentPosition ? {
+      overflowAnchor: "none"
+    } : {}
   };
   const className = contentContainerClassName ? `${LEGEND_LIST_CONTENT_CONTAINER_CLASS} ${contentContainerClassName}` : LEGEND_LIST_CONTENT_CONTAINER_CLASS;
   const {
@@ -1750,6 +1782,7 @@ function scrollAdjustBy(el, left, top) {
 function ScrollAdjust() {
   const ctx = useStateContext();
   const lastScrollOffsetRef = React3__namespace.useRef(0);
+  const lastScrollAdjustUserOffsetRef = React3__namespace.useRef(0);
   const resetPaddingRafRef = React3__namespace.useRef(void 0);
   const resetPaddingBaselineRef = React3__namespace.useRef(void 0);
   const contentNodeRef = React3__namespace.useRef(null);
@@ -1758,20 +1791,24 @@ function ScrollAdjust() {
     const scrollAdjust = peek$(ctx, "scrollAdjust");
     const scrollAdjustUserOffset = peek$(ctx, "scrollAdjustUserOffset");
     const scrollOffset = (scrollAdjust || 0) + (scrollAdjustUserOffset || 0);
-    const scrollDelta = scrollOffset - lastScrollOffsetRef.current;
-    if (scrollDelta !== 0) {
+    const signalScrollDelta = scrollOffset - lastScrollOffsetRef.current;
+    if (signalScrollDelta !== 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 currentScroll = horizontal ? el.scrollLeft : el.scrollTop;
+        const userOffsetDelta = (scrollAdjustUserOffset || 0) - lastScrollAdjustUserOffsetRef.current;
+        const intendedScroll = userOffsetDelta !== 0 ? currentScroll + userOffsetDelta : ctx.state.scroll;
+        const scrollDelta = intendedScroll - currentScroll;
+        const shouldScroll = Math.abs(scrollDelta) > 0.01;
         const scrollBy = () => scrollAdjustBy(el, axis.x * scrollDelta, axis.y * scrollDelta);
         contentNodeRef.current = contentNode;
-        if (contentNode) {
-          const prevScroll = horizontal ? el.scrollLeft : el.scrollTop;
+        if (shouldScroll && contentNode) {
           const totalSize = contentNode[axis.contentSizeKey];
           const viewportSize = el[axis.viewportSizeKey];
-          const nextScroll = prevScroll + scrollDelta;
+          const nextScroll = currentScroll + scrollDelta;
           const needsTemporaryPadding = scrollDelta > 0 && !ctx.state.adjustingFromInitialMount && totalSize < nextScroll + viewportSize;
           if (needsTemporaryPadding) {
             const previousPaddingEnd = (_a3 = resetPaddingBaselineRef.current) != null ? _a3 : contentNode.style[axis.paddingEndProp];
@@ -1791,11 +1828,12 @@ function ScrollAdjust() {
           } else {
             scrollBy();
           }
-        } else {
+        } else if (shouldScroll) {
           scrollBy();
         }
       }
       lastScrollOffsetRef.current = scrollOffset;
+      lastScrollAdjustUserOffsetRef.current = scrollAdjustUserOffset || 0;
     }
   }, [ctx]);
   useValueListener$("scrollAdjust", callback);
@@ -1817,7 +1855,7 @@ function WebAnchoredEndSpace({ horizontal }) {
   return /* @__PURE__ */ React3__namespace.createElement("div", { style }, null);
 }
 
-// src/core/updateContentMetrics.ts
+// src/core/updateContentMetricsState.ts
 function getRawContentLength(ctx) {
   var _a3, _b, _c;
   const { state, values } = ctx;
@@ -1828,233 +1866,41 @@ function getAlignItemsAtEndPadding(ctx) {
   const shouldPad = !!state.props.alignItemsAtEndPaddingEnabled && !state.props.horizontal && state.props.data.length > 0 && state.scrollLength > 0;
   return shouldPad ? Math.max(0, state.scrollLength - getRawContentLength(ctx) - getContentInsetEnd(ctx)) : 0;
 }
-function updateContentMetrics(ctx) {
+function updateContentMetricsState(ctx) {
+  const previousPadding = peek$(ctx, "alignItemsAtEndPadding") || 0;
   const nextPadding = getAlignItemsAtEndPadding(ctx);
-  if (peek$(ctx, "alignItemsAtEndPadding") !== nextPadding) {
+  if (previousPadding !== nextPadding) {
     set$(ctx, "alignItemsAtEndPadding", nextPadding);
   }
 }
-function setContentLengthSignal(ctx, signalName, size) {
-  if (peek$(ctx, signalName) !== size) {
-    set$(ctx, signalName, size);
-    updateContentMetrics(ctx);
-  }
-}
-function setHeaderSize(ctx, size) {
-  setContentLengthSignal(ctx, "headerSize", size);
-}
-function setFooterSize(ctx, size) {
-  setContentLengthSignal(ctx, "footerSize", size);
-}
-function areInsetsEqual(left, right) {
-  var _a3, _b, _c, _d, _e, _f, _g, _h;
-  return ((_a3 = left == null ? void 0 : left.top) != null ? _a3 : 0) === ((_b = right == null ? void 0 : right.top) != null ? _b : 0) && ((_c = left == null ? void 0 : left.bottom) != null ? _c : 0) === ((_d = right == null ? void 0 : right.bottom) != null ? _d : 0) && ((_e = left == null ? void 0 : left.left) != null ? _e : 0) === ((_f = right == null ? void 0 : right.left) != null ? _f : 0) && ((_g = left == null ? void 0 : left.right) != null ? _g : 0) === ((_h = right == null ? void 0 : right.right) != null ? _h : 0);
-}
-function setContentInsetOverride(ctx, inset) {
-  const { state } = ctx;
-  const previousInset = state.contentInsetOverride;
-  const nextInset = inset != null ? inset : void 0;
-  const didChange = !areInsetsEqual(previousInset, nextInset);
-  state.contentInsetOverride = nextInset;
-  if (didChange) {
-    updateContentMetrics(ctx);
-  }
-  return didChange;
-}
-function useStableRenderComponent(renderComponent, mapProps) {
-  const renderComponentRef = useLatestRef(renderComponent);
-  const mapPropsRef = useLatestRef(mapProps);
-  return React3__namespace.useMemo(
-    () => React3__namespace.forwardRef(
-      (props, ref) => {
-        var _a3, _b;
-        return (_b = (_a3 = renderComponentRef.current) == null ? void 0 : _a3.call(renderComponentRef, mapPropsRef.current(props, ref))) != null ? _b : null;
-      }
-    ),
-    [mapPropsRef, renderComponentRef]
-  );
-}
-var LayoutView = ({ onLayoutChange, refView, children, ...rest }) => {
-  const localRef = React3.useRef(null);
-  const ref = refView != null ? refView : localRef;
-  useOnLayoutSync({ onLayoutChange, ref });
-  return /* @__PURE__ */ React3__namespace.createElement("div", { ...rest, ref }, children);
-};
 
-// src/components/ListComponent.tsx
-var ListComponent = typedMemo(function ListComponent2({
-  canRender,
-  style,
-  contentContainerStyle,
-  horizontal,
-  initialContentOffset,
-  recycleItems,
-  ItemSeparatorComponent,
-  alignItemsAtEnd: _alignItemsAtEnd,
-  onScroll: onScroll2,
-  onLayout,
-  ListHeaderComponent,
-  ListHeaderComponentStyle,
-  ListFooterComponent,
-  ListFooterComponentStyle,
-  ListEmptyComponent,
-  getRenderedItem: getRenderedItem2,
-  updateItemSize: updateItemSize2,
-  refScrollView,
-  renderScrollComponent,
-  onLayoutFooter,
-  scrollAdjustHandler,
-  snapToIndices,
-  stickyHeaderConfig,
-  stickyHeaderIndices,
-  useWindowScroll = false,
-  ...rest
-}) {
-  const ctx = useStateContext();
-  const maintainVisibleContentPosition = ctx.state.props.maintainVisibleContentPosition;
-  const [alignItemsAtEndPadding = 0, otherAxisSize = 0] = useArr$(["alignItemsAtEndPadding", "otherAxisSize"]);
-  const autoOtherAxisStyle = getAutoOtherAxisStyle({
-    horizontal,
-    needsOtherAxisSize: ctx.state.needsOtherAxisSize,
-    otherAxisSize
-  });
-  const CustomScrollComponent = useStableRenderComponent(
-    renderScrollComponent,
-    (props, ref) => ({ ...props, ref })
-  );
-  const ScrollComponent = renderScrollComponent ? CustomScrollComponent : ListComponentScrollView;
-  const SnapOrScroll = snapToIndices ? SnapWrapper : ScrollComponent;
-  React3.useLayoutEffect(() => {
-    if (!ListHeaderComponent) {
-      setHeaderSize(ctx, 0);
-    }
-    if (!ListFooterComponent) {
-      setFooterSize(ctx, 0);
+// src/core/addTotalSize.ts
+function addTotalSize(ctx, key, add, notifyTotalSize = true) {
+  const state = ctx.state;
+  const prevTotalSize = state.totalSize;
+  let totalSize = state.totalSize;
+  if (key === null) {
+    totalSize = add;
+    if (state.timeoutSetPaddingTop) {
+      clearTimeout(state.timeoutSetPaddingTop);
+      state.timeoutSetPaddingTop = void 0;
     }
-  }, [ListHeaderComponent, ListFooterComponent, ctx]);
-  const onLayoutHeader = React3.useCallback(
-    (rect) => {
-      const size = rect[horizontal ? "width" : "height"];
-      setHeaderSize(ctx, size);
-    },
-    [ctx, horizontal]
-  );
-  const onLayoutFooterInternal = React3.useCallback(
-    (rect, fromLayoutEffect) => {
-      const size = rect[horizontal ? "width" : "height"];
-      setFooterSize(ctx, size);
-      onLayoutFooter == null ? void 0 : onLayoutFooter(rect, fromLayoutEffect);
-    },
-    [ctx, horizontal, onLayoutFooter]
-  );
-  return /* @__PURE__ */ React3__namespace.createElement(
-    SnapOrScroll,
+  } else {
+    totalSize += add;
+  }
+  if (prevTotalSize !== totalSize) {
     {
-      ...rest,
-      ...ScrollComponent === ListComponentScrollView ? { useWindowScroll } : {},
-      contentContainerStyle: [
-        horizontal ? {
-          height: "100%"
-        } : {},
-        contentContainerStyle
-      ],
-      contentOffset: initialContentOffset !== void 0 ? horizontal ? { x: initialContentOffset, y: 0 } : { x: 0, y: initialContentOffset } : void 0,
-      horizontal,
-      maintainVisibleContentPosition: maintainVisibleContentPosition.size || maintainVisibleContentPosition.data ? { minIndexForVisible: 0 } : void 0,
-      onLayout,
-      onScroll: onScroll2,
-      ref: refScrollView,
-      ScrollComponent: snapToIndices ? ScrollComponent : void 0,
-      style: autoOtherAxisStyle ? [autoOtherAxisStyle, style] : style
-    },
-    /* @__PURE__ */ React3__namespace.createElement(ScrollAdjust, null),
-    ListHeaderComponent && /* @__PURE__ */ React3__namespace.createElement(LayoutView, { onLayoutChange: onLayoutHeader, style: ListHeaderComponentStyle }, getComponent(ListHeaderComponent)),
-    ListEmptyComponent && getComponent(ListEmptyComponent),
-    alignItemsAtEndPadding > 0 && /* @__PURE__ */ React3__namespace.createElement(
-      View,
-      {
-        style: horizontal ? { flexShrink: 0, width: alignItemsAtEndPadding } : { flexShrink: 0, height: alignItemsAtEndPadding }
-      },
-      null
-    ),
-    canRender && !ListEmptyComponent && /* @__PURE__ */ React3__namespace.createElement(
-      Containers,
-      {
-        getRenderedItem: getRenderedItem2,
-        horizontal,
-        ItemSeparatorComponent,
-        recycleItems,
-        stickyHeaderConfig,
-        updateItemSize: updateItemSize2
+      state.pendingTotalSize = void 0;
+      state.totalSize = totalSize;
+      if (notifyTotalSize) {
+        set$(ctx, "totalSize", totalSize);
       }
-    ),
-    ListFooterComponent && /* @__PURE__ */ React3__namespace.createElement(LayoutView, { onLayoutChange: onLayoutFooterInternal, style: ListFooterComponentStyle }, getComponent(ListFooterComponent)),
-    /* @__PURE__ */ React3__namespace.createElement(WebAnchoredEndSpace, { horizontal }),
-    IS_DEV && ENABLE_DEVMODE
-  );
-});
-var WEB_UNBOUNDED_HEIGHT_MIN_DATA_LENGTH = 100;
-var WEB_UNBOUNDED_HEIGHT_CONTAINER_RATIO = 0.9;
-var WEB_UNBOUNDED_HEIGHT_VIEWPORT_RATIO = 0.9;
-function useDevChecksImpl(props) {
-  const ctx = useStateContext();
-  const { childrenMode, keyExtractor, renderScrollComponent, useWindowScroll } = props;
-  React3.useEffect(() => {
-    if (useWindowScroll && renderScrollComponent) {
-      warnDevOnce(
-        "useWindowScrollRenderScrollComponent",
-        "useWindowScroll is not supported when renderScrollComponent is provided."
-      );
-    }
-  }, [renderScrollComponent, useWindowScroll]);
-  React3.useEffect(() => {
-    if (!keyExtractor && !ctx.state.isFirst && ctx.state.didDataChange && !childrenMode) {
-      warnDevOnce(
-        "keyExtractor",
-        "Changing data without a keyExtractor can cause slow performance and resetting scroll. If your list data can change you should use a keyExtractor with a unique id for best performance and behavior."
-      );
-    }
-  }, [childrenMode, ctx, keyExtractor]);
-  React3.useEffect(() => {
-    const state = ctx.state;
-    const dataLength = state.props.data.length;
-    const useWindowScrollResolved = state.props.useWindowScroll;
-    if (useWindowScrollResolved || dataLength < WEB_UNBOUNDED_HEIGHT_MIN_DATA_LENGTH) {
-      return;
+      updateContentMetricsState(ctx);
     }
-    const warnIfUnboundedOuterSize = () => {
-      const readyToRender = peek$(ctx, "readyToRender");
-      const numContainers = peek$(ctx, "numContainers") || 0;
-      const totalSize = peek$(ctx, "totalSize") || 0;
-      const scrollLength = ctx.state.scrollLength || 0;
-      if (!readyToRender || totalSize <= 0 || scrollLength <= 0) {
-        return;
-      }
-      const rendersAlmostEverything = numContainers >= Math.ceil(dataLength * WEB_UNBOUNDED_HEIGHT_CONTAINER_RATIO);
-      const viewportMatchesContent = scrollLength >= totalSize * WEB_UNBOUNDED_HEIGHT_VIEWPORT_RATIO;
-      if (rendersAlmostEverything && viewportMatchesContent) {
-        warnDevOnce(
-          "webUnboundedOuterSize",
-          "LegendList appears to have an unbounded outer height on web, so virtualization is effectively disabled. Set a bounded height or flex: 1 on the list container, or use useWindowScroll."
-        );
-      }
-    };
-    warnIfUnboundedOuterSize();
-    const unsubscribe = [
-      listen$(ctx, "numContainers", warnIfUnboundedOuterSize),
-      listen$(ctx, "readyToRender", warnIfUnboundedOuterSize),
-      listen$(ctx, "totalSize", warnIfUnboundedOuterSize)
-    ];
-    return () => {
-      for (const unsub of unsubscribe) {
-        unsub();
-      }
-    };
-  }, [ctx]);
-}
-function useDevChecksNoop(_props) {
+  } else if (notifyTotalSize && ctx.values.get("totalSize") !== totalSize) {
+    set$(ctx, "totalSize", totalSize);
+  }
 }
-var useDevChecks = IS_DEV ? useDevChecksImpl : useDevChecksNoop;
 
 // src/core/deferredPublicOnScroll.ts
 function withResolvedContentOffset(state, event, resolvedOffset) {
@@ -2367,6 +2213,66 @@ function recalculateSettledScroll(ctx) {
   checkThresholds(ctx);
 }
 
+// src/core/adaptiveRender.ts
+var DEFAULT_ENTER_VELOCITY = 4;
+var DEFAULT_EXIT_VELOCITY = 1;
+var DEFAULT_EXIT_DELAY = 1e3;
+function scheduleAdaptiveRenderExit(ctx, exitDelay) {
+  const state = ctx.state;
+  const previousTimeout = state.timeoutAdaptiveRender;
+  if (previousTimeout !== void 0) {
+    clearTimeout(previousTimeout);
+    state.timeouts.delete(previousTimeout);
+    state.timeoutAdaptiveRender = void 0;
+  }
+  if (exitDelay <= 0) {
+    setAdaptiveRender(ctx, "normal");
+  } else {
+    const timeout = setTimeout(() => {
+      state.timeouts.delete(timeout);
+      state.timeoutAdaptiveRender = void 0;
+      setAdaptiveRender(ctx, "normal");
+    }, exitDelay);
+    state.timeoutAdaptiveRender = timeout;
+    state.timeouts.add(timeout);
+  }
+}
+function setAdaptiveRender(ctx, mode) {
+  var _a3, _b;
+  const previousMode = peek$(ctx, "adaptiveRender");
+  if (previousMode !== mode) {
+    set$(ctx, "adaptiveRender", mode);
+    (_b = (_a3 = ctx.state.props.adaptiveRender) == null ? void 0 : _a3.onChange) == null ? void 0 : _b.call(_a3, mode);
+  }
+}
+function updateAdaptiveRender(ctx, scrollVelocity) {
+  var _a3, _b, _c;
+  const state = ctx.state;
+  const adaptiveRender = state.props.adaptiveRender;
+  const enterVelocity = (_a3 = adaptiveRender == null ? void 0 : adaptiveRender.enterVelocity) != null ? _a3 : DEFAULT_ENTER_VELOCITY;
+  const exitVelocity = (_b = adaptiveRender == null ? void 0 : adaptiveRender.exitVelocity) != null ? _b : DEFAULT_EXIT_VELOCITY;
+  const exitDelay = (_c = adaptiveRender == null ? void 0 : adaptiveRender.exitDelay) != null ? _c : DEFAULT_EXIT_DELAY;
+  const currentMode = peek$(ctx, "adaptiveRender");
+  const threshold = currentMode === "light" ? exitVelocity : enterVelocity;
+  const nextMode = Math.abs(scrollVelocity) > threshold ? "light" : "normal";
+  const previousMode = state.timeoutAdaptiveRender !== void 0 ? "normal" : currentMode;
+  if (nextMode !== previousMode) {
+    if (nextMode === "light") {
+      setAdaptiveRender(ctx, "light");
+      scheduleAdaptiveRenderExit(ctx, exitDelay);
+    } else if (currentMode === "light") {
+      scheduleAdaptiveRenderExit(ctx, exitDelay);
+    }
+  }
+}
+
+// src/utils/getEffectiveDrawDistance.ts
+var INITIAL_DRAW_DISTANCE = 100;
+function getEffectiveDrawDistance(ctx) {
+  const drawDistance = ctx.state.props.drawDistance;
+  return peek$(ctx, "readyToRender") ? drawDistance : Math.min(drawDistance, INITIAL_DRAW_DISTANCE);
+}
+
 // src/utils/setInitialRenderState.ts
 function setInitialRenderState(ctx, {
   didLayout,
@@ -2386,8 +2292,15 @@ function setInitialRenderState(ctx, {
   const isReadyToRender = Boolean(state.didContainersLayout && state.didFinishInitialScroll);
   if (isReadyToRender && !peek$(ctx, "readyToRender")) {
     set$(ctx, "readyToRender", true);
-    if (onLoad) {
-      onLoad({ elapsedTimeInMs: Date.now() - loadStartTime });
+    setAdaptiveRender(ctx, "normal");
+    if (state.props.drawDistance > INITIAL_DRAW_DISTANCE) {
+      requestAnimationFrame(() => {
+        var _a3;
+        (_a3 = state.triggerCalculateItemsInView) == null ? void 0 : _a3.call(state);
+      });
+    }
+    if (onLoad) {
+      onLoad({ elapsedTimeInMs: Date.now() - loadStartTime });
     }
   }
 }
@@ -2460,200 +2373,6 @@ function finishInitialScroll(ctx, options) {
   complete();
 }
 
-// src/core/calculateOffsetForIndex.ts
-function calculateOffsetForIndex(ctx, index) {
-  const state = ctx.state;
-  return index !== void 0 ? state.positions[index] || 0 : 0;
-}
-
-// src/core/getTopOffsetAdjustment.ts
-function getTopOffsetAdjustment(ctx) {
-  return (peek$(ctx, "stylePaddingTop") || 0) + (peek$(ctx, "alignItemsAtEndPadding") || 0) + (peek$(ctx, "headerSize") || 0);
-}
-
-// src/utils/getId.ts
-function getId(state, index) {
-  const { data, keyExtractor } = state.props;
-  if (!data) {
-    return "";
-  }
-  const ret = index < data.length ? keyExtractor ? keyExtractor(data[index], index) : index : null;
-  const id = ret;
-  state.idCache[index] = id;
-  return id;
-}
-
-// src/core/addTotalSize.ts
-function addTotalSize(ctx, key, add, notifyTotalSize = true) {
-  const state = ctx.state;
-  const prevTotalSize = state.totalSize;
-  let totalSize = state.totalSize;
-  if (key === null) {
-    totalSize = add;
-    if (state.timeoutSetPaddingTop) {
-      clearTimeout(state.timeoutSetPaddingTop);
-      state.timeoutSetPaddingTop = void 0;
-    }
-  } else {
-    totalSize += add;
-  }
-  if (prevTotalSize !== totalSize) {
-    {
-      state.pendingTotalSize = void 0;
-      state.totalSize = totalSize;
-      if (notifyTotalSize) {
-        set$(ctx, "totalSize", totalSize);
-      }
-      updateContentMetrics(ctx);
-    }
-  } else if (notifyTotalSize && ctx.values.get("totalSize") !== totalSize) {
-    set$(ctx, "totalSize", totalSize);
-  }
-}
-
-// src/core/setSize.ts
-function setSize(ctx, itemKey, size, notifyTotalSize = true) {
-  const state = ctx.state;
-  const { sizes } = state;
-  const previousSize = sizes.get(itemKey);
-  const diff = previousSize !== void 0 ? size - previousSize : size;
-  if (diff !== 0) {
-    addTotalSize(ctx, itemKey, diff, notifyTotalSize);
-  }
-  sizes.set(itemKey, size);
-}
-
-// src/utils/getItemSize.ts
-function getKnownOrFixedSize(ctx, key, index, data, resolved) {
-  var _a3, _b;
-  const state = ctx.state;
-  const { getFixedItemSize, getItemType } = state.props;
-  let size = key ? state.sizesKnown.get(key) : void 0;
-  if (size === void 0 && key && getFixedItemSize) {
-    const itemType = (_b = resolved == null ? void 0 : resolved.itemType) != null ? _b : getItemType ? (_a3 = getItemType(data, index)) != null ? _a3 : "" : "";
-    size = (resolved == null ? void 0 : resolved.didResolveFixedItemSize) ? resolved.fixedItemSize : getFixedItemSize(data, index, itemType);
-    if (size !== void 0) {
-      state.sizesKnown.set(key, size);
-    }
-  }
-  return size;
-}
-function getKnownOrFixedItemSize(ctx, index) {
-  const key = getId(ctx.state, index);
-  return getKnownOrFixedSize(ctx, key, index, ctx.state.props.data[index]);
-}
-function areKnownOrFixedItemSizesAvailable(ctx, startIndex, endIndex) {
-  for (let index = startIndex; index <= endIndex; index++) {
-    if (getKnownOrFixedItemSize(ctx, index) === void 0) {
-      return false;
-    }
-  }
-  return true;
-}
-function getItemSize(ctx, key, index, data, useAverageSize, preferCachedSize, notifyTotalSize, resolved) {
-  var _a3, _b, _c, _d;
-  const state = ctx.state;
-  const {
-    sizes,
-    averageSizes,
-    props: { estimatedItemSize, getItemType },
-    scrollingTo
-  } = state;
-  const sizeKnown = state.sizesKnown.get(key);
-  if (sizeKnown !== void 0) {
-    return sizeKnown;
-  }
-  let size;
-  const renderedSize = sizes.get(key);
-  if (preferCachedSize) {
-    if (renderedSize !== void 0) {
-      return renderedSize;
-    }
-  }
-  size = getKnownOrFixedSize(ctx, key, index, data, resolved);
-  if (size !== void 0) {
-    setSize(ctx, key, size, notifyTotalSize);
-    return size;
-  }
-  const itemType = (_b = resolved == null ? void 0 : resolved.itemType) != null ? _b : getItemType ? (_a3 = getItemType(data, index)) != null ? _a3 : "" : "";
-  if (useAverageSize && !scrollingTo) {
-    const averageSizeForType = (_c = averageSizes[itemType]) == null ? void 0 : _c.avg;
-    if (averageSizeForType !== void 0) {
-      size = roundSize(averageSizeForType);
-    }
-  }
-  if (size === void 0 && renderedSize !== void 0) {
-    return renderedSize;
-  }
-  if (size === void 0 && useAverageSize && scrollingTo) {
-    const averageSizeForType = (_d = scrollingTo.averageSizeSnapshot) == null ? void 0 : _d[itemType];
-    if (averageSizeForType !== void 0) {
-      size = roundSize(averageSizeForType);
-    }
-  }
-  if (size === void 0) {
-    size = estimatedItemSize;
-  }
-  setSize(ctx, key, size, notifyTotalSize);
-  return size;
-}
-function getItemSizeAtIndex(ctx, index) {
-  if (index === void 0 || index < 0) {
-    return void 0;
-  }
-  const targetId = getId(ctx.state, index);
-  return getItemSize(ctx, targetId, index, ctx.state.props.data[index]);
-}
-
-// src/core/calculateOffsetWithOffsetPosition.ts
-function calculateOffsetWithOffsetPosition(ctx, offsetParam, params) {
-  var _a3;
-  const state = ctx.state;
-  const { index, viewOffset, viewPosition } = params;
-  let offset = offsetParam;
-  if (viewOffset) {
-    offset -= viewOffset;
-  }
-  if (index !== void 0) {
-    const topOffsetAdjustment = getTopOffsetAdjustment(ctx);
-    if (topOffsetAdjustment) {
-      offset += topOffsetAdjustment;
-    }
-  }
-  if (viewPosition !== void 0 && index !== void 0) {
-    const dataLength = state.props.data.length;
-    if (dataLength === 0) {
-      return offset;
-    }
-    const isOutOfBounds = index < 0 || index >= dataLength;
-    const fallbackEstimatedSize = (_a3 = state.props.estimatedItemSize) != null ? _a3 : 0;
-    const itemSize = isOutOfBounds ? fallbackEstimatedSize : getItemSize(ctx, getId(state, index), index, state.props.data[index]);
-    const trailingInset = getContentInsetEnd(ctx);
-    offset -= viewPosition * (state.scrollLength - trailingInset - itemSize);
-    if (!isOutOfBounds && index === state.props.data.length - 1) {
-      const footerSize = peek$(ctx, "footerSize") || 0;
-      offset += footerSize;
-    }
-  }
-  return offset;
-}
-
-// src/core/clampScrollOffset.ts
-function clampScrollOffset(ctx, offset, scrollTarget) {
-  const state = ctx.state;
-  const contentSize = getContentSize(ctx);
-  let clampedOffset = offset;
-  if (Number.isFinite(contentSize) && Number.isFinite(state.scrollLength) && (Platform.OS !== "android")) {
-    const baseMaxOffset = Math.max(0, contentSize - state.scrollLength);
-    const viewOffset = scrollTarget == null ? void 0 : scrollTarget.viewOffset;
-    const extraEndOffset = typeof viewOffset === "number" && viewOffset < 0 ? -viewOffset : 0;
-    const maxOffset = baseMaxOffset + extraEndOffset;
-    clampedOffset = Math.min(offset, maxOffset);
-  }
-  clampedOffset = Math.max(0, clampedOffset);
-  return clampedOffset;
-}
-
 // src/core/finishScrollTo.ts
 function finishScrollTo(ctx) {
   var _a3, _b;
@@ -2730,50 +2449,491 @@ function listenForScrollEnd(ctx, params) {
     finishScrollTo(ctx);
     return;
   }
-  const supportsScrollEnd = "onscrollend" in target;
-  let idleTimeout;
-  let settled = false;
-  const targetToken = ctx.state.scrollingTo;
-  const maxTimeout = setTimeout(() => finish("max"), SCROLL_END_MAX_MS);
-  const cleanup = () => {
-    target.removeEventListener("scroll", onScroll2);
-    if (supportsScrollEnd) {
-      target.removeEventListener("scrollend", onScrollEnd);
+  const supportsScrollEnd = "onscrollend" in target;
+  let idleTimeout;
+  let settled = false;
+  const targetToken = ctx.state.scrollingTo;
+  const maxTimeout = setTimeout(() => finish("max"), SCROLL_END_MAX_MS);
+  const cleanup = () => {
+    target.removeEventListener("scroll", onScroll2);
+    if (supportsScrollEnd) {
+      target.removeEventListener("scrollend", onScrollEnd);
+    }
+    if (idleTimeout) {
+      clearTimeout(idleTimeout);
+    }
+    clearTimeout(maxTimeout);
+  };
+  const finish = (reason) => {
+    if (settled) return;
+    if (targetToken !== ctx.state.scrollingTo) {
+      settled = true;
+      cleanup();
+      return;
+    }
+    const currentOffset = readOffset();
+    const isNearTarget = Math.abs(currentOffset - targetOffset) <= SCROLL_END_TARGET_EPSILON;
+    if (reason === "scrollend" && !isNearTarget) {
+      return;
+    }
+    settled = true;
+    cleanup();
+    finishScrollTo(ctx);
+  };
+  const onScroll2 = () => {
+    if (idleTimeout) {
+      clearTimeout(idleTimeout);
+    }
+    idleTimeout = setTimeout(() => finish("idle"), SCROLL_END_IDLE_MS);
+  };
+  const onScrollEnd = () => finish("scrollend");
+  target.addEventListener("scroll", onScroll2);
+  if (supportsScrollEnd) {
+    target.addEventListener("scrollend", onScrollEnd);
+  } else {
+    idleTimeout = setTimeout(() => finish("idle"), SMOOTH_SCROLL_DURATION_MS);
+  }
+}
+
+// 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/updateContentMetrics.ts
+var SCROLL_ADJUST_EPSILON = 0.1;
+function setContentLengthSignal(ctx, signalName, size) {
+  if (peek$(ctx, signalName) !== size) {
+    set$(ctx, signalName, size);
+    updateContentMetricsState(ctx);
+  }
+}
+function shouldAdjustForHeaderSizeChange(ctx, previousHeaderSize, nextHeaderSize) {
+  const { didContainersLayout, didFinishInitialScroll, props, scroll, scrollingTo } = ctx.state;
+  const sizeDiff = nextHeaderSize - previousHeaderSize;
+  const leadingPadding = props.horizontal ? props.stylePaddingLeft : props.stylePaddingTop;
+  const previousHeaderEnd = (leadingPadding || 0) + previousHeaderSize;
+  return props.maintainVisibleContentPosition.size && didContainersLayout && didFinishInitialScroll && !scrollingTo && scroll >= previousHeaderEnd - SCROLL_ADJUST_EPSILON && Math.abs(sizeDiff) > SCROLL_ADJUST_EPSILON;
+}
+function setHeaderSize(ctx, size) {
+  const { state } = ctx;
+  const previousHeaderSize = peek$(ctx, "headerSize") || 0;
+  const didChange = previousHeaderSize !== size;
+  const hasMeasuredOrEstimatedHeaderBaseline = state.didMeasureHeader || previousHeaderSize > SCROLL_ADJUST_EPSILON;
+  if (didChange) {
+    set$(ctx, "headerSize", size);
+    updateContentMetricsState(ctx);
+    if (hasMeasuredOrEstimatedHeaderBaseline && shouldAdjustForHeaderSizeChange(ctx, previousHeaderSize, size)) {
+      requestAdjust(ctx, size - previousHeaderSize);
+    }
+  }
+  state.didMeasureHeader = true;
+}
+function setFooterSize(ctx, size) {
+  setContentLengthSignal(ctx, "footerSize", size);
+}
+function areInsetsEqual(left, right) {
+  var _a3, _b, _c, _d, _e, _f, _g, _h;
+  return ((_a3 = left == null ? void 0 : left.top) != null ? _a3 : 0) === ((_b = right == null ? void 0 : right.top) != null ? _b : 0) && ((_c = left == null ? void 0 : left.bottom) != null ? _c : 0) === ((_d = right == null ? void 0 : right.bottom) != null ? _d : 0) && ((_e = left == null ? void 0 : left.left) != null ? _e : 0) === ((_f = right == null ? void 0 : right.left) != null ? _f : 0) && ((_g = left == null ? void 0 : left.right) != null ? _g : 0) === ((_h = right == null ? void 0 : right.right) != null ? _h : 0);
+}
+function setContentInsetOverride(ctx, inset) {
+  const { state } = ctx;
+  const previousInset = state.contentInsetOverride;
+  const nextInset = inset != null ? inset : void 0;
+  const didChange = !areInsetsEqual(previousInset, nextInset);
+  state.contentInsetOverride = nextInset;
+  if (didChange) {
+    updateContentMetricsState(ctx);
+  }
+  return didChange;
+}
+function useStableRenderComponent(renderComponent, mapProps) {
+  const renderComponentRef = useLatestRef(renderComponent);
+  const mapPropsRef = useLatestRef(mapProps);
+  return React3__namespace.useMemo(
+    () => React3__namespace.forwardRef(
+      (props, ref) => {
+        var _a3, _b;
+        return (_b = (_a3 = renderComponentRef.current) == null ? void 0 : _a3.call(renderComponentRef, mapPropsRef.current(props, ref))) != null ? _b : null;
+      }
+    ),
+    [mapPropsRef, renderComponentRef]
+  );
+}
+var LayoutView = ({ onLayoutChange, refView, children, ...rest }) => {
+  const localRef = React3.useRef(null);
+  const ref = refView != null ? refView : localRef;
+  useOnLayoutSync({ onLayoutChange, ref });
+  return /* @__PURE__ */ React3__namespace.createElement("div", { ...rest, ref }, children);
+};
+
+// src/components/ListComponent.tsx
+var AlignItemsAtEndSpacer = typedMemo(function AlignItemsAtEndSpacer2({ horizontal }) {
+  const [alignItemsAtEndPadding = 0] = useArr$(["alignItemsAtEndPadding"]);
+  if (alignItemsAtEndPadding <= 0) {
+    return null;
+  }
+  return /* @__PURE__ */ React3__namespace.createElement(
+    View,
+    {
+      style: horizontal ? { flexShrink: 0, width: alignItemsAtEndPadding } : { flexShrink: 0, height: alignItemsAtEndPadding }
+    },
+    null
+  );
+});
+var ListComponent = typedMemo(function ListComponent2({
+  canRender,
+  style,
+  contentContainerStyle,
+  horizontal,
+  initialContentOffset,
+  recycleItems,
+  ItemSeparatorComponent,
+  alignItemsAtEnd: _alignItemsAtEnd,
+  onScroll: onScroll2,
+  onLayout,
+  ListHeaderComponent,
+  ListHeaderComponentStyle,
+  ListFooterComponent,
+  ListFooterComponentStyle,
+  ListEmptyComponent,
+  getRenderedItem: getRenderedItem2,
+  updateItemSize: updateItemSize2,
+  refScrollView,
+  renderScrollComponent,
+  onLayoutFooter,
+  scrollAdjustHandler,
+  snapToIndices,
+  stickyHeaderConfig,
+  stickyHeaderIndices,
+  useWindowScroll = false,
+  ...rest
+}) {
+  const ctx = useStateContext();
+  const maintainVisibleContentPosition = ctx.state.props.maintainVisibleContentPosition;
+  const [otherAxisSize = 0] = useArr$(["otherAxisSize"]);
+  const shouldRenderAlignItemsAtEndSpacer = ctx.state.props.alignItemsAtEndPaddingEnabled;
+  const autoOtherAxisStyle = getAutoOtherAxisStyle({
+    horizontal,
+    needsOtherAxisSize: ctx.state.needsOtherAxisSize,
+    otherAxisSize
+  });
+  const CustomScrollComponent = useStableRenderComponent(
+    renderScrollComponent,
+    (props, ref) => ({ ...props, ref })
+  );
+  const ScrollComponent = renderScrollComponent ? CustomScrollComponent : ListComponentScrollView;
+  const SnapOrScroll = snapToIndices ? SnapWrapper : ScrollComponent;
+  React3.useLayoutEffect(() => {
+    if (!ListHeaderComponent) {
+      setHeaderSize(ctx, 0);
+    }
+    if (!ListFooterComponent) {
+      setFooterSize(ctx, 0);
+    }
+  }, [ListHeaderComponent, ListFooterComponent, ctx]);
+  const onLayoutHeader = React3.useCallback(
+    (rect) => {
+      const size = rect[horizontal ? "width" : "height"];
+      setHeaderSize(ctx, size);
+    },
+    [ctx, horizontal]
+  );
+  const onLayoutFooterInternal = React3.useCallback(
+    (rect, fromLayoutEffect) => {
+      const size = rect[horizontal ? "width" : "height"];
+      setFooterSize(ctx, size);
+      onLayoutFooter == null ? void 0 : onLayoutFooter(rect, fromLayoutEffect);
+    },
+    [ctx, horizontal, onLayoutFooter]
+  );
+  return /* @__PURE__ */ React3__namespace.createElement(
+    SnapOrScroll,
+    {
+      ...rest,
+      ...ScrollComponent === ListComponentScrollView ? { useWindowScroll } : {},
+      contentContainerStyle: [
+        horizontal ? {
+          height: "100%"
+        } : {},
+        contentContainerStyle
+      ],
+      contentOffset: initialContentOffset !== void 0 ? horizontal ? { x: initialContentOffset, y: 0 } : { x: 0, y: initialContentOffset } : void 0,
+      horizontal,
+      maintainVisibleContentPosition: maintainVisibleContentPosition.size || maintainVisibleContentPosition.data ? { minIndexForVisible: 0 } : void 0,
+      onLayout,
+      onScroll: onScroll2,
+      ref: refScrollView,
+      ScrollComponent: snapToIndices ? ScrollComponent : void 0,
+      style: autoOtherAxisStyle ? [autoOtherAxisStyle, style] : style
+    },
+    /* @__PURE__ */ React3__namespace.createElement(ScrollAdjust, null),
+    ListHeaderComponent && /* @__PURE__ */ React3__namespace.createElement(LayoutView, { onLayoutChange: onLayoutHeader, style: ListHeaderComponentStyle }, getComponent(ListHeaderComponent)),
+    ListEmptyComponent && getComponent(ListEmptyComponent),
+    shouldRenderAlignItemsAtEndSpacer && /* @__PURE__ */ React3__namespace.createElement(AlignItemsAtEndSpacer, { horizontal }),
+    canRender && !ListEmptyComponent && /* @__PURE__ */ React3__namespace.createElement(
+      Containers,
+      {
+        getRenderedItem: getRenderedItem2,
+        horizontal,
+        ItemSeparatorComponent,
+        recycleItems,
+        stickyHeaderConfig,
+        updateItemSize: updateItemSize2
+      }
+    ),
+    ListFooterComponent && /* @__PURE__ */ React3__namespace.createElement(LayoutView, { onLayoutChange: onLayoutFooterInternal, style: ListFooterComponentStyle }, getComponent(ListFooterComponent)),
+    /* @__PURE__ */ React3__namespace.createElement(WebAnchoredEndSpace, { horizontal }),
+    IS_DEV && ENABLE_DEVMODE
+  );
+});
+var WEB_UNBOUNDED_HEIGHT_MIN_DATA_LENGTH = 100;
+var WEB_UNBOUNDED_HEIGHT_CONTAINER_RATIO = 0.9;
+var WEB_UNBOUNDED_HEIGHT_VIEWPORT_RATIO = 0.9;
+function useDevChecksImpl(props) {
+  const ctx = useStateContext();
+  const { childrenMode, keyExtractor, renderScrollComponent, useWindowScroll } = props;
+  React3.useEffect(() => {
+    if (useWindowScroll && renderScrollComponent) {
+      warnDevOnce(
+        "useWindowScrollRenderScrollComponent",
+        "useWindowScroll is not supported when renderScrollComponent is provided."
+      );
+    }
+  }, [renderScrollComponent, useWindowScroll]);
+  React3.useEffect(() => {
+    if (!keyExtractor && !ctx.state.isFirst && ctx.state.didDataChange && !childrenMode) {
+      warnDevOnce(
+        "keyExtractor",
+        "Changing data without a keyExtractor can cause slow performance and resetting scroll. If your list data can change you should use a keyExtractor with a unique id for best performance and behavior."
+      );
+    }
+  }, [childrenMode, ctx, keyExtractor]);
+  React3.useEffect(() => {
+    const state = ctx.state;
+    const dataLength = state.props.data.length;
+    const useWindowScrollResolved = state.props.useWindowScroll;
+    if (useWindowScrollResolved || dataLength < WEB_UNBOUNDED_HEIGHT_MIN_DATA_LENGTH) {
+      return;
+    }
+    const warnIfUnboundedOuterSize = () => {
+      const readyToRender = peek$(ctx, "readyToRender");
+      const numContainers = peek$(ctx, "numContainers") || 0;
+      const totalSize = peek$(ctx, "totalSize") || 0;
+      const scrollLength = ctx.state.scrollLength || 0;
+      if (!readyToRender || totalSize <= 0 || scrollLength <= 0) {
+        return;
+      }
+      const rendersAlmostEverything = numContainers >= Math.ceil(dataLength * WEB_UNBOUNDED_HEIGHT_CONTAINER_RATIO);
+      const viewportMatchesContent = scrollLength >= totalSize * WEB_UNBOUNDED_HEIGHT_VIEWPORT_RATIO;
+      if (rendersAlmostEverything && viewportMatchesContent) {
+        warnDevOnce(
+          "webUnboundedOuterSize",
+          "LegendList appears to have an unbounded outer height on web, so virtualization is effectively disabled. Set a bounded height or flex: 1 on the list container, or use useWindowScroll."
+        );
+      }
+    };
+    warnIfUnboundedOuterSize();
+    const unsubscribe = [
+      listen$(ctx, "numContainers", warnIfUnboundedOuterSize),
+      listen$(ctx, "readyToRender", warnIfUnboundedOuterSize),
+      listen$(ctx, "totalSize", warnIfUnboundedOuterSize)
+    ];
+    return () => {
+      for (const unsub of unsubscribe) {
+        unsub();
+      }
+    };
+  }, [ctx]);
+}
+function useDevChecksNoop(_props) {
+}
+var useDevChecks = IS_DEV ? useDevChecksImpl : useDevChecksNoop;
+
+// src/core/calculateOffsetForIndex.ts
+function calculateOffsetForIndex(ctx, index) {
+  const state = ctx.state;
+  return index !== void 0 ? state.positions[index] || 0 : 0;
+}
+
+// src/core/getTopOffsetAdjustment.ts
+function getTopOffsetAdjustment(ctx) {
+  return (peek$(ctx, "stylePaddingTop") || 0) + (peek$(ctx, "alignItemsAtEndPadding") || 0) + (peek$(ctx, "headerSize") || 0);
+}
+
+// src/utils/getId.ts
+function getId(state, index) {
+  const { data, keyExtractor } = state.props;
+  if (!data) {
+    return "";
+  }
+  const ret = index < data.length ? keyExtractor ? keyExtractor(data[index], index) : index : null;
+  const id = ret;
+  state.idCache[index] = id;
+  return id;
+}
+
+// src/core/setSize.ts
+function setSize(ctx, itemKey, size, notifyTotalSize = true) {
+  const state = ctx.state;
+  const { sizes } = state;
+  const previousSize = sizes.get(itemKey);
+  const diff = previousSize !== void 0 ? size - previousSize : size;
+  if (diff !== 0) {
+    addTotalSize(ctx, itemKey, diff, notifyTotalSize);
+  }
+  sizes.set(itemKey, size);
+}
+
+// src/utils/getItemSize.ts
+function getKnownOrFixedSize(ctx, key, index, data, resolved) {
+  var _a3, _b;
+  const state = ctx.state;
+  const { getFixedItemSize, getItemType } = state.props;
+  let size = key ? state.sizesKnown.get(key) : void 0;
+  if (size === void 0 && key && getFixedItemSize) {
+    const itemType = (_b = resolved == null ? void 0 : resolved.itemType) != null ? _b : getItemType ? (_a3 = getItemType(data, index)) != null ? _a3 : "" : "";
+    const fixedSize = (resolved == null ? void 0 : resolved.didResolveFixedItemSize) ? resolved.fixedItemSize : getFixedItemSize(data, index, itemType);
+    if (fixedSize !== void 0) {
+      size = fixedSize + ctx.scrollAxisGap;
+      state.sizesKnown.set(key, size);
+    }
+  }
+  return size;
+}
+function getKnownOrFixedItemSize(ctx, index) {
+  const key = getId(ctx.state, index);
+  return getKnownOrFixedSize(ctx, key, index, ctx.state.props.data[index]);
+}
+function areKnownOrFixedItemSizesAvailable(ctx, startIndex, endIndex) {
+  for (let index = startIndex; index <= endIndex; index++) {
+    if (getKnownOrFixedItemSize(ctx, index) === void 0) {
+      return false;
+    }
+  }
+  return true;
+}
+function getItemSize(ctx, key, index, data, useAverageSize, preferCachedSize, notifyTotalSize, resolved) {
+  var _a3, _b, _c, _d;
+  const state = ctx.state;
+  const {
+    sizes,
+    averageSizes,
+    props: { estimatedItemSize, getItemType },
+    scrollingTo
+  } = state;
+  const sizeKnown = state.sizesKnown.get(key);
+  if (sizeKnown !== void 0) {
+    return sizeKnown;
+  }
+  let size;
+  const renderedSize = sizes.get(key);
+  if (preferCachedSize) {
+    if (renderedSize !== void 0) {
+      return renderedSize;
+    }
+  }
+  size = getKnownOrFixedSize(ctx, key, index, data, resolved);
+  if (size !== void 0) {
+    setSize(ctx, key, size, notifyTotalSize);
+    return size;
+  }
+  const itemType = (_b = resolved == null ? void 0 : resolved.itemType) != null ? _b : getItemType ? (_a3 = getItemType(data, index)) != null ? _a3 : "" : "";
+  if (useAverageSize && !scrollingTo) {
+    const averageSizeForType = (_c = averageSizes[itemType]) == null ? void 0 : _c.avg;
+    if (averageSizeForType !== void 0) {
+      size = roundSize(averageSizeForType);
     }
-    if (idleTimeout) {
-      clearTimeout(idleTimeout);
+  }
+  if (size === void 0 && renderedSize !== void 0) {
+    return renderedSize;
+  }
+  if (size === void 0 && useAverageSize && scrollingTo) {
+    const averageSizeForType = (_d = scrollingTo.averageSizeSnapshot) == null ? void 0 : _d[itemType];
+    if (averageSizeForType !== void 0) {
+      size = roundSize(averageSizeForType);
     }
-    clearTimeout(maxTimeout);
-  };
-  const finish = (reason) => {
-    if (settled) return;
-    if (targetToken !== ctx.state.scrollingTo) {
-      settled = true;
-      cleanup();
-      return;
+  }
+  if (size === void 0) {
+    size = estimatedItemSize + ctx.scrollAxisGap;
+  }
+  setSize(ctx, key, size, notifyTotalSize);
+  return size;
+}
+function getItemSizeAtIndex(ctx, index) {
+  if (index === void 0 || index < 0) {
+    return void 0;
+  }
+  const targetId = getId(ctx.state, index);
+  return getItemSize(ctx, targetId, index, ctx.state.props.data[index]);
+}
+
+// src/core/calculateOffsetWithOffsetPosition.ts
+function calculateOffsetWithOffsetPosition(ctx, offsetParam, params) {
+  var _a3;
+  const state = ctx.state;
+  const { index, viewOffset, viewPosition } = params;
+  let offset = offsetParam;
+  if (viewOffset) {
+    offset -= viewOffset;
+  }
+  if (index !== void 0) {
+    const topOffsetAdjustment = getTopOffsetAdjustment(ctx);
+    if (topOffsetAdjustment) {
+      offset += topOffsetAdjustment;
     }
-    const currentOffset = readOffset();
-    const isNearTarget = Math.abs(currentOffset - targetOffset) <= SCROLL_END_TARGET_EPSILON;
-    if (reason === "scrollend" && !isNearTarget) {
-      return;
+  }
+  if (viewPosition !== void 0 && index !== void 0) {
+    const dataLength = state.props.data.length;
+    if (dataLength === 0) {
+      return offset;
     }
-    settled = true;
-    cleanup();
-    finishScrollTo(ctx);
-  };
-  const onScroll2 = () => {
-    if (idleTimeout) {
-      clearTimeout(idleTimeout);
+    const isOutOfBounds = index < 0 || index >= dataLength;
+    const fallbackEstimatedSize = (_a3 = state.props.estimatedItemSize) != null ? _a3 : 0;
+    const itemSize = isOutOfBounds ? fallbackEstimatedSize : getItemSize(ctx, getId(state, index), index, state.props.data[index]);
+    const trailingInset = getContentInsetEnd(ctx);
+    offset -= viewPosition * (state.scrollLength - trailingInset - itemSize);
+    if (!isOutOfBounds && index === state.props.data.length - 1) {
+      const footerSize = peek$(ctx, "footerSize") || 0;
+      offset += footerSize;
     }
-    idleTimeout = setTimeout(() => finish("idle"), SCROLL_END_IDLE_MS);
-  };
-  const onScrollEnd = () => finish("scrollend");
-  target.addEventListener("scroll", onScroll2);
-  if (supportsScrollEnd) {
-    target.addEventListener("scrollend", onScrollEnd);
-  } else {
-    idleTimeout = setTimeout(() => finish("idle"), SMOOTH_SCROLL_DURATION_MS);
   }
+  return offset;
+}
+
+// src/core/clampScrollOffset.ts
+function clampScrollOffset(ctx, offset, scrollTarget) {
+  const state = ctx.state;
+  const contentSize = getContentSize(ctx);
+  let clampedOffset = offset;
+  if (Number.isFinite(contentSize) && Number.isFinite(state.scrollLength) && (Platform.OS !== "android")) {
+    const baseMaxOffset = Math.max(0, contentSize - state.scrollLength);
+    const viewOffset = scrollTarget == null ? void 0 : scrollTarget.viewOffset;
+    const extraEndOffset = typeof viewOffset === "number" && viewOffset < 0 ? -viewOffset : 0;
+    const maxOffset = baseMaxOffset + extraEndOffset;
+    clampedOffset = Math.min(offset, maxOffset);
+  }
+  clampedOffset = Math.max(0, clampedOffset);
+  return clampedOffset;
 }
 
 // src/core/doMaintainScrollAtEnd.ts
@@ -2798,9 +2958,12 @@ function doMaintainScrollAtEnd(ctx) {
       state.scroll = 0;
     }
     if (!state.maintainingScrollAtEnd) {
-      state.maintainingScrollAtEnd = true;
+      const pendingState = maintainScrollAtEnd.animated ? "pending-animated" : "pending-instant";
+      const activeState = maintainScrollAtEnd.animated ? "animated" : "instant";
+      state.maintainingScrollAtEnd = pendingState;
       requestAnimationFrame(() => {
         if (peek$(ctx, "isWithinMaintainScrollAtEndThreshold")) {
+          state.maintainingScrollAtEnd = activeState;
           const scroller = refScroller.current;
           if (state.props.horizontal && isHorizontalRTL(state)) {
             const currentContentSize = getContentSize(ctx);
@@ -2818,12 +2981,14 @@ function doMaintainScrollAtEnd(ctx) {
           }
           setTimeout(
             () => {
-              state.maintainingScrollAtEnd = false;
+              if (state.maintainingScrollAtEnd === activeState) {
+                state.maintainingScrollAtEnd = void 0;
+              }
             },
             maintainScrollAtEnd.animated ? 500 : 0
           );
-        } else {
-          state.maintainingScrollAtEnd = false;
+        } else if (state.maintainingScrollAtEnd === pendingState) {
+          state.maintainingScrollAtEnd = void 0;
         }
       });
     }
@@ -2832,30 +2997,6 @@ function doMaintainScrollAtEnd(ctx) {
   return false;
 }
 
-// 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;
@@ -3001,6 +3142,10 @@ function prepareMVCP(ctx, dataChanged) {
   const now = Date.now();
   const enableMVCPAnchorLock = (!!dataChanged || !!state.mvcpAnchorLock);
   const scrollingTo = state.scrollingTo;
+  if (dataChanged && state.pendingScrollToEnd && scrollingTo === void 0) {
+    state.mvcpAnchorLock = void 0;
+    return void 0;
+  }
   const anchorLock = resolveAnchorLock(state, enableMVCPAnchorLock, mvcpData, now) ;
   let prevPosition;
   let targetId;
@@ -3129,7 +3274,7 @@ function prepareMVCP(ctx, dataChanged) {
         return;
       }
       if (Math.abs(positionDiff) > MVCP_POSITION_EPSILON) {
-        const shouldSkipAdjustForMaintainedEnd = state.maintainingScrollAtEnd && peek$(ctx, "isWithinMaintainScrollAtEndThreshold");
+        const shouldSkipAdjustForMaintainedEnd = (state.maintainingScrollAtEnd === "pending-animated" || state.maintainingScrollAtEnd === "animated") && peek$(ctx, "isWithinMaintainScrollAtEndThreshold");
         if (!shouldSkipAdjustForMaintainedEnd) {
           requestAdjust(ctx, positionDiff);
         }
@@ -3138,6 +3283,45 @@ function prepareMVCP(ctx, dataChanged) {
   }
 }
 
+// src/utils/getScrollVelocity.ts
+var getScrollVelocity = (state) => {
+  const { scrollHistory } = state;
+  const newestIndex = scrollHistory.length - 1;
+  if (newestIndex < 1) {
+    return 0;
+  }
+  const newest = scrollHistory[newestIndex];
+  const now = Date.now();
+  let direction = 0;
+  for (let i = newestIndex; i > 0; i--) {
+    const delta = scrollHistory[i].scroll - scrollHistory[i - 1].scroll;
+    if (delta !== 0) {
+      direction = Math.sign(delta);
+      break;
+    }
+  }
+  if (direction === 0) {
+    return 0;
+  }
+  let oldest = newest;
+  for (let i = newestIndex - 1; i >= 0; i--) {
+    const current = scrollHistory[i];
+    const next = scrollHistory[i + 1];
+    const delta = next.scroll - current.scroll;
+    const deltaSign = Math.sign(delta);
+    if (deltaSign !== 0 && deltaSign !== direction) {
+      break;
+    }
+    if (now - current.time > 1e3) {
+      break;
+    }
+    oldest = current;
+  }
+  const scrollDiff = newest.scroll - oldest.scroll;
+  const timeDiff = newest.time - oldest.time;
+  return timeDiff > 0 ? scrollDiff / timeDiff : 0;
+};
+
 // src/core/updateScroll.ts
 function updateScroll(ctx, newScroll, forceUpdate, options) {
   var _a3;
@@ -3163,6 +3347,8 @@ function updateScroll(ctx, newScroll, forceUpdate, options) {
   if (scrollHistory.length > 5) {
     scrollHistory.shift();
   }
+  const scrollVelocity = getScrollVelocity(state);
+  updateAdaptiveRender(ctx, scrollVelocity);
   if (ignoreScrollFromMVCP && !scrollingTo) {
     const { lt, gt } = ignoreScrollFromMVCP;
     if (lt && newScroll < lt || gt && newScroll > gt) {
@@ -3186,7 +3372,7 @@ function updateScroll(ctx, newScroll, forceUpdate, options) {
     state.lastScrollDelta = scrollDelta;
     const runCalculateItems = () => {
       var _a4;
-      (_a4 = state.triggerCalculateItemsInView) == null ? void 0 : _a4.call(state, { doMVCP: scrollingTo !== void 0 });
+      (_a4 = state.triggerCalculateItemsInView) == null ? void 0 : _a4.call(state, { doMVCP: scrollingTo !== void 0, scrollVelocity });
       checkThresholds(ctx);
     };
     if (scrollLength > 0 && scrollingTo === void 0 && scrollDelta > scrollLength && !state.pendingNativeMVCPAdjust) {
@@ -4266,9 +4452,32 @@ function initializeInitialScrollOnMount(ctx, options) {
 }
 function handleInitialScrollDataChange(ctx, options) {
   var _a3, _b, _c;
-  const { dataLength, didDataChange, initialScrollAtEnd, stylePaddingBottom, useBootstrapInitialScroll } = options;
+  const {
+    dataLength,
+    didDataChange,
+    initialScrollAtEnd,
+    latestInitialScroll,
+    latestInitialScrollSessionKind,
+    stylePaddingBottom,
+    useBootstrapInitialScroll
+  } = options;
   const state = ctx.state;
   const previousDataLength = (_b = (_a3 = state.initialScrollSession) == null ? void 0 : _a3.previousDataLength) != null ? _b : 0;
+  const isFirstNonEmptyData = !state.hasHadNonEmptyData && dataLength > 0;
+  if (dataLength > 0) {
+    state.hasHadNonEmptyData = true;
+  }
+  if (isFirstNonEmptyData) {
+    if (latestInitialScroll) {
+      setInitialScrollTarget(state, latestInitialScroll);
+      setInitialScrollSession(state, {
+        kind: latestInitialScrollSessionKind,
+        previousDataLength
+      });
+    } else {
+      clearPreservedInitialScrollTarget(state);
+    }
+  }
   if (state.initialScrollSession) {
     state.initialScrollSession.previousDataLength = dataLength;
   }
@@ -4492,45 +4701,6 @@ function updateTotalSize(ctx) {
   }
 }
 
-// src/utils/getScrollVelocity.ts
-var getScrollVelocity = (state) => {
-  const { scrollHistory } = state;
-  const newestIndex = scrollHistory.length - 1;
-  if (newestIndex < 1) {
-    return 0;
-  }
-  const newest = scrollHistory[newestIndex];
-  const now = Date.now();
-  let direction = 0;
-  for (let i = newestIndex; i > 0; i--) {
-    const delta = scrollHistory[i].scroll - scrollHistory[i - 1].scroll;
-    if (delta !== 0) {
-      direction = Math.sign(delta);
-      break;
-    }
-  }
-  if (direction === 0) {
-    return 0;
-  }
-  let oldest = newest;
-  for (let i = newestIndex - 1; i >= 0; i--) {
-    const current = scrollHistory[i];
-    const next = scrollHistory[i + 1];
-    const delta = next.scroll - current.scroll;
-    const deltaSign = Math.sign(delta);
-    if (deltaSign !== 0 && deltaSign !== direction) {
-      break;
-    }
-    if (now - current.time > 1e3) {
-      break;
-    }
-    oldest = current;
-  }
-  const scrollDiff = newest.scroll - oldest.scroll;
-  const timeDiff = newest.time - oldest.time;
-  return timeDiff > 0 ? scrollDiff / timeDiff : 0;
-};
-
 // src/utils/updateSnapToOffsets.ts
 function updateSnapToOffsets(ctx) {
   const state = ctx.state;
@@ -5266,7 +5436,7 @@ function updateViewabilityForCachedRange(ctx, viewabilityConfigCallbackPairs, sc
 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;
+    var _a3, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t;
     const {
       columns,
       containerItemKeys,
@@ -5275,14 +5445,7 @@ function calculateItemsInView(ctx, params = {}) {
       indexByKey,
       minIndexSizeChanged,
       positions,
-      props: {
-        alwaysRenderIndicesArr,
-        alwaysRenderIndicesSet,
-        drawDistance,
-        getItemType,
-        keyExtractor,
-        onStickyHeaderChange
-      },
+      props: { alwaysRenderIndicesArr, alwaysRenderIndicesSet, getItemType, keyExtractor, onStickyHeaderChange },
       scrollForNextCalculateItemsInView,
       scrollLength,
       sizes,
@@ -5294,6 +5457,7 @@ function calculateItemsInView(ctx, params = {}) {
     const stickyHeaderIndicesSet = state.props.stickyHeaderIndicesSet || /* @__PURE__ */ new Set();
     const alwaysRenderArr = alwaysRenderIndicesArr || [];
     const alwaysRenderSet = alwaysRenderIndicesSet || /* @__PURE__ */ new Set();
+    const drawDistance = getEffectiveDrawDistance(ctx);
     const { dataChanged, doMVCP, forceFullItemPositions } = params;
     const bootstrapInitialScrollState = ((_a3 = state.initialScrollSession) == null ? void 0 : _a3.kind) === "bootstrap" ? state.initialScrollSession.bootstrap : void 0;
     const suppressInitialScrollSideEffects = !!bootstrapInitialScrollState;
@@ -5304,10 +5468,10 @@ function calculateItemsInView(ctx, params = {}) {
     let totalSize = getContentSize(ctx);
     const topPad = peek$(ctx, "stylePaddingTop") + peek$(ctx, "alignItemsAtEndPadding") + peek$(ctx, "headerSize");
     const numColumns = peek$(ctx, "numColumns");
-    const speed = getScrollVelocity(state);
+    const speed = (_b = params.scrollVelocity) != null ? _b : getScrollVelocity(state);
     const scrollExtra = 0;
     const { initialScroll, queuedInitialLayout } = state;
-    const scrollState = suppressInitialScrollSideEffects ? (_b = bootstrapInitialScrollState == null ? void 0 : bootstrapInitialScrollState.scroll) != null ? _b : state.scroll : !queuedInitialLayout && hasActiveInitialScroll(state) && initialScroll ? (
+    const scrollState = suppressInitialScrollSideEffects ? (_c = bootstrapInitialScrollState == null ? void 0 : bootstrapInitialScrollState.scroll) != null ? _c : state.scroll : !queuedInitialLayout && hasActiveInitialScroll(state) && initialScroll ? (
       // Before the initial layout settles, keep viewport math anchored to the
       // current initial-scroll target instead of transient native adjustments.
       resolveInitialScrollOffset(ctx, initialScroll)
@@ -5331,19 +5495,25 @@ function calculateItemsInView(ctx, params = {}) {
     };
     updateScroll2(scrollState);
     const previousStickyIndex = peek$(ctx, "activeStickyIndex");
-    const currentStickyIdx = stickyHeaderIndicesArr.length > 0 ? findCurrentStickyIndex(stickyHeaderIndicesArr, scroll, state) : -1;
-    const nextActiveStickyIndex = currentStickyIdx >= 0 ? stickyHeaderIndicesArr[currentStickyIdx] : -1;
-    const stickyIndexDidChange = previousStickyIndex !== nextActiveStickyIndex;
-    if (currentStickyIdx >= 0 || previousStickyIndex >= 0) {
-      set$(ctx, "activeStickyIndex", nextActiveStickyIndex);
-    }
-    const shouldNotifyStickyHeaderChange = !!onStickyHeaderChange && stickyHeaderIndicesArr.length > 0 && stickyIndexDidChange;
-    const finishCalculateItemsInView = shouldNotifyStickyHeaderChange ? () => {
-      const item = data[nextActiveStickyIndex];
-      if (item !== void 0) {
-        onStickyHeaderChange == null ? void 0 : onStickyHeaderChange({ index: nextActiveStickyIndex, item });
+    const resolveStickyState = () => {
+      const currentStickyIdx = stickyHeaderIndicesArr.length > 0 ? findCurrentStickyIndex(stickyHeaderIndicesArr, scroll, state) : -1;
+      const nextActiveStickyIndex = currentStickyIdx >= 0 ? stickyHeaderIndicesArr[currentStickyIdx] : -1;
+      const stickyIndexDidChange = previousStickyIndex !== nextActiveStickyIndex;
+      if (currentStickyIdx >= 0 || previousStickyIndex >= 0) {
+        set$(ctx, "activeStickyIndex", nextActiveStickyIndex);
       }
-    } : void 0;
+      const shouldNotifyStickyHeaderChange = !!onStickyHeaderChange && stickyHeaderIndicesArr.length > 0 && stickyIndexDidChange;
+      return {
+        currentStickyIdx,
+        finishCalculateItemsInView: shouldNotifyStickyHeaderChange ? () => {
+          const item = data[nextActiveStickyIndex];
+          if (item !== void 0) {
+            onStickyHeaderChange == null ? void 0 : onStickyHeaderChange({ index: nextActiveStickyIndex, item });
+          }
+        } : void 0
+      };
+    };
+    let stickyState = dataChanged ? void 0 : resolveStickyState();
     let scrollBufferTop = drawDistance;
     let scrollBufferBottom = drawDistance;
     if (speed > 0 || speed === 0 && scroll < Math.max(50, drawDistance)) {
@@ -5376,7 +5546,7 @@ function calculateItemsInView(ctx, params = {}) {
               scrollBottom
             );
           }
-          finishCalculateItemsInView == null ? void 0 : finishCalculateItemsInView();
+          (_d = stickyState == null ? void 0 : stickyState.finishCalculateItemsInView) == null ? void 0 : _d.call(stickyState);
           return;
         }
       }
@@ -5385,7 +5555,7 @@ function calculateItemsInView(ctx, params = {}) {
     if (dataChanged) {
       resetLayoutCachesForDataChange(state);
     }
-    const startIndex = forceFullItemPositions || dataChanged ? 0 : (_c = minIndexSizeChanged != null ? minIndexSizeChanged : state.startBuffered) != null ? _c : 0;
+    const startIndex = forceFullItemPositions || dataChanged ? 0 : (_e = minIndexSizeChanged != null ? minIndexSizeChanged : state.startBuffered) != null ? _e : 0;
     const optimizeForVisibleWindow = !forceFullItemPositions && !dataChanged && numColumns > 1 && minIndexSizeChanged !== void 0;
     updateItemPositions(ctx, dataChanged, {
       doMVCP,
@@ -5411,21 +5581,24 @@ function calculateItemsInView(ctx, params = {}) {
       }
     }
     const scrollBeforeMVCP = state.scroll;
-    const scrollAdjustPendingBeforeMVCP = (_d = peek$(ctx, "scrollAdjustPending")) != null ? _d : 0;
+    const scrollAdjustPendingBeforeMVCP = (_f = peek$(ctx, "scrollAdjustPending")) != null ? _f : 0;
     checkMVCP == null ? void 0 : checkMVCP();
-    const didMVCPAdjustScroll = !!checkMVCP && (state.scroll !== scrollBeforeMVCP || ((_e = peek$(ctx, "scrollAdjustPending")) != null ? _e : 0) !== scrollAdjustPendingBeforeMVCP);
+    const didMVCPAdjustScroll = !!checkMVCP && (state.scroll !== scrollBeforeMVCP || ((_g = peek$(ctx, "scrollAdjustPending")) != null ? _g : 0) !== scrollAdjustPendingBeforeMVCP);
     if (didMVCPAdjustScroll && initialScroll) {
       updateScroll2(state.scroll);
       updateScrollRange();
     }
+    if (dataChanged) {
+      stickyState = resolveStickyState();
+    }
     let startBuffered = null;
     let startBufferedId = null;
     let endBuffered = null;
-    let loopStart = (_f = suppressInitialScrollSideEffects ? bootstrapInitialScrollState == null ? void 0 : bootstrapInitialScrollState.targetIndexSeed : void 0) != null ? _f : !dataChanged && startBufferedIdOrig ? indexByKey.get(startBufferedIdOrig) || 0 : 0;
+    let loopStart = (_h = suppressInitialScrollSideEffects ? bootstrapInitialScrollState == null ? void 0 : bootstrapInitialScrollState.targetIndexSeed : void 0) != null ? _h : !dataChanged && startBufferedIdOrig ? indexByKey.get(startBufferedIdOrig) || 0 : 0;
     for (let i = loopStart; i >= 0; i--) {
-      const id = (_g = idCache[i]) != null ? _g : getId(state, i);
+      const id = (_i = idCache[i]) != null ? _i : getId(state, i);
       const top = positions[i];
-      const size = (_h = sizes.get(id)) != null ? _h : getItemSize(ctx, id, i, data[i]);
+      const size = (_j = sizes.get(id)) != null ? _j : getItemSize(ctx, id, i, data[i]);
       const bottom = top + size;
       if (bottom > scrollTopBuffered) {
         loopStart = i;
@@ -5460,8 +5633,8 @@ function calculateItemsInView(ctx, params = {}) {
     };
     const dataLength = data.length;
     for (let i = Math.max(0, loopStart); i < dataLength && (!foundEnd || i <= maxIndexRendered); 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 id = (_k = idCache[i]) != null ? _k : getId(state, i);
+      const size = (_l = sizes.get(id)) != null ? _l : getItemSize(ctx, id, i, data[i]);
       const top = positions[i];
       if (!foundEnd) {
         trackVisibleRange(visibleRange, i, top, size, scroll, scrollBottom);
@@ -5517,7 +5690,7 @@ function calculateItemsInView(ctx, params = {}) {
       const needNewContainers = [];
       const needNewContainersSet = /* @__PURE__ */ new Set();
       for (let i = startBuffered; i <= endBuffered; i++) {
-        const id = (_k = idCache[i]) != null ? _k : getId(state, i);
+        const id = (_m = idCache[i]) != null ? _m : getId(state, i);
         if (!containerItemKeys.has(id)) {
           needNewContainersSet.add(i);
           needNewContainers.push(i);
@@ -5526,7 +5699,7 @@ function calculateItemsInView(ctx, params = {}) {
       if (alwaysRenderArr.length > 0) {
         for (const index of alwaysRenderArr) {
           if (index < 0 || index >= dataLength) continue;
-          const id = (_l = idCache[index]) != null ? _l : getId(state, index);
+          const id = (_n = idCache[index]) != null ? _n : getId(state, index);
           if (id && !containerItemKeys.has(id) && !needNewContainersSet.has(index)) {
             needNewContainersSet.add(index);
             needNewContainers.push(index);
@@ -5537,7 +5710,7 @@ function calculateItemsInView(ctx, params = {}) {
         handleStickyActivation(
           ctx,
           stickyHeaderIndicesArr,
-          currentStickyIdx,
+          (_o = stickyState == null ? void 0 : stickyState.currentStickyIdx) != null ? _o : -1,
           needNewContainers,
           needNewContainersSet,
           startBuffered,
@@ -5563,7 +5736,7 @@ function calculateItemsInView(ctx, params = {}) {
         for (const allocation of availableContainerAllocations) {
           const i = allocation.itemIndex;
           const containerIndex = allocation.containerIndex;
-          const id = (_m = idCache[i]) != null ? _m : getId(state, i);
+          const id = (_p = idCache[i]) != null ? _p : getId(state, i);
           const oldKey = peek$(ctx, `containerItemKey${containerIndex}`);
           if (oldKey && oldKey !== id) {
             containerItemKeys.delete(oldKey);
@@ -5574,7 +5747,7 @@ function calculateItemsInView(ctx, params = {}) {
             state.containerItemTypes.set(containerIndex, allocation.itemType);
           }
           containerItemKeys.set(id, containerIndex);
-          (_n = state.userScrollAnchorReset) == null ? void 0 : _n.keys.add(id);
+          (_q = state.userScrollAnchorReset) == null ? void 0 : _q.keys.add(id);
           const containerSticky = `containerSticky${containerIndex}`;
           const isSticky = stickyHeaderIndicesSet.has(i);
           const isAlwaysRender = alwaysRenderSet.has(i);
@@ -5605,14 +5778,12 @@ function calculateItemsInView(ctx, params = {}) {
       if (state.userScrollAnchorReset) {
         if (state.userScrollAnchorReset.keys.size === 0) {
           state.userScrollAnchorReset = void 0;
-        } else {
-          state.userScrollAnchorReset.batchSize = state.userScrollAnchorReset.keys.size;
         }
       }
       if (alwaysRenderArr.length > 0) {
         for (const index of alwaysRenderArr) {
           if (index < 0 || index >= dataLength) continue;
-          const id = (_o = idCache[index]) != null ? _o : getId(state, index);
+          const id = (_r = idCache[index]) != null ? _r : getId(state, index);
           const containerIndex = containerItemKeys.get(id);
           if (containerIndex !== void 0) {
             state.stickyContainerPool.add(containerIndex);
@@ -5626,7 +5797,7 @@ function calculateItemsInView(ctx, params = {}) {
         stickyHeaderIndicesArr,
         scroll,
         drawDistance,
-        currentStickyIdx,
+        (_s = stickyState == null ? void 0 : stickyState.currentStickyIdx) != null ? _s : -1,
         pendingRemoval,
         alwaysRenderSet
       );
@@ -5687,7 +5858,7 @@ function calculateItemsInView(ctx, params = {}) {
         );
       }
     }
-    finishCalculateItemsInView == null ? void 0 : finishCalculateItemsInView();
+    (_t = stickyState == null ? void 0 : stickyState.finishCalculateItemsInView) == null ? void 0 : _t.call(stickyState);
   });
 }
 
@@ -5770,8 +5941,9 @@ function doInitialAllocateContainers(ctx) {
   const state = ctx.state;
   const {
     scrollLength,
-    props: { data, drawDistance, getFixedItemSize, getItemType, numColumns, estimatedItemSize }
+    props: { data, getFixedItemSize, getItemType, numColumns, estimatedItemSize }
   } = state;
+  const drawDistance = getEffectiveDrawDistance(ctx);
   const hasContainers = peek$(ctx, "numContainers");
   if (scrollLength > 0 && data.length > 0 && !hasContainers) {
     let averageItemSize;
@@ -5782,12 +5954,12 @@ function doInitialAllocateContainers(ctx) {
         const item = data[i];
         if (item !== void 0) {
           const itemType = (_a3 = getItemType == null ? void 0 : getItemType(item, i)) != null ? _a3 : "";
-          totalSize += (_b = getFixedItemSize(item, i, itemType)) != null ? _b : estimatedItemSize;
+          totalSize += ((_b = getFixedItemSize(item, i, itemType)) != null ? _b : estimatedItemSize) + ctx.scrollAxisGap;
         }
       }
       averageItemSize = totalSize / num;
     } else {
-      averageItemSize = estimatedItemSize;
+      averageItemSize = estimatedItemSize + ctx.scrollAxisGap;
     }
     const numContainers = Math.max(
       1,
@@ -5846,7 +6018,7 @@ function handleLayout(ctx, layoutParam, setCanRender) {
   if (didChange) {
     state.scrollLength = scrollLength;
     state.otherAxisSize = otherAxisSize;
-    updateContentMetrics(ctx);
+    updateContentMetricsState(ctx);
     state.lastBatchingAction = Date.now();
     state.scrollForNextCalculateItemsInView = void 0;
     if (scrollLength > 0) {
@@ -6083,28 +6255,12 @@ function updateContentInsetEndAdjustment(ctx, previousContentInsetEndAdjustment)
 
 // src/core/updateItemSize.ts
 function runOrScheduleMVCPRecalculate(ctx) {
-  var _a3, _b;
+  var _a3;
   const state = ctx.state;
   if (state.userScrollAnchorReset !== void 0) {
-    const replacementBatchSize = (_a3 = state.userScrollAnchorReset.batchSize) != null ? _a3 : state.userScrollAnchorReset.keys.size;
-    const replacementMeasurementBatchThreshold = 3;
-    const shouldBatchReplacementMeasurements = replacementBatchSize > replacementMeasurementBatchThreshold;
-    if (shouldBatchReplacementMeasurements) {
-      if (state.queuedMVCPRecalculate === void 0) {
-        state.queuedMVCPRecalculate = requestAnimationFrame(() => {
-          var _a4;
-          state.queuedMVCPRecalculate = void 0;
-          calculateItemsInView(ctx);
-          if (((_a4 = state.userScrollAnchorReset) == null ? void 0 : _a4.keys.size) === 0) {
-            state.userScrollAnchorReset = void 0;
-          }
-        });
-      }
-    } else {
-      calculateItemsInView(ctx);
-      if (((_b = state.userScrollAnchorReset) == null ? void 0 : _b.keys.size) === 0) {
-        state.userScrollAnchorReset = void 0;
-      }
+    calculateItemsInView(ctx);
+    if (((_a3 = state.userScrollAnchorReset) == null ? void 0 : _a3.keys.size) === 0) {
+      state.userScrollAnchorReset = void 0;
     }
   } else {
     if (!state.mvcpAnchorLock) {
@@ -6564,6 +6720,9 @@ function createImperativeHandle(ctx, scheduleImperativeScrollCommit) {
       scrollTo(ctx, params);
       return true;
     }),
+    setItemSize: (itemKey, size) => {
+      updateItemSize(ctx, itemKey, size);
+    },
     setScrollProcessingEnabled: (enabled) => {
       state.scrollProcessingEnabled = enabled;
     },
@@ -6788,7 +6947,7 @@ var LegendList = typedMemo(
   })
 );
 var LegendListInner = typedForwardRef(function LegendListInner2(props, forwardedRef) {
-  var _a3, _b, _c, _d, _e, _f, _g, _h, _i;
+  var _a3, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o;
   const noopOnScroll = React3.useCallback((_event) => {
   }, []);
   if (props.recycleItems === void 0) {
@@ -6819,6 +6978,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     initialScrollAtEnd = false,
     initialScrollIndex: initialScrollIndexProp,
     initialScrollOffset: initialScrollOffsetProp,
+    experimental_adaptiveRender,
     itemsAreEqual,
     keyExtractor: keyExtractorProp,
     ListEmptyComponent,
@@ -6915,6 +7075,8 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
   const [, scheduleImperativeScrollCommit] = React3__namespace.useReducer((value) => value + 1, 0);
   const ctx = useStateContext();
   ctx.columnWrapperStyle = columnWrapperStyle || (contentContainerStyle ? createColumnWrapperStyle(contentContainerStyle) : void 0);
+  const scrollAxisGap = horizontal ? (_f = (_d = ctx.columnWrapperStyle) == null ? void 0 : _d.columnGap) != null ? _f : (_e = ctx.columnWrapperStyle) == null ? void 0 : _e.gap : (_i = (_g = ctx.columnWrapperStyle) == null ? void 0 : _g.rowGap) != null ? _i : (_h = ctx.columnWrapperStyle) == null ? void 0 : _h.gap;
+  const nextScrollAxisGap = typeof scrollAxisGap === "number" && Number.isFinite(scrollAxisGap) ? scrollAxisGap : 0;
   const refScroller = React3.useRef(null);
   const combinedRef = useCombinedRef(refScroller, refScrollView);
   const keyExtractor = keyExtractorProp != null ? keyExtractorProp : ((_item, index) => index.toString());
@@ -6928,8 +7090,8 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     anchoredEndSpace == null ? void 0 : anchoredEndSpace.anchorIndex,
     alwaysRender == null ? void 0 : alwaysRender.top,
     alwaysRender == null ? void 0 : alwaysRender.bottom,
-    (_d = alwaysRender == null ? void 0 : alwaysRender.indices) == null ? void 0 : _d.join(","),
-    (_e = alwaysRender == null ? void 0 : alwaysRender.keys) == null ? void 0 : _e.join(","),
+    (_j = alwaysRender == null ? void 0 : alwaysRender.indices) == null ? void 0 : _j.join(","),
+    (_k = alwaysRender == null ? void 0 : alwaysRender.keys) == null ? void 0 : _k.join(","),
     dataProp,
     dataVersion,
     keyExtractor
@@ -6957,6 +7119,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
         endNoBuffer: -1,
         endReachedSnapshot: void 0,
         firstFullyOnScreenIndex: -1,
+        hasHadNonEmptyData: dataProp.length > 0,
         idCache: [],
         idsInView: [],
         indexByKey: /* @__PURE__ */ new Map(),
@@ -6999,6 +7162,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
         startReachedSnapshotDataChangeEpoch: void 0,
         stickyContainerPool: /* @__PURE__ */ new Set(),
         stickyContainers: /* @__PURE__ */ new Map(),
+        timeoutAdaptiveRender: void 0,
         timeouts: /* @__PURE__ */ new Set(),
         totalSize: 0,
         viewabilityConfigCallbackPairs: void 0
@@ -7017,11 +7181,13 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
   const state = refState.current;
   const isFirstLocal = state.isFirst;
   const previousNumColumnsProp = state.props.numColumns;
-  state.didColumnsChange = numColumnsProp !== previousNumColumnsProp;
+  const didScrollAxisGapChange = !isFirstLocal && ctx.scrollAxisGap !== nextScrollAxisGap;
+  ctx.scrollAxisGap = nextScrollAxisGap;
+  state.didColumnsChange = numColumnsProp !== previousNumColumnsProp || didScrollAxisGapChange;
   const didDataReferenceChangeLocal = state.props.data !== dataProp;
   const didDataVersionChangeLocal = state.props.dataVersion !== dataVersion;
   const didDataChangeLocal = didDataVersionChangeLocal || didDataReferenceChangeLocal && checkStructuralDataChange(state, dataProp, state.props.data);
-  if (didDataChangeLocal && !initialScrollAtEnd && state.didFinishInitialScroll && ((_f = state.initialScroll) == null ? void 0 : _f.viewPosition) === 1 && state.props.data.length > 0) {
+  if (didDataChangeLocal && !initialScrollAtEnd && state.didFinishInitialScroll && ((_l = state.initialScroll) == null ? void 0 : _l.viewPosition) === 1 && state.props.data.length > 0) {
     clearPreservedInitialScrollTarget(state);
   }
   if (didDataChangeLocal) {
@@ -7033,8 +7199,9 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
   const throttledOnScroll = useThrottledOnScroll(onScrollProp != null ? onScrollProp : noopOnScroll, scrollEventThrottle != null ? scrollEventThrottle : 0);
   const throttleScrollFn = scrollEventThrottle && onScrollProp ? throttledOnScroll : onScrollProp;
   const anchoredEndSpaceResolved = anchoredEndSpace ? { ...anchoredEndSpace, includeInEndInset: true } : anchoredEndSpace;
-  const didAnchoredEndSpaceAnchorIndexChange = !isFirstLocal && !didDataChangeLocal && ((_g = state.props.anchoredEndSpace) == null ? void 0 : _g.anchorIndex) !== (anchoredEndSpaceResolved == null ? void 0 : anchoredEndSpaceResolved.anchorIndex);
+  const didAnchoredEndSpaceAnchorIndexChange = !isFirstLocal && !didDataChangeLocal && ((_m = state.props.anchoredEndSpace) == null ? void 0 : _m.anchorIndex) !== (anchoredEndSpaceResolved == null ? void 0 : anchoredEndSpaceResolved.anchorIndex);
   state.props = {
+    adaptiveRender: experimental_adaptiveRender,
     alignItemsAtEnd,
     alignItemsAtEndPaddingEnabled: useAlignItemsAtEndPadding,
     alwaysRender,
@@ -7042,6 +7209,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     alwaysRenderIndicesSet: alwaysRenderIndices.set,
     anchoredEndSpace: anchoredEndSpaceResolved,
     animatedProps: animatedPropsInternal,
+    contentContainerAlignItems: contentContainerStyle.alignItems,
     contentInset,
     contentInsetEndAdjustment: contentInsetEndAdjustmentResolved,
     data: dataProp,
@@ -7094,7 +7262,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     const prevPaddingTop = peek$(ctx, "stylePaddingTop");
     setPaddingTop(ctx, { stylePaddingTop: stylePaddingTopState });
     refState.current.props.stylePaddingBottom = stylePaddingBottomState;
-    updateContentMetrics(ctx);
+    updateContentMetricsState(ctx);
     let paddingDiff = stylePaddingTopState - prevPaddingTop;
     if (shouldAdjustPadding && maintainVisibleContentPositionConfig.size && paddingDiff && prevPaddingTop !== void 0 && Platform.OS === "ios") ;
   };
@@ -7126,7 +7294,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       useBootstrapInitialScroll: usesBootstrapInitialScroll
     });
   }, []);
-  if (isFirstLocal || didDataChangeLocal || numColumnsProp !== peek$(ctx, "numColumns")) {
+  if (isFirstLocal || didDataChangeLocal || state.didColumnsChange) {
     refState.current.lastBatchingAction = Date.now();
     if (!keyExtractorProp && !isFirstLocal && didDataChangeLocal) {
       refState.current.sizes.clear();
@@ -7143,6 +7311,8 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       dataLength: dataProp.length,
       didDataChange: didDataChangeLocal,
       initialScrollAtEnd,
+      latestInitialScroll: initialScrollProp,
+      latestInitialScrollSessionKind: initialScrollUsesOffsetOnly ? "offset" : "bootstrap",
       stylePaddingBottom: stylePaddingBottomState,
       useBootstrapInitialScroll: usesBootstrapInitialScroll
     });
@@ -7217,6 +7387,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       dataVersion,
       memoizedLastItemKeys.join(","),
       numColumnsProp,
+      nextScrollAxisGap,
       stylePaddingBottomState,
       stylePaddingTopState,
       useAlignItemsAtEndPadding
@@ -7239,7 +7410,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     state.didColumnsChange = false;
     state.didDataChange = false;
     state.isFirst = false;
-  }, [dataProp, dataVersion, numColumnsProp]);
+  }, [dataProp, dataVersion, numColumnsProp, nextScrollAxisGap]);
   React3.useLayoutEffect(() => {
     var _a4;
     set$(ctx, "extraData", extraData);
@@ -7287,6 +7458,14 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
   useInit(() => {
   });
   React3.useImperativeHandle(forwardedRef, () => createImperativeHandle(ctx, scheduleImperativeScrollCommit), []);
+  React3.useEffect(() => {
+    return () => {
+      for (const timeout of state.timeouts) {
+        clearTimeout(timeout);
+      }
+      state.timeouts.clear();
+    };
+  }, [state]);
   React3.useLayoutEffect(() => {
     var _a4;
     (_a4 = state.runPendingScrollToEnd) == null ? void 0 : _a4.call(state);
@@ -7334,7 +7513,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       onScroll: onScrollHandler,
       recycleItems,
       refreshControl: refreshControlElement ? stylePaddingTopState > 0 ? React3__namespace.cloneElement(refreshControlElement, {
-        progressViewOffset: ((_h = refreshControlElement.props.progressViewOffset) != null ? _h : 0) + stylePaddingTopState
+        progressViewOffset: ((_n = refreshControlElement.props.progressViewOffset) != null ? _n : 0) + stylePaddingTopState
       }) : refreshControlElement : onRefresh && /* @__PURE__ */ React3__namespace.createElement(
         RefreshControl,
         {
@@ -7345,7 +7524,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       ),
       refScrollView: combinedRef,
       renderScrollComponent,
-      scrollAdjustHandler: (_i = refState.current) == null ? void 0 : _i.scrollAdjustHandler,
+      scrollAdjustHandler: (_o = refState.current) == null ? void 0 : _o.scrollAdjustHandler,
       scrollEventThrottle: 0,
       snapToIndices,
       stickyHeaderIndices,
@@ -7403,6 +7582,8 @@ var internal2 = internal;
 
 exports.LegendList = LegendList3;
 exports.internal = internal2;
+exports.useAdaptiveRender = useAdaptiveRender;
+exports.useAdaptiveRenderChange = useAdaptiveRenderChange;
 exports.useIsLastItem = useIsLastItem;
 exports.useListScrollSize = useListScrollSize;
 exports.useRecyclingEffect = useRecyclingEffect;