@legendapp/list 3.0.6 → 3.1.1

package/react-native.mjs

@@ -131,6 +131,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],
@@ -143,6 +144,7 @@ function StateProvider({ children }) {
       ["isNearEnd", false],
       ["isNearStart", false],
       ["isWithinMaintainScrollAtEndThreshold", false],
+      ["adaptiveRender", "light"],
       ["totalSize", 0],
       ["scrollAdjustPending", 0]
     ]),
@@ -588,6 +590,24 @@ var ContextContainer = createContext(null);
 function useContextContainer() {
   return useContext(ContextContainer);
 }
+function useAdaptiveRender() {
+  const [mode] = useArr$(["adaptiveRender"]);
+  return mode;
+}
+function useAdaptiveRenderChange(callback) {
+  const ctx = useStateContext();
+  const callbackRef = useRef(callback);
+  callbackRef.current = callback;
+  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();
@@ -804,6 +824,7 @@ function isInMVCPActiveMode(state) {
 // src/components/Container.tsx
 function getContainerPositionStyle({
   columnWrapperStyle,
+  contentContainerAlignItems,
   horizontal,
   hasItemSeparator,
   isHorizontalRTLList,
@@ -829,13 +850,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,
@@ -889,6 +911,7 @@ var Container = typedMemo(function Container2({
   const style = useMemo(
     () => getContainerPositionStyle({
       columnWrapperStyle,
+      contentContainerAlignItems: ctx.state.props.contentContainerAlignItems,
       hasItemSeparator: !!ItemSeparatorComponent,
       horizontal,
       isHorizontalRTLList,
@@ -902,6 +925,7 @@ var Container = typedMemo(function Container2({
       otherAxisPos,
       otherAxisSize,
       columnWrapperStyle,
+      ctx.state.props.contentContainerAlignItems,
       numColumns,
       ItemSeparatorComponent
     ]
@@ -1172,7 +1196,91 @@ function WebAnchoredEndSpace({ horizontal }) {
   return /* @__PURE__ */ React2.createElement("div", { style }, null);
 }
 
-// src/core/updateContentMetrics.ts
+// src/core/doMaintainScrollAtEnd.ts
+function doMaintainScrollAtEnd(ctx) {
+  const state = ctx.state;
+  const {
+    didContainersLayout,
+    pendingNativeMVCPAdjust,
+    refScroller,
+    props: { maintainScrollAtEnd }
+  } = state;
+  const isWithinMaintainScrollAtEndThreshold = peek$(ctx, "isWithinMaintainScrollAtEndThreshold");
+  const shouldMaintainScrollAtEnd = !!(isWithinMaintainScrollAtEndThreshold && maintainScrollAtEnd && didContainersLayout);
+  if (pendingNativeMVCPAdjust) {
+    state.pendingMaintainScrollAtEnd = shouldMaintainScrollAtEnd;
+    return false;
+  }
+  state.pendingMaintainScrollAtEnd = false;
+  if (shouldMaintainScrollAtEnd) {
+    const contentSize = getContentSize(ctx);
+    if (contentSize < state.scrollLength) {
+      state.scroll = 0;
+    }
+    if (!state.maintainingScrollAtEnd) {
+      const pendingState = maintainScrollAtEnd.animated ? "pending-animated" : "pending-instant";
+      const activeState = maintainScrollAtEnd.animated ? "animated" : "instant";
+      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);
+            const logicalEndOffset = getLogicalHorizontalMaxOffset(state, currentContentSize);
+            const nativeOffset = toNativeHorizontalOffset(state, logicalEndOffset, currentContentSize);
+            scroller == null ? void 0 : scroller.scrollTo({
+              animated: maintainScrollAtEnd.animated,
+              x: nativeOffset,
+              y: 0
+            });
+          } else {
+            scroller == null ? void 0 : scroller.scrollToEnd({
+              animated: maintainScrollAtEnd.animated
+            });
+          }
+          setTimeout(
+            () => {
+              if (state.maintainingScrollAtEnd === activeState) {
+                state.maintainingScrollAtEnd = void 0;
+              }
+            },
+            maintainScrollAtEnd.animated ? 500 : 0
+          );
+        } else if (state.maintainingScrollAtEnd === pendingState) {
+          state.maintainingScrollAtEnd = void 0;
+        }
+      });
+    }
+    return true;
+  }
+  return false;
+}
+
+// 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/updateContentMetricsState.ts
 function getRawContentLength(ctx) {
   var _a3, _b, _c;
   const { state, values } = ctx;
@@ -1183,240 +1291,187 @@ 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);
+
+// 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) {
+    if (!IsNewArchitecture && state.initialScroll && totalSize < prevTotalSize) {
+      state.pendingTotalSize = totalSize;
+    } else {
+      state.pendingTotalSize = void 0;
+      state.totalSize = totalSize;
+      if (notifyTotalSize) {
+        set$(ctx, "totalSize", totalSize);
+      }
+      updateContentMetricsState(ctx);
+    }
+  } else if (notifyTotalSize && ctx.values.get("totalSize") !== totalSize) {
+    set$(ctx, "totalSize", totalSize);
   }
 }
-function setHeaderSize(ctx, size) {
-  setContentLengthSignal(ctx, "headerSize", size);
+
+// 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);
 }
-function setFooterSize(ctx, size) {
-  setContentLengthSignal(ctx, "footerSize", 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 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 getKnownOrFixedItemSize(ctx, index) {
+  const key = getId(ctx.state, index);
+  return getKnownOrFixedSize(ctx, key, index, ctx.state.props.data[index]);
 }
-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);
+function areKnownOrFixedItemSizesAvailable(ctx, startIndex, endIndex) {
+  for (let index = startIndex; index <= endIndex; index++) {
+    if (getKnownOrFixedItemSize(ctx, index) === void 0) {
+      return false;
+    }
   }
-  return didChange;
+  return true;
 }
-function useLatestRef(value) {
-  const ref = React2.useRef(value);
-  ref.current = value;
-  return ref;
+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 + ctx.scrollAxisGap;
+  }
+  setSize(ctx, key, size, notifyTotalSize);
+  return size;
 }
-
-// src/hooks/useStableRenderComponent.tsx
-function useStableRenderComponent(renderComponent, mapProps) {
-  const renderComponentRef = useLatestRef(renderComponent);
-  const mapPropsRef = useLatestRef(mapProps);
-  return React2.useMemo(
-    () => React2.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]
-  );
+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]);
 }
-var LayoutView = ({ onLayoutChange, refView, ...rest }) => {
-  const localRef = useRef(null);
-  const ref = refView != null ? refView : localRef;
-  const { onLayout } = useOnLayoutSync({ onLayoutChange, ref });
-  return /* @__PURE__ */ React2.createElement(View$1, { ...rest, onLayout, ref });
-};
 
-// 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;
-  useLayoutEffect(() => {
-    if (!ListHeaderComponent) {
-      setHeaderSize(ctx, 0);
-    }
-    if (!ListFooterComponent) {
-      setFooterSize(ctx, 0);
-    }
-  }, [ListHeaderComponent, ListFooterComponent, ctx]);
-  const onLayoutHeader = useCallback(
-    (rect) => {
-      const size = rect[horizontal ? "width" : "height"];
-      setHeaderSize(ctx, size);
-    },
-    [ctx, horizontal]
-  );
-  const onLayoutFooterInternal = useCallback(
-    (rect, fromLayoutEffect) => {
-      const size = rect[horizontal ? "width" : "height"];
-      setFooterSize(ctx, size);
-      onLayoutFooter == null ? void 0 : onLayoutFooter(rect, fromLayoutEffect);
-    },
-    [ctx, horizontal, onLayoutFooter]
-  );
-  return /* @__PURE__ */ React2.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__ */ React2.createElement(ScrollAdjust, null),
-    ListHeaderComponent && /* @__PURE__ */ React2.createElement(LayoutView, { onLayoutChange: onLayoutHeader, style: ListHeaderComponentStyle }, getComponent(ListHeaderComponent)),
-    ListEmptyComponent && getComponent(ListEmptyComponent),
-    alignItemsAtEndPadding > 0 && /* @__PURE__ */ React2.createElement(
-      View,
-      {
-        style: horizontal ? { flexShrink: 0, width: alignItemsAtEndPadding } : { flexShrink: 0, height: alignItemsAtEndPadding }
-      },
-      null
-    ),
-    canRender && !ListEmptyComponent && /* @__PURE__ */ React2.createElement(
-      Containers,
-      {
-        getRenderedItem: getRenderedItem2,
-        horizontal,
-        ItemSeparatorComponent,
-        recycleItems,
-        stickyHeaderConfig,
-        updateItemSize: updateItemSize2
-      }
-    ),
-    ListFooterComponent && /* @__PURE__ */ React2.createElement(LayoutView, { onLayoutChange: onLayoutFooterInternal, style: ListFooterComponentStyle }, getComponent(ListFooterComponent)),
-    Platform.OS === "web" && /* @__PURE__ */ React2.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;
-  useEffect(() => {
-    if (useWindowScroll && renderScrollComponent) {
-      warnDevOnce(
-        "useWindowScrollRenderScrollComponent",
-        "useWindowScroll is not supported when renderScrollComponent is provided."
-      );
-    }
-  }, [renderScrollComponent, useWindowScroll]);
-  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."
-      );
+// 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;
     }
