@legendapp/list 1.1.4 → 2.0.0-next.0

package/index.mjs

@@ -1,8 +1,7 @@
 import * as React2 from 'react';
-import React2__default, { useReducer, useEffect, createContext, useMemo, useRef, useCallback, useLayoutEffect, useImperativeHandle, useContext, useState, forwardRef, memo } from 'react';
+import { useReducer, useEffect, createContext, useMemo, useState, useRef, useCallback, useLayoutEffect, useImperativeHandle, useContext, forwardRef, memo } from 'react';
 import { View, Text, Platform, Animated, ScrollView, StyleSheet, Dimensions, RefreshControl } from 'react-native';
 import { useSyncExternalStore } from 'use-sync-external-store/shim';
-import { LegendList as LegendList$1 } from '@legendapp/list';
 
 // src/LegendList.tsx
 var ContextState = React2.createContext(null);
@@ -10,7 +9,6 @@ function StateProvider({ children }) {
   const [value] = React2.useState(() => ({
     listeners: /* @__PURE__ */ new Map(),
     values: /* @__PURE__ */ new Map([
-      ["paddingTop", 0],
       ["alignItemsPaddingTop", 0],
       ["stylePaddingTop", 0],
       ["headerSize", 0]
@@ -113,17 +111,8 @@ var DebugRow = ({ children }) => {
 };
 var DebugView = React2.memo(function DebugView2({ state }) {
   const ctx = useStateContext();
-  const [
-    totalSize = 0,
-    totalSizeWithScrollAdjust = 0,
-    scrollAdjust = 0,
-    rawScroll = 0,
-    scroll = 0,
-    numContainers = 0,
-    numContainersPooled = 0
-  ] = useArr$([
+  const [totalSize = 0, scrollAdjust = 0, rawScroll = 0, scroll = 0, numContainers = 0, numContainersPooled = 0] = useArr$([
     "totalSize",
-    "totalSizeWithScrollAdjust",
     "scrollAdjust",
     "debugRawScroll",
     "debugComputedScroll",
@@ -156,7 +145,6 @@ var DebugView = React2.memo(function DebugView2({ state }) {
     /* @__PURE__ */ React2.createElement(DebugRow, null, /* @__PURE__ */ React2.createElement(Text, null, "At end:"), /* @__PURE__ */ React2.createElement(Text, null, String(state.isAtEnd))),
     /* @__PURE__ */ React2.createElement(Text, null),
     /* @__PURE__ */ React2.createElement(DebugRow, null, /* @__PURE__ */ React2.createElement(Text, null, "ScrollAdjust:"), /* @__PURE__ */ React2.createElement(Text, null, scrollAdjust.toFixed(2))),
-    /* @__PURE__ */ React2.createElement(DebugRow, null, /* @__PURE__ */ React2.createElement(Text, null, "TotalSizeReal: "), /* @__PURE__ */ React2.createElement(Text, null, totalSizeWithScrollAdjust.toFixed(2))),
     /* @__PURE__ */ React2.createElement(Text, null),
     /* @__PURE__ */ React2.createElement(DebugRow, null, /* @__PURE__ */ React2.createElement(Text, null, "RawScroll: "), /* @__PURE__ */ React2.createElement(Text, null, rawScroll.toFixed(2))),
     /* @__PURE__ */ React2.createElement(DebugRow, null, /* @__PURE__ */ React2.createElement(Text, null, "ComputedScroll: "), /* @__PURE__ */ React2.createElement(Text, null, scroll.toFixed(2)))
@@ -311,11 +299,6 @@ var LeanView = Platform.OS === "android" || Platform.OS === "ios" ? LeanViewComp
 
 // src/constants.ts
 var POSITION_OUT_OF_VIEW = -1e7;
-var ANCHORED_POSITION_OUT_OF_VIEW = {
-  type: "top",
-  relativeCoordinate: POSITION_OUT_OF_VIEW,
-  top: POSITION_OUT_OF_VIEW
-};
 var ENABLE_DEVMODE = __DEV__ && false;
 var ENABLE_DEBUG_VIEW = __DEV__ && false;
 var IsNewArchitecture = global.nativeFabricUIManager != null;
@@ -331,23 +314,13 @@ var Container = ({
 }) => {
   const ctx = useStateContext();
   const columnWrapperStyle = ctx.columnWrapperStyle;
-  const [
-    maintainVisibleContentPosition,
-    position = ANCHORED_POSITION_OUT_OF_VIEW,
-    column = 0,
-    numColumns,
-    lastItemKeys,
-    itemKey,
-    data,
-    extraData
-  ] = useArr$([
-    "maintainVisibleContentPosition",
-    `containerPosition${id}`,
+  const [column = 0, data, itemKey, position = POSITION_OUT_OF_VIEW, numColumns, lastItemKeys, extraData] = useArr$([
     `containerColumn${id}`,
+    `containerItemData${id}`,
+    `containerItemKey${id}`,
+    `containerPosition${id}`,
     "numColumns",
     "lastItemKeys",
-    `containerItemKey${id}`,
-    `containerItemData${id}`,
     "extraData"
   ]);
   const refLastSize = useRef();
@@ -356,6 +329,7 @@ var Container = ({
   const otherAxisPos = numColumns > 1 ? `${(column - 1) / numColumns * 100}%` : 0;
   const otherAxisSize = numColumns > 1 ? `${1 / numColumns * 100}%` : void 0;
   const isALastItem = lastItemKeys.includes(itemKey);
+  let didLayout = false;
   let paddingStyles;
   if (columnWrapperStyle) {
     const { columnGap, rowGap, gap } = columnWrapperStyle;
@@ -376,14 +350,14 @@ var Container = ({
     position: "absolute",
     top: otherAxisPos,
     height: otherAxisSize,
-    left: position.relativeCoordinate,
+    left: position,
     ...paddingStyles || {}
   } : {
     position: "absolute",
     left: otherAxisPos,
     right: numColumns > 1 ? null : 0,
     width: otherAxisSize,
-    top: position.relativeCoordinate,
+    top: position,
     ...paddingStyles || {}
   };
   const renderedItemInfo = useMemo(
@@ -394,9 +368,14 @@ var Container = ({
   const triggerLayout = useCallback(() => {
     forceLayoutRender((v) => v + 1);
   }, []);
+  const contextValue = useMemo(() => {
+    ctx.viewRefs.set(id, ref);
+    return { containerId: id, itemKey, index, value: data, triggerLayout };
+  }, [id, itemKey, index, data]);
   const onLayout = (event) => {
     var _a, _b;
     if (!isNullOrUndefined(itemKey)) {
+      didLayout = true;
       let layout = event.nativeEvent.layout;
       const size = layout[horizontal ? "width" : "height"];
       const doUpdate = () => {
@@ -430,7 +409,7 @@ var Container = ({
     useEffect(() => {
       if (!isNullOrUndefined(itemKey)) {
         const timeout = setTimeout(() => {
-          if (refLastSize.current) {
+          if (!didLayout && refLastSize.current) {
             updateItemSize(itemKey, refLastSize.current);
           }
         }, 16);
@@ -440,20 +419,7 @@ var Container = ({
       }
     }, [itemKey]);
   }
-  const contextValue = useMemo(() => {
-    ctx.viewRefs.set(id, ref);
-    return { containerId: id, itemKey, index, value: data, triggerLayout };
-  }, [id, itemKey, index, data]);
-  const contentFragment = /* @__PURE__ */ React2__default.createElement(React2__default.Fragment, { key: recycleItems ? void 0 : itemKey }, /* @__PURE__ */ React2__default.createElement(ContextContainer.Provider, { value: contextValue }, renderedItem, renderedItemInfo && ItemSeparatorComponent && !isALastItem && /* @__PURE__ */ React2__default.createElement(ItemSeparatorComponent, { leadingItem: renderedItemInfo.item })));
-  if (maintainVisibleContentPosition) {
-    const anchorStyle = horizontal ? position.type === "top" ? { position: "absolute", left: 0, top: 0, bottom: 0, flexDirection: "row", alignItems: "stretch" } : { position: "absolute", right: 0, top: 0, bottom: 0, flexDirection: "row", alignItems: "stretch" } : position.type === "top" ? { position: "absolute", top: 0, left: 0, right: 0 } : { position: "absolute", bottom: 0, left: 0, right: 0 };
-    if (__DEV__ && ENABLE_DEVMODE) {
-      anchorStyle.borderColor = position.type === "top" ? "red" : "blue";
-      anchorStyle.borderWidth = 1;
-    }
-    return /* @__PURE__ */ React2__default.createElement(LeanView, { style }, /* @__PURE__ */ React2__default.createElement(LeanView, { style: [anchorStyle, paddingStyles], onLayout, ref }, contentFragment, __DEV__ && ENABLE_DEVMODE && /* @__PURE__ */ React2__default.createElement(Text, { style: { position: "absolute", top: 0, left: 0, zIndex: 1e3 } }, position.top)));
-  }
-  return /* @__PURE__ */ React2__default.createElement(LeanView, { style, onLayout, ref }, contentFragment);
+  return /* @__PURE__ */ React2.createElement(LeanView, { style, onLayout, ref, key: recycleItems ? void 0 : itemKey }, /* @__PURE__ */ React2.createElement(ContextContainer.Provider, { value: contextValue }, renderedItem, renderedItemInfo && ItemSeparatorComponent && !isALastItem && /* @__PURE__ */ React2.createElement(ItemSeparatorComponent, { leadingItem: renderedItemInfo.item })));
 };
 var typedForwardRef = forwardRef;
 var typedMemo = memo;
@@ -462,21 +428,35 @@ var useAnimatedValue = (initialValue) => {
 };
 
 // src/useValue$.ts
-function useValue$(key, getValue, useMicrotask) {
+function useValue$(key, params) {
   var _a;
+  const { getValue, delay } = params || {};
   const ctx = useStateContext();
   const animValue = useAnimatedValue((_a = getValue ? getValue(peek$(ctx, key)) : peek$(ctx, key)) != null ? _a : 0);
   useMemo(() => {
     let newValue = void 0;
+    let prevValue = void 0;
+    let didQueueTask = false;
     listen$(ctx, key, (v) => {
-      if (useMicrotask && newValue === void 0) {
-        queueMicrotask(() => {
-          animValue.setValue(newValue);
-          newValue = void 0;
-        });
-      }
       newValue = getValue ? getValue(v) : v;
-      if (!useMicrotask) {
+      if (delay !== void 0) {
+        const fn = () => {
+          didQueueTask = false;
+          if (newValue !== void 0) {
+            animValue.setValue(newValue);
+          }
+        };
+        const delayValue = typeof delay === "function" ? delay(newValue, prevValue) : delay;
+        prevValue = newValue;
+        if (!didQueueTask) {
+          didQueueTask = true;
+          if (delayValue === 0) {
+            queueMicrotask(fn);
+          } else {
+            setTimeout(fn, delayValue);
+          }
+        }
+      } else {
         animValue.setValue(newValue);
       }
     });
@@ -496,19 +476,12 @@ var Containers = typedMemo(function Containers2({
   const ctx = useStateContext();
   const columnWrapperStyle = ctx.columnWrapperStyle;
   const [numContainers, numColumns] = useArr$(["numContainersPooled", "numColumns"]);
-  const animSize = useValue$(
-    "totalSizeWithScrollAdjust",
-    void 0,
-    /*useMicrotask*/
-    true
-  );
-  const animOpacity = waitForInitialLayout ? useValue$("containersDidLayout", (value) => value ? 1 : 0) : void 0;
-  const otherAxisSize = useValue$(
-    "otherAxisSize",
-    void 0,
-    /*useMicrotask*/
-    true
-  );
+  const animSize = useValue$("totalSize", {
+    // Use a microtask if increasing the size significantly, otherwise use a timeout
+    delay: (value, prevValue) => !prevValue || value - prevValue > 20 ? 0 : 200
+  });
+  const animOpacity = waitForInitialLayout && !IsNewArchitecture ? useValue$("containersDidLayout", { getValue: (value) => value ? 1 : 0 }) : void 0;
+  const otherAxisSize = useValue$("otherAxisSize", { delay: 0 });
   const containers = [];
   for (let i = 0; i < numContainers; i++) {
     containers.push(
@@ -543,33 +516,41 @@ var Containers = typedMemo(function Containers2({
   }
   return /* @__PURE__ */ React2.createElement(Animated.View, { style }, containers);
 });
-function ListHeaderComponentContainer({
-  children,
-  style,
-  ctx,
-  horizontal,
-  waitForInitialLayout
-}) {
-  var _a;
-  const hasData = ((_a = peek$(ctx, "lastItemKeys")) == null ? void 0 : _a.length) > 0;
-  const scrollAdjust = useValue$("scrollAdjust", (v) => v != null ? v : 0, true);
-  const animOpacity = waitForInitialLayout ? useValue$("containersDidLayout", (value) => value ? 1 : 0) : void 0;
-  const additionalSize = {
-    transform: [{ translateY: Animated.multiply(scrollAdjust, -1) }],
-    // Header should show if there's no data yet, but containersDidLayout will be false until it has some data
-    opacity: hasData ? animOpacity : 1
-  };
+function ScrollAdjust() {
+  const bias = 1e7;
+  const [scrollAdjust, scrollAdjustUserOffset] = useArr$(["scrollAdjust", "scrollAdjustUserOffset"]);
+  const scrollOffset = (scrollAdjust || 0) + (scrollAdjustUserOffset || 0) + bias;
   return /* @__PURE__ */ React2.createElement(
-    Animated.View,
+    View,
     {
-      style: [style, additionalSize],
-      onLayout: (event) => {
-        const size = event.nativeEvent.layout[horizontal ? "width" : "height"];
-        set$(ctx, "headerSize", size);
+      style: {
+        position: "absolute",
+        height: 0,
+        width: 0,
+        top: scrollOffset,
+        left: 0
       }
+    }
+  );
+}
+function useSyncLayout({
+  onChange
+}) {
+  const ref = useRef(null);
+  const onLayout = useCallback(
+    (event) => {
+      onChange(event.nativeEvent.layout, false);
     },
-    children
+    [onChange]
   );
+  useLayoutEffect(() => {
+    if (ref.current) {
+      ref.current.measure((x, y, width, height) => {
+        onChange({ x, y, width, height }, true);
+      });
+    }
+  }, []);
+  return { onLayout, ref };
 }
 
 // src/ListComponent.tsx
@@ -582,58 +563,28 @@ var getComponent = (Component) => {
   }
   return null;
 };
-var PaddingAndAdjust = () => {
-  const animPaddingTop = useValue$("paddingTop", (v) => v, true);
-  const animScrollAdjust = useValue$("scrollAdjust", (v) => v, true);
-  const additionalSize = { marginTop: animScrollAdjust, paddingTop: animPaddingTop };
-  return /* @__PURE__ */ React2.createElement(Animated.View, { style: additionalSize });
+var Padding = () => {
+  const animPaddingTop = useValue$("alignItemsPaddingTop", { delay: 0 });
+  return /* @__PURE__ */ React2.createElement(Animated.View, { style: { paddingTop: animPaddingTop } });
 };
-var PaddingAndAdjustDevMode = () => {
-  const animPaddingTop = useValue$("paddingTop", (v) => v, true);
-  const animScrollAdjust = useValue$("scrollAdjust", (v) => v, true);
-  return /* @__PURE__ */ React2.createElement(React2.Fragment, null, /* @__PURE__ */ React2.createElement(Animated.View, { style: { marginTop: animScrollAdjust } }), /* @__PURE__ */ React2.createElement(Animated.View, { style: { paddingTop: animPaddingTop } }), /* @__PURE__ */ React2.createElement(
+var PaddingDevMode = () => {
+  const animPaddingTop = useValue$("alignItemsPaddingTop", { delay: 0 });
+  return /* @__PURE__ */ React2.createElement(React2.Fragment, null, /* @__PURE__ */ React2.createElement(Animated.View, { style: { paddingTop: animPaddingTop } }), /* @__PURE__ */ React2.createElement(
     Animated.View,
     {
       style: {
         position: "absolute",
-        top: Animated.add(animScrollAdjust, Animated.multiply(animScrollAdjust, -1)),
+        top: 0,
         height: animPaddingTop,
         left: 0,
         right: 0,
         backgroundColor: "green"
       }
     }
-  ), /* @__PURE__ */ React2.createElement(
-    Animated.View,
-    {
-      style: {
-        position: "absolute",
-        top: animPaddingTop,
-        height: animScrollAdjust,
-        left: -16,
-        right: -16,
-        backgroundColor: "lightblue"
-      }
-    }
-  ), /* @__PURE__ */ React2.createElement(
-    Animated.View,
-    {
-      style: {
-        position: "absolute",
-        top: animPaddingTop,
-        height: Animated.multiply(animScrollAdjust, -1),
-        width: 8,
-        right: 4,
-        borderStyle: "dashed",
-        borderColor: "blue",
-        borderWidth: 1,
-        backgroundColor: "lightblue"
-        //backgroundColor: "blue",
-      }
-    }
   ));
 };
 var ListComponent = typedMemo(function ListComponent2({
+  canRender,
   style,
   contentContainerStyle,
   horizontal,
@@ -654,13 +605,25 @@ var ListComponent = typedMemo(function ListComponent2({
   refScrollView,
   maintainVisibleContentPosition,
   renderScrollComponent,
+  scrollAdjustHandler,
+  onLayoutHeader,
   ...rest
 }) {
   const ctx = useStateContext();
+  const { onLayout: onLayoutHeaderSync, ref: refHeader } = useSyncLayout({
+    onChange: onLayoutHeader
+  });
   const ScrollComponent = renderScrollComponent ? useMemo(
     () => React2.forwardRef((props, ref) => renderScrollComponent({ ...props, ref })),
     [renderScrollComponent]
   ) : ScrollView;
+  React2.useEffect(() => {
+    if (canRender) {
+      setTimeout(() => {
+        scrollAdjustHandler.setMounted();
+      }, 0);
+    }
+  }, [canRender]);
   return /* @__PURE__ */ React2.createElement(
     ScrollComponent,
     {
@@ -679,19 +642,11 @@ var ListComponent = typedMemo(function ListComponent2({
       contentOffset: initialContentOffset ? horizontal ? { x: initialContentOffset, y: 0 } : { x: 0, y: initialContentOffset } : void 0,
       ref: refScrollView
     },
-    ENABLE_DEVMODE ? /* @__PURE__ */ React2.createElement(PaddingAndAdjustDevMode, null) : /* @__PURE__ */ React2.createElement(PaddingAndAdjust, null),
-    ListHeaderComponent && /* @__PURE__ */ React2.createElement(
-      ListHeaderComponentContainer,
-      {
-        style: ListHeaderComponentStyle,
-        ctx,
-        horizontal,
-        waitForInitialLayout
-      },
-      getComponent(ListHeaderComponent)
-    ),
+    maintainVisibleContentPosition && /* @__PURE__ */ React2.createElement(ScrollAdjust, null),
+    ENABLE_DEVMODE ? /* @__PURE__ */ React2.createElement(PaddingDevMode, null) : /* @__PURE__ */ React2.createElement(Padding, null),
+    ListHeaderComponent && /* @__PURE__ */ React2.createElement(View, { style: ListHeaderComponentStyle, onLayout: onLayoutHeaderSync, ref: refHeader }, getComponent(ListHeaderComponent)),
     ListEmptyComponent && getComponent(ListEmptyComponent),
-    /* @__PURE__ */ React2.createElement(
+    canRender && /* @__PURE__ */ React2.createElement(
       Containers,
       {
         horizontal,
@@ -719,49 +674,22 @@ var ListComponent = typedMemo(function ListComponent2({
 // src/ScrollAdjustHandler.ts
 var ScrollAdjustHandler = class {
   constructor(ctx) {
-    this.ctx = ctx;
     this.appliedAdjust = 0;
-    this.busy = false;
-    this.isPaused = false;
-    this.isDisabled = false;
+    this.mounted = false;
     this.context = ctx;
   }
-  doAjdust() {
-    set$(this.context, "scrollAdjust", this.appliedAdjust);
-    this.busy = false;
-  }
-  requestAdjust(adjust, onAdjusted) {
-    if (this.isDisabled) {
-      return;
-    }
-    const oldAdjustTop = peek$(this.context, "scrollAdjust");
-    if (oldAdjustTop === adjust) {
-      return;
-    }
-    this.appliedAdjust = adjust;
-    if (!this.busy && !this.isPaused) {
-      this.busy = true;
-      this.doAjdust();
-      onAdjusted(oldAdjustTop - adjust);
+  requestAdjust(add) {
+    const oldAdjustTop = peek$(this.context, "scrollAdjust") || 0;
+    this.appliedAdjust = add + oldAdjustTop;
+    const set = () => set$(this.context, "scrollAdjust", this.appliedAdjust);
+    if (this.mounted) {
+      set();
+    } else {
+      requestAnimationFrame(set);
     }
   }
-  getAppliedAdjust() {
-    return this.appliedAdjust;
-  }
-  pauseAdjust() {
-    this.isPaused = true;
-  }
-  setDisableAdjust(disable) {
-    this.isDisabled = disable;
-  }
-  // return true if it was paused
-  unPauseAdjust() {
-    if (this.isPaused) {
-      this.isPaused = false;
-      this.doAjdust();
-      return true;
-    }
-    return false;
+  setMounted() {
+    this.mounted = true;
   }
 };
 var useCombinedRef = (...refs) => {
@@ -909,13 +837,12 @@ function updateViewableItemsWithConfig(data, viewabilityConfigCallbackPair, getI
   }
 }
 function computeViewability(state, ctx, viewabilityConfig, containerId, key, scrollSize, item, index) {
-  const { sizes, positions, scroll: scrollState, scrollAdjustHandler } = state;
+  const { sizes, positions, scroll: scrollState } = state;
   const topPad = (peek$(ctx, "stylePaddingTop") || 0) + (peek$(ctx, "headerSize") || 0);
   const { itemVisiblePercentThreshold, viewAreaCoveragePercentThreshold } = viewabilityConfig;
   const viewAreaMode = viewAreaCoveragePercentThreshold != null;
   const viewablePercentThreshold = viewAreaMode ? viewAreaCoveragePercentThreshold : itemVisiblePercentThreshold;
-  const previousScrollAdjust = scrollAdjustHandler.getAppliedAdjust();
-  const scroll = scrollState - previousScrollAdjust - topPad;
+  const scroll = scrollState - topPad;
   const top = positions.get(key) - scroll;
   const size = sizes.get(key) || 0;
   const bottom = top + size;
@@ -987,6 +914,7 @@ var LegendList = typedForwardRef(function LegendList2(props, forwardedRef) {
   return /* @__PURE__ */ React2.createElement(StateProvider, null, /* @__PURE__ */ React2.createElement(LegendListInner, { ...props, ref: forwardedRef }));
 });
 var LegendListInner = typedForwardRef(function LegendListInner2(props, forwardedRef) {
+  var _a;
   const {
     data: dataProp = [],
     initialScrollIndex: initialScrollIndexProp,
@@ -1029,9 +957,11 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     onViewableItemsChanged,
     ...rest
   } = props;
+  const [renderNum, setRenderNum] = useState(0);
   const initialScroll = typeof initialScrollIndexProp === "number" ? { index: initialScrollIndexProp } : initialScrollIndexProp;
   const initialScrollIndex = initialScroll == null ? void 0 : initialScroll.index;
   const refLoadStartTime = useRef(Date.now());
+  const [canRender, setCanRender] = React2.useState(!IsNewArchitecture);
   const callbacks = useRef({
     onStartReached: rest.onStartReached,
     onEndReached: rest.onEndReached
@@ -1042,12 +972,6 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
   const style = { ...StyleSheet.flatten(styleProp) };
   const stylePaddingTopState = extractPadding(style, contentContainerStyle, "Top");
   const stylePaddingBottomState = extractPadding(style, contentContainerStyle, "Bottom");
-  if (style == null ? void 0 : style.paddingTop) {
-    style.paddingTop = void 0;
-  }
-  if (contentContainerStyle == null ? void 0 : contentContainerStyle.paddingTop) {
-    contentContainerStyle.paddingTop = void 0;
-  }
   const ctx = useStateContext();
   ctx.columnWrapperStyle = columnWrapperStyle || (contentContainerStyle ? createColumnWrapperStyle(contentContainerStyle) : void 0);
   const refScroller = useRef(null);
@@ -1057,56 +981,45 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
   const keyExtractor = keyExtractorProp != null ? keyExtractorProp : (item, index) => index.toString();
   const refState = useRef();
   const getId = (index) => {
-    var _a;
-    const data = (_a = refState.current) == null ? void 0 : _a.data;
-    if (!data) {
+    const state = refState.current;
+    if (!(state == null ? void 0 : state.data)) {
       return "";
     }
+    const data = state.data;
     const ret = index < data.length ? keyExtractor ? keyExtractor(data[index], index) : index : null;
-    return `${ret}`;
+    const id = ret;
+    state.idCache.set(index, id);
+    return id;
   };
   const getItemSize = (key, index, data, useAverageSize = false) => {
     const state = refState.current;
-    state.sizesKnown.get(key);
+    const sizeKnown = state.sizesKnown.get(key);
+    if (sizeKnown !== void 0) {
+      return sizeKnown;
+    }
     const sizePrevious = state.sizes.get(key);
-    let size;
-    peek$(ctx, "numColumns");
-    if (size === void 0 && sizePrevious !== void 0) {
+    if (sizePrevious !== void 0) {
       return sizePrevious;
     }
-    if (size === void 0) {
-      size = getEstimatedItemSize ? getEstimatedItemSize(index, data) : estimatedItemSize;
-    }
+    const size = getEstimatedItemSize ? getEstimatedItemSize(index, data) : estimatedItemSize;
     state.sizes.set(key, size);
     return size;
   };
-  const calculateOffsetForIndex = (indexParam) => {
-    var _a;
-    const isFromInit = indexParam === void 0;
-    const index = isFromInit ? initialScrollIndex : indexParam;
-    const data = dataProp;
+  const calculateOffsetForIndex = (index) => {
+    var _a2;
+    let position = 0;
     if (index !== void 0) {
-      let offset = 0;
-      const canGetSize = !!refState.current;
-      if (canGetSize || getEstimatedItemSize) {
-        const sizeFn = (index2) => {
-          if (canGetSize) {
-            return getItemSize(getId(index2), index2, data[index2], true);
-          }
-          return getEstimatedItemSize(index2, data[index2]);
-        };
-        for (let i = 0; i < index; i++) {
-          offset += sizeFn(i);
-        }
-      } else {
-        offset = index * estimatedItemSize;
-      }
-      const adjust = peek$(ctx, "containersDidLayout") ? ((_a = refState.current) == null ? void 0 : _a.scrollAdjustHandler.getAppliedAdjust()) || 0 : 0;
-      const stylePaddingTop = isFromInit ? stylePaddingTopState : peek$(ctx, "stylePaddingTop");
-      const topPad = (stylePaddingTop != null ? stylePaddingTop : 0) + peek$(ctx, "headerSize");
-      return offset / numColumnsProp - adjust + topPad;
+      position = ((_a2 = refState.current) == null ? void 0 : _a2.positions.get(getId(index))) || 0;
     }
-    return 0;
+    const paddingTop = peek$(ctx, "stylePaddingTop");
+    if (paddingTop) {
+      position += paddingTop;
+    }
+    const headerSize = peek$(ctx, "headerSize");
+    if (headerSize) {
+      position += headerSize;
+    }
+    return position;
   };
   const calculateOffsetWithOffsetPosition = (offsetParam, params) => {
     const { index, viewOffset, viewPosition } = params;
@@ -1120,15 +1033,14 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     }
     return offset;
   };
-  const initialContentOffset = initialScrollOffset != null ? initialScrollOffset : useMemo(() => calculateOffsetForIndex(void 0), []);
   if (!refState.current) {
-    const initialScrollLength = (estimatedListSize != null ? estimatedListSize : Dimensions.get("window"))[horizontal ? "width" : "height"];
+    const initialScrollLength = (estimatedListSize != null ? estimatedListSize : IsNewArchitecture ? { width: 0, height: 0 } : Dimensions.get("window"))[horizontal ? "width" : "height"];
     refState.current = {
       sizes: /* @__PURE__ */ new Map(),
       positions: /* @__PURE__ */ new Map(),
       columns: /* @__PURE__ */ new Map(),
       pendingAdjust: 0,
-      isStartReached: initialContentOffset < initialScrollLength * onStartReachedThreshold,
+      isStartReached: false,
       isEndReached: false,
       isAtEnd: false,
       isAtStart: false,
@@ -1138,9 +1050,9 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       startNoBuffer: -1,
       endBuffered: -1,
       endNoBuffer: -1,
-      scroll: initialContentOffset || 0,
+      firstFullyOnScreenIndex: -1,
+      scroll: 0,
       totalSize: 0,
-      totalSizeBelowAnchor: 0,
       timeouts: /* @__PURE__ */ new Set(),
       viewabilityConfigCallbackPairs: void 0,
       renderItem: void 0,
@@ -1152,12 +1064,8 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       scrollPending: 0,
       indexByKey: /* @__PURE__ */ new Map(),
       scrollHistory: [],
-      scrollVelocity: 0,
       sizesKnown: /* @__PURE__ */ new Map(),
       timeoutSizeMessage: 0,
-      scrollTimer: void 0,
-      belowAnchorElementPositions: void 0,
-      rowHeights: /* @__PURE__ */ new Map(),
       startReachedBlockedByTimer: false,
       endReachedBlockedByTimer: false,
       scrollForNextCalculateItemsInView: void 0,
@@ -1166,41 +1074,126 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       queuedCalculateItemsInView: 0,
       lastBatchingAction: Date.now(),
       averageSizes: {},
-      onScroll: onScrollProp
+      onScroll: onScrollProp,
+      idsInView: [],
+      containerItemKeys: /* @__PURE__ */ new Set(),
+      idCache: /* @__PURE__ */ new Map()
     };
-    const dataLength = dataProp.length;
-    if (maintainVisibleContentPosition && dataLength > 0) {
-      if (initialScrollIndex && initialScrollIndex < dataLength) {
-        refState.current.anchorElement = {
-          coordinate: initialContentOffset,
-          id: getId(initialScrollIndex)
-        };
-      } else if (dataLength > 0) {
-        refState.current.anchorElement = {
-          coordinate: initialContentOffset,
-          id: getId(0)
-        };
-      } else {
-        __DEV__ && warnDevOnce(
-          "maintainVisibleContentPosition",
-          "[legend-list] maintainVisibleContentPosition was not able to find an anchor element"
-        );
-      }
-    }
-    set$(ctx, "scrollAdjust", 0);
     set$(ctx, "maintainVisibleContentPosition", maintainVisibleContentPosition);
     set$(ctx, "extraData", extraData);
   }
   const didDataChange = refState.current.data !== dataProp;
   refState.current.data = dataProp;
   refState.current.onScroll = onScrollProp;
-  const getAnchorElementIndex = () => {
-    const state = refState.current;
-    if (state.anchorElement) {
-      const el = state.indexByKey.get(state.anchorElement.id);
-      return el;
+  const getScrollVelocity = () => {
+    const { scrollHistory } = refState.current;
+    let velocity = 0;
+    if (scrollHistory.length >= 1) {
+      const newest = scrollHistory[scrollHistory.length - 1];
+      let oldest;
+      for (let i = 0; i < scrollHistory.length - 1; i++) {
+        const entry = scrollHistory[i];
+        const nextEntry = scrollHistory[i + 1];
+        if (i > 0) {
+          const prevEntry = scrollHistory[i - 1];
+          const prevDirection = entry.scroll - prevEntry.scroll;
+          const currentDirection = nextEntry.scroll - entry.scroll;
+          if (prevDirection > 0 && currentDirection < 0 || prevDirection < 0 && currentDirection > 0) {
+            break;
+          }
+        }
+      }
+      for (let i = 0; i < scrollHistory.length - 1; i++) {
+        const entry = scrollHistory[i];
+        if (newest.time - entry.time <= 1e3) {
+          oldest = entry;
+          break;
+        }
+      }
+      if (oldest) {
+        const scrollDiff = newest.scroll - oldest.scroll;
+        const timeDiff = newest.time - oldest.time;
+        velocity = timeDiff > 0 ? scrollDiff / timeDiff : 0;
+      }
+    }
+    return velocity;
+  };
+  const updateAllPositions = (dataChanged) => {
+    var _a2, _b, _c;
+    const { columns, data, indexByKey, positions, firstFullyOnScreenIndex, idCache, sizes } = refState.current;
+    const numColumns = (_a2 = peek$(ctx, "numColumns")) != null ? _a2 : numColumnsProp;
+    const indexByKeyForChecking = __DEV__ ? /* @__PURE__ */ new Map() : void 0;
+    const scrollVelocity = getScrollVelocity();
+    if (dataChanged) {
+      indexByKey.clear();
+      idCache.clear();
+    }
+    const shouldUseBackwards = !dataChanged && scrollVelocity < 0 && firstFullyOnScreenIndex > 5 && firstFullyOnScreenIndex < data.length;
+    if (shouldUseBackwards && firstFullyOnScreenIndex !== void 0) {
+      const anchorId = getId(firstFullyOnScreenIndex);
+      const anchorPosition = positions.get(anchorId);
+      if (anchorPosition !== void 0) {
+        let currentRowTop2 = anchorPosition;
+        let maxSizeInRow2 = 0;
+        let bailout = false;
+        for (let i = firstFullyOnScreenIndex - 1; i >= 0; i--) {
+          const id = getId(i);
+          const size = getItemSize(id, i, data[i], false);
+          const itemColumn = columns.get(id);
+          maxSizeInRow2 = Math.max(maxSizeInRow2, size);
+          if (itemColumn === 1) {
+            currentRowTop2 -= maxSizeInRow2;
+            maxSizeInRow2 = 0;
+          }
+          if (currentRowTop2 < -2e3) {
+            bailout = true;
+            break;
+          }
+          positions.set(id, currentRowTop2);
+        }
+        if (!bailout) {
+          updateTotalSize();
+          return;
+        }
+      }
+    }
+    let currentRowTop = 0;
+    let column = 1;
+    let maxSizeInRow = 0;
+    const hasColumns = numColumns > 1;
+    const needsIndexByKey = dataChanged || indexByKey.size === 0;
+    const dataLength = data.length;
+    for (let i = 0; i < dataLength; i++) {
+      const id = (_b = idCache.get(i)) != null ? _b : getId(i);
+      const size = (_c = sizes.get(id)) != null ? _c : getItemSize(id, i, data[i], false);
+      if (__DEV__ && needsIndexByKey) {
+        if (indexByKeyForChecking.has(id)) {
+          console.error(
+            `[legend-list] Error: Detected overlapping key (${id}) which causes missing items and gaps and other terrrible things. Check that keyExtractor returns unique values.`
+          );
+        }
+        indexByKeyForChecking.set(id, i);
+      }
+      positions.set(id, currentRowTop);
+      if (needsIndexByKey) {
+        indexByKey.set(id, i);
+      }
+      columns.set(id, column);
+      if (hasColumns) {
+        if (size > maxSizeInRow) {
+          maxSizeInRow = size;
+        }
+        column++;
+        if (column > numColumns) {
+          currentRowTop += maxSizeInRow;
+          column = 1;
+          maxSizeInRow = 0;
+        }
+      } else {
+        currentRowTop += size;
+      }
     }
-    return void 0;
+    updateTotalSize();
   };
   const scrollToIndex = ({
     index,
@@ -1208,7 +1201,6 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     animated = true,
     viewPosition
   }) => {
-    var _a;
     const state = refState.current;
     if (index >= state.data.length) {
       index = state.data.length - 1;
@@ -1217,220 +1209,33 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     }
     const firstIndexOffset = calculateOffsetForIndex(index);
     const isLast = index === state.data.length - 1;
-    if (isLast && viewPosition !== void 0) {
+    if (isLast && viewPosition === void 0) {
       viewPosition = 1;
     }
-    let firstIndexScrollPostion = firstIndexOffset - viewOffset;
-    const diff = Math.abs(state.scroll - firstIndexScrollPostion);
-    const topPad = peek$(ctx, "stylePaddingTop") + peek$(ctx, "headerSize");
-    const needsReanchoring = maintainVisibleContentPosition && diff > 100;
+    const firstIndexScrollPostion = firstIndexOffset - viewOffset;
     state.scrollForNextCalculateItemsInView = void 0;
-    if (needsReanchoring) {
-      const id = getId(index);
-      state.anchorElement = { id, coordinate: firstIndexOffset - topPad };
-      (_a = state.belowAnchorElementPositions) == null ? void 0 : _a.clear();
-      state.positions.clear();
-      calcTotalSizesAndPositions({ forgetPositions: true });
-      state.startBufferedId = id;
-      state.minIndexSizeChanged = index;
-      firstIndexScrollPostion = firstIndexOffset - viewOffset + state.scrollAdjustHandler.getAppliedAdjust();
-    }
     scrollTo({ offset: firstIndexScrollPostion, animated, index, viewPosition: viewPosition != null ? viewPosition : 0, viewOffset });
   };
   const setDidLayout = () => {
     refState.current.queuedInitialLayout = true;
     checkAtBottom();
-    const setIt = () => {
-      set$(ctx, "containersDidLayout", true);
-      if (props.onLoad) {
-        props.onLoad({ elapsedTimeInMs: Date.now() - refLoadStartTime.current });
-      }
-    };
-    if (initialScroll) {
-      queueMicrotask(() => {
-        scrollToIndex({ ...initialScroll, animated: false });
-        requestAnimationFrame(() => {
-          if (!IsNewArchitecture) {
-            scrollToIndex({ ...initialScroll, animated: false });
-          }
-          setIt();
-        });
-      });
-    } else {
-      queueMicrotask(setIt);
+    set$(ctx, "containersDidLayout", true);
+    if (props.onLoad) {
+      props.onLoad({ elapsedTimeInMs: Date.now() - refLoadStartTime.current });
     }
   };
-  const addTotalSize = useCallback((key, add, totalSizeBelowAnchor) => {
+  const addTotalSize = useCallback((key, add) => {
     const state = refState.current;
-    const { indexByKey, anchorElement } = state;
-    const index = key === null ? 0 : indexByKey.get(key);
-    let isAboveAnchor = false;
-    if (maintainVisibleContentPosition) {
-      if (anchorElement && index < getAnchorElementIndex()) {
-        isAboveAnchor = true;
-      }
-    }
     if (key === null) {
       state.totalSize = add;
-      state.totalSizeBelowAnchor = totalSizeBelowAnchor;
     } else {
       state.totalSize += add;
-      if (isAboveAnchor) {
-        state.totalSizeBelowAnchor += add;
-      }
-    }
-    let applyAdjustValue = 0;
-    let resultSize = state.totalSize;
-    if (maintainVisibleContentPosition && anchorElement !== void 0) {
-      const newAdjust = anchorElement.coordinate - state.totalSizeBelowAnchor;
-      applyAdjustValue = -newAdjust;
-      state.belowAnchorElementPositions = buildElementPositionsBelowAnchor();
-      state.rowHeights.clear();
-      if (applyAdjustValue !== void 0) {
-        resultSize -= applyAdjustValue;
-        state.scrollAdjustHandler.requestAdjust(applyAdjustValue, (diff) => {
-          state.scroll -= diff;
-        });
-      }
     }
     set$(ctx, "totalSize", state.totalSize);
-    set$(ctx, "totalSizeWithScrollAdjust", resultSize);
     if (alignItemsAtEnd) {
       updateAlignItemsPaddingTop();
     }
   }, []);
-  const getRowHeight = (n) => {
-    const { rowHeights, data } = refState.current;
-    const numColumns = peek$(ctx, "numColumns");
-    if (numColumns === 1) {
-      const id = getId(n);
-      return getItemSize(id, n, data[n]);
-    }
-    if (rowHeights.has(n)) {
-      return rowHeights.get(n) || 0;
-    }
-    let rowHeight = 0;
-    const startEl = n * numColumns;
-    for (let i = startEl; i < startEl + numColumns && i < data.length; i++) {
-      const id = getId(i);
-      const size = getItemSize(id, i, data[i]);
-      rowHeight = Math.max(rowHeight, size);
-    }
-    rowHeights.set(n, rowHeight);
-    return rowHeight;
-  };
-  const buildElementPositionsBelowAnchor = () => {
-    const state = refState.current;
-    if (!state.anchorElement) {
-      return /* @__PURE__ */ new Map();
-    }
-    const anchorIndex = state.indexByKey.get(state.anchorElement.id);
-    if (anchorIndex === 0) {
-      return /* @__PURE__ */ new Map();
-    }
-    const map = state.belowAnchorElementPositions || /* @__PURE__ */ new Map();
-    const numColumns = peek$(ctx, "numColumns");
-    let top = state.anchorElement.coordinate;
-    for (let i = anchorIndex - 1; i >= 0; i--) {
-      const id = getId(i);
-      const rowNumber = Math.floor(i / numColumns);
-      if (i % numColumns === 0) {
-        top -= getRowHeight(rowNumber);
-      }
-      map.set(id, top);
-    }
-    return map;
-  };
-  const disableScrollJumps = (timeout) => {
-    const state = refState.current;
-    if (state.scrollingTo === void 0) {
-      state.disableScrollJumpsFrom = state.scroll - state.scrollAdjustHandler.getAppliedAdjust();
-      state.scrollHistory.length = 0;
-      setTimeout(() => {
-        state.disableScrollJumpsFrom = void 0;
-        if (state.scrollPending !== void 0 && state.scrollPending !== state.scroll) {
-          updateScroll(state.scrollPending);
-        }
-      }, timeout);
-    }
-  };
-  const getElementPositionBelowAchor = (id) => {
-    var _a;
-    const state = refState.current;
-    if (!refState.current.belowAnchorElementPositions) {
-      state.belowAnchorElementPositions = buildElementPositionsBelowAnchor();
-    }
-    const res = state.belowAnchorElementPositions.get(id);
-    if (res === void 0) {
-      console.warn(`Undefined position below anchor ${id} ${(_a = state.anchorElement) == null ? void 0 : _a.id}`);
-      return 0;
-    }
-    return res;
-  };
-  const fixGaps = useCallback(() => {
-    var _a;
-    const state = refState.current;
-    const { data, scrollLength, positions, startBuffered, endBuffered } = state;
-    const numColumns = peek$(ctx, "numColumns");
-    if (!data || scrollLength === 0 || numColumns > 1) {
-      return;
-    }
-    const numContainers = ctx.values.get("numContainers");
-    let numMeasurements = 0;
-    for (let i = 0; i < numContainers; i++) {
-      const itemKey = peek$(ctx, `containerItemKey${i}`);
-      const isSizeKnown = state.sizesKnown.get(itemKey);
-      if (itemKey && !isSizeKnown) {
-        const containerRef = ctx.viewRefs.get(i);
-        if (containerRef) {
-          let measured;
-          (_a = containerRef.current) == null ? void 0 : _a.measure((x, y, width, height) => {
-            measured = { width, height };
-          });
-          numMeasurements++;
-          if (measured) {
-            updateItemSize(
-              itemKey,
-              measured,
-              /*fromFixGaps*/
-              true
-            );
-          }
-        }
-      }
-    }
-    if (numMeasurements > 0) {
-      let top;
-      const diffs = /* @__PURE__ */ new Map();
-      for (let i = startBuffered; i <= endBuffered; i++) {
-        const id = getId(i);
-        if (top === void 0) {
-          top = positions.get(id);
-        }
-        if (positions.get(id) !== top) {
-          diffs.set(id, top - positions.get(id));
-          positions.set(id, top);
-        }
-        const size = getItemSize(id, i, data[i]);
-        const bottom = top + size;
-        top = bottom;
-      }
-      for (let i = 0; i < numContainers; i++) {
-        const itemKey = peek$(ctx, `containerItemKey${i}`);
-        const diff = diffs.get(itemKey);
-        if (diff) {
-          const prevPos = peek$(ctx, `containerPosition${i}`);
-          const newPos = prevPos.top + diff;
-          if (prevPos.top !== newPos) {
-            const pos = { ...prevPos };
-            pos.relativeCoordinate += diff;
-            pos.top += diff;
-            set$(ctx, `containerPosition${i}`, pos);
-          }
-        }
-      }
-    }
-  }, []);
   const checkAllSizesKnown = useCallback(() => {
     const { startBuffered, endBuffered, sizesKnown } = refState.current;
     if (endBuffered !== null) {
@@ -1443,8 +1248,70 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     }
     return false;
   }, []);
-  const calculateItemsInView = useCallback((isReset) => {
-    var _a;
+  const requestAdjust = (positionDiff) => {
+    if (Math.abs(positionDiff) > 0.1) {
+      const state = refState.current;
+      const doit = () => {
+        state.scrollAdjustHandler.requestAdjust(positionDiff);
+      };
+      state.scroll += positionDiff;
+      state.scrollForNextCalculateItemsInView = void 0;
+      if (peek$(ctx, "containersDidLayout")) {
+        doit();
+      } else {
+        requestAnimationFrame(doit);
+      }
+      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);
+      }
+      state.ignoreScrollFromMVCPTimeout = setTimeout(() => {
+        state.ignoreScrollFromMVCP = void 0;
+      }, 100);
+    }
+  };
+  const prepareMVCP = useCallback(() => {
+    const state = refState.current;
+    const { positions, scrollingTo } = state;
+    let prevPosition;
+    let targetId;
+    let targetIndex;
+    const scrollTarget = scrollingTo == null ? void 0 : scrollingTo.index;
+    if (maintainVisibleContentPosition) {
+      const indexByKey = state.indexByKey;
+      if (scrollTarget !== void 0) {
+        targetId = getId(scrollTarget);
+        targetIndex = scrollTarget;
+      } else if (state.idsInView.length > 0 && peek$(ctx, "containersDidLayout")) {
+        targetId = state.idsInView.find((id) => indexByKey.get(id) !== void 0);
+        targetIndex = indexByKey.get(targetId);
+      }
+      if (targetId !== void 0 && targetIndex !== void 0) {
+        prevPosition = positions.get(targetId);
+      }
+    }
+    return () => {
+      if (targetId !== void 0 && prevPosition !== void 0) {
+        const newPosition = positions.get(targetId);
+        if (newPosition !== void 0) {
+          const positionDiff = newPosition - prevPosition;
+          if (Math.abs(positionDiff) > 0.1) {
+            requestAdjust(positionDiff);
+          }
+        }
+      }
+    };
+  }, []);
+  const calculateItemsInView = useCallback((params = {}) => {
+    var _a2, _b, _c, _d, _e, _f, _g, _h;
     const state = refState.current;
     const {
       data,
@@ -1452,20 +1319,33 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       startBufferedId: startBufferedIdOrig,
       positions,
       columns,
-      scrollAdjustHandler,
-      scrollVelocity: speed
+      containerItemKeys,
+      idCache,
+      sizes,
+      indexByKey,
+      scrollForNextCalculateItemsInView,
+      enableScrollForNextCalculateItemsInView,
+      minIndexSizeChanged
     } = state;
     if (!data || scrollLength === 0) {
       return;
     }
-    const totalSize = peek$(ctx, "totalSizeWithScrollAdjust");
+    const totalSize = peek$(ctx, "totalSize");
     const topPad = peek$(ctx, "stylePaddingTop") + peek$(ctx, "headerSize");
     const numColumns = peek$(ctx, "numColumns");
-    const previousScrollAdjust = scrollAdjustHandler.getAppliedAdjust();
-    let scrollState = state.scroll;
+    const previousScrollAdjust = 0;
+    const { dataChanged, doMVCP } = params;
+    const speed = getScrollVelocity();
+    if (doMVCP || dataChanged) {
+      const checkMVCP = doMVCP ? prepareMVCP() : void 0;
+      updateAllPositions(dataChanged);
+      checkMVCP == null ? void 0 : checkMVCP();
+    }
     const scrollExtra = 0;
-    const useAverageSize = !state.disableScrollJumpsFrom && speed >= 0 && peek$(ctx, "containersDidLayout");
-    if (!state.queuedInitialLayout && initialScroll) {
+    const useAverageSize = false;
+    const { queuedInitialLayout } = state;
+    let { scroll: scrollState } = state;
+    if (!queuedInitialLayout && initialScroll) {
       const updatedOffset = calculateOffsetWithOffsetPosition(
         calculateOffsetForIndex(initialScroll.index),
         initialScroll
@@ -1483,21 +1363,19 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     }
     let scrollBufferTop = scrollBuffer;
     let scrollBufferBottom = scrollBuffer;
-    if (Math.abs(speed) > 4) {
-      if (speed > 0) {
-        scrollBufferTop = scrollBuffer * 0.1;
-        scrollBufferBottom = scrollBuffer * 1.9;
-      } else {
-        scrollBufferTop = scrollBuffer * 1.9;
-        scrollBufferBottom = scrollBuffer * 0.1;
-      }
+    if (speed > 0) {
+      scrollBufferTop = scrollBuffer * 0.5;
+      scrollBufferBottom = scrollBuffer * 1.5;
+    } else {
+      scrollBufferTop = scrollBuffer * 1.5;
+      scrollBufferBottom = scrollBuffer * 0.5;
     }
     const scrollTopBuffered = scroll - scrollBufferTop;
     const scrollBottom = scroll + scrollLength;
     const scrollBottomBuffered = scrollBottom + scrollBufferBottom;
-    if (state.scrollForNextCalculateItemsInView) {
-      const { top: top2, bottom } = state.scrollForNextCalculateItemsInView;
-      if (scrollTopBuffered > top2 && scrollBottomBuffered < bottom) {
+    if (scrollForNextCalculateItemsInView) {
+      const { top, bottom } = scrollForNextCalculateItemsInView;
+      if (scrollTopBuffered > top && scrollBottomBuffered < bottom) {
         return;
       }
     }
@@ -1506,51 +1384,26 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     let startBufferedId = null;
     let endNoBuffer = null;
     let endBuffered = null;
-    let loopStart = startBufferedIdOrig ? state.indexByKey.get(startBufferedIdOrig) || 0 : 0;
-    if (state.minIndexSizeChanged !== void 0) {
-      loopStart = Math.min(state.minIndexSizeChanged, loopStart);
+    let loopStart = startBufferedIdOrig ? indexByKey.get(startBufferedIdOrig) || 0 : 0;
+    if (minIndexSizeChanged !== void 0) {
+      loopStart = Math.min(minIndexSizeChanged, loopStart);
       state.minIndexSizeChanged = void 0;
     }
-    const anchorElementIndex = getAnchorElementIndex();
     for (let i = loopStart; i >= 0; i--) {
-      const id = getId(i);
-      let newPosition;
-      if (maintainVisibleContentPosition && anchorElementIndex && i < anchorElementIndex) {
-        newPosition = getElementPositionBelowAchor(id);
-        if (newPosition !== void 0) {
-          positions.set(id, newPosition);
-        }
-      }
-      const top2 = newPosition || positions.get(id);
-      if (top2 !== void 0) {
-        const size = getItemSize(id, i, data[i], useAverageSize);
-        const bottom = top2 + size;
-        if (bottom > scroll - scrollBuffer) {
-          loopStart = i;
-        } else {
-          break;
-        }
+      const id = (_a2 = idCache.get(i)) != null ? _a2 : getId(i);
+      const top = positions.get(id);
+      const size = (_b = sizes.get(id)) != null ? _b : getItemSize(id, i, data[i], useAverageSize);
+      const bottom = top + size;
+      if (bottom > scroll - scrollBuffer) {
+        loopStart = i;
+      } else {
+        break;
       }
     }
     const loopStartMod = loopStart % numColumns;
     if (loopStartMod > 0) {
       loopStart -= loopStartMod;
     }
-    let top = void 0;
-    let column = 1;
-    let maxSizeInRow = 0;
-    const getInitialTop = (i) => {
-      var _a2;
-      const id = getId(i);
-      let topOffset = 0;
-      if (positions.get(id)) {
-        topOffset = positions.get(id);
-      }
-      if (id === ((_a2 = state.anchorElement) == null ? void 0 : _a2.id)) {
-        topOffset = state.anchorElement.coordinate;
-      }
-      return topOffset;
-    };
     let foundEnd = false;
     let nextTop;
     let nextBottom;
@@ -1559,27 +1412,23 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     for (let i = 0; i < prevNumContainers; i++) {
       const key = peek$(ctx, `containerItemKey${i}`);
       if (key !== void 0) {
-        const index = state.indexByKey.get(key);
+        const index = indexByKey.get(key);
         maxIndexRendered = Math.max(maxIndexRendered, index);
       }
     }
-    for (let i = Math.max(0, loopStart); i < data.length && (!foundEnd || i <= maxIndexRendered); i++) {
-      const id = getId(i);
-      const size = getItemSize(id, i, data[i], useAverageSize);
-      maxSizeInRow = Math.max(maxSizeInRow, size);
-      if (top === void 0 || id === ((_a = state.anchorElement) == null ? void 0 : _a.id)) {
-        top = getInitialTop(i);
-      }
-      if (positions.get(id) !== top) {
-        positions.set(id, top);
-      }
-      if (columns.get(id) !== column) {
-        columns.set(id, column);
-      }
+    let firstFullyOnScreenIndex;
+    const dataLength = data.length;
+    for (let i = Math.max(0, loopStart); i < dataLength && (!foundEnd || i <= maxIndexRendered); i++) {
+      const id = (_c = idCache.get(i)) != null ? _c : getId(i);
+      const size = (_d = sizes.get(id)) != null ? _d : getItemSize(id, i, data[i], useAverageSize);
+      const top = positions.get(id);
       if (!foundEnd) {
         if (startNoBuffer === null && top + size > scroll) {
           startNoBuffer = i;
         }
+        if (firstFullyOnScreenIndex === void 0 && top >= scroll - 10) {
+          firstFullyOnScreenIndex = i;
+        }
         if (startBuffered === null && top + size > scrollTopBuffered) {
           startBuffered = i;
           startBufferedId = id;
@@ -1591,46 +1440,49 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
           }
           if (top <= scrollBottomBuffered) {
             endBuffered = i;
-            nextBottom = top + maxSizeInRow - scrollLength;
+            nextBottom = top + size;
           } else {
             foundEnd = true;
           }
         }
       }
-      column++;
-      if (column > numColumns) {
-        top += maxSizeInRow;
-        column = 1;
-        maxSizeInRow = 0;
-      }
+    }
+    const idsInView = [];
+    for (let i = firstFullyOnScreenIndex; i <= endNoBuffer; i++) {
+      const id = (_e = idCache.get(i)) != null ? _e : getId(i);
+      idsInView.push(id);
     }
     Object.assign(state, {
       startBuffered,
       startBufferedId,
       startNoBuffer,
       endBuffered,
-      endNoBuffer
+      endNoBuffer,
+      idsInView,
+      firstFullyOnScreenIndex
     });
-    if (state.enableScrollForNextCalculateItemsInView && nextTop !== void 0 && nextBottom !== void 0 && state.disableScrollJumpsFrom === void 0) {
+    if (enableScrollForNextCalculateItemsInView && nextTop !== void 0 && nextBottom !== void 0) {
       state.scrollForNextCalculateItemsInView = nextTop !== void 0 && nextBottom !== void 0 ? {
         top: nextTop,
         bottom: nextBottom
       } : void 0;
     }
+    const numContainers = peek$(ctx, "numContainers");
+    const pendingRemoval = [];
+    if (dataChanged) {
+      for (let i = 0; i < numContainers; i++) {
+        const itemKey = peek$(ctx, `containerItemKey${i}`);
+        if (!keyExtractorProp || itemKey && indexByKey.get(itemKey) === void 0) {
+          pendingRemoval.push(i);
+        }
+      }
+    }
     if (startBuffered !== null && endBuffered !== null) {
-      let numContainers = prevNumContainers;
+      let numContainers2 = prevNumContainers;
       const needNewContainers = [];
-      const isContained = (i) => {
-        const id = getId(i);
-        for (let j = 0; j < numContainers; j++) {
-          const key = peek$(ctx, `containerItemKey${j}`);
-          if (key === id) {
-            return true;
-          }
-        }
-      };
       for (let i = startBuffered; i <= endBuffered; i++) {
-        if (!isContained(i)) {
+        const id = (_f = idCache.get(i)) != null ? _f : getId(i);
+        if (!containerItemKeys.has(id)) {
           needNewContainers.push(i);
         }
       }
@@ -1638,75 +1490,79 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
         const availableContainers = findAvailableContainers(
           needNewContainers.length,
           startBuffered,
-          endBuffered
+          endBuffered,
+          pendingRemoval
         );
         for (let idx = 0; idx < needNewContainers.length; idx++) {
           const i = needNewContainers[idx];
           const containerIndex = availableContainers[idx];
-          const id = getId(i);
+          const id = (_g = idCache.get(i)) != null ? _g : getId(i);
+          const oldKey = peek$(ctx, `containerItemKey${containerIndex}`);
+          if (oldKey && oldKey !== id) {
+            containerItemKeys.delete(oldKey);
+          }
           set$(ctx, `containerItemKey${containerIndex}`, id);
           set$(ctx, `containerItemData${containerIndex}`, data[i]);
-          if (containerIndex >= numContainers) {
-            numContainers = containerIndex + 1;
+          containerItemKeys.add(id);
+          if (containerIndex >= numContainers2) {
+            numContainers2 = containerIndex + 1;
           }
         }
-        if (numContainers !== prevNumContainers) {
-          set$(ctx, "numContainers", numContainers);
-          if (numContainers > peek$(ctx, "numContainersPooled")) {
-            set$(ctx, "numContainersPooled", Math.ceil(numContainers * 1.5));
+        if (numContainers2 !== prevNumContainers) {
+          set$(ctx, "numContainers", numContainers2);
+          if (numContainers2 > peek$(ctx, "numContainersPooled")) {
+            set$(ctx, "numContainersPooled", Math.ceil(numContainers2 * 1.5));
           }
         }
       }
-      for (let i = 0; i < numContainers; i++) {
+      for (let i = 0; i < numContainers2; i++) {
         const itemKey = peek$(ctx, `containerItemKey${i}`);
-        const itemIndex = state.indexByKey.get(itemKey);
-        const item = data[itemIndex];
-        if (item !== void 0) {
-          const id = getId(itemIndex);
-          const position = positions.get(id);
-          if (position === void 0) {
-            set$(ctx, `containerPosition${i}`, ANCHORED_POSITION_OUT_OF_VIEW);
-          } else {
-            const pos = {
-              type: "top",
-              relativeCoordinate: positions.get(id),
-              top: positions.get(id)
-            };
-            const column2 = columns.get(id) || 1;
-            if (maintainVisibleContentPosition && itemIndex < anchorElementIndex) {
-              const currentRow = Math.floor(itemIndex / numColumns);
-              const rowHeight = getRowHeight(currentRow);
-              const elementHeight = getItemSize(id, itemIndex, data[i]);
-              const diff = rowHeight - elementHeight;
-              pos.relativeCoordinate = pos.top + getRowHeight(currentRow) - diff;
-              pos.type = "bottom";
-            }
-            const prevPos = peek$(ctx, `containerPosition${i}`);
-            const prevColumn = peek$(ctx, `containerColumn${i}`);
-            const prevData = peek$(ctx, `containerItemData${i}`);
-            if (!prevPos || pos.relativeCoordinate > POSITION_OUT_OF_VIEW && pos.top !== prevPos.top) {
-              set$(ctx, `containerPosition${i}`, pos);
-            }
-            if (column2 >= 0 && column2 !== prevColumn) {
-              set$(ctx, `containerColumn${i}`, column2);
-            }
-            if (prevData !== item) {
-              set$(ctx, `containerItemData${i}`, data[itemIndex]);
+        if (pendingRemoval.includes(i)) {
+          if (itemKey) {
+            containerItemKeys.delete(itemKey);
+          }
+          set$(ctx, `containerItemKey${i}`, void 0);
+          set$(ctx, `containerItemData${i}`, void 0);
+          set$(ctx, `containerPosition${i}`, POSITION_OUT_OF_VIEW);
+          set$(ctx, `containerColumn${i}`, -1);
+        } else {
+          const itemIndex = indexByKey.get(itemKey);
+          const item = data[itemIndex];
+          if (item !== void 0) {
+            const id = (_h = idCache.get(itemIndex)) != null ? _h : getId(itemIndex);
+            const position = positions.get(id);
+            if (position === void 0) {
+              set$(ctx, `containerPosition${i}`, POSITION_OUT_OF_VIEW);
+            } else {
+              const pos = positions.get(id);
+              const column = columns.get(id) || 1;
+              const prevPos = peek$(ctx, `containerPosition${i}`);
+              const prevColumn = peek$(ctx, `containerColumn${i}`);
+              const prevData = peek$(ctx, `containerItemData${i}`);
+              if (!prevPos || pos > POSITION_OUT_OF_VIEW && pos !== prevPos) {
+                set$(ctx, `containerPosition${i}`, pos);
+              }
+              if (column >= 0 && column !== prevColumn) {
+                set$(ctx, `containerColumn${i}`, column);
+              }
+              if (prevData !== item) {
+                set$(ctx, `containerItemData${i}`, data[itemIndex]);
+              }
             }
           }
         }
       }
     }
-    if (!state.queuedInitialLayout && endBuffered !== null) {
+    if (!queuedInitialLayout && endBuffered !== null) {
       if (checkAllSizesKnown()) {
         setDidLayout();
       }
     }
-    if (state.viewabilityConfigCallbackPairs) {
+    if (viewabilityConfigCallbackPairs) {
       updateViewableItems(
         state,
         ctx,
-        state.viewabilityConfigCallbackPairs,
+        viewabilityConfigCallbackPairs,
         getId,
         scrollLength,
         startNoBuffer,
@@ -1721,10 +1577,10 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     if (stylePaddingTop !== void 0) {
       const prevStylePaddingTop = peek$(ctx, "stylePaddingTop") || 0;
       if (stylePaddingTop < prevStylePaddingTop) {
-        const prevTotalSize = peek$(ctx, "totalSizeWithScrollAdjust") || 0;
-        set$(ctx, "totalSizeWithScrollAdjust", prevTotalSize + prevStylePaddingTop);
+        const prevTotalSize = peek$(ctx, "totalSize") || 0;
+        set$(ctx, "totalSize", prevTotalSize + prevStylePaddingTop);
         setTimeout(() => {
-          set$(ctx, "totalSizeWithScrollAdjust", prevTotalSize);
+          set$(ctx, "totalSize", prevTotalSize);
         }, 16);
       }
       set$(ctx, "stylePaddingTop", stylePaddingTop);
@@ -1732,11 +1588,6 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     if (alignItemsPaddingTop !== void 0) {
       set$(ctx, "alignItemsPaddingTop", alignItemsPaddingTop);
     }
-    set$(
-      ctx,
-      "paddingTop",
-      (stylePaddingTop != null ? stylePaddingTop : peek$(ctx, "stylePaddingTop")) + (alignItemsPaddingTop != null ? alignItemsPaddingTop : peek$(ctx, "alignItemsPaddingTop"))
-    );
   };
   const updateAlignItemsPaddingTop = () => {
     if (alignItemsAtEnd) {
@@ -1753,27 +1604,25 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     const state = refState.current;
     if (state) {
       state.scrollingTo = void 0;
-      state.scrollAdjustHandler.setDisableAdjust(false);
       state.scrollHistory.length = 0;
-      calculateItemsInView();
     }
   };
   const scrollTo = (params = {}) => {
-    var _a;
+    var _a2;
     const state = refState.current;
     const { animated } = params;
     const offset = calculateOffsetWithOffsetPosition(params.offset, params);
-    state.scrollAdjustHandler.setDisableAdjust(true);
     state.scrollHistory.length = 0;
     state.scrollingTo = params;
     state.scrollPending = offset;
-    (_a = refScroller.current) == null ? void 0 : _a.scrollTo({
+    (_a2 = refScroller.current) == null ? void 0 : _a2.scrollTo({
       x: horizontal ? offset : 0,
       y: horizontal ? 0 : offset,
       animated: !!animated
     });
     if (!animated) {
-      requestAnimationFrame(finishScrollTo);
+      refState.current.scroll = offset;
+      setTimeout(finishScrollTo, 100);
     }
   };
   const doMaintainScrollAtEnd = (animated) => {
@@ -1783,11 +1632,10 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       if (paddingTop > 0) {
         state.scroll = 0;
       }
-      state.disableScrollJumpsFrom = void 0;
       requestAnimationFrame(() => {
-        var _a;
+        var _a2;
         state.maintainingScrollAtEnd = true;
-        (_a = refScroller.current) == null ? void 0 : _a.scrollToEnd({
+        (_a2 = refScroller.current) == null ? void 0 : _a2.scrollToEnd({
           animated
         });
         setTimeout(
@@ -1836,8 +1684,8 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
         refState.current.isEndReached,
         refState.current.endReachedBlockedByTimer,
         (distance) => {
-          var _a, _b;
-          return (_b = (_a = callbacks.current).onEndReached) == null ? void 0 : _b.call(_a, { distanceFromEnd: distance });
+          var _a2, _b;
+          return (_b = (_a2 = callbacks.current).onEndReached) == null ? void 0 : _b.call(_a2, { distanceFromEnd: distance });
         },
         (block) => {
           refState.current.endReachedBlockedByTimer = block;
@@ -1859,8 +1707,8 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       refState.current.isStartReached,
       refState.current.startReachedBlockedByTimer,
       (distance) => {
-        var _a, _b;
-        return (_b = (_a = callbacks.current).onStartReached) == null ? void 0 : _b.call(_a, { distanceFromStart: distance });
+        var _a2, _b;
+        return (_b = (_a2 = callbacks.current).onStartReached) == null ? void 0 : _b.call(_a2, { distanceFromStart: distance });
       },
       (block) => {
         refState.current.startReachedBlockedByTimer = block;
@@ -1872,30 +1720,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     if (state) {
       state.data = dataProp;
       if (!isFirst2) {
-        const totalSizeBefore = state.previousTotalSize;
-        const totalSizeAfter = state.totalSize;
-        const scrollDiff = state.scroll - state.scrollPrev;
-        const sizeDiff = totalSizeAfter - totalSizeBefore;
-        if (Math.abs(scrollDiff - sizeDiff) < 10) {
-          disableScrollJumps(1e3);
-        }
-        const numContainers = peek$(ctx, "numContainers");
-        for (let i = 0; i < numContainers; i++) {
-          const itemKey = peek$(ctx, `containerItemKey${i}`);
-          if (!keyExtractorProp || itemKey && state.indexByKey.get(itemKey) === void 0) {
-            set$(ctx, `containerItemKey${i}`, void 0);
-            set$(ctx, `containerItemData${i}`, void 0);
-            set$(ctx, `containerPosition${i}`, ANCHORED_POSITION_OUT_OF_VIEW);
-            set$(ctx, `containerColumn${i}`, -1);
-          }
-        }
-        if (!keyExtractorProp) {
-          state.positions.clear();
-        }
-        calculateItemsInView(
-          /*isReset*/
-          true
-        );
+        calculateItemsInView({ dataChanged: true, doMVCP: true });
         const didMaintainScrollAtEnd = doMaintainScrollAtEnd(false);
         if (!didMaintainScrollAtEnd && dataProp.length > state.data.length) {
           state.isEndReached = false;
@@ -1907,106 +1732,40 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       }
     }
   };
-  const calcTotalSizesAndPositions = ({ forgetPositions = false }) => {
-    var _a, _b;
-    const state = refState.current;
-    let totalSize = 0;
-    let totalSizeBelowIndex = 0;
-    const indexByKey = /* @__PURE__ */ new Map();
-    const newPositions = /* @__PURE__ */ new Map();
-    let column = 1;
-    let maxSizeInRow = 0;
-    const numColumns = (_a = peek$(ctx, "numColumns")) != null ? _a : numColumnsProp;
-    if (!state) {
-      return;
-    }
-    for (let i = 0; i < dataProp.length; i++) {
-      const key = getId(i);
-      if (__DEV__) {
-        if (indexByKey.has(key)) {
-          console.error(
-            `[legend-list] Error: Detected overlapping key (${key}) which causes missing items and gaps and other terrrible things. Check that keyExtractor returns unique values.`
-          );
-        }
-      }
-      indexByKey.set(key, i);
-      if (!forgetPositions && state.positions.get(key) != null && state.indexByKey.get(key) === i) {
-        newPositions.set(key, state.positions.get(key));
-      }
-    }
-    state.indexByKey = indexByKey;
-    state.positions = newPositions;
-    if (!forgetPositions && !isFirst) {
-      if (maintainVisibleContentPosition) {
-        if (state.anchorElement == null || indexByKey.get(state.anchorElement.id) == null) {
-          if (dataProp.length) {
-            const newAnchorElement = {
-              coordinate: 0,
-              id: getId(0)
-            };
-            state.anchorElement = newAnchorElement;
-            (_b = state.belowAnchorElementPositions) == null ? void 0 : _b.clear();
-            scrollTo({ offset: 0, animated: false });
-            setTimeout(() => {
-              calculateItemsInView(
-                /*reset*/
-                true
-              );
-            }, 0);
-          } else {
-            state.startBufferedId = void 0;
-          }
-        }
-      } else {
-        if (state.startBufferedId != null && newPositions.get(state.startBufferedId) == null) {
-          if (dataProp.length) {
-            state.startBufferedId = getId(0);
-          } else {
-            state.startBufferedId = void 0;
+  const updateTotalSize = () => {
+    const { data, positions } = refState.current;
+    if (data.length === 0) {
+      addTotalSize(null, 0);
+    } else {
+      const lastId = getId(data.length - 1);
+      if (lastId !== void 0) {
+        const lastPosition = positions.get(lastId);
+        if (lastPosition !== void 0) {
+          const lastSize = getItemSize(lastId, data.length - 1, data[dataProp.length - 1]);
+          if (lastSize !== void 0) {
+            const totalSize = lastPosition + lastSize;
+            addTotalSize(null, totalSize);
           }
-          scrollTo({ offset: 0, animated: false });
-          setTimeout(() => {
-            calculateItemsInView(
-              /*reset*/
-              true
-            );
-          }, 0);
         }
       }
     }
-    const anchorElementIndex = getAnchorElementIndex();
-    for (let i = 0; i < dataProp.length; i++) {
-      const key = getId(i);
-      const size = getItemSize(key, i, dataProp[i]);
-      maxSizeInRow = Math.max(maxSizeInRow, size);
-      column++;
-      if (column > numColumns) {
-        if (maintainVisibleContentPosition && anchorElementIndex !== void 0 && i < anchorElementIndex) {
-          totalSizeBelowIndex += maxSizeInRow;
-        }
-        totalSize += maxSizeInRow;
-        column = 1;
-        maxSizeInRow = 0;
-      }
-    }
-    if (maxSizeInRow > 0) {
-      totalSize += maxSizeInRow;
-    }
-    state.ignoreScrollFromCalcTotal = true;
-    requestAnimationFrame(() => {
-      state.ignoreScrollFromCalcTotal = false;
-    });
-    addTotalSize(null, totalSize, totalSizeBelowIndex);
   };
-  const findAvailableContainers = (numNeeded, startBuffered, endBuffered) => {
+  const findAvailableContainers = (numNeeded, startBuffered, endBuffered, pendingRemoval) => {
     const state = refState.current;
     const numContainers = peek$(ctx, "numContainers");
-    if (numNeeded === 0) return [];
     const result = [];
     const availableContainers = [];
     for (let u = 0; u < numContainers; u++) {
       const key = peek$(ctx, `containerItemKey${u}`);
-      if (key === void 0) {
+      let isOk = key === void 0;
+      if (!isOk) {
+        const index = pendingRemoval.indexOf(u);
+        if (index !== -1) {
+          pendingRemoval.splice(index, 1);
+          isOk = true;
+        }
+      }
+      if (isOk) {
         result.push(u);
         if (result.length >= numNeeded) {
           return result;
@@ -2072,14 +1831,21 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     refState.current.stylePaddingBottom = stylePaddingBottomState;
     const paddingDiff = stylePaddingTopState - prevPaddingTop;
     if (paddingDiff && prevPaddingTop !== void 0 && Platform.OS === "ios") {
-      queueMicrotask(() => {
-        scrollTo({ offset: refState.current.scrollPending + paddingDiff, animated: false });
-      });
+      requestAdjust(paddingDiff);
     }
   };
   if (isFirst) {
     initalizeStateVars();
+    updateAllPositions();
   }
+  const initialContentOffset = useMemo(() => {
+    const initialContentOffset2 = initialScrollOffset || calculateOffsetForIndex(initialScrollIndex);
+    refState.current.isStartReached = initialContentOffset2 < refState.current.scrollLength * onStartReachedThreshold;
+    if (initialContentOffset2 > 0) {
+      scrollTo({ offset: initialContentOffset2, animated: false, index: initialScrollIndex });
+    }
+    return initialContentOffset2;
+  }, [renderNum]);
   if (isFirst || didDataChange || numColumnsProp !== peek$(ctx, "numColumns")) {
     refState.current.lastBatchingAction = Date.now();
     if (!keyExtractorProp && !isFirst && didDataChange) {
@@ -2090,22 +1856,38 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       refState.current.sizes.clear();
       refState.current.positions.clear();
     }
-    refState.current.previousTotalSize = peek$(ctx, "totalSize");
-    calcTotalSizesAndPositions({ forgetPositions: false });
   }
-  useEffect(() => {
-    if (initialScroll && ListHeaderComponent) {
-      const dispose = listen$(ctx, "headerSize", (size) => {
-        if (size > 0) {
-          scrollToIndex({ ...initialScroll, animated: false });
-          dispose == null ? void 0 : dispose();
+  useLayoutEffect(() => {
+    var _a2, _b;
+    if (IsNewArchitecture) {
+      const measured = (_b = (_a2 = refScroller.current) == null ? void 0 : _a2.unstable_getBoundingClientRect) == null ? void 0 : _b.call(_a2);
+      if (measured) {
+        const size = Math.floor(measured[horizontal ? "width" : "height"] * 8) / 8;
+        if (size) {
+          handleLayout(measured);
         }
-      });
-      setTimeout(dispose, 0);
-      return dispose;
+      }
+    }
+    if (!isFirst) {
+      calculateItemsInView({ doMVCP: true });
+    }
+  }, [dataProp]);
+  const onLayoutHeader = useCallback((rect, fromLayoutEffect) => {
+    const size = rect[horizontal ? "width" : "height"];
+    set$(ctx, "headerSize", size);
+    if (initialScroll) {
+      if (IsNewArchitecture && Platform.OS !== "android") {
+        if (fromLayoutEffect) {
+          setRenderNum((v) => v + 1);
+        }
+      } else {
+        setTimeout(() => {
+          scrollToIndex({ ...initialScroll, animated: false });
+        }, 17);
+      }
     }
   }, []);
-  useEffect(() => {
+  useLayoutEffect(() => {
     const didAllocateContainers = doInitialAllocateContainers();
     if (!didAllocateContainers) {
       checkResetContainers(
@@ -2114,11 +1896,11 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       );
     }
   }, [dataProp, numColumnsProp]);
-  useEffect(() => {
+  useLayoutEffect(() => {
     set$(ctx, "extraData", extraData);
   }, [extraData]);
   refState.current.renderItem = renderItem2;
-  useEffect(initalizeStateVars, [
+  useLayoutEffect(initalizeStateVars, [
     memoizedLastItemKeys.join(","),
     numColumnsProp,
     stylePaddingTopState,
@@ -2151,25 +1933,24 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     const { scrollLength, data } = state;
     if (scrollLength > 0 && data.length > 0 && !peek$(ctx, "numContainers")) {
       const averageItemSize = getEstimatedItemSize ? getEstimatedItemSize(0, data[0]) : estimatedItemSize;
-      const numContainers = Math.ceil((scrollLength + scrollBuffer * 2) / averageItemSize) * numColumnsProp;
+      const Extra = 1.5;
+      const numContainers = Math.ceil(
+        (scrollLength + scrollBuffer * 2) / averageItemSize * numColumnsProp * Extra
+      );
       for (let i = 0; i < numContainers; i++) {
-        set$(ctx, `containerPosition${i}`, ANCHORED_POSITION_OUT_OF_VIEW);
+        set$(ctx, `containerPosition${i}`, POSITION_OUT_OF_VIEW);
         set$(ctx, `containerColumn${i}`, -1);
       }
       set$(ctx, "numContainers", numContainers);
       set$(ctx, "numContainersPooled", numContainers * initialContainerPoolRatio);
-      if (initialScroll) {
-        requestAnimationFrame(() => {
-          calculateItemsInView(
-            /*isReset*/
-            true
-          );
-        });
-      } else {
-        calculateItemsInView(
-          /*isReset*/
-          true
-        );
+      if (!IsNewArchitecture) {
+        if (initialScroll) {
+          requestAnimationFrame(() => {
+            calculateItemsInView();
+          });
+        } else {
+          calculateItemsInView();
+        }
       }
       return true;
     }
@@ -2184,131 +1965,137 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     state.viewabilityConfigCallbackPairs = viewability;
     state.enableScrollForNextCalculateItemsInView = !viewability;
   }, [viewabilityConfig, viewabilityConfigCallbackPairs, onViewableItemsChanged]);
-  useInit(() => {
-    doInitialAllocateContainers();
-  });
-  const updateItemSize = useCallback(
-    (itemKey, sizeObj, fromFixGaps) => {
+  if (!IsNewArchitecture) {
+    useInit(() => {
+      doInitialAllocateContainers();
+    });
+  }
+  const updateOneItemSize = useCallback((itemKey, sizeObj) => {
+    const state = refState.current;
+    const { sizes, indexByKey, sizesKnown, data, averageSizes } = state;
+    if (!data) return 0;
+    const index = indexByKey.get(itemKey);
+    const prevSize = getItemSize(itemKey, index, data);
+    const size = Math.floor((horizontal ? sizeObj.width : sizeObj.height) * 8) / 8;
+    sizesKnown.set(itemKey, size);
+    const itemType = "";
+    let averages = averageSizes[itemType];
+    if (!averages) {
+      averages = averageSizes[itemType] = { num: 0, avg: 0 };
+    }
+    averages.avg = (averages.avg * averages.num + size) / (averages.num + 1);
+    averages.num++;
+    if (!prevSize || Math.abs(prevSize - size) > 0.1) {
+      sizes.set(itemKey, size);
+      return size - prevSize;
+    }
+    return 0;
+  }, []);
+  const updateItemSizes = useCallback(
+    (itemUpdates) => {
+      var _a2;
       const state = refState.current;
-      const {
-        sizes,
-        indexByKey,
-        sizesKnown,
-        data,
-        rowHeights,
-        startBuffered,
-        endBuffered,
-        averageSizes,
-        queuedInitialLayout
-      } = state;
-      if (!data) {
-        return;
-      }
-      const index = indexByKey.get(itemKey);
-      const numColumns = peek$(ctx, "numColumns");
-      state.scrollForNextCalculateItemsInView = void 0;
-      state.minIndexSizeChanged = state.minIndexSizeChanged !== void 0 ? Math.min(state.minIndexSizeChanged, index) : index;
-      const prevSize = getItemSize(itemKey, index, data);
-      const prevSizeKnown = sizesKnown.get(itemKey);
-      let needsCalculate = false;
-      let needsUpdateContainersDidLayout = false;
-      const size = Math.floor((horizontal ? sizeObj.width : sizeObj.height) * 8) / 8;
-      sizesKnown.set(itemKey, size);
-      const itemType = "";
-      let averages = averageSizes[itemType];
-      if (!averages) {
-        averages = averageSizes[itemType] = {
-          num: 0,
-          avg: 0
-        };
-      }
-      averages.avg = (averages.avg * averages.num + size) / (averages.num + 1);
-      averages.num++;
-      if (!prevSize || Math.abs(prevSize - size) > 0.1) {
-        let diff;
-        needsCalculate = true;
-        if (numColumns > 1) {
-          const rowNumber = Math.floor(index / numColumnsProp);
-          const prevSizeInRow = getRowHeight(rowNumber);
-          sizes.set(itemKey, size);
-          rowHeights.delete(rowNumber);
-          const sizeInRow = getRowHeight(rowNumber);
-          diff = sizeInRow - prevSizeInRow;
-        } else {
-          sizes.set(itemKey, size);
-          diff = size - prevSize;
-        }
-        if (__DEV__ && suggestEstimatedItemSize) {
-          if (state.timeoutSizeMessage) {
-            clearTimeout(state.timeoutSizeMessage);
+      if (!state.data) return;
+      let needsRecalculate = false;
+      let shouldMaintainScrollAtEnd = false;
+      let minIndexSizeChanged;
+      let maxOtherAxisSize = peek$(ctx, "otherAxisSize") || 0;
+      for (const { itemKey, sizeObj } of itemUpdates) {
+        const index = state.indexByKey.get(itemKey);
+        const prevSizeKnown = state.sizesKnown.get(itemKey);
+        const diff = updateOneItemSize(itemKey, sizeObj);
+        const size = Math.floor((horizontal ? sizeObj.width : sizeObj.height) * 8) / 8;
+        if (diff !== 0) {
+          minIndexSizeChanged = minIndexSizeChanged !== void 0 ? Math.min(minIndexSizeChanged, index) : index;
+          if (((_a2 = state.scrollingTo) == null ? void 0 : _a2.viewPosition) && maintainVisibleContentPosition && index === state.scrollingTo.index) {
+            requestAdjust(diff * state.scrollingTo.viewPosition);
           }
-          state.timeoutSizeMessage = setTimeout(() => {
-            state.timeoutSizeMessage = void 0;
-            const num = sizesKnown.size;
-            const avg = state.averageSizes[""].avg;
-            console.warn(
-              `[legend-list] Based on the ${num} items rendered so far, the optimal estimated size is ${avg}.`
-            );
-          }, 1e3);
-        }
-        state.scrollForNextCalculateItemsInView = void 0;
-        addTotalSize(itemKey, diff, 0);
-        if (prevSizeKnown !== void 0 && Math.abs(prevSizeKnown - size) > 5) {
-          doMaintainScrollAtEnd(false);
-        }
-        if (onItemSizeChanged) {
-          onItemSizeChanged({
+          const { startBuffered, endBuffered } = state;
+          needsRecalculate || (needsRecalculate = index >= startBuffered && index <= endBuffered);
+          if (!needsRecalculate) {
+            const numContainers = ctx.values.get("numContainers");
+            for (let i = 0; i < numContainers; i++) {
+              if (peek$(ctx, `containerItemKey${i}`) === itemKey) {
+                needsRecalculate = true;
+                break;
+              }
+            }
+          }
+          if (state.needsOtherAxisSize) {
+            const otherAxisSize = horizontal ? sizeObj.height : sizeObj.width;
+            maxOtherAxisSize = Math.max(maxOtherAxisSize, otherAxisSize);
+          }
+          if (prevSizeKnown !== void 0 && Math.abs(prevSizeKnown - size) > 5) {
+            shouldMaintainScrollAtEnd = true;
+          }
+          onItemSizeChanged == null ? void 0 : onItemSizeChanged({
             size,
-            previous: prevSize,
+            previous: size - diff,
             index,
             itemKey,
-            itemData: data[index]
+            itemData: state.data[index]
           });
         }
       }
-      if (!queuedInitialLayout && checkAllSizesKnown()) {
-        needsUpdateContainersDidLayout = true;
+      if (minIndexSizeChanged !== void 0) {
+        state.minIndexSizeChanged = state.minIndexSizeChanged !== void 0 ? Math.min(state.minIndexSizeChanged, minIndexSizeChanged) : minIndexSizeChanged;
       }
-      let isInView = index >= startBuffered && index <= endBuffered;
-      if (!isInView) {
-        const numContainers = ctx.values.get("numContainers");
-        for (let i = 0; i < numContainers; i++) {
-          if (peek$(ctx, `containerItemKey${i}`) === itemKey) {
-            isInView = true;
-            break;
-          }
-        }
+      if (__DEV__ && suggestEstimatedItemSize && minIndexSizeChanged !== void 0) {
+        if (state.timeoutSizeMessage) clearTimeout(state.timeoutSizeMessage);
+        state.timeoutSizeMessage = setTimeout(() => {
+          var _a3;
+          state.timeoutSizeMessage = void 0;
+          const num = state.sizesKnown.size;
+          const avg = (_a3 = state.averageSizes[""]) == null ? void 0 : _a3.avg;
+          console.warn(
+            `[legend-list] Based on the ${num} items rendered so far, the optimal estimated size is ${avg}.`
+          );
+        }, 1e3);
       }
-      if (needsUpdateContainersDidLayout || !fromFixGaps && needsCalculate && (isInView || !queuedInitialLayout)) {
-        const scrollVelocity = state.scrollVelocity;
-        let didCalculate = false;
-        if ((Number.isNaN(scrollVelocity) || Math.abs(scrollVelocity) < 1 || state.scrollingTo !== void 0) && (!waitForInitialLayout || needsUpdateContainersDidLayout || queuedInitialLayout)) {
-          if (Date.now() - state.lastBatchingAction < 500) {
-            if (!state.queuedCalculateItemsInView) {
-              state.queuedCalculateItemsInView = requestAnimationFrame(() => {
-                state.queuedCalculateItemsInView = void 0;
-                calculateItemsInView();
-              });
-            }
-          } else {
-            calculateItemsInView();
-            didCalculate = true;
-          }
-        }
-        if (!didCalculate && !needsUpdateContainersDidLayout && IsNewArchitecture) {
-          fixGaps();
-        }
+      const cur = peek$(ctx, "otherAxisSize");
+      if (!cur || maxOtherAxisSize > cur) {
+        set$(ctx, "otherAxisSize", maxOtherAxisSize);
       }
-      if (state.needsOtherAxisSize) {
-        const otherAxisSize = horizontal ? sizeObj.height : sizeObj.width;
-        const cur = peek$(ctx, "otherAxisSize");
-        if (!cur || otherAxisSize > cur) {
-          set$(ctx, "otherAxisSize", otherAxisSize);
+      const containersDidLayout = peek$(ctx, "containersDidLayout");
+      if (containersDidLayout || checkAllSizesKnown()) {
+        if (needsRecalculate) {
+          state.scrollForNextCalculateItemsInView = void 0;
+          calculateItemsInView({ doMVCP: true });
+        }
+        if (shouldMaintainScrollAtEnd) {
+          doMaintainScrollAtEnd(false);
         }
       }
     },
     []
   );
+  const updateItemSize = useCallback((itemKey, sizeObj) => {
+    var _a2, _b;
+    if (IsNewArchitecture) {
+      const { sizesKnown } = refState.current;
+      const numContainers = ctx.values.get("numContainers");
+      const changes = [];
+      for (let i = 0; i < numContainers; i++) {
+        const containerItemKey = peek$(ctx, `containerItemKey${i}`);
+        if (itemKey === containerItemKey) {
+          changes.push({ itemKey, sizeObj });
+        } else if (!sizesKnown.has(containerItemKey) && containerItemKey !== void 0) {
+          const containerRef = ctx.viewRefs.get(i);
+          if (containerRef) {
+            const measured = (_b = (_a2 = containerRef.current) == null ? void 0 : _a2.unstable_getBoundingClientRect) == null ? void 0 : _b.call(_a2);
+            if (measured) {
+              changes.push({ itemKey: containerItemKey, sizeObj: measured });
+            }
+          }
+        }
+      }
+      if (changes.length > 0) {
+        updateItemSizes(changes);
+      }
+    } else {
+      updateItemSizes([{ itemKey, sizeObj }]);
+    }
+  }, []);
   const handleLayout = useCallback((size) => {
     const scrollLength = size[horizontal ? "width" : "height"];
     const otherAxisSize = size[horizontal ? "height" : "width"];
@@ -2320,16 +2107,16 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     state.lastBatchingAction = Date.now();
     state.scrollForNextCalculateItemsInView = void 0;
     doInitialAllocateContainers();
-    doMaintainScrollAtEnd(false);
-    updateAlignItemsPaddingTop();
-    checkAtBottom();
-    checkAtTop();
     if (didChange) {
-      calculateItemsInView();
+      calculateItemsInView({ doMVCP: true });
     }
     if (didChange || otherAxisSize !== prevOtherAxisSize) {
       set$(ctx, "scrollSize", { width: size.width, height: size.height });
     }
+    doMaintainScrollAtEnd(false);
+    updateAlignItemsPaddingTop();
+    checkAtBottom();
+    checkAtTop();
     if (refState.current) {
       refState.current.needsOtherAxisSize = otherAxisSize - (stylePaddingTopState || 0) < 10;
     }
@@ -2339,40 +2126,32 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
         `List ${horizontal ? "width" : "height"} is 0. You may need to set a style or \`flex: \` for the list, because children are absolutely positioned.`
       );
     }
+    calculateItemsInView({ doMVCP: true });
+    setCanRender(true);
   }, []);
   const onLayout = useCallback((event) => {
     const layout = event.nativeEvent.layout;
     handleLayout(layout);
-    layout[horizontal ? "width" : "height"];
-    layout[horizontal ? "height" : "width"];
     if (onLayoutProp) {
       onLayoutProp(event);
     }
   }, []);
-  if (IsNewArchitecture) {
-    useLayoutEffect(() => {
-      var _a, _b;
-      const measured = (_b = (_a = refScroller.current) == null ? void 0 : _a.unstable_getBoundingClientRect) == null ? void 0 : _b.call(_a);
-      if (measured) {
-        const size = Math.floor(measured[horizontal ? "width" : "height"] * 8) / 8;
-        if (size) {
-          handleLayout(measured);
-        }
-      }
-    }, []);
-  }
   const handleScroll = useCallback(
     (event) => {
-      var _a, _b, _c, _d;
-      if (((_b = (_a = event.nativeEvent) == null ? void 0 : _a.contentSize) == null ? void 0 : _b.height) === 0 && ((_c = event.nativeEvent.contentSize) == null ? void 0 : _c.width) === 0) {
+      var _a2, _b, _c, _d;
+      if (((_b = (_a2 = event.nativeEvent) == null ? void 0 : _a2.contentSize) == null ? void 0 : _b.height) === 0 && ((_c = event.nativeEvent.contentSize) == null ? void 0 : _c.width) === 0) {
         return;
       }
       const state = refState.current;
       const newScroll = event.nativeEvent.contentOffset[horizontal ? "x" : "y"];
-      state.scrollPending = newScroll;
-      if (state.ignoreScrollFromCalcTotal && newScroll !== 0) {
-        return;
+      const ignoreScrollFromMVCP = state.ignoreScrollFromMVCP;
+      if (ignoreScrollFromMVCP && !state.scrollingTo) {
+        const { lt, gt } = ignoreScrollFromMVCP;
+        if (lt && newScroll < lt || gt && newScroll > gt) {
+          return;
+        }
       }
+      state.scrollPending = newScroll;
       updateScroll(newScroll);
       (_d = state.onScroll) == null ? void 0 : _d.call(state, event);
     },
@@ -2381,53 +2160,19 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
   const updateScroll = useCallback((newScroll) => {
     const state = refState.current;
     const scrollingTo = state.scrollingTo;
-    if (scrollingTo !== void 0 && Math.abs(newScroll - scrollingTo.offset) < 10) {
-      finishScrollTo();
-    }
-    if (state.disableScrollJumpsFrom !== void 0) {
-      const scrollMinusAdjust = newScroll - state.scrollAdjustHandler.getAppliedAdjust();
-      if (Math.abs(scrollMinusAdjust - state.disableScrollJumpsFrom) > 200) {
-        return;
-      }
-      state.disableScrollJumpsFrom = void 0;
-    }
     state.hasScrolled = true;
     state.lastBatchingAction = Date.now();
     const currentTime = performance.now();
-    if (scrollingTo === void 0 && !(state.scrollHistory.length === 0 && newScroll === initialContentOffset)) {
+    if (scrollingTo === void 0 && !(state.scrollHistory.length === 0 && newScroll === state.scroll)) {
       state.scrollHistory.push({ scroll: newScroll, time: currentTime });
     }
     if (state.scrollHistory.length > 5) {
       state.scrollHistory.shift();
     }
-    if (state.scrollTimer !== void 0) {
-      clearTimeout(state.scrollTimer);
-    }
-    state.scrollTimer = setTimeout(() => {
-      state.scrollVelocity = 0;
-    }, 500);
-    let velocity = 0;
-    if (state.scrollHistory.length >= 2) {
-      const newest = state.scrollHistory[state.scrollHistory.length - 1];
-      let oldest;
-      for (let i = 0; i < state.scrollHistory.length - 1; i++) {
-        const entry = state.scrollHistory[i];
-        if (newest.time - entry.time <= 100) {
-          oldest = entry;
-          break;
-        }
-      }
-      if (oldest) {
-        const scrollDiff = newest.scroll - oldest.scroll;
-        const timeDiff = newest.time - oldest.time;
-        velocity = timeDiff > 0 ? scrollDiff / timeDiff : 0;
-      }
-    }
     state.scrollPrev = state.scroll;
     state.scrollPrevTime = state.scrollTime;
     state.scroll = newScroll;
     state.scrollTime = currentTime;
-    state.scrollVelocity = velocity;
     calculateItemsInView();
     checkAtBottom();
     checkAtTop();
@@ -2493,8 +2238,17 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
           if (index !== -1) {
             const paddingBottom = stylePaddingBottom || 0;
             const footerSize = peek$(ctx, "footerSize") || 0;
-            scrollToIndex({ index, viewPosition: 1, viewOffset: -paddingBottom - footerSize, ...options });
+            scrollToIndex({
+              index,
+              viewPosition: 1,
+              viewOffset: -paddingBottom - footerSize,
+              ...options
+            });
           }
+        },
+        setVisibleContentAnchorOffset: (value) => {
+          const val = typeof value === "function" ? value(peek$(ctx, "scrollAdjustUserOffset") || 0) : value;
+          set$(ctx, "scrollAdjustUserOffset", val);
         }
       };
     },
@@ -2502,14 +2256,8 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
   );
   if (Platform.OS === "web") {
     useEffect(() => {
-      var _a;
       if (initialContentOffset) {
-        (_a = refState.current) == null ? void 0 : _a.scrollAdjustHandler.setDisableAdjust(true);
         scrollTo({ offset: initialContentOffset, animated: false });
-        setTimeout(() => {
-          var _a2;
-          (_a2 = refState.current) == null ? void 0 : _a2.scrollAdjustHandler.setDisableAdjust(false);
-        }, 0);
       }
     }, []);
   }
@@ -2517,6 +2265,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     ListComponent,
     {
       ...rest,
+      canRender,
       horizontal,
       refScrollView: combinedRef,
       initialContentOffset,
@@ -2524,23 +2273,9 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       updateItemSize,
       handleScroll,
       onMomentumScrollEnd: (event) => {
-        var _a;
-        const scrollingTo = (_a = refState.current) == null ? void 0 : _a.scrollingTo;
-        if (scrollingTo !== void 0) {
-          requestAnimationFrame(() => {
-            scrollTo({ ...scrollingTo, animated: false });
-            refState.current.scrollingTo = void 0;
-            requestAnimationFrame(() => {
-              refState.current.scrollAdjustHandler.setDisableAdjust(false);
-            });
-          });
-        }
-        const wasPaused = refState.current.scrollAdjustHandler.unPauseAdjust();
-        if (wasPaused) {
-          refState.current.scrollVelocity = 0;
-          refState.current.scrollHistory = [];
-          calculateItemsInView();
-        }
+        requestAnimationFrame(() => {
+          finishScrollTo();
+        });
         if (onMomentumScrollEnd) {
           onMomentumScrollEnd(event);
         }
@@ -2564,7 +2299,9 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
         }
       ),
       style,
-      contentContainerStyle
+      contentContainerStyle,
+      scrollAdjustHandler: (_a = refState.current) == null ? void 0 : _a.scrollAdjustHandler,
+      onLayoutHeader
     }
   ), __DEV__ && ENABLE_DEBUG_VIEW && /* @__PURE__ */ React2.createElement(DebugView, { state: refState.current }));
 });
@@ -2572,7 +2309,7 @@ var typedForwardRef2 = forwardRef;
 var renderItem = ({ item }) => item;
 var LazyLegendList = typedForwardRef2(function LazyLegendList2(props, forwardedRef) {
   const { LegendList: LegendListProp, children, ...rest } = props;
-  const LegendListComponent = LegendListProp != null ? LegendListProp : LegendList$1;
+  const LegendListComponent = LegendListProp != null ? LegendListProp : LegendList;
   const data = (isArray(children) ? children : React2.Children.toArray(children)).flat(1);
   return (
     // @ts-expect-error TODO: Fix this type