@legendapp/list 2.1.0-beta.1 → 2.1.0-beta.11

package/index.mjs

@@ -33,7 +33,10 @@ function StateProvider({ children }) {
       ["stylePaddingTop", 0],
       ["headerSize", 0],
       ["numContainers", 0],
-      ["totalSize", 0]
+      ["activeStickyIndex", void 0],
+      ["totalSize", 0],
+      ["scrollAdjustPending", 0],
+      ["scrollingTo", void 0]
     ]),
     viewRefs: /* @__PURE__ */ new Map()
   }));
@@ -102,11 +105,12 @@ function set$(ctx, signalName, value) {
   }
 }
 function getContentSize(ctx) {
+  var _a3, _b;
   const { values } = ctx;
   const stylePaddingTop = values.get("stylePaddingTop") || 0;
   const headerSize = values.get("headerSize") || 0;
   const footerSize = values.get("footerSize") || 0;
-  const totalSize = values.get("totalSize");
+  const totalSize = (_b = (_a3 = ctx.internalState) == null ? void 0 : _a3.pendingTotalSize) != null ? _b : values.get("totalSize");
   return headerSize + footerSize + totalSize + stylePaddingTop;
 }
 function useArr$(signalNames) {
@@ -187,6 +191,47 @@ var ENABLE_DEBUG_VIEW = IS_DEV && false;
 var typedForwardRef = forwardRef;
 var typedMemo = memo;
 
+// src/utils/helpers.ts
+function isFunction(obj) {
+  return typeof obj === "function";
+}
+function isArray(obj) {
+  return Array.isArray(obj);
+}
+var warned = /* @__PURE__ */ new Set();
+function warnDevOnce(id, text) {
+  if (IS_DEV && !warned.has(id)) {
+    warned.add(id);
+    console.warn(`[legend-list] ${text}`);
+  }
+}
+function roundSize(size) {
+  return Math.floor(size * 8) / 8;
+}
+function isNullOrUndefined(value) {
+  return value === null || value === void 0;
+}
+function comparatorDefault(a, b) {
+  return a - b;
+}
+function getPadding(s, type) {
+  var _a3, _b, _c;
+  return (_c = (_b = (_a3 = s[`padding${type}`]) != null ? _a3 : s.paddingVertical) != null ? _b : s.padding) != null ? _c : 0;
+}
+function extractPadding(style, contentContainerStyle, type) {
+  return getPadding(style, type) + getPadding(contentContainerStyle, type);
+}
+function findContainerId(ctx, key) {
+  const numContainers = peek$(ctx, "numContainers");
+  for (let i = 0; i < numContainers; i++) {
+    const itemKey = peek$(ctx, `containerItemKey${i}`);
+    if (itemKey === key) {
+      return i;
+    }
+  }
+  return -1;
+}
+
 // src/components/PositionView.tsx
 var PositionViewState = typedMemo(function PositionView({
   id,
@@ -196,8 +241,11 @@ var PositionViewState = typedMemo(function PositionView({
   ...rest
 }) {
   const [position = POSITION_OUT_OF_VIEW] = useArr$([`containerPosition${id}`]);
-  const base = Array.isArray(style) ? Object.assign({}, ...style) : style;
-  const combinedStyle = horizontal ? { ...base, left: position } : { ...base, top: position };
+  const base = {
+    contain: "paint layout style"
+  };
+  const composed = isArray(style) ? Object.assign({}, ...style) : style;
+  const combinedStyle = horizontal ? { ...base, ...composed, left: position } : { ...base, ...composed, top: position };
   return /* @__PURE__ */ React3.createElement("div", { ref: refView, style: combinedStyle, ...rest });
 });
 var PositionViewSticky = typedMemo(function PositionViewSticky2({
@@ -206,19 +254,42 @@ var PositionViewSticky = typedMemo(function PositionViewSticky2({
   style,
   refView,
   index,
+  stickyOffset,
+  animatedScrollY: _animatedScrollY,
+  children,
   ...rest
 }) {
-  const [position = POSITION_OUT_OF_VIEW, _headerSize] = useArr$([`containerPosition${id}`, "headerSize"]);
+  const [position = POSITION_OUT_OF_VIEW, headerSize = 0, activeStickyIndex] = useArr$([
+    `containerPosition${id}`,
+    "headerSize",
+    "activeStickyIndex"
+  ]);
+  const base = {
+    contain: "paint layout style"
+  };
+  const composed = React3.useMemo(
+    () => {
+      var _a3;
+      return (_a3 = isArray(style) ? Object.assign({}, ...style) : style) != null ? _a3 : {};
+    },
+    [style]
+  );
   const viewStyle = React3.useMemo(() => {
-    const base = Array.isArray(style) ? Object.assign({}, ...style) : style;
-    const axisStyle = horizontal ? { transform: `translateX(${position}px)` } : { top: position };
-    return {
-      ...base,
-      zIndex: index + 1e3,
-      ...axisStyle
-    };
-  }, [style, position, horizontal, index]);
-  return /* @__PURE__ */ React3.createElement("div", { ref: refView, style: viewStyle, ...rest });
+    var _a3;
+    const styleBase = { ...base, ...composed };
+    delete styleBase.transform;
+    const offset = (_a3 = stickyOffset != null ? stickyOffset : headerSize) != null ? _a3 : 0;
+    const isActive = activeStickyIndex === index;
+    styleBase.position = isActive ? "sticky" : "absolute";
+    styleBase.zIndex = index + 1e3;
+    if (horizontal) {
+      styleBase.left = isActive ? offset : position;
+    } else {
+      styleBase.top = isActive ? offset : position;
+    }
+    return styleBase;
+  }, [composed, horizontal, position, index, stickyOffset, headerSize, activeStickyIndex]);
+  return /* @__PURE__ */ React3.createElement("div", { ref: refView, style: viewStyle, ...rest }, children);
 });
 var PositionView2 = PositionViewState;
 
@@ -233,37 +304,6 @@ function useInit(cb) {
   return refValue.current;
 }
 
-// src/utils/helpers.ts
-function isFunction(obj) {
-  return typeof obj === "function";
-}
-function isArray(obj) {
-  return Array.isArray(obj);
-}
-var warned = /* @__PURE__ */ new Set();
-function warnDevOnce(id, text) {
-  if (IS_DEV && !warned.has(id)) {
-    warned.add(id);
-    console.warn(`[legend-list] ${text}`);
-  }
-}
-function roundSize(size) {
-  return Math.floor(size * 8) / 8;
-}
-function isNullOrUndefined(value) {
-  return value === null || value === void 0;
-}
-function comparatorDefault(a, b) {
-  return a - b;
-}
-function getPadding(s, type) {
-  var _a3, _b, _c;
-  return (_c = (_b = (_a3 = s[`padding${type}`]) != null ? _a3 : s.paddingVertical) != null ? _b : s.padding) != null ? _c : 0;
-}
-function extractPadding(style, contentContainerStyle, type) {
-  return getPadding(style, type) + getPadding(contentContainerStyle, type);
-}
-
 // src/state/ContextContainer.ts
 var ContextContainer = createContext(null);
 function useViewability(callback, configId) {
@@ -392,6 +432,10 @@ function getGlobalResizeObserver() {
 }
 var callbackMap = /* @__PURE__ */ new WeakMap();
 function createResizeObserver(element, callback) {
+  if (typeof ResizeObserver === "undefined") {
+    return () => {
+    };
+  }
   if (!element) {
     return () => {
     };
@@ -427,7 +471,7 @@ function useOnLayoutSync({
     const current = ref.current;
     const scrollableNode = (_b = (_a3 = current == null ? void 0 : current.getScrollableNode) == null ? void 0 : _a3.call(current)) != null ? _b : null;
     const element = scrollableNode || current;
-    if (!element || !(element instanceof HTMLElement)) {
+    if (!element) {
       return;
     }
     const emit = (layout, fromLayoutEffect) => {
@@ -449,6 +493,9 @@ function useOnLayoutSync({
   return {};
 }
 function toLayout(rect) {
+  if (!rect) {
+    return { height: 0, width: 0, x: 0, y: 0 };
+  }
   return {
     height: rect.height,
     width: rect.width,
@@ -550,7 +597,7 @@ var Container = typedMemo(function Container2({
     }
     didLayoutRef.current = true;
     let layout = rectangle;
-    Math.floor(rectangle[currentHorizontal ? "width" : "height"] * 8) / 8;
+    roundSize(rectangle[currentHorizontal ? "width" : "height"]);
     const doUpdate = () => {
       itemLayoutRef.current.lastSize = { height: layout.height, width: layout.width };
       updateItemSizeFn(currentItemKey, layout);
@@ -708,7 +755,7 @@ var ContainersInner = typedMemo(function ContainersInner2({ horizontal, numColum
   const columnWrapperStyle = ctx.columnWrapperStyle;
   const [totalSize, otherAxisSize] = useArr$(["totalSize", "otherAxisSize"]);
   useDOMOrder(ref);
-  const style = horizontal ? { minHeight: otherAxisSize, width: totalSize } : { height: totalSize, minWidth: otherAxisSize };
+  const style = horizontal ? { minHeight: otherAxisSize, position: "relative", width: totalSize } : { height: totalSize, minWidth: otherAxisSize, position: "relative" };
   if (columnWrapperStyle && numColumns > 1) {
     const { columnGap, rowGap, gap } = columnWrapperStyle;
     const gapX = columnGap || gap || 0;
@@ -780,7 +827,7 @@ function DevNumbers() {
 
 // src/platform/StyleSheet.tsx
 function flattenStyles(styles) {
-  if (Array.isArray(styles)) {
+  if (isArray(styles)) {
     return Object.assign({}, ...styles.filter(Boolean));
   }
   return styles;
@@ -970,10 +1017,11 @@ function PaddingDevMode() {
 function useValueListener$(key, callback) {
   const ctx = useStateContext();
   useLayoutEffect(() => {
-    listen$(ctx, key, (value) => {
+    const unsubscribe = listen$(ctx, key, (value) => {
       callback(value);
     });
-  }, []);
+    return unsubscribe;
+  }, [callback, ctx, key]);
 }
 
 // src/components/ScrollAdjust.tsx
@@ -1138,13 +1186,84 @@ function calculateOffsetForIndex(ctx, state, index) {
   return position;
 }
 
+// src/utils/setPaddingTop.ts
+function setPaddingTop(ctx, state, { stylePaddingTop, alignItemsPaddingTop }) {
+  if (stylePaddingTop !== void 0) {
+    const prevStylePaddingTop = peek$(ctx, "stylePaddingTop") || 0;
+    if (stylePaddingTop < prevStylePaddingTop) {
+      let prevTotalSize = peek$(ctx, "totalSize") || 0;
+      set$(ctx, "totalSize", prevTotalSize + prevStylePaddingTop);
+      state.timeoutSetPaddingTop = setTimeout(() => {
+        prevTotalSize = peek$(ctx, "totalSize") || 0;
+        set$(ctx, "totalSize", prevTotalSize - prevStylePaddingTop);
+      }, 16);
+    }
+    set$(ctx, "stylePaddingTop", stylePaddingTop);
+  }
+  if (alignItemsPaddingTop !== void 0) {
+    set$(ctx, "alignItemsPaddingTop", alignItemsPaddingTop);
+  }
+}
+
+// src/utils/updateAlignItemsPaddingTop.ts
+function updateAlignItemsPaddingTop(ctx, state) {
+  const {
+    scrollLength,
+    props: { alignItemsAtEnd, data }
+  } = state;
+  if (alignItemsAtEnd) {
+    let alignItemsPaddingTop = 0;
+    if ((data == null ? void 0 : data.length) > 0) {
+      const contentSize = getContentSize(ctx);
+      alignItemsPaddingTop = Math.max(0, Math.floor(scrollLength - contentSize));
+    }
+    setPaddingTop(ctx, state, { alignItemsPaddingTop });
+  }
+}
+
+// src/core/addTotalSize.ts
+function addTotalSize(ctx, state, key, add) {
+  const { alignItemsAtEnd } = state.props;
+  const prevTotalSize = state.totalSize;
+  let totalSize = state.totalSize;
+  if (key === null) {
+    totalSize = add;
+    if (state.timeoutSetPaddingTop) {
+      clearTimeout(state.timeoutSetPaddingTop);
+      state.timeoutSetPaddingTop = void 0;
+    }
+  } else {
+    totalSize += add;
+  }
+  if (prevTotalSize !== totalSize) {
+    {
+      state.pendingTotalSize = void 0;
+      state.totalSize = totalSize;
+      set$(ctx, "totalSize", totalSize);
+      if (alignItemsAtEnd) {
+        updateAlignItemsPaddingTop(ctx, state);
+      }
+    }
+  }
+}
+
+// src/core/setSize.ts
+function setSize(ctx, state, itemKey, size) {
+  const { sizes } = state;
+  const previousSize = sizes.get(itemKey);
+  const diff = previousSize !== void 0 ? size - previousSize : size;
+  if (diff !== 0) {
+    addTotalSize(ctx, state, itemKey, diff);
+  }
+  sizes.set(itemKey, size);
+}
+
 // src/utils/getItemSize.ts
-function getItemSize(state, key, index, data, useAverageSize) {
+function getItemSize(ctx, state, key, index, data, useAverageSize, preferCachedSize) {
   var _a3, _b;
   const {
     sizesKnown,
     sizes,
-    scrollingTo,
     averageSizes,
     props: { estimatedItemSize, getEstimatedItemSize, getFixedItemSize, getItemType }
   } = state;
@@ -1154,6 +1273,13 @@ function getItemSize(state, key, index, data, useAverageSize) {
   }
   let size;
   const itemType = getItemType ? (_a3 = getItemType(data, index)) != null ? _a3 : "" : "";
+  const scrollingTo = peek$(ctx, "scrollingTo");
+  if (preferCachedSize) {
+    const cachedSize = sizes.get(key);
+    if (cachedSize !== void 0) {
+      return cachedSize;
+    }
+  }
   if (getFixedItemSize) {
     size = getFixedItemSize(index, data, itemType);
     if (size !== void 0) {
@@ -1175,108 +1301,326 @@ function getItemSize(state, key, index, data, useAverageSize) {
   if (size === void 0) {
     size = getEstimatedItemSize ? getEstimatedItemSize(index, data, itemType) : estimatedItemSize;
   }
-  sizes.set(key, size);
+  setSize(ctx, state, key, size);
   return size;
 }
 
 // src/core/calculateOffsetWithOffsetPosition.ts
-function calculateOffsetWithOffsetPosition(state, offsetParam, params) {
+function calculateOffsetWithOffsetPosition(ctx, state, offsetParam, params) {
   const { index, viewOffset, viewPosition } = params;
   let offset = offsetParam;
   if (viewOffset) {
     offset -= viewOffset;
   }
   if (viewPosition !== void 0 && index !== void 0) {
-    offset -= viewPosition * (state.scrollLength - getItemSize(state, getId(state, index), index, state.props.data[index]));
+    offset -= viewPosition * (state.scrollLength - getItemSize(ctx, state, getId(state, index), index, state.props.data[index]));
   }
   return offset;
 }
 
-// src/core/finishScrollTo.ts
-var finishScrollTo = (state) => {
-  if (state) {
-    state.scrollingTo = void 0;
-    state.scrollHistory.length = 0;
+// src/utils/checkThreshold.ts
+var HYSTERESIS_MULTIPLIER = 1.3;
+var checkThreshold = (distance, atThreshold, threshold, wasReached, snapshot, context, onReached, setSnapshot) => {
+  const absDistance = Math.abs(distance);
+  const within = atThreshold || threshold > 0 && absDistance <= threshold;
+  const updateSnapshot = () => {
+    setSnapshot == null ? void 0 : setSnapshot({
+      atThreshold,
+      contentSize: context.contentSize,
+      dataLength: context.dataLength,
+      scrollPosition: context.scrollPosition
+    });
+  };
+  if (!wasReached) {
+    if (!within) {
+      return false;
+    }
+    onReached == null ? void 0 : onReached(distance);
+    updateSnapshot();
+    return true;
+  }
+  const reset = !atThreshold && threshold > 0 && absDistance >= threshold * HYSTERESIS_MULTIPLIER || !atThreshold && threshold <= 0 && absDistance > 0;
+  if (reset) {
+    setSnapshot == null ? void 0 : setSnapshot(void 0);
+    return false;
+  }
+  if (within) {
+    const changed = !snapshot || snapshot.atThreshold !== atThreshold || snapshot.contentSize !== context.contentSize || snapshot.dataLength !== context.dataLength;
+    if (changed) {
+      onReached == null ? void 0 : onReached(distance);
+      updateSnapshot();
+    }
   }
+  return true;
 };
 
-// src/core/scrollTo.ts
-function scrollTo(state, params = {}) {
+// src/utils/checkAtBottom.ts
+function checkAtBottom(ctx, state) {
   var _a3;
-  const { animated, noScrollingTo, isInitialScroll } = params;
+  if (!state) {
+    return;
+  }
   const {
-    refScroller,
-    props: { horizontal }
+    queuedInitialLayout,
+    scrollLength,
+    scroll,
+    maintainingScrollAtEnd,
+    props: { maintainScrollAtEndThreshold, onEndReachedThreshold }
   } = state;
-  const offset = calculateOffsetWithOffsetPosition(state, params.offset, params);
-  state.scrollHistory.length = 0;
-  if (!noScrollingTo) {
-    state.scrollingTo = params;
-  }
-  state.scrollPending = offset;
-  if (!params.isInitialScroll || Platform.OS === "android") {
-    (_a3 = refScroller.current) == null ? void 0 : _a3.scrollTo({
-      animated: !!animated,
-      x: horizontal ? offset : 0,
-      y: horizontal ? 0 : offset
-    });
-  }
-  if (!animated) {
-    state.scroll = offset;
-    setTimeout(() => finishScrollTo(state), 100);
-    if (isInitialScroll) {
-      setTimeout(() => {
-        state.initialScroll = void 0;
-      }, 500);
-    }
+  const contentSize = getContentSize(ctx);
+  if (contentSize > 0 && queuedInitialLayout && !maintainingScrollAtEnd) {
+    const distanceFromEnd = contentSize - scroll - scrollLength;
+    const isContentLess = contentSize < scrollLength;
+    state.isAtEnd = isContentLess || distanceFromEnd < scrollLength * maintainScrollAtEndThreshold;
+    state.isEndReached = checkThreshold(
+      distanceFromEnd,
+      isContentLess,
+      onEndReachedThreshold * scrollLength,
+      state.isEndReached,
+      state.endReachedSnapshot,
+      {
+        contentSize,
+        dataLength: (_a3 = state.props.data) == null ? void 0 : _a3.length,
+        scrollPosition: scroll
+      },
+      (distance) => {
+        var _a4, _b;
+        return (_b = (_a4 = state.props).onEndReached) == null ? void 0 : _b.call(_a4, { distanceFromEnd: distance });
+      },
+      (snapshot) => {
+        state.endReachedSnapshot = snapshot;
+      }
+    );
   }
 }
 
-// src/utils/requestAdjust.ts
-function requestAdjust(ctx, state, positionDiff, dataChanged) {
-  if (Math.abs(positionDiff) > 0.1) {
-    const doit = () => {
-      {
-        state.scrollAdjustHandler.requestAdjust(positionDiff);
-      }
-    };
-    state.scroll += positionDiff;
-    state.scrollForNextCalculateItemsInView = void 0;
-    const didLayout = peek$(ctx, "containersDidLayout");
-    if (didLayout) {
-      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
-      );
+// src/utils/checkAtTop.ts
+function checkAtTop(state) {
+  var _a3;
+  if (!state) {
+    return;
+  }
+  const {
+    scrollLength,
+    scroll,
+    props: { onStartReachedThreshold }
+  } = state;
+  const distanceFromTop = scroll;
+  state.isAtStart = distanceFromTop <= 0;
+  state.isStartReached = checkThreshold(
+    distanceFromTop,
+    false,
+    onStartReachedThreshold * scrollLength,
+    state.isStartReached,
+    state.startReachedSnapshot,
+    {
+      contentSize: state.totalSize,
+      dataLength: (_a3 = state.props.data) == null ? void 0 : _a3.length,
+      scrollPosition: scroll
+    },
+    (distance) => {
+      var _a4, _b;
+      return (_b = (_a4 = state.props).onStartReached) == null ? void 0 : _b.call(_a4, { distanceFromStart: distance });
+    },
+    (snapshot) => {
+      state.startReachedSnapshot = snapshot;
+    }
+  );
+}
+
+// src/core/onScroll.ts
+function onScroll(ctx, state, event) {
+  var _a3, _b, _c;
+  const {
+    scrollProcessingEnabled,
+    props: { onScroll: onScrollProp }
+  } = state;
+  if (scrollProcessingEnabled === false) {
+    return;
+  }
+  if (((_b = (_a3 = event.nativeEvent) == null ? void 0 : _a3.contentSize) == null ? void 0 : _b.height) === 0 && ((_c = event.nativeEvent.contentSize) == null ? void 0 : _c.width) === 0) {
+    return;
+  }
+  const newScroll = event.nativeEvent.contentOffset[state.props.horizontal ? "x" : "y"];
+  state.scrollPending = newScroll;
+  updateScroll(ctx, state, newScroll);
+  onScrollProp == null ? void 0 : onScrollProp(event);
+}
+function updateScroll(ctx, state, newScroll, forceUpdate) {
+  var _a3;
+  const scrollingTo = peek$(ctx, "scrollingTo");
+  state.hasScrolled = true;
+  state.lastBatchingAction = Date.now();
+  const currentTime = Date.now();
+  const adjust = state.scrollAdjustHandler.getAdjust();
+  const lastHistoryAdjust = state.lastScrollAdjustForHistory;
+  const adjustChanged = lastHistoryAdjust !== void 0 && Math.abs(adjust - lastHistoryAdjust) > 0.1;
+  if (adjustChanged) {
+    state.scrollHistory.length = 0;
+  }
+  state.lastScrollAdjustForHistory = adjust;
+  if (scrollingTo === void 0 && !(state.scrollHistory.length === 0 && newScroll === state.scroll)) {
+    if (!adjustChanged) {
+      state.scrollHistory.push({ scroll: newScroll, time: currentTime });
+    }
+  }
+  if (state.scrollHistory.length > 5) {
+    state.scrollHistory.shift();
+  }
+  state.scrollPrev = state.scroll;
+  state.scrollPrevTime = state.scrollTime;
+  state.scroll = newScroll;
+  state.scrollTime = currentTime;
+  const ignoreScrollFromMVCP = state.ignoreScrollFromMVCP;
+  if (ignoreScrollFromMVCP && !scrollingTo) {
+    const { lt, gt } = ignoreScrollFromMVCP;
+    if (lt && newScroll < lt || gt && newScroll > gt) {
+      state.ignoreScrollFromMVCPIgnored = true;
+      return;
+    }
+  }
+  if (state.dataChangeNeedsScrollUpdate || Math.abs(state.scroll - state.scrollPrev) > 2) {
+    state.ignoreScrollFromMVCPIgnored = false;
+    (_a3 = state.triggerCalculateItemsInView) == null ? void 0 : _a3.call(state, { doMVCP: scrollingTo !== void 0 });
+    checkAtBottom(ctx, state);
+    checkAtTop(state);
+    state.dataChangeNeedsScrollUpdate = false;
+  }
+}
+
+// src/core/finishScrollTo.ts
+function finishScrollTo(ctx, state) {
+  var _a3, _b;
+  if (state) {
+    state.scrollHistory.length = 0;
+    state.initialScroll = void 0;
+    state.initialAnchor = void 0;
+    set$(ctx, "scrollingTo", void 0);
+    if (state.pendingTotalSize !== void 0) {
+      addTotalSize(ctx, state, null, state.pendingTotalSize);
+    }
+    if ((_a3 = state.props) == null ? void 0 : _a3.data) {
+      (_b = state.triggerCalculateItemsInView) == null ? void 0 : _b.call(state, { forceFullItemPositions: true });
+    }
+  }
+}
+
+// src/core/scrollTo.ts
+function scrollTo(ctx, state, params) {
+  var _a3;
+  const { noScrollingTo, ...scrollTarget } = params;
+  const { animated, isInitialScroll, offset: scrollTargetOffset, precomputedWithViewOffset } = scrollTarget;
+  const {
+    refScroller,
+    props: { horizontal }
+  } = state;
+  let offset = precomputedWithViewOffset ? scrollTargetOffset : calculateOffsetWithOffsetPosition(ctx, state, scrollTargetOffset, scrollTarget);
+  if (Number.isFinite(state.scrollLength) && Number.isFinite(state.totalSize)) {
+    const maxOffset = Math.max(0, getContentSize(ctx) - state.scrollLength);
+    offset = Math.min(offset, maxOffset);
+  }
+  state.scrollHistory.length = 0;
+  if (!noScrollingTo) {
+    set$(ctx, "scrollingTo", scrollTarget);
+  }
+  state.scrollPending = offset;
+  if (!isInitialScroll || Platform.OS === "android") {
+    (_a3 = refScroller.current) == null ? void 0 : _a3.scrollTo({
+      animated: !!animated,
+      x: horizontal ? offset : 0,
+      y: horizontal ? 0 : offset
+    });
+  }
+  if (!animated) {
+    state.scroll = offset;
+    setTimeout(() => finishScrollTo(ctx, state), 100);
+    if (isInitialScroll) {
+      setTimeout(() => {
+        state.initialScroll = void 0;
+      }, 500);
+    }
+  }
+}
+
+// src/utils/requestAdjust.ts
+function requestAdjust(ctx, state, positionDiff, dataChanged) {
+  if (Math.abs(positionDiff) > 0.1) {
+    const doit = () => {
+      {
+        state.scrollAdjustHandler.requestAdjust(positionDiff);
+      }
+    };
+    state.scroll += positionDiff;
+    state.scrollForNextCalculateItemsInView = void 0;
+    const didLayout = peek$(ctx, "containersDidLayout");
+    if (didLayout) {
+      doit();
     } else {
       requestAnimationFrame(doit);
     }
   }
 }
 
+// src/core/ensureInitialAnchor.ts
+var INITIAL_ANCHOR_TOLERANCE = 0.5;
+var INITIAL_ANCHOR_MAX_ATTEMPTS = 4;
+var INITIAL_ANCHOR_SETTLED_TICKS = 2;
+function ensureInitialAnchor(ctx, state) {
+  var _a3, _b, _c, _d, _e;
+  const anchor = state.initialAnchor;
+  const item = state.props.data[anchor.index];
+  const containersDidLayout = peek$(ctx, "containersDidLayout");
+  if (!containersDidLayout) {
+    return;
+  }
+  const id = getId(state, anchor.index);
+  if (state.positions.get(id) === void 0) {
+    return;
+  }
+  const size = getItemSize(ctx, state, id, anchor.index, item, true, true);
+  if (size === void 0) {
+    return;
+  }
+  const availableSpace = Math.max(0, state.scrollLength - size);
+  const desiredOffset = calculateOffsetForIndex(ctx, state, anchor.index) - ((_a3 = anchor.viewOffset) != null ? _a3 : 0) - ((_b = anchor.viewPosition) != null ? _b : 0) * availableSpace;
+  const contentSize = getContentSize(ctx);
+  const maxOffset = Math.max(0, contentSize - state.scrollLength);
+  const clampedDesiredOffset = Math.max(0, Math.min(desiredOffset, maxOffset));
+  const delta = clampedDesiredOffset - state.scroll;
+  if (Math.abs(delta) <= INITIAL_ANCHOR_TOLERANCE) {
+    const settledTicks = ((_c = anchor.settledTicks) != null ? _c : 0) + 1;
+    if (settledTicks >= INITIAL_ANCHOR_SETTLED_TICKS) {
+      state.initialAnchor = void 0;
+    } else {
+      anchor.settledTicks = settledTicks;
+    }
+    return;
+  }
+  if (((_d = anchor.attempts) != null ? _d : 0) >= INITIAL_ANCHOR_MAX_ATTEMPTS) {
+    state.initialAnchor = void 0;
+    return;
+  }
+  const lastDelta = anchor.lastDelta;
+  if (lastDelta !== void 0 && Math.abs(delta) >= Math.abs(lastDelta)) {
+    state.initialAnchor = void 0;
+    return;
+  }
+  Object.assign(anchor, {
+    attempts: ((_e = anchor.attempts) != null ? _e : 0) + 1,
+    lastDelta: delta,
+    settledTicks: 0
+  });
+  requestAdjust(ctx, state, delta);
+}
+
 // src/core/mvcp.ts
 function prepareMVCP(ctx, state, dataChanged) {
   const {
     idsInView,
     positions,
-    scrollingTo,
     props: { maintainVisibleContentPosition }
   } = state;
+  const scrollingTo = peek$(ctx, "scrollingTo");
   let prevPosition;
   let targetId;
   const idsInViewWithPositions = [];
@@ -1317,7 +1661,7 @@ function prepareMVCP(ctx, state, dataChanged) {
     if (targetId !== void 0 && prevPosition !== void 0) {
       const newPosition = positions.get(targetId);
       if (newPosition !== void 0) {
-        const totalSize = peek$(ctx, "totalSize");
+        const totalSize = getContentSize(ctx);
         let diff = newPosition - prevPosition;
         if (diff !== 0 && state.scroll + state.scrollLength > totalSize) {
           if (diff > 0) {
@@ -1352,7 +1696,7 @@ function prepareColumnStartState(ctx, state, startIndex, useAverageSize) {
     const prevId = state.idCache[prevIndex];
     const prevPosition = (_a3 = state.positions.get(prevId)) != null ? _a3 : 0;
     const prevRowStart = findRowStartIndex(state, numColumns, prevIndex);
-    const prevRowHeight = calculateRowMaxSize(state, prevRowStart, prevIndex, useAverageSize);
+    const prevRowHeight = calculateRowMaxSize(ctx, state, prevRowStart, prevIndex, useAverageSize);
     currentRowTop = prevPosition + prevRowHeight;
   }
   return {
@@ -1375,7 +1719,7 @@ function findRowStartIndex(state, numColumns, index) {
   }
   return rowStart;
 }
-function calculateRowMaxSize(state, startIndex, endIndex, useAverageSize) {
+function calculateRowMaxSize(ctx, state, startIndex, endIndex, useAverageSize) {
   if (endIndex < startIndex) {
     return 0;
   }
@@ -1389,7 +1733,7 @@ function calculateRowMaxSize(state, startIndex, endIndex, useAverageSize) {
       continue;
     }
     const id = state.idCache[i];
-    const size = getItemSize(state, id, i, data[i], useAverageSize);
+    const size = getItemSize(ctx, state, id, i, data[i], useAverageSize);
     if (size > maxSize) {
       maxSize = size;
     }
@@ -1397,41 +1741,6 @@ function calculateRowMaxSize(state, startIndex, endIndex, useAverageSize) {
   return maxSize;
 }
 
-// src/utils/setPaddingTop.ts
-function setPaddingTop(ctx, state, { stylePaddingTop, alignItemsPaddingTop }) {
-  if (stylePaddingTop !== void 0) {
-    const prevStylePaddingTop = peek$(ctx, "stylePaddingTop") || 0;
-    if (stylePaddingTop < prevStylePaddingTop) {
-      let prevTotalSize = peek$(ctx, "totalSize") || 0;
-      set$(ctx, "totalSize", prevTotalSize + prevStylePaddingTop);
-      state.timeoutSetPaddingTop = setTimeout(() => {
-        prevTotalSize = peek$(ctx, "totalSize") || 0;
-        set$(ctx, "totalSize", prevTotalSize - prevStylePaddingTop);
-      }, 16);
-    }
-    set$(ctx, "stylePaddingTop", stylePaddingTop);
-  }
-  if (alignItemsPaddingTop !== void 0) {
-    set$(ctx, "alignItemsPaddingTop", alignItemsPaddingTop);
-  }
-}
-
-// src/utils/updateAlignItemsPaddingTop.ts
-function updateAlignItemsPaddingTop(ctx, state) {
-  const {
-    scrollLength,
-    props: { alignItemsAtEnd, data }
-  } = state;
-  if (alignItemsAtEnd) {
-    let alignItemsPaddingTop = 0;
-    if ((data == null ? void 0 : data.length) > 0) {
-      const contentSize = getContentSize(ctx);
-      alignItemsPaddingTop = Math.max(0, Math.floor(scrollLength - contentSize));
-    }
-    setPaddingTop(ctx, state, { alignItemsPaddingTop });
-  }
-}
-
 // src/core/updateTotalSize.ts
 function updateTotalSize(ctx, state) {
   const {
@@ -1445,7 +1754,7 @@ function updateTotalSize(ctx, state) {
     if (lastId !== void 0) {
       const lastPosition = positions.get(lastId);
       if (lastPosition !== void 0) {
-        const lastSize = getItemSize(state, lastId, data.length - 1, data[data.length - 1]);
+        const lastSize = getItemSize(ctx, state, lastId, data.length - 1, data[data.length - 1]);
         if (lastSize !== void 0) {
           const totalSize = lastPosition + lastSize;
           addTotalSize(ctx, state, null, totalSize);
@@ -1454,25 +1763,44 @@ function updateTotalSize(ctx, state) {
     }
   }
 }
-function addTotalSize(ctx, state, key, add) {
-  const { alignItemsAtEnd } = state.props;
-  const prevTotalSize = state.totalSize;
-  if (key === null) {
-    state.totalSize = add;
-    if (state.timeoutSetPaddingTop) {
-      clearTimeout(state.timeoutSetPaddingTop);
-      state.timeoutSetPaddingTop = void 0;
+
+// src/utils/getScrollVelocity.ts
+var getScrollVelocity = (state) => {
+  const { scrollHistory } = state;
+  let velocity = 0;
+  if (scrollHistory.length >= 1) {
+    const newest = scrollHistory[scrollHistory.length - 1];
+    let oldest;
+    let start = 0;
+    const now = Date.now();
+    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) {
+          start = i;
+          break;
+        }
+      }
     }
-  } else {
-    state.totalSize += add;
-  }
-  if (prevTotalSize !== state.totalSize) {
-    set$(ctx, "totalSize", state.totalSize);
-    if (alignItemsAtEnd) {
-      updateAlignItemsPaddingTop(ctx, state);
+    for (let i = start; i < scrollHistory.length - 1; i++) {
+      const entry = scrollHistory[i];
+      if (now - entry.time <= 1e3) {
+        oldest = entry;
+        break;
+      }
+    }
+    if (oldest && oldest !== newest) {
+      const scrollDiff = newest.scroll - oldest.scroll;
+      const timeDiff = newest.time - oldest.time;
+      velocity = timeDiff > 0 ? scrollDiff / timeDiff : 0;
     }
   }
-}
+  return velocity;
+};
 
 // src/utils/updateSnapToOffsets.ts
 function updateSnapToOffsets(ctx, state) {
@@ -1490,23 +1818,30 @@ function updateSnapToOffsets(ctx, state) {
 }
 
 // src/core/updateItemPositions.ts
-function updateItemPositions(ctx, state, dataChanged, { startIndex, scrollBottomBuffered } = { scrollBottomBuffered: -1, startIndex: 0 }) {
-  var _a3, _b, _c, _d;
+function updateItemPositions(ctx, state, dataChanged, { startIndex, scrollBottomBuffered, forceFullUpdate = false } = {
+  forceFullUpdate: false,
+  scrollBottomBuffered: -1,
+  startIndex: 0
+}) {
+  var _a3, _b, _c, _d, _e;
   const {
     columns,
     indexByKey,
     positions,
     idCache,
     sizesKnown,
-    props: { getEstimatedItemSize, snapToIndices, enableAverages }
+    props: { getEstimatedItemSize, snapToIndices, enableAverages, maintainVisibleContentPosition }
   } = state;
   const data = state.props.data;
   const dataLength = data.length;
   const numColumns = peek$(ctx, "numColumns");
+  const scrollingTo = peek$(ctx, "scrollingTo");
   const hasColumns = numColumns > 1;
   const indexByKeyForChecking = IS_DEV ? /* @__PURE__ */ new Map() : void 0;
+  const shouldOptimize = !forceFullUpdate && !dataChanged && Math.abs(getScrollVelocity(state)) > 0;
   const maxVisibleArea = scrollBottomBuffered + 1e3;
   const useAverageSize = enableAverages && !getEstimatedItemSize;
+  const preferCachedSize = maintainVisibleContentPosition && (dataChanged || state.scrollAdjustHandler.getAdjust() !== 0 || ((_a3 = peek$(ctx, "scrollAdjustPending")) != null ? _a3 : 0) !== 0);
   let currentRowTop = 0;
   let column = 1;
   let maxSizeInRow = 0;
@@ -1523,8 +1858,8 @@ function updateItemPositions(ctx, state, dataChanged, { startIndex, scrollBottom
     } else if (startIndex < dataLength) {
       const prevIndex = startIndex - 1;
       const prevId = getId(state, prevIndex);
-      const prevPosition = (_a3 = positions.get(prevId)) != null ? _a3 : 0;
-      const prevSize = (_b = sizesKnown.get(prevId)) != null ? _b : getItemSize(state, prevId, prevIndex, data[prevIndex], useAverageSize);
+      const prevPosition = (_b = positions.get(prevId)) != null ? _b : 0;
+      const prevSize = (_c = sizesKnown.get(prevId)) != null ? _c : getItemSize(ctx, state, prevId, prevIndex, data[prevIndex], useAverageSize, preferCachedSize);
       currentRowTop = prevPosition + prevSize;
     }
   }
@@ -1532,16 +1867,16 @@ function updateItemPositions(ctx, state, dataChanged, { startIndex, scrollBottom
   let didBreakEarly = false;
   let breakAt;
   for (let i = startIndex; i < dataLength; i++) {
-    if (breakAt && i > breakAt) {
+    if (shouldOptimize && breakAt !== void 0 && i > breakAt) {
       didBreakEarly = true;
       break;
     }
-    if (breakAt === void 0 && !dataChanged && currentRowTop > maxVisibleArea) {
+    if (shouldOptimize && breakAt === void 0 && !scrollingTo && !dataChanged && currentRowTop > maxVisibleArea) {
       const itemsPerRow = hasColumns ? numColumns : 1;
       breakAt = i + itemsPerRow + 10;
     }
-    const id = (_c = idCache[i]) != null ? _c : getId(state, i);
-    const size = (_d = sizesKnown.get(id)) != null ? _d : getItemSize(state, id, i, data[i], useAverageSize);
+    const id = (_d = idCache[i]) != null ? _d : getId(state, i);
+    const size = (_e = sizesKnown.get(id)) != null ? _e : getItemSize(ctx, state, id, i, data[i], useAverageSize, preferCachedSize);
     if (IS_DEV && needsIndexByKey) {
       if (indexByKeyForChecking.has(id)) {
         console.error(
@@ -1759,16 +2094,6 @@ function isViewable(state, ctx, viewabilityConfig, containerId, key, scrollSize,
   const value = ctx.mapViewabilityAmountValues.get(containerId) || computeViewability(state, ctx, viewabilityConfig, containerId, key, scrollSize, item, index);
   return value.isViewable;
 }
-function findContainerId(ctx, key) {
-  const numContainers = peek$(ctx, "numContainers");
-  for (let i = 0; i < numContainers; i++) {
-    const itemKey = peek$(ctx, `containerItemKey${i}`);
-    if (itemKey === key) {
-      return i;
-    }
-  }
-  return -1;
-}
 function maybeUpdateViewabilityCallback(ctx, configId, containerId, viewToken) {
   const key = containerId + configId;
   ctx.mapViewabilityValues.set(key, viewToken);
@@ -1817,7 +2142,7 @@ function findAvailableContainers(ctx, state, numNeeded, startBuffered, endBuffer
     for (const containerIndex of stickyContainerPool) {
       const key = peek$(ctx, `containerItemKey${containerIndex}`);
       const isPendingRemoval = pendingRemovalSet.has(containerIndex);
-      if ((key === void 0 || isPendingRemoval) && canReuseContainer(containerIndex, requiredType)) {
+      if ((key === void 0 || isPendingRemoval) && canReuseContainer(containerIndex, requiredType) && !result.includes(containerIndex)) {
         result.push(containerIndex);
         if (isPendingRemoval && pendingRemovalSet.delete(containerIndex)) {
           pendingRemovalChanged = true;
@@ -1910,144 +2235,30 @@ function findAvailableContainers(ctx, state, numNeeded, startBuffered, endBuffer
   }
   return result.sort(comparatorDefault);
 }
-function comparatorByDistance(a, b) {
-  return b.distance - a.distance;
-}
-
-// src/utils/getScrollVelocity.ts
-var getScrollVelocity = (state) => {
-  const { scrollHistory } = state;
-  let velocity = 0;
-  if (scrollHistory.length >= 1) {
-    const newest = scrollHistory[scrollHistory.length - 1];
-    let oldest;
-    let start = 0;
-    const now = Date.now();
-    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) {
-          start = i;
-          break;
-        }
-      }
-    }
-    for (let i = start; i < scrollHistory.length - 1; i++) {
-      const entry = scrollHistory[i];
-      if (now - entry.time <= 1e3) {
-        oldest = entry;
-        break;
-      }
-    }
-    if (oldest && oldest !== newest) {
-      const scrollDiff = newest.scroll - oldest.scroll;
-      const timeDiff = newest.time - oldest.time;
-      velocity = timeDiff > 0 ? scrollDiff / timeDiff : 0;
-    }
-  }
-  return velocity;
-};
-
-// src/core/scrollToIndex.ts
-function scrollToIndex(ctx, state, { index, viewOffset = 0, animated = true, viewPosition }) {
-  if (index >= state.props.data.length) {
-    index = state.props.data.length - 1;
-  } else if (index < 0) {
-    index = 0;
-  }
-  const firstIndexOffset = calculateOffsetForIndex(ctx, state, index);
-  const isLast = index === state.props.data.length - 1;
-  if (isLast && viewPosition === void 0) {
-    viewPosition = 1;
-  }
-  state.scrollForNextCalculateItemsInView = void 0;
-  scrollTo(state, {
-    animated,
-    index,
-    offset: firstIndexOffset,
-    viewOffset,
-    viewPosition: viewPosition != null ? viewPosition : 0
-  });
-}
-
-// src/utils/checkThreshold.ts
-var HYSTERESIS_MULTIPLIER = 1.3;
-var checkThreshold = (distance, atThreshold, threshold, wasReached, snapshot, context, onReached, setSnapshot) => {
-  const absDistance = Math.abs(distance);
-  const within = atThreshold || threshold > 0 && absDistance <= threshold;
-  const updateSnapshot = () => {
-    setSnapshot == null ? void 0 : setSnapshot({
-      atThreshold,
-      contentSize: context.contentSize,
-      dataLength: context.dataLength,
-      scrollPosition: context.scrollPosition
-    });
-  };
-  if (!wasReached) {
-    if (!within) {
-      return false;
-    }
-    onReached == null ? void 0 : onReached(distance);
-    updateSnapshot();
-    return true;
-  }
-  const reset = !atThreshold && threshold > 0 && absDistance >= threshold * HYSTERESIS_MULTIPLIER || !atThreshold && threshold <= 0 && absDistance > 0;
-  if (reset) {
-    setSnapshot == null ? void 0 : setSnapshot(void 0);
-    return false;
-  }
-  if (within) {
-    const changed = !snapshot || snapshot.atThreshold !== atThreshold || snapshot.contentSize !== context.contentSize || snapshot.dataLength !== context.dataLength;
-    if (changed) {
-      onReached == null ? void 0 : onReached(distance);
-      updateSnapshot();
-    }
-  }
-  return true;
-};
+function comparatorByDistance(a, b) {
+  return b.distance - a.distance;
+}
 
-// src/utils/checkAtBottom.ts
-function checkAtBottom(ctx, state) {
-  var _a3;
-  if (!state) {
-    return;
+// src/core/scrollToIndex.ts
+function scrollToIndex(ctx, state, { index, viewOffset = 0, animated = true, viewPosition }) {
+  if (index >= state.props.data.length) {
+    index = state.props.data.length - 1;
+  } else if (index < 0) {
+    index = 0;
   }
-  const {
-    queuedInitialLayout,
-    scrollLength,
-    scroll,
-    maintainingScrollAtEnd,
-    props: { maintainScrollAtEndThreshold, onEndReachedThreshold }
-  } = state;
-  const contentSize = getContentSize(ctx);
-  if (contentSize > 0 && queuedInitialLayout && !maintainingScrollAtEnd) {
-    const distanceFromEnd = contentSize - scroll - scrollLength;
-    const isContentLess = contentSize < scrollLength;
-    state.isAtEnd = isContentLess || distanceFromEnd < scrollLength * maintainScrollAtEndThreshold;
-    state.isEndReached = checkThreshold(
-      distanceFromEnd,
-      isContentLess,
-      onEndReachedThreshold * scrollLength,
-      state.isEndReached,
-      state.endReachedSnapshot,
-      {
-        scrollPosition: scroll,
-        contentSize,
-        dataLength: (_a3 = state.props.data) == null ? void 0 : _a3.length
-      },
-      (distance) => {
-        var _a4, _b;
-        return (_b = (_a4 = state.props).onEndReached) == null ? void 0 : _b.call(_a4, { distanceFromEnd: distance });
-      },
-      (snapshot) => {
-        state.endReachedSnapshot = snapshot;
-      }
-    );
+  const firstIndexOffset = calculateOffsetForIndex(ctx, state, index);
+  const isLast = index === state.props.data.length - 1;
+  if (isLast && viewPosition === void 0) {
+    viewPosition = 1;
   }
+  state.scrollForNextCalculateItemsInView = void 0;
+  scrollTo(ctx, state, {
+    animated,
+    index,
+    offset: firstIndexOffset,
+    viewOffset,
+    viewPosition: viewPosition != null ? viewPosition : 0
+  });
 }
 
 // src/utils/setDidLayout.ts
@@ -2129,7 +2340,7 @@ function handleStickyRecycling(ctx, state, stickyArray, scroll, scrollBuffer, cu
       const currentId = (_b = state.idCache[itemIndex]) != null ? _b : getId(state, itemIndex);
       if (currentId) {
         const currentPos = state.positions.get(currentId);
-        const currentSize = (_c = state.sizes.get(currentId)) != null ? _c : getItemSize(state, currentId, itemIndex, state.props.data[itemIndex]);
+        const currentSize = (_c = state.sizes.get(currentId)) != null ? _c : getItemSize(ctx, state, currentId, itemIndex, state.props.data[itemIndex]);
         shouldRecycle = currentPos !== void 0 && scroll > currentPos + currentSize + scrollBuffer * 3;
       }
     }
@@ -2140,46 +2351,52 @@ function handleStickyRecycling(ctx, state, stickyArray, scroll, scrollBuffer, cu
 }
 function calculateItemsInView(ctx, state, params = {}) {
   unstable_batchedUpdates(() => {
-    var _a3, _b, _c, _d, _e, _f, _g, _h, _i;
+    var _a3, _b, _c, _d, _e, _f, _g, _h, _i, _j;
     const {
       columns,
       containerItemKeys,
       enableScrollForNextCalculateItemsInView,
       idCache,
       indexByKey,
+      initialScroll,
       minIndexSizeChanged,
       positions,
+      props: { getItemType, itemsAreEqual, keyExtractor, onStickyHeaderChange, scrollBuffer },
       scrollForNextCalculateItemsInView,
       scrollLength,
       sizes,
       startBufferedId: startBufferedIdOrig,
-      viewabilityConfigCallbackPairs,
-      props: { getItemType, initialScroll, itemsAreEqual, keyExtractor, onStickyHeaderChange, scrollBuffer }
+      viewabilityConfigCallbackPairs
     } = state;
     const { data } = state.props;
     const stickyIndicesArr = state.props.stickyIndicesArr || [];
     const stickyIndicesSet = state.props.stickyIndicesSet || /* @__PURE__ */ new Set();
     const prevNumContainers = peek$(ctx, "numContainers");
     if (!data || scrollLength === 0 || !prevNumContainers) {
+      if (state.initialAnchor) {
+        ensureInitialAnchor(ctx, state);
+      }
       return;
     }
-    const totalSize = peek$(ctx, "totalSize");
+    const totalSize = getContentSize(ctx);
     const topPad = peek$(ctx, "stylePaddingTop") + peek$(ctx, "headerSize");
     const numColumns = peek$(ctx, "numColumns");
-    const { dataChanged, doMVCP } = params;
+    const { dataChanged, doMVCP, forceFullItemPositions } = params;
     const speed = getScrollVelocity(state);
     const scrollExtra = 0;
     const { queuedInitialLayout } = state;
     let { scroll: scrollState } = state;
     if (!queuedInitialLayout && initialScroll) {
       const updatedOffset = calculateOffsetWithOffsetPosition(
+        ctx,
         state,
         calculateOffsetForIndex(ctx, state, initialScroll.index),
         initialScroll
       );
       scrollState = updatedOffset;
     }
-    const scrollAdjustPad = -topPad;
+    const scrollAdjustPending = (_a3 = peek$(ctx, "scrollAdjustPending")) != null ? _a3 : 0;
+    const scrollAdjustPad = scrollAdjustPending - topPad;
     let scroll = scrollState + scrollExtra + scrollAdjustPad;
     if (scroll + scrollLength > totalSize) {
       scroll = Math.max(0, totalSize - scrollLength);
@@ -2192,6 +2409,7 @@ function calculateItemsInView(ctx, state, params = {}) {
     const currentStickyIdx = stickyIndicesArr.length > 0 ? findCurrentStickyIndex(stickyIndicesArr, scroll, state) : -1;
     const nextActiveStickyIndex = currentStickyIdx >= 0 ? stickyIndicesArr[currentStickyIdx] : void 0;
     state.activeStickyIndex = nextActiveStickyIndex;
+    set$(ctx, "activeStickyIndex", nextActiveStickyIndex);
     let scrollBufferTop = scrollBuffer;
     let scrollBufferBottom = scrollBuffer;
     if (speed > 0 || speed === 0 && scroll < Math.max(50, scrollBuffer)) {
@@ -2207,6 +2425,9 @@ function calculateItemsInView(ctx, state, params = {}) {
     if (!dataChanged && scrollForNextCalculateItemsInView) {
       const { top, bottom } = scrollForNextCalculateItemsInView;
       if (scrollTopBuffered > top && scrollBottomBuffered < bottom) {
+        if (state.initialAnchor) {
+          ensureInitialAnchor(ctx, state);
+        }
         return;
       }
     }
@@ -2216,8 +2437,12 @@ function calculateItemsInView(ctx, state, params = {}) {
       idCache.length = 0;
       positions.clear();
     }
-    const startIndex = dataChanged ? 0 : (_a3 = minIndexSizeChanged != null ? minIndexSizeChanged : state.startBuffered) != null ? _a3 : 0;
-    updateItemPositions(ctx, state, dataChanged, { scrollBottomBuffered, startIndex });
+    const startIndex = dataChanged ? 0 : (_b = minIndexSizeChanged != null ? minIndexSizeChanged : state.startBuffered) != null ? _b : 0;
+    updateItemPositions(ctx, state, dataChanged, {
+      forceFullUpdate: !!forceFullItemPositions,
+      scrollBottomBuffered,
+      startIndex
+    });
     if (minIndexSizeChanged !== void 0) {
       state.minIndexSizeChanged = void 0;
     }
@@ -2229,9 +2454,9 @@ function calculateItemsInView(ctx, state, params = {}) {
     let endBuffered = null;
     let loopStart = !dataChanged && startBufferedIdOrig ? indexByKey.get(startBufferedIdOrig) || 0 : 0;
     for (let i = loopStart; i >= 0; i--) {
-      const id = (_b = idCache[i]) != null ? _b : getId(state, i);
+      const id = (_c = idCache[i]) != null ? _c : getId(state, i);
       const top = positions.get(id);
-      const size = (_c = sizes.get(id)) != null ? _c : getItemSize(state, id, i, data[i]);
+      const size = (_d = sizes.get(id)) != null ? _d : getItemSize(ctx, state, id, i, data[i]);
       const bottom = top + size;
       if (bottom > scroll - scrollBuffer) {
         loopStart = i;
@@ -2257,8 +2482,8 @@ function calculateItemsInView(ctx, state, params = {}) {
     let firstFullyOnScreenIndex;
     const dataLength = data.length;
     for (let i = Math.max(0, loopStart); i < dataLength && (!foundEnd || i <= maxIndexRendered); i++) {
-      const id = (_d = idCache[i]) != null ? _d : getId(state, i);
-      const size = (_e = sizes.get(id)) != null ? _e : getItemSize(state, id, i, data[i]);
+      const id = (_e = idCache[i]) != null ? _e : getId(state, i);
+      const size = (_f = sizes.get(id)) != null ? _f : getItemSize(ctx, state, id, i, data[i]);
       const top = positions.get(id);
       if (!foundEnd) {
         if (startNoBuffer === null && top + size > scroll) {
@@ -2287,7 +2512,7 @@ function calculateItemsInView(ctx, state, params = {}) {
     }
     const idsInView = [];
     for (let i = firstFullyOnScreenIndex; i <= endNoBuffer; i++) {
-      const id = (_f = idCache[i]) != null ? _f : getId(state, i);
+      const id = (_g = idCache[i]) != null ? _g : getId(state, i);
       idsInView.push(id);
     }
     Object.assign(state, {
@@ -2319,7 +2544,7 @@ function calculateItemsInView(ctx, state, params = {}) {
       let numContainers2 = prevNumContainers;
       const needNewContainers = [];
       for (let i = startBuffered; i <= endBuffered; i++) {
-        const id = (_g = idCache[i]) != null ? _g : getId(state, i);
+        const id = (_h = idCache[i]) != null ? _h : getId(state, i);
         if (!containerItemKeys.has(id)) {
           needNewContainers.push(i);
         }
@@ -2337,6 +2562,7 @@ function calculateItemsInView(ctx, state, params = {}) {
         );
       } else {
         state.activeStickyIndex = void 0;
+        set$(ctx, "activeStickyIndex", void 0);
       }
       if (needNewContainers.length > 0) {
         const requiredItemTypes = getItemType ? needNewContainers.map((i) => {
@@ -2356,7 +2582,7 @@ function calculateItemsInView(ctx, state, params = {}) {
         for (let idx = 0; idx < needNewContainers.length; idx++) {
           const i = needNewContainers[idx];
           const containerIndex = availableContainers[idx];
-          const id = (_h = idCache[i]) != null ? _h : getId(state, i);
+          const id = (_i = idCache[i]) != null ? _i : getId(state, i);
           const oldKey = peek$(ctx, `containerItemKey${containerIndex}`);
           if (oldKey && oldKey !== id) {
             containerItemKeys.delete(oldKey);
@@ -2395,7 +2621,7 @@ function calculateItemsInView(ctx, state, params = {}) {
     for (let i = 0; i < numContainers; i++) {
       const itemKey = peek$(ctx, `containerItemKey${i}`);
       if (pendingRemoval.includes(i)) {
-        if (itemKey) {
+        if (itemKey !== void 0) {
           containerItemKeys.delete(itemKey);
         }
         state.containerItemTypes.delete(i);
@@ -2412,11 +2638,12 @@ function calculateItemsInView(ctx, state, params = {}) {
         const itemIndex = indexByKey.get(itemKey);
         const item = data[itemIndex];
         if (item !== void 0) {
-          const id = (_i = idCache[itemIndex]) != null ? _i : getId(state, itemIndex);
-          const position = positions.get(id);
-          if (position === void 0) {
+          const id = (_j = idCache[itemIndex]) != null ? _j : getId(state, itemIndex);
+          const positionValue = positions.get(id);
+          if (positionValue === void 0) {
             set$(ctx, `containerPosition${i}`, POSITION_OUT_OF_VIEW);
           } else {
+            const position = (positionValue || 0) - scrollAdjustPending;
             const column = columns.get(id) || 1;
             const prevPos = peek$(ctx, `containerPosition${i}`);
             const prevColumn = peek$(ctx, `containerColumn${i}`);
@@ -2453,6 +2680,29 @@ function calculateItemsInView(ctx, state, params = {}) {
       }
     }
   });
+  if (state.initialAnchor) {
+    ensureInitialAnchor(ctx, state);
+  }
+}
+
+// src/core/checkActualChange.ts
+function checkActualChange(state, dataProp, previousData) {
+  if (!previousData || !dataProp || dataProp.length !== previousData.length) {
+    return true;
+  }
+  const {
+    idCache,
+    props: { keyExtractor }
+  } = state;
+  for (let i = 0; i < dataProp.length; i++) {
+    if (dataProp[i] !== previousData[i]) {
+      return true;
+    }
+    if (keyExtractor ? idCache[i] !== keyExtractor(previousData[i], i) : dataProp[i] !== previousData[i]) {
+      return true;
+    }
+  }
+  return false;
 }
 
 // src/core/doMaintainScrollAtEnd.ts
@@ -2485,40 +2735,6 @@ function doMaintainScrollAtEnd(ctx, state, animated) {
   }
 }
 
-// src/utils/checkAtTop.ts
-function checkAtTop(state) {
-  var _a3;
-  if (!state) {
-    return;
-  }
-  const {
-    scrollLength,
-    scroll,
-    props: { onStartReachedThreshold }
-  } = state;
-  const distanceFromTop = scroll;
-  state.isAtStart = distanceFromTop <= 0;
-  state.isStartReached = checkThreshold(
-    distanceFromTop,
-    false,
-    onStartReachedThreshold * scrollLength,
-    state.isStartReached,
-    state.startReachedSnapshot,
-    {
-      scrollPosition: scroll,
-      contentSize: state.totalSize,
-      dataLength: (_a3 = state.props.data) == null ? void 0 : _a3.length
-    },
-    (distance) => {
-      var _a4, _b;
-      return (_b = (_a4 = state.props).onStartReached) == null ? void 0 : _b.call(_a4, { distanceFromStart: distance });
-    },
-    (snapshot) => {
-      state.startReachedSnapshot = snapshot;
-    }
-  );
-}
-
 // src/utils/updateAveragesOnDataChange.ts
 function updateAveragesOnDataChange(state, oldData, newData) {
   var _a3;
@@ -2572,25 +2788,23 @@ function updateAveragesOnDataChange(state, oldData, newData) {
 }
 
 // src/core/checkResetContainers.ts
-function checkResetContainers(ctx, state, isFirst, dataProp) {
-  if (state) {
-    if (!isFirst && state.props.data !== dataProp) {
-      updateAveragesOnDataChange(state, state.props.data, dataProp);
-    }
-    const { maintainScrollAtEnd } = state.props;
-    if (!isFirst) {
-      calculateItemsInView(ctx, state, { dataChanged: true, doMVCP: true });
-      const shouldMaintainScrollAtEnd = maintainScrollAtEnd === true || maintainScrollAtEnd.onDataChange;
-      const didMaintainScrollAtEnd = shouldMaintainScrollAtEnd && doMaintainScrollAtEnd(ctx, state, false);
-      if (!didMaintainScrollAtEnd && dataProp.length > state.props.data.length) {
-        state.isEndReached = false;
-      }
-      if (!didMaintainScrollAtEnd) {
-        checkAtTop(state);
-        checkAtBottom(ctx, state);
-      }
-    }
+function checkResetContainers(ctx, state, dataProp) {
+  const { previousData } = state;
+  if (previousData) {
+    updateAveragesOnDataChange(state, previousData, dataProp);
+  }
+  const { maintainScrollAtEnd } = state.props;
+  calculateItemsInView(ctx, state, { dataChanged: true, doMVCP: true });
+  const shouldMaintainScrollAtEnd = maintainScrollAtEnd === true || maintainScrollAtEnd.onDataChange;
+  const didMaintainScrollAtEnd = shouldMaintainScrollAtEnd && doMaintainScrollAtEnd(ctx, state, false);
+  if (!didMaintainScrollAtEnd && previousData && dataProp.length > previousData.length) {
+    state.isEndReached = false;
+  }
+  if (!didMaintainScrollAtEnd) {
+    checkAtTop(state);
+    checkAtBottom(ctx, state);
   }
+  delete state.previousData;
 }
 
 // src/core/doInitialAllocateContainers.ts
@@ -2631,7 +2845,7 @@ function doInitialAllocateContainers(ctx, state) {
     set$(ctx, "numContainers", numContainers);
     set$(ctx, "numContainersPooled", numContainers * state.props.initialContainerPoolRatio);
     if (state.lastLayout) {
-      if (state.props.initialScroll) {
+      if (state.initialScroll) {
         requestAnimationFrame(() => {
           calculateItemsInView(ctx, state, { dataChanged: true, doMVCP: true });
         });
@@ -2687,78 +2901,47 @@ function handleLayout(ctx, state, layout, setCanRender) {
   setCanRender(true);
 }
 
-// src/core/onScroll.ts
-function onScroll(ctx, state, event) {
-  var _a3, _b, _c;
-  const {
-    scrollProcessingEnabled,
-    props: { onScroll: onScrollProp }
-  } = state;
-  if (scrollProcessingEnabled === false) {
-    return;
-  }
-  if (((_b = (_a3 = event.nativeEvent) == null ? void 0 : _a3.contentSize) == null ? void 0 : _b.height) === 0 && ((_c = event.nativeEvent.contentSize) == null ? void 0 : _c.width) === 0) {
-    return;
-  }
-  const newScroll = event.nativeEvent.contentOffset[state.props.horizontal ? "x" : "y"];
-  state.scrollPending = newScroll;
-  updateScroll(ctx, state, newScroll);
-  onScrollProp == null ? void 0 : onScrollProp(event);
-}
-function updateScroll(ctx, state, newScroll) {
-  const scrollingTo = state.scrollingTo;
-  state.hasScrolled = true;
-  state.lastBatchingAction = Date.now();
-  const currentTime = Date.now();
-  const adjust = state.scrollAdjustHandler.getAdjust();
-  const lastHistoryAdjust = state.lastScrollAdjustForHistory;
-  const adjustChanged = lastHistoryAdjust !== void 0 && Math.abs(adjust - lastHistoryAdjust) > 0.1;
-  if (adjustChanged) {
-    state.scrollHistory.length = 0;
-  }
-  state.lastScrollAdjustForHistory = adjust;
-  if (scrollingTo === void 0 && !(state.scrollHistory.length === 0 && newScroll === state.scroll)) {
-    if (!adjustChanged) {
-      state.scrollHistory.push({ scroll: newScroll, time: currentTime });
-    }
-  }
-  if (state.scrollHistory.length > 5) {
-    state.scrollHistory.shift();
-  }
-  state.scrollPrev = state.scroll;
-  state.scrollPrevTime = state.scrollTime;
-  state.scroll = newScroll;
-  state.scrollTime = currentTime;
-  const ignoreScrollFromMVCP = state.ignoreScrollFromMVCP;
-  if (ignoreScrollFromMVCP && !state.scrollingTo) {
-    const { lt, gt } = ignoreScrollFromMVCP;
-    if (lt && newScroll < lt || gt && newScroll > gt) {
-      return;
-    }
-  }
-  if (state.dataChangeNeedsScrollUpdate || Math.abs(state.scroll - state.scrollPrev) > 2) {
-    calculateItemsInView(ctx, state, { doMVCP: state.scrollingTo !== void 0 });
-    checkAtBottom(ctx, state);
-    checkAtTop(state);
-    state.dataChangeNeedsScrollUpdate = false;
-  }
-}
-
 // src/core/ScrollAdjustHandler.ts
 var ScrollAdjustHandler = class {
   constructor(ctx) {
     this.appliedAdjust = 0;
+    this.pendingAdjust = 0;
     this.mounted = false;
     this.context = ctx;
+    {
+      const commitPendingAdjust = () => {
+        const state = this.context.internalState;
+        const pending = this.pendingAdjust;
+        if (pending !== 0) {
+          this.pendingAdjust = 0;
+          this.appliedAdjust += pending;
+          state.scroll += pending;
+          state.scrollForNextCalculateItemsInView = void 0;
+          set$(this.context, "scrollAdjustPending", 0);
+          set$(this.context, "scrollAdjust", this.appliedAdjust);
+          calculateItemsInView(this.context, this.context.internalState);
+        }
+      };
+      listen$(this.context, "scrollingTo", (value) => {
+        if (value === void 0) {
+          commitPendingAdjust();
+        }
+      });
+    }
   }
   requestAdjust(add) {
-    const oldAdjustTop = this.appliedAdjust;
-    this.appliedAdjust = add + oldAdjustTop;
-    const set = () => set$(this.context, "scrollAdjust", this.appliedAdjust);
-    if (this.mounted) {
-      set();
+    const scrollingTo = peek$(this.context, "scrollingTo");
+    if ((scrollingTo == null ? void 0 : scrollingTo.animated) && !scrollingTo.isInitialScroll) {
+      this.pendingAdjust += add;
+      set$(this.context, "scrollAdjustPending", this.pendingAdjust);
     } else {
-      requestAnimationFrame(set);
+      this.appliedAdjust += add;
+      const setter = () => set$(this.context, "scrollAdjust", this.appliedAdjust);
+      if (this.mounted) {
+        setter();
+      } else {
+        requestAnimationFrame(setter);
+      }
     }
   }
   setMounted() {
@@ -2806,8 +2989,8 @@ function updateItemSize(ctx, state, itemKey, sizeObj) {
   let minIndexSizeChanged;
   let maxOtherAxisSize = peek$(ctx, "otherAxisSize") || 0;
   const prevSizeKnown = state.sizesKnown.get(itemKey);
-  const diff = updateOneItemSize(state, itemKey, sizeObj);
-  const size = Math.floor((horizontal ? sizeObj.width : sizeObj.height) * 8) / 8;
+  const diff = updateOneItemSize(ctx, state, itemKey, sizeObj);
+  const size = roundSize(horizontal ? sizeObj.width : sizeObj.height);
   if (diff !== 0) {
     minIndexSizeChanged = minIndexSizeChanged !== void 0 ? Math.min(minIndexSizeChanged, index) : index;
     const { startBuffered, endBuffered } = state;
@@ -2828,7 +3011,6 @@ function updateItemSize(ctx, state, itemKey, sizeObj) {
     if (prevSizeKnown !== void 0 && Math.abs(prevSizeKnown - size) > 5) {
       shouldMaintainScrollAtEnd = true;
     }
-    addTotalSize(ctx, state, itemKey, diff);
     onItemSizeChanged == null ? void 0 : onItemSizeChanged({
       index,
       itemData: state.props.data[index],
@@ -2868,7 +3050,7 @@ function updateItemSize(ctx, state, itemKey, sizeObj) {
     }
   }
 }
-function updateOneItemSize(state, itemKey, sizeObj) {
+function updateOneItemSize(ctx, state, itemKey, sizeObj) {
   var _a3;
   const {
     sizes,
@@ -2879,7 +3061,7 @@ function updateOneItemSize(state, itemKey, sizeObj) {
   } = state;
   if (!data) return 0;
   const index = indexByKey.get(itemKey);
-  const prevSize = getItemSize(state, itemKey, index, data[index]);
+  const prevSize = getItemSize(ctx, state, itemKey, index, data[index]);
   const rawSize = horizontal ? sizeObj.width : sizeObj.height;
   const size = Math.round(rawSize) ;
   sizesKnown.set(itemKey, size);
@@ -2893,7 +3075,7 @@ function updateOneItemSize(state, itemKey, sizeObj) {
     averages.num++;
   }
   if (!prevSize || Math.abs(prevSize - size) > 0.1) {
-    sizes.set(itemKey, size);
+    setSize(ctx, state, itemKey, size);
     return size - prevSize;
   }
   return 0;
@@ -2938,6 +3120,91 @@ function createColumnWrapperStyle(contentContainerStyle) {
     };
   }
 }
+
+// src/utils/createImperativeHandle.ts
+function createImperativeHandle(ctx, state) {
+  const scrollIndexIntoView = (options) => {
+    if (state) {
+      const { index, ...rest } = options;
+      const { startNoBuffer, endNoBuffer } = state;
+      if (index < startNoBuffer || index > endNoBuffer) {
+        const viewPosition = index < startNoBuffer ? 0 : 1;
+        scrollToIndex(ctx, state, {
+          ...rest,
+          index,
+          viewPosition
+        });
+      }
+    }
+  };
+  const refScroller = state.refScroller;
+  return {
+    flashScrollIndicators: () => refScroller.current.flashScrollIndicators(),
+    getNativeScrollRef: () => refScroller.current,
+    getScrollableNode: () => refScroller.current.getScrollableNode(),
+    getScrollResponder: () => refScroller.current.getScrollResponder(),
+    getState: () => ({
+      activeStickyIndex: state.activeStickyIndex,
+      contentLength: state.totalSize,
+      data: state.props.data,
+      elementAtIndex: (index) => {
+        var _a3;
+        return (_a3 = ctx.viewRefs.get(findContainerId(ctx, getId(state, index)))) == null ? void 0 : _a3.current;
+      },
+      end: state.endNoBuffer,
+      endBuffered: state.endBuffered,
+      isAtEnd: state.isAtEnd,
+      isAtStart: state.isAtStart,
+      positionAtIndex: (index) => state.positions.get(getId(state, index)),
+      positions: state.positions,
+      scroll: state.scroll,
+      scrollLength: state.scrollLength,
+      sizeAtIndex: (index) => state.sizesKnown.get(getId(state, index)),
+      sizes: state.sizesKnown,
+      start: state.startNoBuffer,
+      startBuffered: state.startBuffered
+    }),
+    scrollIndexIntoView,
+    scrollItemIntoView: ({ item, ...props }) => {
+      const data = state.props.data;
+      const index = data.indexOf(item);
+      if (index !== -1) {
+        scrollIndexIntoView({ index, ...props });
+      }
+    },
+    scrollToEnd: (options) => {
+      const data = state.props.data;
+      const stylePaddingBottom = state.props.stylePaddingBottom;
+      const index = data.length - 1;
+      if (index !== -1) {
+        const paddingBottom = stylePaddingBottom || 0;
+        const footerSize = peek$(ctx, "footerSize") || 0;
+        scrollToIndex(ctx, state, {
+          index,
+          viewOffset: -paddingBottom - footerSize + ((options == null ? void 0 : options.viewOffset) || 0),
+          viewPosition: 1,
+          ...options
+        });
+      }
+    },
+    scrollToIndex: (params) => scrollToIndex(ctx, state, params),
+    scrollToItem: ({ item, ...props }) => {
+      const data = state.props.data;
+      const index = data.indexOf(item);
+      if (index !== -1) {
+        scrollToIndex(ctx, state, { index, ...props });
+      }
+    },
+    scrollToOffset: (params) => scrollTo(ctx, state, params),
+    setScrollProcessingEnabled: (enabled) => {
+      state.scrollProcessingEnabled = enabled;
+    },
+    setVisibleContentAnchorOffset: (value) => {
+      const val = isFunction(value) ? value(peek$(ctx, "scrollAdjustUserOffset") || 0) : value;
+      set$(ctx, "scrollAdjustUserOffset", val);
+    }
+  };
+}
 function getRenderedItem(ctx, state, key) {
   var _a3;
   if (!state) {
@@ -3032,12 +3299,13 @@ var LegendList = typedMemo(
   })
 );
 var LegendListInner = typedForwardRef(function LegendListInner2(props, forwardedRef) {
-  var _a3;
+  var _a3, _b;
   const {
     alignItemsAtEnd = false,
     columnWrapperStyle,
     contentContainerStyle: contentContainerStyleProp,
     data: dataProp = [],
+    dataVersion,
     drawDistance = 250,
     enableAverages = true,
     estimatedItemSize: estimatedItemSizeProp,
@@ -3048,6 +3316,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     getItemType,
     horizontal,
     initialContainerPoolRatio = 2,
+    initialScrollAtEnd = false,
     initialScrollIndex: initialScrollIndexProp,
     initialScrollOffset: initialScrollOffsetProp,
     itemsAreEqual,
@@ -3086,13 +3355,13 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     waitForInitialLayout = true,
     ...rest
   } = props;
-  const [renderNum, setRenderNum] = useState(0);
-  const initialScroll = initialScrollIndexProp || initialScrollOffsetProp ? typeof initialScrollIndexProp === "object" ? { index: initialScrollIndexProp.index || 0, viewOffset: initialScrollIndexProp.viewOffset || 0 } : { index: initialScrollIndexProp || 0, viewOffset: initialScrollOffsetProp || 0 } : void 0;
-  const [canRender, setCanRender] = React3.useState(!IsNewArchitecture);
   const contentContainerStyle = { ...StyleSheet.flatten(contentContainerStyleProp) };
   const style = { ...StyleSheet.flatten(styleProp) };
   const stylePaddingTopState = extractPadding(style, contentContainerStyle, "Top");
   const stylePaddingBottomState = extractPadding(style, contentContainerStyle, "Bottom");
+  const [renderNum, setRenderNum] = useState(0);
+  const initialScrollProp = initialScrollAtEnd ? { index: Math.max(0, dataProp.length - 1), viewOffset: -stylePaddingBottomState } : initialScrollIndexProp || initialScrollOffsetProp ? typeof initialScrollIndexProp === "object" ? { index: initialScrollIndexProp.index || 0, viewOffset: initialScrollIndexProp.viewOffset || 0 } : { index: initialScrollIndexProp || 0, viewOffset: initialScrollOffsetProp || 0 } : void 0;
+  const [canRender, setCanRender] = React3.useState(!IsNewArchitecture);
   const ctx = useStateContext();
   ctx.columnWrapperStyle = columnWrapperStyle || (contentContainerStyle ? createColumnWrapperStyle(contentContainerStyle) : void 0);
   const refScroller = useRef(null);
@@ -3111,6 +3380,8 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
         containerItemKeys: /* @__PURE__ */ new Set(),
         containerItemTypes: /* @__PURE__ */ new Map(),
         dataChangeNeedsScrollUpdate: false,
+        didColumnsChange: false,
+        didDataChange: false,
         enableScrollForNextCalculateItemsInView: true,
         endBuffered: -1,
         endNoBuffer: -1,
@@ -3119,10 +3390,18 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
         idCache: [],
         idsInView: [],
         indexByKey: /* @__PURE__ */ new Map(),
-        initialScroll,
+        initialAnchor: (initialScrollProp == null ? void 0 : initialScrollProp.index) !== void 0 && (initialScrollProp == null ? void 0 : initialScrollProp.viewPosition) !== void 0 ? {
+          attempts: 0,
+          index: initialScrollProp.index,
+          settledTicks: 0,
+          viewOffset: (_a3 = initialScrollProp.viewOffset) != null ? _a3 : 0,
+          viewPosition: initialScrollProp.viewPosition
+        } : void 0,
+        initialScroll: initialScrollProp,
         isAtEnd: false,
         isAtStart: false,
         isEndReached: false,
+        isFirst: true,
         isStartReached: false,
         lastBatchingAction: Date.now(),
         lastLayout: void 0,
@@ -3155,21 +3434,27 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
         totalSize: 0,
         viewabilityConfigCallbackPairs: void 0
       };
+      const internalState = ctx.internalState;
+      internalState.triggerCalculateItemsInView = (params) => calculateItemsInView(ctx, internalState, params);
       set$(ctx, "maintainVisibleContentPosition", maintainVisibleContentPosition);
       set$(ctx, "extraData", extraData);
     }
     refState.current = ctx.internalState;
   }
   const state = refState.current;
-  const isFirst = !state.props.renderItem;
-  const didDataChange = state.props.data !== dataProp;
-  if (didDataChange) {
+  const isFirstLocal = state.isFirst;
+  state.didColumnsChange = numColumnsProp !== state.props.numColumns;
+  const didDataChangeLocal = state.props.dataVersion !== dataVersion || state.props.data !== dataProp && checkActualChange(state, dataProp, state.props.data);
+  if (didDataChangeLocal) {
     state.dataChangeNeedsScrollUpdate = true;
+    state.didDataChange = true;
+    state.previousData = state.props.data;
   }
   const throttleScrollFn = scrollEventThrottle && onScrollProp ? useThrottledOnScroll(onScrollProp, scrollEventThrottle) : onScrollProp;
   state.props = {
     alignItemsAtEnd,
     data: dataProp,
+    dataVersion,
     enableAverages,
     estimatedItemSize,
     getEstimatedItemSize,
@@ -3177,7 +3462,6 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     getItemType,
     horizontal: !!horizontal,
     initialContainerPoolRatio,
-    initialScroll,
     itemsAreEqual,
     keyExtractor,
     maintainScrollAtEnd,
@@ -3209,7 +3493,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       { length: Math.min(numColumnsProp, dataProp.length) },
       (_, i) => getId(state, dataProp.length - 1 - i)
     );
-  }, [dataProp, numColumnsProp]);
+  }, [dataProp, dataVersion, numColumnsProp]);
   const initializeStateVars = () => {
     set$(ctx, "lastItemKeys", memoizedLastItemKeys);
     set$(ctx, "numColumns", numColumnsProp);
@@ -3224,7 +3508,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       requestAdjust(ctx, state, paddingDiff);
     }
   };
-  if (isFirst) {
+  if (isFirstLocal) {
     initializeStateVars();
     updateItemPositions(
       ctx,
@@ -3234,38 +3518,53 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     );
   }
   const initialContentOffset = useMemo(() => {
-    if (initialScroll) {
-      const { index, viewOffset } = initialScroll;
-      let initialContentOffset2 = viewOffset || 0;
-      if (index !== void 0) {
-        initialContentOffset2 += calculateOffsetForIndex(ctx, state, index);
-      }
-      refState.current.isStartReached = initialContentOffset2 < refState.current.scrollLength * onStartReachedThreshold;
-      if (initialContentOffset2 > 0) {
-        scrollTo(state, {
-          animated: false,
-          index,
-          isInitialScroll: true,
-          offset: initialContentOffset2,
-          viewPosition: index === dataProp.length - 1 ? 1 : 0
-        });
-      }
-      return initialContentOffset2;
+    var _a4, _b2;
+    const { initialScroll } = refState.current;
+    if (!initialScroll) {
+      refState.current.initialAnchor = void 0;
+      return 0;
+    }
+    if (initialScroll.index !== void 0 && (!refState.current.initialAnchor || ((_a4 = refState.current.initialAnchor) == null ? void 0 : _a4.index) !== initialScroll.index)) {
+      refState.current.initialAnchor = {
+        attempts: 0,
+        index: initialScroll.index,
+        settledTicks: 0,
+        viewOffset: (_b2 = initialScroll.viewOffset) != null ? _b2 : 0,
+        viewPosition: initialScroll.viewPosition
+      };
     }
-    return 0;
-  }, [renderNum]);
-  if (isFirst || didDataChange || numColumnsProp !== peek$(ctx, "numColumns")) {
+    if (initialScroll.contentOffset !== void 0) {
+      return initialScroll.contentOffset;
+    }
+    const baseOffset = initialScroll.index !== void 0 ? calculateOffsetForIndex(ctx, state, initialScroll.index) : 0;
+    const resolvedOffset = calculateOffsetWithOffsetPosition(ctx, state, baseOffset, initialScroll);
+    let clampedOffset = resolvedOffset;
+    if (Number.isFinite(state.scrollLength) && Number.isFinite(state.totalSize)) {
+      const maxOffset = Math.max(0, state.totalSize - state.scrollLength);
+      clampedOffset = Math.min(clampedOffset, maxOffset);
+    }
+    clampedOffset = Math.max(0, clampedOffset);
+    const updatedInitialScroll = { ...initialScroll, contentOffset: clampedOffset };
+    refState.current.initialScroll = updatedInitialScroll;
+    state.initialScroll = updatedInitialScroll;
+    refState.current.isStartReached = clampedOffset < refState.current.scrollLength * onStartReachedThreshold;
+    return clampedOffset;
+  }, [renderNum, state.initialScroll]);
+  if (isFirstLocal || didDataChangeLocal || numColumnsProp !== peek$(ctx, "numColumns")) {
     refState.current.lastBatchingAction = Date.now();
-    if (!keyExtractorProp && !isFirst && didDataChange) {
+    if (!keyExtractorProp && !isFirstLocal && didDataChangeLocal) {
       IS_DEV && warnDevOnce(
         "keyExtractor",
         "Changing data without a keyExtractor can cause slow performance and resetting scroll. If your list data can change you should use a keyExtractor with a unique id for best performance and behavior."
       );
       refState.current.sizes.clear();
       refState.current.positions.clear();
+      refState.current.totalSize = 0;
+      set$(ctx, "totalSize", 0);
     }
   }
   const onLayoutHeader = useCallback((rect, fromLayoutEffect) => {
+    const { initialScroll } = refState.current;
     const size = rect[horizontal ? "width" : "height"];
     set$(ctx, "headerSize", size);
     if ((initialScroll == null ? void 0 : initialScroll.index) !== void 0) {
@@ -3276,31 +3575,58 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       }
     }
   }, []);
+  const doInitialScroll = useCallback(() => {
+    var _a4;
+    const initialScroll = state.initialScroll;
+    if (initialScroll) {
+      scrollTo(ctx, state, {
+        animated: false,
+        index: (_a4 = state.initialScroll) == null ? void 0 : _a4.index,
+        isInitialScroll: true,
+        offset: initialContentOffset,
+        precomputedWithViewOffset: true
+      });
+    }
+  }, [initialContentOffset, state.initialScroll]);
+  const onLayoutChange = useCallback((layout) => {
+    doInitialScroll();
+    handleLayout(ctx, state, layout, setCanRender);
+  }, []);
+  const { onLayout } = useOnLayoutSync({
+    onLayoutChange,
+    onLayoutProp,
+    ref: refScroller
+    // the type of ScrollView doesn't include measure?
+  });
   useLayoutEffect(() => {
     if (snapToIndices) {
       updateSnapToOffsets(ctx, state);
     }
   }, [snapToIndices]);
   useLayoutEffect(() => {
-    const didAllocateContainers = dataProp.length > 0 && doInitialAllocateContainers(ctx, state);
-    if (!didAllocateContainers) {
-      checkResetContainers(
-        ctx,
-        state,
-        /*isFirst*/
-        isFirst,
-        dataProp
-      );
-    }
-  }, [dataProp, numColumnsProp]);
+    const {
+      didColumnsChange,
+      didDataChange,
+      isFirst,
+      props: { data }
+    } = state;
+    const didAllocateContainers = data.length > 0 && doInitialAllocateContainers(ctx, state);
+    if (!didAllocateContainers && !isFirst && (didDataChange || didColumnsChange)) {
+      checkResetContainers(ctx, state, data);
+    }
+    state.didColumnsChange = false;
+    state.didDataChange = false;
+    state.isFirst = false;
+  }, [dataProp, dataVersion, numColumnsProp]);
   useLayoutEffect(() => {
     set$(ctx, "extraData", extraData);
   }, [extraData]);
   useLayoutEffect(initializeStateVars, [
+    dataVersion,
     memoizedLastItemKeys.join(","),
     numColumnsProp,
-    stylePaddingTopState,
-    stylePaddingBottomState
+    stylePaddingBottomState,
+    stylePaddingTopState
   ]);
   useEffect(() => {
     const viewability = setupViewability({
@@ -3311,103 +3637,9 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     state.viewabilityConfigCallbackPairs = viewability;
     state.enableScrollForNextCalculateItemsInView = !viewability;
   }, [viewabilityConfig, viewabilityConfigCallbackPairs, onViewableItemsChanged]);
-  const onLayoutChange = useCallback((layout) => {
-    handleLayout(ctx, state, layout, setCanRender);
-  }, []);
-  const { onLayout } = useOnLayoutSync({
-    onLayoutChange,
-    onLayoutProp,
-    ref: refScroller
-    // the type of ScrollView doesn't include measure?
-  });
-  useImperativeHandle(forwardedRef, () => {
-    const scrollIndexIntoView = (options) => {
-      const state2 = refState.current;
-      if (state2) {
-        const { index, ...rest2 } = options;
-        const { startNoBuffer, endNoBuffer } = state2;
-        if (index < startNoBuffer || index > endNoBuffer) {
-          const viewPosition = index < startNoBuffer ? 0 : 1;
-          scrollToIndex(ctx, state2, {
-            ...rest2,
-            index,
-            viewPosition
-          });
-        }
-      }
-    };
-    return {
-      flashScrollIndicators: () => refScroller.current.flashScrollIndicators(),
-      getNativeScrollRef: () => refScroller.current,
-      getScrollableNode: () => refScroller.current.getScrollableNode(),
-      getScrollResponder: () => refScroller.current.getScrollResponder(),
-      getState: () => {
-        const state2 = refState.current;
-        return state2 ? {
-          activeStickyIndex: state2.activeStickyIndex,
-          contentLength: state2.totalSize,
-          data: state2.props.data,
-          end: state2.endNoBuffer,
-          endBuffered: state2.endBuffered,
-          isAtEnd: state2.isAtEnd,
-          isAtStart: state2.isAtStart,
-          positionAtIndex: (index) => state2.positions.get(getId(state2, index)),
-          positions: state2.positions,
-          scroll: state2.scroll,
-          scrollLength: state2.scrollLength,
-          sizeAtIndex: (index) => state2.sizesKnown.get(getId(state2, index)),
-          sizes: state2.sizesKnown,
-          start: state2.startNoBuffer,
-          startBuffered: state2.startBuffered
-        } : {};
-      },
-      scrollIndexIntoView,
-      scrollItemIntoView: ({ item, ...props2 }) => {
-        const data = refState.current.props.data;
-        const index = data.indexOf(item);
-        if (index !== -1) {
-          scrollIndexIntoView({ index, ...props2 });
-        }
-      },
-      scrollToEnd: (options) => {
-        const data = refState.current.props.data;
-        const stylePaddingBottom = refState.current.props.stylePaddingBottom;
-        const index = data.length - 1;
-        if (index !== -1) {
-          const paddingBottom = stylePaddingBottom || 0;
-          const footerSize = peek$(ctx, "footerSize") || 0;
-          scrollToIndex(ctx, state, {
-            index,
-            viewOffset: -paddingBottom - footerSize + ((options == null ? void 0 : options.viewOffset) || 0),
-            viewPosition: 1,
-            ...options
-          });
-        }
-      },
-      scrollToIndex: (params) => scrollToIndex(ctx, state, params),
-      scrollToItem: ({ item, ...props2 }) => {
-        const data = refState.current.props.data;
-        const index = data.indexOf(item);
-        if (index !== -1) {
-          scrollToIndex(ctx, state, { index, ...props2 });
-        }
-      },
-      scrollToOffset: (params) => scrollTo(state, params),
-      setScrollProcessingEnabled: (enabled) => {
-        refState.current.scrollProcessingEnabled = enabled;
-      },
-      setVisibleContentAnchorOffset: (value) => {
-        const val = typeof value === "function" ? value(peek$(ctx, "scrollAdjustUserOffset") || 0) : value;
-        set$(ctx, "scrollAdjustUserOffset", val);
-      }
-    };
-  }, []);
+  useImperativeHandle(forwardedRef, () => createImperativeHandle(ctx, state), []);
   {
-    useEffect(() => {
-      if (initialContentOffset) {
-        scrollTo(state, { animated: false, offset: initialContentOffset, ...initialScroll || {} });
-      }
-    }, []);
+    useEffect(doInitialScroll, []);
   }
   const fns = useMemo(
     () => ({
@@ -3436,7 +3668,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       onMomentumScrollEnd: (event) => {
         {
           requestAnimationFrame(() => {
-            finishScrollTo(refState.current);
+            finishScrollTo(ctx, refState.current);
           });
         }
         if (onMomentumScrollEnd) {
@@ -3456,7 +3688,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
         }
       ),
       refScrollView: combinedRef,
-      scrollAdjustHandler: (_a3 = refState.current) == null ? void 0 : _a3.scrollAdjustHandler,
+      scrollAdjustHandler: (_b = refState.current) == null ? void 0 : _b.scrollAdjustHandler,
       scrollEventThrottle: 16 ,
       snapToIndices,
       stickyIndices,