-  }, [childrenMode, ctx, keyExtractor]);
-  useEffect(() => {
-    const state = ctx.state;
+  }
+  if (viewPosition !== void 0 && index !== void 0) {
     const dataLength = state.props.data.length;
-    const useWindowScrollResolved = state.props.useWindowScroll;
-    if (Platform.OS !== "web" || useWindowScrollResolved || dataLength < WEB_UNBOUNDED_HEIGHT_MIN_DATA_LENGTH) {
-      return;
+    if (dataLength === 0) {
+      return offset;
     }
-    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]);
+    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;
 }
-function useDevChecksNoop(_props) {
+
+// 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" || state.lastLayout)) {
+    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;
 }
-var useDevChecks = IS_DEV ? useDevChecksImpl : useDevChecksNoop;
 
 // src/core/deferredPublicOnScroll.ts
 function withResolvedContentOffset(state, event, resolvedOffset) {
@@ -1729,6 +1784,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,
@@ -1748,6 +1863,13 @@ function setInitialRenderState(ctx, {
   const isReadyToRender = Boolean(state.didContainersLayout && state.didFinishInitialScroll);
   if (isReadyToRender && !peek$(ctx, "readyToRender")) {
     set$(ctx, "readyToRender", true);
+    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 });
     }
@@ -1822,235 +1944,39 @@ function finishInitialScroll(ctx, options) {
   complete();
 }
 
-// src/core/calculateOffsetForIndex.ts
-function calculateOffsetForIndex(ctx, index) {
+// src/core/finishScrollTo.ts
+function finishScrollTo(ctx) {
+  var _a3, _b;
   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) {
-    if (!IsNewArchitecture && state.initialScroll && totalSize < prevTotalSize) {
-      state.pendingTotalSize = totalSize;
-    } else {
-      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" || state.lastLayout)) {
-    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;
-  const state = ctx.state;
-  if (state == null ? void 0 : state.scrollingTo) {
-    const resolvePendingScroll = state.pendingScrollResolve;
-    state.pendingScrollResolve = void 0;
-    const scrollingTo = state.scrollingTo;
-    state.scrollHistory.length = 0;
-    state.scrollingTo = void 0;
-    if (state.pendingTotalSize !== void 0) {
-      addTotalSize(ctx, null, state.pendingTotalSize);
-    }
-    if (PlatformAdjustBreaksScroll) {
-      state.scrollAdjustHandler.commitPendingAdjust(scrollingTo);
-    }
-    if (scrollingTo.isInitialScroll || state.initialScroll) {
-      const isOffsetSession = ((_a3 = state.initialScrollSession) == null ? void 0 : _a3.kind) === "offset";
-      const shouldPreserveResizeTarget = !!scrollingTo.isInitialScroll && !state.clearPreservedInitialScrollOnNextFinish && state.props.data.length > 0 && ((_b = state.initialScroll) == null ? void 0 : _b.viewPosition) === 1;
-      finishInitialScroll(ctx, {
-        onFinished: () => {
-          resolvePendingScroll == null ? void 0 : resolvePendingScroll();
-        },
-        preserveTarget: isOffsetSession && state.props.data.length === 0 || shouldPreserveResizeTarget,
-        recalculateItems: true,
-        schedulePreservedTargetClear: shouldPreserveResizeTarget,
-        syncObservedOffset: isOffsetSession,
-        waitForCompletionFrame: !!scrollingTo.waitForInitialScrollCompletionFrame
-      });
-      return;
-    }
-    recalculateSettledScroll(ctx);
-    resolvePendingScroll == null ? void 0 : resolvePendingScroll();
+  if (state == null ? void 0 : state.scrollingTo) {
+    const resolvePendingScroll = state.pendingScrollResolve;
+    state.pendingScrollResolve = void 0;
+    const scrollingTo = state.scrollingTo;
+    state.scrollHistory.length = 0;
+    state.scrollingTo = void 0;
+    if (state.pendingTotalSize !== void 0) {
+      addTotalSize(ctx, null, state.pendingTotalSize);
+    }
+    if (PlatformAdjustBreaksScroll) {
+      state.scrollAdjustHandler.commitPendingAdjust(scrollingTo);
+    }
+    if (scrollingTo.isInitialScroll || state.initialScroll) {
+      const isOffsetSession = ((_a3 = state.initialScrollSession) == null ? void 0 : _a3.kind) === "offset";
+      const shouldPreserveResizeTarget = !!scrollingTo.isInitialScroll && !state.clearPreservedInitialScrollOnNextFinish && state.props.data.length > 0 && ((_b = state.initialScroll) == null ? void 0 : _b.viewPosition) === 1;
+      finishInitialScroll(ctx, {
+        onFinished: () => {
+          resolvePendingScroll == null ? void 0 : resolvePendingScroll();
+        },
+        preserveTarget: isOffsetSession && state.props.data.length === 0 || shouldPreserveResizeTarget,
+        recalculateItems: true,
+        schedulePreservedTargetClear: shouldPreserveResizeTarget,
+        syncObservedOffset: isOffsetSession,
+        waitForCompletionFrame: !!scrollingTo.waitForInitialScrollCompletionFrame
+      });
+      return;
+    }
+    recalculateSettledScroll(ctx);
+    resolvePendingScroll == null ? void 0 : resolvePendingScroll();
   }
 }
 
@@ -2243,113 +2169,328 @@ function doScrollTo(ctx, params) {
   }
 }
 
-// src/core/doMaintainScrollAtEnd.ts
-function doMaintainScrollAtEnd(ctx) {
+// src/utils/requestAdjust.ts
+function requestAdjust(ctx, positionDiff, dataChanged) {
   const state = ctx.state;
-  const {
-    didContainersLayout,
-    pendingNativeMVCPAdjust,
-    refScroller,
-    props: { maintainScrollAtEnd }
-  } = state;
-  const isWithinMaintainScrollAtEndThreshold = peek$(ctx, "isWithinMaintainScrollAtEndThreshold");
-  const shouldMaintainScrollAtEnd = !!(isWithinMaintainScrollAtEndThreshold && maintainScrollAtEnd && didContainersLayout);
-  if (pendingNativeMVCPAdjust) {
-    state.pendingMaintainScrollAtEnd = shouldMaintainScrollAtEnd;
-    return false;
+  if (Math.abs(positionDiff) > 0.1) {
+    const needsScrollWorkaround = Platform.OS === "android" && !IsNewArchitecture && dataChanged && state.scroll <= positionDiff;
+    const doit = () => {
+      if (needsScrollWorkaround) {
+        doScrollTo(ctx, { horizontal: state.props.horizontal, offset: state.scroll });
+      } else {
+        state.scrollAdjustHandler.requestAdjust(positionDiff);
+        if (state.adjustingFromInitialMount) {
+          state.adjustingFromInitialMount--;
+        }
+      }
+    };
+    state.scroll += positionDiff;
+    state.scrollForNextCalculateItemsInView = void 0;
+    const readyToRender = peek$(ctx, "readyToRender");
+    if (readyToRender) {
+      doit();
+      if (Platform.OS !== "web") {
+        const threshold = state.scroll - positionDiff / 2;
+        if (!state.ignoreScrollFromMVCP) {
+          state.ignoreScrollFromMVCP = {};
+        }
+        if (positionDiff > 0) {
+          state.ignoreScrollFromMVCP.lt = threshold;
+        } else {
+          state.ignoreScrollFromMVCP.gt = threshold;
+        }
+        if (state.ignoreScrollFromMVCPTimeout) {
+          clearTimeout(state.ignoreScrollFromMVCPTimeout);
+        }
+        const delay = needsScrollWorkaround ? 250 : 100;
+        state.ignoreScrollFromMVCPTimeout = setTimeout(() => {
+          var _a3;
+          state.ignoreScrollFromMVCP = void 0;
+          const shouldForceUpdate = state.ignoreScrollFromMVCPIgnored && state.scrollProcessingEnabled !== false;
+          if (shouldForceUpdate) {
+            state.ignoreScrollFromMVCPIgnored = false;
+            state.scrollPending = state.scroll;
+            (_a3 = state.reprocessCurrentScroll) == null ? void 0 : _a3.call(state);
+          }
+        }, delay);
+      }
+    } else {
+      state.adjustingFromInitialMount = (state.adjustingFromInitialMount || 0) + 1;
+      requestAnimationFrame(doit);
+    }
   }
-  state.pendingMaintainScrollAtEnd = false;
-  if (shouldMaintainScrollAtEnd) {
-    const contentSize = getContentSize(ctx);
-    if (contentSize < state.scrollLength) {
-      state.scroll = 0;
+}
+
+// src/core/updateContentMetrics.ts
+var SCROLL_ADJUST_EPSILON = 0.1;
+function setContentLengthSignal(ctx, signalName, size) {
+  const didChange = peek$(ctx, signalName) !== size;
+  if (didChange) {
+    set$(ctx, signalName, size);
+    updateContentMetricsState(ctx);
+  }
+  return didChange;
+}
+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 Platform.OS === "web" && 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) {
+  return 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 useLatestRef(value) {
+  const ref = React2.useRef(value);
+  ref.current = value;
+  return ref;
+}
+
+// src/hooks/useStableRenderComponent.tsx
+function useStableRenderComponent(renderComponent, mapProps) {
+  const renderComponentRef = useLatestRef(renderComponent);
+  const mapPropsRef = useLatestRef(mapProps);
+  return React2.useMemo(
+    () => React2.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, ...rest }) => {
+  const localRef = useRef(null);
+  const ref = refView != null ? refView : localRef;
+  const { onLayout } = useOnLayoutSync({ onLayoutChange, ref });
+  return /* @__PURE__ */ React2.createElement(View$1, { ...rest, onLayout, ref });
+};
+
+// src/components/ListComponent.tsx
+var AlignItemsAtEndSpacer = typedMemo(function AlignItemsAtEndSpacer2({ horizontal }) {
+  const [alignItemsAtEndPadding = 0] = useArr$(["alignItemsAtEndPadding"]);
+  if (alignItemsAtEndPadding <= 0) {
+    return null;
+  }
+  return /* @__PURE__ */ React2.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;
+  const updateFooterSize = useCallback(
+    (size, afterSizeUpdate) => {
+      var _a3;
+      const didFooterSizeChange = setFooterSize(ctx, size);
+      afterSizeUpdate == null ? void 0 : afterSizeUpdate();
+      if (didFooterSizeChange && ((_a3 = ctx.state.props.maintainScrollAtEnd) == null ? void 0 : _a3.onFooterLayout)) {
+        doMaintainScrollAtEnd(ctx);
+      }
+    },
+    [ctx]
+  );
+  useLayoutEffect(() => {
+    if (!ListHeaderComponent) {
+      setHeaderSize(ctx, 0);
+    }
+    if (!ListFooterComponent) {
+      updateFooterSize(0);
+    }
+  }, [ListHeaderComponent, ListFooterComponent, ctx, updateFooterSize]);
+  const onLayoutHeader = useCallback(
+    (rect) => {
+      const size = rect[horizontal ? "width" : "height"];
+      setHeaderSize(ctx, size);
+    },
+    [ctx, horizontal]
+  );
+  const onLayoutFooterInternal = useCallback(
+    (rect, fromLayoutEffect) => {
+      const size = rect[horizontal ? "width" : "height"];
+      updateFooterSize(size, () => {
+        onLayoutFooter == null ? void 0 : onLayoutFooter(rect, fromLayoutEffect);
+      });
+    },
+    [horizontal, onLayoutFooter, updateFooterSize]
+  );
+  return /* @__PURE__ */ React2.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__ */ React2.createElement(ScrollAdjust, null),
+    ListHeaderComponent && /* @__PURE__ */ React2.createElement(LayoutView, { onLayoutChange: onLayoutHeader, style: ListHeaderComponentStyle }, getComponent(ListHeaderComponent)),
+    ListEmptyComponent && getComponent(ListEmptyComponent),
+    shouldRenderAlignItemsAtEndSpacer && /* @__PURE__ */ React2.createElement(AlignItemsAtEndSpacer, { horizontal }),
+    canRender && !ListEmptyComponent && /* @__PURE__ */ React2.createElement(
+      Containers,
+      {
+        getRenderedItem: getRenderedItem2,
+        horizontal,
+        ItemSeparatorComponent,
+        recycleItems,
+        stickyHeaderConfig,
+        updateItemSize: updateItemSize2
+      }
+    ),
+    ListFooterComponent && /* @__PURE__ */ React2.createElement(LayoutView, { onLayoutChange: onLayoutFooterInternal, style: ListFooterComponentStyle }, getComponent(ListFooterComponent)),
+    Platform.OS === "web" && /* @__PURE__ */ React2.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;
+  useEffect(() => {
+    if (useWindowScroll && renderScrollComponent) {
+      warnDevOnce(
+        "useWindowScrollRenderScrollComponent",
+        "useWindowScroll is not supported when renderScrollComponent is provided."
+      );
     }
-    if (!state.maintainingScrollAtEnd) {
-      state.maintainingScrollAtEnd = true;
-      requestAnimationFrame(() => {
-        if (peek$(ctx, "isWithinMaintainScrollAtEndThreshold")) {
-          const scroller = refScroller.current;
-          if (state.props.horizontal && isHorizontalRTL(state)) {
-            const currentContentSize = getContentSize(ctx);
-            const logicalEndOffset = getLogicalHorizontalMaxOffset(state, currentContentSize);
-            const nativeOffset = toNativeHorizontalOffset(state, logicalEndOffset, currentContentSize);
-            scroller == null ? void 0 : scroller.scrollTo({
-              animated: maintainScrollAtEnd.animated,
-              x: nativeOffset,
-              y: 0
-            });
-          } else {
-            scroller == null ? void 0 : scroller.scrollToEnd({
-              animated: maintainScrollAtEnd.animated
-            });
-          }
-          setTimeout(
-            () => {
-              state.maintainingScrollAtEnd = false;
-            },
-            maintainScrollAtEnd.animated ? 500 : 0
-          );
-        } else {
-          state.maintainingScrollAtEnd = false;
-        }
-      });
+  }, [renderScrollComponent, useWindowScroll]);
+  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."
+      );
     }
-    return true;
-  }
-  return false;
-}
-
-// src/utils/requestAdjust.ts
-function requestAdjust(ctx, positionDiff, dataChanged) {
-  const state = ctx.state;
-  if (Math.abs(positionDiff) > 0.1) {
-    const needsScrollWorkaround = Platform.OS === "android" && !IsNewArchitecture && dataChanged && state.scroll <= positionDiff;
-    const doit = () => {
-      if (needsScrollWorkaround) {
-        doScrollTo(ctx, { horizontal: state.props.horizontal, offset: state.scroll });
-      } else {
-        state.scrollAdjustHandler.requestAdjust(positionDiff);
-        if (state.adjustingFromInitialMount) {
-          state.adjustingFromInitialMount--;
-        }
+  }, [childrenMode, ctx, keyExtractor]);
+  useEffect(() => {
+    const state = ctx.state;
+    const dataLength = state.props.data.length;
+    const useWindowScrollResolved = state.props.useWindowScroll;
+    if (Platform.OS !== "web" || 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."
+        );
       }
     };
-    state.scroll += positionDiff;
-    state.scrollForNextCalculateItemsInView = void 0;
-    const readyToRender = peek$(ctx, "readyToRender");
-    if (readyToRender) {
-      doit();
-      if (Platform.OS !== "web") {
-        const threshold = state.scroll - positionDiff / 2;
-        if (!state.ignoreScrollFromMVCP) {
-          state.ignoreScrollFromMVCP = {};
-        }
-        if (positionDiff > 0) {
-          state.ignoreScrollFromMVCP.lt = threshold;
-        } else {
-          state.ignoreScrollFromMVCP.gt = threshold;
-        }
-        if (state.ignoreScrollFromMVCPTimeout) {
-          clearTimeout(state.ignoreScrollFromMVCPTimeout);
-        }
-        const delay = needsScrollWorkaround ? 250 : 100;
-        state.ignoreScrollFromMVCPTimeout = setTimeout(() => {
-          var _a3;
-          state.ignoreScrollFromMVCP = void 0;
-          const shouldForceUpdate = state.ignoreScrollFromMVCPIgnored && state.scrollProcessingEnabled !== false;
-          if (shouldForceUpdate) {
-            state.ignoreScrollFromMVCPIgnored = false;
-            state.scrollPending = state.scroll;
-            (_a3 = state.reprocessCurrentScroll) == null ? void 0 : _a3.call(state);
-          }
-        }, delay);
+    warnIfUnboundedOuterSize();
+    const unsubscribe = [
+      listen$(ctx, "numContainers", warnIfUnboundedOuterSize),
+      listen$(ctx, "readyToRender", warnIfUnboundedOuterSize),
+      listen$(ctx, "totalSize", warnIfUnboundedOuterSize)
+    ];
+    return () => {
+      for (const unsub of unsubscribe) {
+        unsub();
       }
-    } else {
-      state.adjustingFromInitialMount = (state.adjustingFromInitialMount || 0) + 1;
-      requestAnimationFrame(doit);
-    }
-  }
+    };
+  }, [ctx]);
+}
+function useDevChecksNoop(_props) {
 }
+var useDevChecks = IS_DEV ? useDevChecksImpl : useDevChecksNoop;
 
 // src/core/mvcp.ts
 var MVCP_POSITION_EPSILON = 0.1;
@@ -2499,6 +2640,10 @@ function prepareMVCP(ctx, dataChanged) {
   const now = Date.now();
   const enableMVCPAnchorLock = isWeb && (!!dataChanged || !!state.mvcpAnchorLock);
   const scrollingTo = state.scrollingTo;
+  if (isWeb && dataChanged && state.pendingScrollToEnd && scrollingTo === void 0) {
+    state.mvcpAnchorLock = void 0;
+    return void 0;
+  }
   const anchorLock = isWeb ? resolveAnchorLock(state, enableMVCPAnchorLock, mvcpData, now) : void 0;
   let prevPosition;
   let targetId;
@@ -2634,7 +2779,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, dataChanged && mvcpData);
         }
@@ -2648,6 +2793,45 @@ var flushSync = (fn) => {
   fn();
 };
 
+// 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;
@@ -2673,6 +2857,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) {
@@ -2696,7 +2882,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) {
@@ -3631,9 +3817,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;
   }
@@ -3857,45 +4066,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;
@@ -4631,7 +4801,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,
@@ -4640,14 +4810,7 @@ function calculateItemsInView(ctx, params = {}) {
       indexByKey,
       minIndexSizeChanged,
       positions,
-      props: {
-        alwaysRenderIndicesArr,
-        alwaysRenderIndicesSet,
-        drawDistance,
-        getItemType,
-        keyExtractor,
-        onStickyHeaderChange
-      },
+      props: { alwaysRenderIndicesArr, alwaysRenderIndicesSet, getItemType, keyExtractor, onStickyHeaderChange },
       scrollForNextCalculateItemsInView,
       scrollLength,
       sizes,
@@ -4659,6 +4822,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;
@@ -4669,10 +4833,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)
@@ -4696,19 +4860,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)) {
@@ -4741,7 +4911,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;
         }
       }
@@ -4750,7 +4920,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,
@@ -4776,21 +4946,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;
@@ -4825,8 +4998,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);
@@ -4882,7 +5055,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);
@@ -4891,7 +5064,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);
@@ -4902,7 +5075,7 @@ function calculateItemsInView(ctx, params = {}) {
         handleStickyActivation(
           ctx,
           stickyHeaderIndicesArr,
-          currentStickyIdx,
+          (_o = stickyState == null ? void 0 : stickyState.currentStickyIdx) != null ? _o : -1,
           needNewContainers,
           needNewContainersSet,
           startBuffered,
@@ -4928,7 +5101,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);
@@ -4939,7 +5112,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);
@@ -4970,14 +5143,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);
@@ -4991,7 +5162,7 @@ function calculateItemsInView(ctx, params = {}) {
         stickyHeaderIndicesArr,
         scroll,
         drawDistance,
-        currentStickyIdx,
+        (_s = stickyState == null ? void 0 : stickyState.currentStickyIdx) != null ? _s : -1,
         pendingRemoval,
         alwaysRenderSet
       );
@@ -5052,7 +5223,7 @@ function calculateItemsInView(ctx, params = {}) {
         );
       }
     }
-    finishCalculateItemsInView == null ? void 0 : finishCalculateItemsInView();
+    (_t = stickyState == null ? void 0 : stickyState.finishCalculateItemsInView) == null ? void 0 : _t.call(stickyState);
   });
 }
 
@@ -5135,8 +5306,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;
@@ -5147,12 +5319,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,
@@ -5207,7 +5379,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) {
@@ -5448,28 +5620,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 (Platform.OS === "web") {
     if (!state.mvcpAnchorLock) {
@@ -5947,6 +6103,9 @@ function createImperativeHandle(ctx, scheduleImperativeScrollCommit) {
       scrollTo(ctx, params);
       return true;
     }),
+    setItemSize: (itemKey, size) => {
+      updateItemSize(ctx, itemKey, size);
+    },
     setScrollProcessingEnabled: (enabled) => {
       state.scrollProcessingEnabled = enabled;
     },
@@ -6044,12 +6203,13 @@ function getRenderedItem(ctx, key) {
 
 // src/utils/normalizeMaintainScrollAtEnd.ts
 function normalizeMaintainScrollAtEndOn(on, hasExplicitOn) {
-  var _a3, _b, _c;
+  var _a3, _b, _c, _d;
   return {
     animated: false,
     onDataChange: hasExplicitOn ? (_a3 = on == null ? void 0 : on.dataChange) != null ? _a3 : false : true,
-    onItemLayout: hasExplicitOn ? (_b = on == null ? void 0 : on.itemLayout) != null ? _b : false : true,
-    onLayout: hasExplicitOn ? (_c = on == null ? void 0 : on.layout) != null ? _c : false : true
+    onFooterLayout: hasExplicitOn ? (_b = on == null ? void 0 : on.footerLayout) != null ? _b : false : true,
+    onItemLayout: hasExplicitOn ? (_c = on == null ? void 0 : on.itemLayout) != null ? _c : false : true,
+    onLayout: hasExplicitOn ? (_d = on == null ? void 0 : on.layout) != null ? _d : false : true
   };
 }
 function normalizeMaintainScrollAtEnd(value) {
@@ -6171,7 +6331,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 = useCallback((_event) => {
   }, []);
   if (props.recycleItems === void 0) {
@@ -6202,6 +6362,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     initialScrollAtEnd = false,
     initialScrollIndex: initialScrollIndexProp,
     initialScrollOffset: initialScrollOffsetProp,
+    experimental_adaptiveRender,
     itemsAreEqual,
     keyExtractor: keyExtractorProp,
     ListEmptyComponent,
@@ -6298,6 +6459,8 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
   const [, scheduleImperativeScrollCommit] = React2.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 = useRef(null);
   const combinedRef = useCombinedRef(refScroller, refScrollView);
   const keyExtractor = keyExtractorProp != null ? keyExtractorProp : ((_item, index) => index.toString());
@@ -6311,8 +6474,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
@@ -6340,6 +6503,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(),
@@ -6382,6 +6546,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
@@ -6400,11 +6565,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) {
@@ -6416,8 +6583,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 = Platform.OS === "web" && 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,
@@ -6425,6 +6593,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     alwaysRenderIndicesSet: alwaysRenderIndices.set,
     anchoredEndSpace: anchoredEndSpaceResolved,
     animatedProps: animatedPropsInternal,
+    contentContainerAlignItems: contentContainerStyle.alignItems,
     contentInset,
     contentInsetEndAdjustment: contentInsetEndAdjustmentResolved,
     data: dataProp,
@@ -6477,7 +6646,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") {
       if (state.scroll < 0) {
@@ -6514,7 +6683,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();
@@ -6531,6 +6700,8 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       dataLength: dataProp.length,
       didDataChange: didDataChangeLocal,
       initialScrollAtEnd,
+      latestInitialScroll: initialScrollProp,
+      latestInitialScrollSessionKind: initialScrollUsesOffsetOnly ? "offset" : "bootstrap",
       stylePaddingBottom: stylePaddingBottomState,
       useBootstrapInitialScroll: usesBootstrapInitialScroll
     });
@@ -6605,6 +6776,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       dataVersion,
       memoizedLastItemKeys.join(","),
       numColumnsProp,
+      nextScrollAxisGap,
       stylePaddingBottomState,
       stylePaddingTopState,
       useAlignItemsAtEndPadding
@@ -6627,7 +6799,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     state.didColumnsChange = false;
     state.didDataChange = false;
     state.isFirst = false;
-  }, [dataProp, dataVersion, numColumnsProp]);
+  }, [dataProp, dataVersion, numColumnsProp, nextScrollAxisGap]);
   useLayoutEffect(() => {
     var _a4;
     set$(ctx, "extraData", extraData);
@@ -6678,6 +6850,14 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     }
   });
   useImperativeHandle(forwardedRef, () => createImperativeHandle(ctx, scheduleImperativeScrollCommit), []);
+  useEffect(() => {
+    return () => {
+      for (const timeout of state.timeouts) {
+        clearTimeout(timeout);
+      }
+      state.timeouts.clear();
+    };
+  }, [state]);
   useLayoutEffect(() => {
     var _a4;
     (_a4 = state.runPendingScrollToEnd) == null ? void 0 : _a4.call(state);
@@ -6725,7 +6905,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       onScroll: onScrollHandler,
       recycleItems,
       refreshControl: refreshControlElement ? stylePaddingTopState > 0 ? React2.cloneElement(refreshControlElement, {
-        progressViewOffset: ((_h = refreshControlElement.props.progressViewOffset) != null ? _h : 0) + stylePaddingTopState
+        progressViewOffset: ((_n = refreshControlElement.props.progressViewOffset) != null ? _n : 0) + stylePaddingTopState
       }) : refreshControlElement : onRefresh && /* @__PURE__ */ React2.createElement(
         RefreshControl,
         {
@@ -6736,7 +6916,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,
@@ -6768,4 +6948,4 @@ var internal = {
 var LegendList3 = LegendListRuntime;
 var internal2 = internal;
 
-export { LegendList3 as LegendList, internal2 as internal, useIsLastItem, useListScrollSize, useRecyclingEffect, useRecyclingState, useSyncLayout, useViewability, useViewabilityAmount };
+export { LegendList3 as LegendList, internal2 as internal, useAdaptiveRender, useAdaptiveRenderChange, useIsLastItem, useListScrollSize, useRecyclingEffect, useRecyclingState, useSyncLayout, useViewability, useViewabilityAmount };