@legendapp/list 3.2.0 → 3.3.1

package/react-native.js

@@ -1116,32 +1116,34 @@ function scheduleAdaptiveRenderExit(ctx, exitDelay) {
   const state = ctx.state;
   clearAdaptiveRenderExitTimeout(ctx);
   if (exitDelay <= 0) {
-    setAdaptiveRender(ctx, "normal");
+    setAdaptiveRender(ctx, "normal", "scroll");
   } else {
     const timeout = setTimeout(() => {
       state.timeouts.delete(timeout);
       state.timeoutAdaptiveRender = void 0;
-      setAdaptiveRender(ctx, "normal");
+      setAdaptiveRender(ctx, "normal", "scroll");
     }, exitDelay);
     state.timeoutAdaptiveRender = timeout;
     state.timeouts.add(timeout);
   }
 }
-function setAdaptiveRender(ctx, mode) {
+function setAdaptiveRender(ctx, mode, reason) {
   var _a3, _b;
   const previousMode = peek$(ctx, "adaptiveRender");
   if (previousMode !== mode) {
     set$(ctx, "adaptiveRender", mode);
-    (_b = (_a3 = ctx.state.props.adaptiveRender) == null ? void 0 : _a3.onChange) == null ? void 0 : _b.call(_a3, mode);
+    (_b = (_a3 = ctx.state.props.adaptiveRender) == null ? void 0 : _a3.onChange) == null ? void 0 : _b.call(_a3, mode, reason);
   }
 }
 function resetAdaptiveRender(ctx) {
+  var _a3, _b;
   clearAdaptiveRenderExitTimeout(ctx);
-  if (peek$(ctx, "adaptiveRender") !== "normal") {
-    setAdaptiveRender(ctx, "normal");
+  const mode = (_b = (_a3 = ctx.state.props.adaptiveRender) == null ? void 0 : _a3.initialMode) != null ? _b : "normal";
+  if (peek$(ctx, "adaptiveRender") !== mode) {
+    setAdaptiveRender(ctx, mode, "initial");
   }
 }
-function updateAdaptiveRender(ctx, scrollVelocity) {
+function updateAdaptiveRender(ctx, scrollVelocity, options) {
   var _a3, _b, _c;
   const state = ctx.state;
   const adaptiveRender = state.props.adaptiveRender;
@@ -1153,11 +1155,11 @@ function updateAdaptiveRender(ctx, scrollVelocity) {
       const exitVelocity = (_b = adaptiveRender.exitVelocity) != null ? _b : isWeb ? DEFAULT_WEB_ADAPTIVE_RENDER_EXIT_VELOCITY : DEFAULT_ADAPTIVE_RENDER_EXIT_VELOCITY;
       const exitDelay = (_c = adaptiveRender.exitDelay) != null ? _c : isWeb ? DEFAULT_WEB_ADAPTIVE_RENDER_EXIT_DELAY : DEFAULT_ADAPTIVE_RENDER_EXIT_DELAY;
       const threshold = currentMode === "light" ? exitVelocity : enterVelocity;
-      const nextMode = Math.abs(scrollVelocity) > threshold ? "light" : "normal";
+      const nextMode = (options == null ? void 0 : options.forceLight) || Math.abs(scrollVelocity) > threshold ? "light" : "normal";
       const previousMode = state.timeoutAdaptiveRender !== void 0 ? "normal" : currentMode;
       if (nextMode !== previousMode) {
         if (nextMode === "light") {
-          setAdaptiveRender(ctx, "light");
+          setAdaptiveRender(ctx, "light", "scroll");
           scheduleAdaptiveRenderExit(ctx, exitDelay);
         } else if (currentMode === "light") {
           scheduleAdaptiveRenderExit(ctx, exitDelay);
@@ -1170,16 +1172,43 @@ function updateAdaptiveRender(ctx, scrollVelocity) {
 }
 
 // src/utils/getEffectiveDrawDistance.ts
-var INITIAL_DRAW_DISTANCE = 100;
-function getEffectiveDrawDistance(ctx) {
+var INITIAL_DRAW_DISTANCE = 50;
+function getEffectiveDrawDistance(ctx, mode) {
   var _a3;
   const drawDistance = ctx.state.props.drawDistance;
   const initialScroll = ctx.state.initialScroll;
   const needsFullInitialDrawDistance = initialScroll !== void 0 && ((_a3 = initialScroll.viewPosition) != null ? _a3 : 0) > 0;
-  return peek$(ctx, "readyToRender") || needsFullInitialDrawDistance ? drawDistance : Math.min(drawDistance, INITIAL_DRAW_DISTANCE);
+  const shouldCapDrawDistance = mode === "visible-first" || mode !== "full" && !peek$(ctx, "readyToRender") && !needsFullInitialDrawDistance;
+  return shouldCapDrawDistance ? Math.min(drawDistance, INITIAL_DRAW_DISTANCE) : drawDistance;
+}
+function scheduleFullDrawDistancePrewarm(ctx) {
+  const { state } = ctx;
+  if (state.props.drawDistance <= INITIAL_DRAW_DISTANCE || state.queuedFullDrawDistancePrewarm !== void 0) {
+    return;
+  }
+  state.queuedFullDrawDistancePrewarm = requestAnimationFrame(() => {
+    var _a3;
+    state.queuedFullDrawDistancePrewarm = void 0;
+    (_a3 = state.triggerCalculateItemsInView) == null ? void 0 : _a3.call(state);
+  });
 }
 
 // src/utils/setInitialRenderState.ts
+function resetInitialRenderState(ctx, {
+  resetLayout,
+  resetInitialScroll
+}) {
+  const { state } = ctx;
+  if (resetLayout) {
+    state.didContainersLayout = false;
+    state.queuedInitialLayout = false;
+  }
+  if (resetInitialScroll) {
+    state.didFinishInitialScroll = false;
+  }
+  set$(ctx, "readyToRender", false);
+  resetAdaptiveRender(ctx);
+}
 function setInitialRenderState(ctx, {
   didLayout,
   didInitialScroll
@@ -1198,15 +1227,15 @@ function setInitialRenderState(ctx, {
   const isReadyToRender = Boolean(state.didContainersLayout && state.didFinishInitialScroll);
   if (isReadyToRender && !peek$(ctx, "readyToRender")) {
     set$(ctx, "readyToRender", true);
-    setAdaptiveRender(ctx, "normal");
+    setAdaptiveRender(ctx, "normal", "ready");
     if (state.props.drawDistance > INITIAL_DRAW_DISTANCE) {
-      requestAnimationFrame(() => {
-        var _a3;
-        (_a3 = state.triggerCalculateItemsInView) == null ? void 0 : _a3.call(state);
-      });
+      scheduleFullDrawDistancePrewarm(ctx);
     }
-    if (onLoad) {
-      onLoad({ elapsedTimeInMs: Date.now() - loadStartTime });
+    if (!state.didLoad) {
+      state.didLoad = true;
+      if (onLoad) {
+        onLoad({ elapsedTimeInMs: Date.now() - loadStartTime });
+      }
     }
   }
 }
@@ -1505,6 +1534,7 @@ function finishScrollTo(ctx) {
     const scrollingTo = state.scrollingTo;
     state.scrollHistory.length = 0;
     state.scrollingTo = void 0;
+    state.scrollTargetPinnedRange = void 0;
     if (state.pendingTotalSize !== void 0) {
       addTotalSize(ctx, null, state.pendingTotalSize);
     }
@@ -1735,8 +1765,8 @@ function doMaintainScrollAtEnd(ctx) {
     state.pendingMaintainScrollAtEnd = shouldMaintainScrollAtEnd;
     return false;
   }
-  state.pendingMaintainScrollAtEnd = false;
   if (shouldMaintainScrollAtEnd) {
+    state.pendingMaintainScrollAtEnd = false;
     const contentSize = getContentSize(ctx);
     if (contentSize < state.scrollLength) {
       state.scroll = 0;
@@ -1767,6 +1797,9 @@ function doMaintainScrollAtEnd(ctx) {
             () => {
               if (state.maintainingScrollAtEnd === activeState) {
                 state.maintainingScrollAtEnd = void 0;
+                if (state.pendingMaintainScrollAtEnd) {
+                  doMaintainScrollAtEnd(ctx);
+                }
               }
             },
             maintainScrollAtEnd.animated ? 500 : 0
@@ -1775,9 +1808,12 @@ function doMaintainScrollAtEnd(ctx) {
           state.maintainingScrollAtEnd = void 0;
         }
       });
+    } else {
+      state.pendingMaintainScrollAtEnd = true;
     }
     return true;
   }
+  state.pendingMaintainScrollAtEnd = false;
   return false;
 }
 
@@ -2138,6 +2174,8 @@ var flushSync = (fn) => {
 };
 
 // src/utils/getScrollVelocity.ts
+var MAX_SCROLL_VELOCITY_WINDOW_MS = 1e3;
+var SCROLL_VELOCITY_HALF_LIFE_MS = 200;
 var getScrollVelocity = (state) => {
   const { scrollHistory } = state;
   const newestIndex = scrollHistory.length - 1;
@@ -2145,35 +2183,37 @@ var getScrollVelocity = (state) => {
     return 0;
   }
   const newest = scrollHistory[newestIndex];
-  const now = Date.now();
-  let direction = 0;
-  for (let i = newestIndex; i > 0; i--) {
-    const delta = scrollHistory[i].scroll - scrollHistory[i - 1].scroll;
-    if (delta !== 0) {
-      direction = Math.sign(delta);
-      break;
-    }
-  }
-  if (direction === 0) {
+  if (Date.now() - newest.time > MAX_SCROLL_VELOCITY_WINDOW_MS) {
     return 0;
   }
-  let oldest = newest;
-  for (let i = newestIndex - 1; i >= 0; i--) {
+  let direction = 0;
+  let weightedVelocity = 0;
+  let totalWeight = 0;
+  for (let i = newestIndex; i > 0; i--) {
     const current = scrollHistory[i];
-    const next = scrollHistory[i + 1];
-    const delta = next.scroll - current.scroll;
-    const deltaSign = Math.sign(delta);
-    if (deltaSign !== 0 && deltaSign !== direction) {
-      break;
+    const previous = scrollHistory[i - 1];
+    const scrollDiff = current.scroll - previous.scroll;
+    const timeDiff = current.time - previous.time;
+    const deltaSign = Math.sign(scrollDiff);
+    if (deltaSign !== 0) {
+      if (direction === 0) {
+        direction = deltaSign;
+      } else if (deltaSign !== direction) {
+        break;
+      }
     }
-    if (now - current.time > 1e3) {
+    if (newest.time - previous.time > MAX_SCROLL_VELOCITY_WINDOW_MS) {
       break;
     }
-    oldest = current;
+    if (scrollDiff === 0 || timeDiff <= 0) {
+      continue;
+    }
+    const age = newest.time - current.time;
+    const weight = Math.exp(-age / SCROLL_VELOCITY_HALF_LIFE_MS);
+    weightedVelocity += scrollDiff / timeDiff * weight;
+    totalWeight += weight;
   }
-  const scrollDiff = newest.scroll - oldest.scroll;
-  const timeDiff = newest.time - oldest.time;
-  return timeDiff > 0 ? scrollDiff / timeDiff : 0;
+  return totalWeight > 0 ? weightedVelocity / totalWeight : 0;
 };
 
 // src/core/updateScroll.ts
@@ -2201,8 +2241,6 @@ function updateScroll(ctx, newScroll, forceUpdate, options) {
   if (scrollHistory.length > 5) {
     scrollHistory.shift();
   }
-  const scrollVelocity = getScrollVelocity(state);
-  updateAdaptiveRender(ctx, scrollVelocity);
   if (ignoreScrollFromMVCP && !scrollingTo) {
     const { lt, gt } = ignoreScrollFromMVCP;
     if (lt && newScroll < lt || gt && newScroll > gt) {
@@ -2217,6 +2255,9 @@ function updateScroll(ctx, newScroll, forceUpdate, options) {
   const scrollDelta = Math.abs(newScroll - prevScroll);
   const didResolvePendingNativeMVCPAdjust = resolvePendingNativeMVCPAdjust(ctx, newScroll);
   const scrollLength = state.scrollLength;
+  const isLargeUserScrollJump = scrollLength > 0 && scrollingTo === void 0 && scrollDelta > scrollLength && !state.pendingNativeMVCPAdjust;
+  const scrollVelocity = getScrollVelocity(state);
+  updateAdaptiveRender(ctx, scrollVelocity, { forceLight: isLargeUserScrollJump });
   const lastCalculated = state.scrollLastCalculate;
   const useAggressiveItemRecalculation = isInMVCPActiveMode(state);
   const shouldUpdate = useAggressiveItemRecalculation || didResolvePendingNativeMVCPAdjust || forceUpdate || lastCalculated === void 0 || Math.abs(state.scroll - lastCalculated) > 2;
@@ -2226,10 +2267,17 @@ function updateScroll(ctx, newScroll, forceUpdate, options) {
     state.lastScrollDelta = scrollDelta;
     const runCalculateItems = () => {
       var _a4;
-      (_a4 = state.triggerCalculateItemsInView) == null ? void 0 : _a4.call(state, { doMVCP: scrollingTo !== void 0, scrollVelocity });
+      const calculateItemsParams = {
+        doMVCP: scrollingTo !== void 0,
+        scrollVelocity
+      };
+      if (isLargeUserScrollJump) {
+        calculateItemsParams.drawDistanceMode = "visible-first";
+      }
+      (_a4 = state.triggerCalculateItemsInView) == null ? void 0 : _a4.call(state, calculateItemsParams);
       checkThresholds(ctx);
     };
-    if (scrollLength > 0 && scrollingTo === void 0 && scrollDelta > scrollLength && !state.pendingNativeMVCPAdjust) {
+    if (isLargeUserScrollJump) {
       state.mvcpAnchorLock = void 0;
       state.pendingNativeMVCPAdjust = void 0;
       state.userScrollAnchorReset = { keys: /* @__PURE__ */ new Set() };
@@ -2238,6 +2286,7 @@ function updateScroll(ctx, newScroll, forceUpdate, options) {
         state.queuedMVCPRecalculate = void 0;
       }
       flushSync(runCalculateItems);
+      scheduleFullDrawDistancePrewarm(ctx);
     } else {
       runCalculateItems();
     }
@@ -2281,8 +2330,93 @@ function syncInitialScrollNativeWatchdog(state, options) {
     initialScrollWatchdog.clear(state);
   }
 }
-function scrollTo(ctx, params) {
+function findPositionIndexAtOrBeforeOffset(ctx, offset) {
+  const state = ctx.state;
+  const dataLength = state.props.data.length;
+  let low = 0;
+  let high = dataLength - 1;
+  let match;
+  while (low <= high) {
+    const mid = Math.floor((low + high) / 2);
+    const top = state.positions[mid];
+    if (top === void 0) {
+      high = mid - 1;
+    } else {
+      if (top <= offset) {
+        match = mid;
+        low = mid + 1;
+      } else {
+        high = mid - 1;
+      }
+    }
+  }
+  return match;
+}
+function getItemBottom(ctx, index) {
   var _a3;
+  const top = ctx.state.positions[index];
+  if (top === void 0) {
+    return void 0;
+  }
+  const itemSize = (_a3 = getItemSizeAtIndex(ctx, index)) != null ? _a3 : 0;
+  return top + (Number.isFinite(itemSize) ? itemSize : 0);
+}
+function getTargetViewportRenderRange(ctx, targetOffset, targetIndex) {
+  const state = ctx.state;
+  const dataLength = state.props.data.length;
+  if (dataLength === 0) {
+    return void 0;
+  }
+  const viewportStart = Math.max(0, targetOffset);
+  const viewportEnd = Math.max(viewportStart, targetOffset + state.scrollLength);
+  let start = targetIndex !== void 0 ? Math.max(0, Math.min(dataLength - 1, targetIndex)) : findPositionIndexAtOrBeforeOffset(ctx, viewportStart);
+  if (start === void 0) {
+    return void 0;
+  }
+  if (targetIndex !== void 0 && state.positions[start] === void 0) {
+    return { end: start, start };
+  }
+  if (targetIndex === void 0) {
+    const startBottom = getItemBottom(ctx, start);
+    if (startBottom === void 0 || startBottom <= viewportStart) {
+      return void 0;
+    }
+  }
+  while (start > 0) {
+    const top = state.positions[start];
+    if (top === void 0 || top <= viewportStart || state.positions[start - 1] === void 0) {
+      break;
+    }
+    start--;
+  }
+  while (start > 0) {
+    const previousBottom = getItemBottom(ctx, start - 1);
+    if (previousBottom === void 0 || previousBottom <= viewportStart) {
+      break;
+    }
+    start--;
+  }
+  let end = start;
+  while (end + 1 < dataLength) {
+    const nextTop = state.positions[end + 1];
+    if (nextTop === void 0 || nextTop > viewportEnd) {
+      break;
+    }
+    end++;
+  }
+  return { end, start };
+}
+function pinScrollTargetRenderRange(ctx, targetOffset, targetIndex) {
+  const range = getTargetViewportRenderRange(ctx, targetOffset, targetIndex);
+  if (range) {
+    ctx.state.scrollTargetPinnedRange = range;
+    ctx.state.scrollForNextCalculateItemsInView = void 0;
+  } else {
+    ctx.state.scrollTargetPinnedRange = void 0;
+  }
+}
+function scrollTo(ctx, params) {
+  var _a3, _b;
   const state = ctx.state;
   const { noScrollingTo, forceScroll, ...scrollTarget } = params;
   const {
@@ -2317,11 +2451,20 @@ function scrollTo(ctx, params) {
       targetOffset,
       waitForInitialScrollCompletionFrame
     };
+    if (!isInitialScroll) {
+      pinScrollTargetRenderRange(ctx, targetOffset, scrollTarget.index);
+    }
   }
   state.scrollPending = targetOffset;
   syncInitialScrollNativeWatchdog(state, { isInitialScroll, requestedOffset: offset, targetOffset });
-  if (!animated && !isInitialScroll && !noScrollingTo && Math.abs(state.scroll - targetOffset) > 1) {
-    updateScroll(ctx, targetOffset, false, { markHasScrolled: false });
+  if (!isInitialScroll && !noScrollingTo && Math.abs(state.scroll - targetOffset) > 1) {
+    if (animated) {
+      if (state.scrollTargetPinnedRange) {
+        (_b = state.triggerCalculateItemsInView) == null ? void 0 : _b.call(state);
+      }
+    } else {
+      updateScroll(ctx, targetOffset, true, { markHasScrolled: false });
+    }
   }
   if (forceScroll || !isInitialScroll || Platform.OS === "android") {
     doScrollTo(ctx, { animated, horizontal, isInitialScroll, offset });
@@ -2392,16 +2535,17 @@ function dispatchInitialScroll(ctx, params) {
     waitForInitialScrollCompletionFrame: waitForCompletionFrame
   });
 }
-function setInitialScrollTarget(state, target, options) {
+function setInitialScrollTarget(ctx, target, options) {
   var _a3;
+  const { state } = ctx;
   state.clearPreservedInitialScrollOnNextFinish = void 0;
   if (state.timeoutPreservedInitialScrollClear !== void 0) {
     clearTimeout(state.timeoutPreservedInitialScrollClear);
     state.timeoutPreservedInitialScrollClear = void 0;
   }
   state.initialScroll = target;
-  if ((options == null ? void 0 : options.resetDidFinish) && state.didFinishInitialScroll) {
-    state.didFinishInitialScroll = false;
+  if (options == null ? void 0 : options.resetDidFinish) {
+    resetInitialRenderState(ctx, { resetInitialScroll: true });
   }
   setInitialScrollSession(state, {
     kind: ((_a3 = state.initialScrollSession) == null ? void 0 : _a3.kind) === "offset" ? "offset" : "bootstrap"
@@ -2455,7 +2599,7 @@ function advanceMeasuredInitialScroll(ctx, options) {
     return false;
   }
   if (didOffsetChange && ((_b = state.initialScrollSession) == null ? void 0 : _b.kind) !== "offset") {
-    setInitialScrollTarget(state, { ...initialScroll, contentOffset: resolvedOffset });
+    setInitialScrollTarget(ctx, { ...initialScroll, contentOffset: resolvedOffset });
   }
   const forceScroll = (_c = options == null ? void 0 : options.forceScroll) != null ? _c : !!queuedInitialLayout || isInitialScrollInProgress && didOffsetChange;
   dispatchInitialScroll(ctx, {
@@ -2728,7 +2872,6 @@ function areEquivalentBootstrapInitialScrollTargets(current, next) {
 }
 function clearPendingInitialScrollFooterLayout(ctx, options) {
   const { dataLength, stylePaddingBottom, target } = options;
-  const state = ctx.state;
   if (!shouldPreserveInitialScrollForFooterLayout(target)) {
     return;
   }
@@ -2738,7 +2881,7 @@ function clearPendingInitialScrollFooterLayout(ctx, options) {
     preserveForFooterLayout: void 0,
     stylePaddingBottom
   });
-  setInitialScrollTarget(state, clearedFooterTarget);
+  setInitialScrollTarget(ctx, clearedFooterTarget);
 }
 function clearFinishedViewportRetargetableInitialScroll(state) {
   clearPreservedInitialScrollTarget(state);
@@ -2885,7 +3028,7 @@ function handleBootstrapInitialScrollDataChange(ctx, options) {
       return;
     }
     if (!areEquivalentBootstrapInitialScrollTargets(initialScroll, updatedInitialScroll) || !!bootstrapInitialScroll || shouldResetDidFinish || didDataChange) {
-      setInitialScrollTarget(state, updatedInitialScroll, {
+      setInitialScrollTarget(ctx, updatedInitialScroll, {
         resetDidFinish: shouldResetDidFinish
       });
       rearmBootstrapInitialScroll(ctx, {
@@ -2900,7 +3043,7 @@ function handleBootstrapInitialScrollDataChange(ctx, options) {
     return;
   }
   if (bootstrapInitialScroll || shouldResetDidFinish) {
-    setInitialScrollTarget(state, initialScroll, {
+    setInitialScrollTarget(ctx, initialScroll, {
       resetDidFinish: shouldResetDidFinish
     });
     rearmBootstrapInitialScroll(ctx, {
@@ -2946,7 +3089,7 @@ function handleBootstrapInitialScrollFooterLayout(ctx, options) {
       });
     } else {
       const didFinishInitialScroll = !!state.didFinishInitialScroll;
-      setInitialScrollTarget(state, updatedInitialScroll, {
+      setInitialScrollTarget(ctx, updatedInitialScroll, {
         resetDidFinish: didFinishInitialScroll
       });
       rearmBootstrapInitialScroll(ctx, {
@@ -3135,7 +3278,7 @@ function initializeInitialScrollOnMount(ctx, options) {
   const resolvedInitialContentOffset = initialContentOffset != null ? initialContentOffset : 0;
   const preserveForFooterLayout = useBootstrapInitialScroll && initialScrollAtEnd && hasFooterComponent;
   if (initialScroll && (initialScroll.contentOffset === void 0 || !!initialScroll.preserveForFooterLayout !== preserveForFooterLayout && ((_a3 = state.initialScrollSession) == null ? void 0 : _a3.kind) !== "offset")) {
-    setInitialScrollTarget(state, {
+    setInitialScrollTarget(ctx, {
       ...initialScroll,
       contentOffset: resolvedInitialContentOffset,
       preserveForFooterLayout
@@ -3164,6 +3307,7 @@ function handleInitialScrollDataChange(ctx, options) {
   const {
     dataLength,
     didDataChange,
+    didStartFreshData,
     initialScrollAtEnd,
     latestInitialScroll,
     latestInitialScrollSessionKind,
@@ -3171,17 +3315,17 @@ function handleInitialScrollDataChange(ctx, options) {
     useBootstrapInitialScroll
   } = options;
   const state = ctx.state;
-  const previousDataLength = (_b = (_a3 = state.initialScrollSession) == null ? void 0 : _a3.previousDataLength) != null ? _b : 0;
-  const isFirstNonEmptyData = !state.hasHadNonEmptyData && dataLength > 0;
+  const previousInitialScrollDataLength = (_b = (_a3 = state.initialScrollSession) == null ? void 0 : _a3.previousDataLength) != null ? _b : 0;
+  const shouldUseLatestInitialScroll = dataLength > 0 && (!state.hasHadNonEmptyData || didStartFreshData);
   if (dataLength > 0) {
     state.hasHadNonEmptyData = true;
   }
-  if (isFirstNonEmptyData) {
+  if (shouldUseLatestInitialScroll) {
     if (latestInitialScroll) {
-      setInitialScrollTarget(state, latestInitialScroll);
+      setInitialScrollTarget(ctx, latestInitialScroll);
       setInitialScrollSession(state, {
         kind: latestInitialScrollSessionKind,
-        previousDataLength
+        previousDataLength: previousInitialScrollDataLength
       });
     } else {
       clearPreservedInitialScrollTarget(state);
@@ -3196,17 +3340,17 @@ function handleInitialScrollDataChange(ctx, options) {
       dataLength,
       didDataChange,
       initialScrollAtEnd,
-      previousDataLength,
+      previousDataLength: previousInitialScrollDataLength,
       stylePaddingBottom
     });
     return;
   }
-  const shouldReplayFinishedOffsetInitialScroll = previousDataLength === 0 && dataLength > 0 && !!state.initialScroll && ((_c = ctx.state.initialScrollSession) == null ? void 0 : _c.kind) === "offset" && !!state.didFinishInitialScroll;
-  if (previousDataLength !== 0 || dataLength === 0 || !state.initialScroll || !state.queuedInitialLayout || state.didFinishInitialScroll && !shouldReplayFinishedOffsetInitialScroll) {
+  const shouldReplayFinishedOffsetInitialScroll = previousInitialScrollDataLength === 0 && dataLength > 0 && !!state.initialScroll && ((_c = ctx.state.initialScrollSession) == null ? void 0 : _c.kind) === "offset" && !!state.didFinishInitialScroll;
+  if (previousInitialScrollDataLength !== 0 || dataLength === 0 || !state.initialScroll || !state.queuedInitialLayout || state.didFinishInitialScroll && !shouldReplayFinishedOffsetInitialScroll) {
     return;
   }
   if (shouldReplayFinishedOffsetInitialScroll) {
-    state.didFinishInitialScroll = false;
+    resetInitialRenderState(ctx, { resetInitialScroll: true });
   }
   advanceCurrentInitialScrollSession(ctx);
 }
@@ -3992,6 +4136,32 @@ function setDidLayout(ctx) {
 }
 
 // src/core/calculateItemsInView.ts
+var RENDER_RANGE_PROJECTION_FULL_VELOCITY = 4;
+var RENDER_RANGE_PROJECTION_SETTLE_DELAY = 100;
+function getProjectedBufferAdjustment(scrollVelocity, trailingBuffer) {
+  if (trailingBuffer <= 0) {
+    return 0;
+  }
+  const velocityProgress = Math.min(1, Math.abs(scrollVelocity) / RENDER_RANGE_PROJECTION_FULL_VELOCITY);
+  return Math.sign(scrollVelocity) * trailingBuffer * velocityProgress;
+}
+function scheduleRenderRangeProjectionSettle(ctx) {
+  const state = ctx.state;
+  const previousTimeout = state.timeoutRenderRangeProjectionSettle;
+  if (previousTimeout !== void 0) {
+    clearTimeout(previousTimeout);
+    state.timeouts.delete(previousTimeout);
+  }
+  const timeout = setTimeout(() => {
+    var _a3;
+    state.timeoutRenderRangeProjectionSettle = void 0;
+    state.timeouts.delete(timeout);
+    state.scrollHistory.length = 0;
+    (_a3 = state.triggerCalculateItemsInView) == null ? void 0 : _a3.call(state);
+  }, RENDER_RANGE_PROJECTION_SETTLE_DELAY);
+  state.timeoutRenderRangeProjectionSettle = timeout;
+  state.timeouts.add(timeout);
+}
 function findCurrentStickyIndex(stickyArray, scroll, state) {
   const positions = state.positions;
   for (let i = stickyArray.length - 1; i >= 0; i--) {
@@ -4032,14 +4202,14 @@ function handleStickyActivation(ctx, stickyArray, currentStickyIdx, needNewConta
     }
   }
 }
-function handleStickyRecycling(ctx, stickyArray, scroll, drawDistance, currentStickyIdx, pendingRemoval, alwaysRenderIndicesSet) {
+function handleStickyRecycling(ctx, stickyArray, scroll, drawDistance, currentStickyIdx, pendingRemoval, isPinnedRenderIndex) {
   var _a3, _b;
   const state = ctx.state;
   for (const containerIndex of state.stickyContainerPool) {
     const itemKey = peek$(ctx, `containerItemKey${containerIndex}`);
     const itemIndex = itemKey ? state.indexByKey.get(itemKey) : void 0;
     if (itemIndex === void 0) continue;
-    if (alwaysRenderIndicesSet.has(itemIndex)) continue;
+    if (isPinnedRenderIndex(itemIndex)) continue;
     const arrayIdx = stickyArray.indexOf(itemIndex);
     if (arrayIdx === -1) {
       state.stickyContainerPool.delete(containerIndex);
@@ -4203,9 +4373,7 @@ function calculateItemsInView(ctx, params = {}) {
     const { data } = state.props;
     const stickyHeaderIndicesArr = state.props.stickyHeaderIndicesArr || [];
     const stickyHeaderIndicesSet = state.props.stickyHeaderIndicesSet || /* @__PURE__ */ new Set();
-    const alwaysRenderArr = alwaysRenderIndicesArr || [];
-    const alwaysRenderSet = alwaysRenderIndicesSet || /* @__PURE__ */ new Set();
-    const drawDistance = getEffectiveDrawDistance(ctx);
+    const drawDistance = getEffectiveDrawDistance(ctx, params.drawDistanceMode);
     const { dataChanged, doMVCP, forceFullItemPositions } = params;
     const bootstrapInitialScrollState = ((_a3 = state.initialScrollSession) == null ? void 0 : _a3.kind) === "bootstrap" ? state.initialScrollSession.bootstrap : void 0;
     const suppressInitialScrollSideEffects = !!bootstrapInitialScrollState;
@@ -4271,14 +4439,19 @@ function calculateItemsInView(ctx, params = {}) {
       scrollBufferTop = drawDistance * 1.5;
       scrollBufferBottom = drawDistance * 0.5;
     }
+    const shouldProjectRenderRange = !dataChanged && !forceFullItemPositions && !suppressInitialScrollSideEffects && !hasActiveInitialScroll(state) && !state.scrollingTo && !state.pendingNativeMVCPAdjust && !!peek$(ctx, "readyToRender");
+    const projectedBufferAdjustment = shouldProjectRenderRange ? getProjectedBufferAdjustment(speed, Math.min(scrollBufferTop, scrollBufferBottom)) : 0;
     const updateScrollRange = () => {
       const scrollStart = Math.max(0, scroll);
       const overscrollBeforeContent = Math.max(0, -nativeScrollState);
-      scrollTopBuffered = scrollStart - scrollBufferTop;
       scrollBottom = Math.max(scrollStart, scroll + scrollLength + overscrollBeforeContent);
-      scrollBottomBuffered = scrollBottom + scrollBufferBottom;
+      scrollTopBuffered = scrollStart - scrollBufferTop + projectedBufferAdjustment;
+      scrollBottomBuffered = scrollBottom + scrollBufferBottom + projectedBufferAdjustment;
     };
     updateScrollRange();
+    if (projectedBufferAdjustment !== 0) {
+      scheduleRenderRangeProjectionSettle(ctx);
+    }
     if (enableScrollForNextCalculateItemsInView && !suppressInitialScrollSideEffects && !dataChanged && !forceFullItemPositions && scrollForNextCalculateItemsInView) {
       const { top, bottom } = scrollForNextCalculateItemsInView;
       if (top === null && bottom === null) {
@@ -4436,9 +4609,34 @@ function calculateItemsInView(ctx, params = {}) {
         }
       }
     }
+    const scrollTargetPinnedRange = state.scrollTargetPinnedRange;
+    let scrollTargetPinnedStart = 0;
+    let scrollTargetPinnedEnd = -1;
+    if (scrollTargetPinnedRange) {
+      scrollTargetPinnedStart = Math.max(0, Math.min(scrollTargetPinnedRange.start, scrollTargetPinnedRange.end));
+      scrollTargetPinnedEnd = Math.min(
+        dataLength - 1,
+        Math.max(scrollTargetPinnedRange.start, scrollTargetPinnedRange.end)
+      );
+    }
+    const hasScrollTargetPinnedRange = scrollTargetPinnedStart <= scrollTargetPinnedEnd;
+    const isPinnedRenderIndex = (index) => alwaysRenderIndicesSet.has(index) || hasScrollTargetPinnedRange && index >= scrollTargetPinnedStart && index <= scrollTargetPinnedEnd;
     if (startBuffered !== null && endBuffered !== null) {
       const needNewContainers = [];
       const needNewContainersSet = /* @__PURE__ */ new Set();
+      const addPinnedIndex = (index) => {
+        var _a4;
+        if (index >= 0 && index < dataLength) {
+          const id = (_a4 = idCache[index]) != null ? _a4 : getId(state, index);
+          const containerIndex = containerItemKeys.get(id);
+          if (containerIndex !== void 0) {
+            state.stickyContainerPool.add(containerIndex);
+          } else if (!isNullOrUndefined(id) && !needNewContainersSet.has(index)) {
+            needNewContainersSet.add(index);
+            needNewContainers.push(index);
+          }
+        }
+      };
       for (let i = startBuffered; i <= endBuffered; i++) {
         const id = (_m = idCache[i]) != null ? _m : getId(state, i);
         if (!containerItemKeys.has(id)) {
@@ -4446,21 +4644,19 @@ function calculateItemsInView(ctx, params = {}) {
           needNewContainers.push(i);
         }
       }
-      if (alwaysRenderArr.length > 0) {
-        for (const index of alwaysRenderArr) {
-          if (index < 0 || index >= dataLength) continue;
-          const id = (_n = idCache[index]) != null ? _n : getId(state, index);
-          if (id && !containerItemKeys.has(id) && !needNewContainersSet.has(index)) {
-            needNewContainersSet.add(index);
-            needNewContainers.push(index);
-          }
+      for (const index of alwaysRenderIndicesArr) {
+        addPinnedIndex(index);
+      }
+      if (hasScrollTargetPinnedRange) {
+        for (let index = scrollTargetPinnedStart; index <= scrollTargetPinnedEnd; index++) {
+          addPinnedIndex(index);
         }
       }
       if (stickyHeaderIndicesArr.length > 0) {
         handleStickyActivation(
           ctx,
           stickyHeaderIndicesArr,
-          (_o = stickyState == null ? void 0 : stickyState.currentStickyIdx) != null ? _o : -1,
+          (_n = stickyState == null ? void 0 : stickyState.currentStickyIdx) != null ? _n : -1,
           needNewContainers,
           needNewContainersSet,
           startBuffered,
@@ -4486,7 +4682,7 @@ function calculateItemsInView(ctx, params = {}) {
         for (const allocation of availableContainerAllocations) {
           const i = allocation.itemIndex;
           const containerIndex = allocation.containerIndex;
-          const id = (_p = idCache[i]) != null ? _p : getId(state, i);
+          const id = (_o = idCache[i]) != null ? _o : getId(state, i);
           const oldKey = peek$(ctx, `containerItemKey${containerIndex}`);
           if (oldKey && oldKey !== id) {
             containerItemKeys.delete(oldKey);
@@ -4497,10 +4693,14 @@ function calculateItemsInView(ctx, params = {}) {
             state.containerItemTypes.set(containerIndex, allocation.itemType);
           }
           containerItemKeys.set(id, containerIndex);
-          (_q = state.userScrollAnchorReset) == null ? void 0 : _q.keys.add(id);
+          (_p = state.userScrollAnchorReset) == null ? void 0 : _p.keys.add(id);
+          if (IsNewArchitecture) {
+            (_q = state.pendingLayoutEffectMeasurements) != null ? _q : state.pendingLayoutEffectMeasurements = /* @__PURE__ */ new Set();
+            state.pendingLayoutEffectMeasurements.add(id);
+          }
           const containerSticky = `containerSticky${containerIndex}`;
           const isSticky = stickyHeaderIndicesSet.has(i);
-          const isAlwaysRender = alwaysRenderSet.has(i);
+          const isPinnedRender = isPinnedRenderIndex(i);
           if (isSticky) {
             set$(ctx, containerSticky, true);
             state.stickyContainerPool.add(containerIndex);
@@ -4508,9 +4708,9 @@ function calculateItemsInView(ctx, params = {}) {
             if (peek$(ctx, containerSticky)) {
               set$(ctx, containerSticky, false);
             }
-            if (isAlwaysRender) {
+            if (isPinnedRender) {
               state.stickyContainerPool.add(containerIndex);
-            } else if (state.stickyContainerPool.has(containerIndex)) {
+            } else {
               state.stickyContainerPool.delete(containerIndex);
             }
           }
@@ -4525,20 +4725,8 @@ function calculateItemsInView(ctx, params = {}) {
           }
         }
       }
-      if (state.userScrollAnchorReset) {
-        if (state.userScrollAnchorReset.keys.size === 0) {
-          state.userScrollAnchorReset = void 0;
-        }
-      }
-      if (alwaysRenderArr.length > 0) {
-        for (const index of alwaysRenderArr) {
-          if (index < 0 || index >= dataLength) continue;
-          const id = (_r = idCache[index]) != null ? _r : getId(state, index);
-          const containerIndex = containerItemKeys.get(id);
-          if (containerIndex !== void 0) {
-            state.stickyContainerPool.add(containerIndex);
-          }
-        }
+      if (((_r = state.userScrollAnchorReset) == null ? void 0 : _r.keys.size) === 0) {
+        state.userScrollAnchorReset = void 0;
       }
     }
     if (state.stickyContainerPool.size > 0) {
@@ -4549,7 +4737,7 @@ function calculateItemsInView(ctx, params = {}) {
         drawDistance,
         (_s = stickyState == null ? void 0 : stickyState.currentStickyIdx) != null ? _s : -1,
         pendingRemoval,
-        alwaysRenderSet
+        isPinnedRenderIndex
       );
     }
     const pendingRemovalSet = pendingRemoval.length > 0 ? new Set(pendingRemoval) : void 0;
@@ -4721,6 +4909,36 @@ function mergeItemSizeUpdateResult(result, next) {
   result.needsRecalculate || (result.needsRecalculate = next.needsRecalculate);
   result.shouldMaintainScrollAtEnd || (result.shouldMaintainScrollAtEnd = next.shouldMaintainScrollAtEnd);
 }
+var batchedItemSizeRecalculates = /* @__PURE__ */ new WeakMap();
+function flushBatchedItemSizeRecalculate(ctx, didFallback = false, expectedResult) {
+  const result = batchedItemSizeRecalculates.get(ctx);
+  if (!result || expectedResult && result !== expectedResult) {
+    return;
+  }
+  batchedItemSizeRecalculates.delete(ctx);
+  if (didFallback) {
+    ctx.state.pendingLayoutEffectMeasurements = void 0;
+  }
+  flushItemSizeUpdates(ctx, result);
+}
+function queueItemSizeRecalculate(ctx, result) {
+  var _a3, _b;
+  const batch = batchedItemSizeRecalculates.get(ctx);
+  if (batch) {
+    mergeItemSizeUpdateResult(batch, result);
+  } else {
+    const nextBatch = { ...result };
+    batchedItemSizeRecalculates.set(ctx, nextBatch);
+    if ((_a3 = ctx.state.pendingLayoutEffectMeasurements) == null ? void 0 : _a3.size) {
+      requestAnimationFrame(() => {
+        flushBatchedItemSizeRecalculate(ctx, true, nextBatch);
+      });
+    }
+  }
+  if (!((_b = ctx.state.pendingLayoutEffectMeasurements) == null ? void 0 : _b.size)) {
+    flushBatchedItemSizeRecalculate(ctx);
+  }
+}
 function flushItemSizeUpdates(ctx, result) {
   var _a3;
   const state = ctx.state;
@@ -4737,12 +4955,22 @@ function flushItemSizeUpdates(ctx, result) {
 function updateItemSizes(ctx, measurement) {
   var _a3, _b, _c, _d;
   const state = ctx.state;
+  let didDrainLayoutEffectMeasurements = false;
+  if (IsNewArchitecture && measurement.fromLayoutEffect) {
+    const pendingLayoutEffectMeasurements = state.pendingLayoutEffectMeasurements;
+    if ((pendingLayoutEffectMeasurements == null ? void 0 : pendingLayoutEffectMeasurements.delete(measurement.itemKey)) && pendingLayoutEffectMeasurements.size === 0) {
+      state.pendingLayoutEffectMeasurements = void 0;
+      didDrainLayoutEffectMeasurements = true;
+    }
+  }
   const pendingKeys = (_a3 = state.userScrollAnchorReset) == null ? void 0 : _a3.keys;
   const shouldBatchPendingMeasurements = IsNewArchitecture && measurement.fromLayoutEffect && !!(pendingKeys == null ? void 0 : pendingKeys.size);
+  const shouldQueueRecalculate = IsNewArchitecture && !!measurement.fromLayoutEffect;
+  let result;
   if (!shouldBatchPendingMeasurements) {
-    flushItemSizeUpdates(ctx, applyItemSize(ctx, measurement.itemKey, measurement.size));
+    result = applyItemSize(ctx, measurement.itemKey, measurement.size);
   } else {
-    const result = {};
+    result = {};
     const updateContainerItemSize = (itemKey, containerId, size) => {
       if (containerId !== void 0 && peek$(ctx, `containerItemKey${containerId}`) === itemKey) {
         mergeItemSizeUpdateResult(result, applyItemSize(ctx, itemKey, size));
@@ -4760,8 +4988,15 @@ function updateItemSizes(ctx, measurement) {
         });
       }
     }
+  }
+  if (shouldQueueRecalculate && result.needsRecalculate) {
+    queueItemSizeRecalculate(ctx, result);
+  } else {
     flushItemSizeUpdates(ctx, result);
   }
+  if (didDrainLayoutEffectMeasurements) {
+    flushBatchedItemSizeRecalculate(ctx);
+  }
 }
 function applyItemSize(ctx, itemKey, sizeObj) {
   var _a3;
@@ -6442,7 +6677,7 @@ var LegendList = typedMemo(
   })
 );
 var LegendListInner = typedForwardRef(function LegendListInner2(props, forwardedRef) {
-  var _a3, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p;
+  var _a3, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r;
   const noopOnScroll = React2.useCallback((_event) => {
   }, []);
   if (props.recycleItems === void 0) {
@@ -6459,6 +6694,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     contentContainerStyle: contentContainerStyleProp,
     contentInset,
     data: dataProp = [],
+    dataKey,
     dataVersion,
     drawDistance = 250,
     contentInsetEndAdjustment,
@@ -6589,6 +6825,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     (_j = alwaysRender == null ? void 0 : alwaysRender.indices) == null ? void 0 : _j.join(","),
     (_k = alwaysRender == null ? void 0 : alwaysRender.keys) == null ? void 0 : _k.join(","),
     dataProp,
+    dataKey,
     dataVersion,
     keyExtractor
   ]);
@@ -6611,6 +6848,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
         dataChangeNeedsScrollUpdate: false,
         didColumnsChange: false,
         didDataChange: false,
+        didLoad: false,
         enableScrollForNextCalculateItemsInView: true,
         endBuffered: -1,
         endNoBuffer: -1,
@@ -6640,6 +6878,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
         positions: [],
         props: {},
         queuedCalculateItemsInView: 0,
+        queuedFullDrawDistancePrewarm: void 0,
         refScroller: { current: null },
         scroll: 0,
         scrollAdjustHandler: new ScrollAdjustHandler(ctx),
@@ -6682,10 +6921,13 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
   const didScrollAxisGapChange = !isFirstLocal && ctx.scrollAxisGap !== nextScrollAxisGap;
   ctx.scrollAxisGap = nextScrollAxisGap;
   state.didColumnsChange = numColumnsProp !== previousNumColumnsProp || didScrollAxisGapChange;
+  const previousDataLength = (_n = (_m = state.props.data) == null ? void 0 : _m.length) != null ? _n : 0;
   const didDataReferenceChangeLocal = state.props.data !== dataProp;
+  const didDataKeyChangeLocal = state.props.dataKey !== dataKey;
   const didDataVersionChangeLocal = state.props.dataVersion !== dataVersion;
-  const didDataChangeLocal = didDataVersionChangeLocal || didDataReferenceChangeLocal && checkStructuralDataChange(state, dataProp, state.props.data);
-  if (didDataChangeLocal && !initialScrollAtEnd && state.didFinishInitialScroll && ((_m = state.initialScroll) == null ? void 0 : _m.viewPosition) === 1 && state.props.data.length > 0) {
+  const didDataChangeLocal = didDataKeyChangeLocal || didDataVersionChangeLocal || didDataReferenceChangeLocal && checkStructuralDataChange(state, dataProp, state.props.data);
+  const shouldResetFreshDataLayout = !isFirstLocal && didDataChangeLocal && state.hasHadNonEmptyData && (didDataKeyChangeLocal || previousDataLength === 0) && dataProp.length > 0;
+  if (didDataChangeLocal && !initialScrollAtEnd && state.didFinishInitialScroll && ((_o = state.initialScroll) == null ? void 0 : _o.viewPosition) === 1 && state.props.data.length > 0) {
     clearPreservedInitialScrollTarget(state);
   }
   if (didDataChangeLocal) {
@@ -6697,7 +6939,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
   const throttledOnScroll = useThrottledOnScroll(onScrollProp != null ? onScrollProp : noopOnScroll, scrollEventThrottle != null ? scrollEventThrottle : 0);
   const throttleScrollFn = scrollEventThrottle && onScrollProp ? throttledOnScroll : onScrollProp;
   const anchoredEndSpaceResolved = Platform.OS === "web" && anchoredEndSpace ? { ...anchoredEndSpace, includeInEndInset: true } : anchoredEndSpace;
-  const didAnchoredEndSpaceAnchorIndexChange = !isFirstLocal && !didDataChangeLocal && ((_n = state.props.anchoredEndSpace) == null ? void 0 : _n.anchorIndex) !== (anchoredEndSpaceResolved == null ? void 0 : anchoredEndSpaceResolved.anchorIndex);
+  const didAnchoredEndSpaceAnchorIndexChange = !isFirstLocal && !didDataChangeLocal && ((_p = state.props.anchoredEndSpace) == null ? void 0 : _p.anchorIndex) !== (anchoredEndSpaceResolved == null ? void 0 : anchoredEndSpaceResolved.anchorIndex);
   state.props = {
     adaptiveRender: experimental_adaptiveRender,
     alignItemsAtEnd,
@@ -6711,6 +6953,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     contentInset,
     contentInsetEndAdjustment: contentInsetEndAdjustmentResolved,
     data: dataProp,
+    dataKey,
     dataVersion,
     drawDistance,
     estimatedItemSize,
@@ -6751,13 +6994,19 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
   if (!isFirstLocal && previousAdaptiveRender && !experimental_adaptiveRender) {
     resetAdaptiveRender(ctx);
   }
+  if (shouldResetFreshDataLayout) {
+    resetInitialRenderState(ctx, {
+      resetInitialScroll: !!initialScrollProp,
+      resetLayout: true
+    });
+  }
   const memoizedLastItemKeys = React2.useMemo(() => {
     if (!dataProp.length) return [];
     return Array.from(
       { length: Math.min(numColumnsProp, dataProp.length) },
       (_, i) => getId(state, dataProp.length - 1 - i)
     );
-  }, [dataProp, dataVersion, numColumnsProp]);
+  }, [dataProp, dataKey, dataVersion, numColumnsProp]);
   const initializeStateVars = (shouldAdjustPadding) => {
     set$(ctx, "lastItemKeys", memoizedLastItemKeys);
     set$(ctx, "numColumns", numColumnsProp);
@@ -6817,13 +7066,22 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     handleInitialScrollDataChange(ctx, {
       dataLength: dataProp.length,
       didDataChange: didDataChangeLocal,
+      didStartFreshData: shouldResetFreshDataLayout,
       initialScrollAtEnd,
       latestInitialScroll: initialScrollProp,
       latestInitialScrollSessionKind: initialScrollUsesOffsetOnly ? "offset" : "bootstrap",
       stylePaddingBottom: stylePaddingBottomState,
       useBootstrapInitialScroll: usesBootstrapInitialScroll
     });
-  }, [dataProp.length, didDataChangeLocal, initialScrollAtEnd, stylePaddingBottomState, usesBootstrapInitialScroll]);
+  }, [
+    dataProp.length,
+    dataKey,
+    didDataChangeLocal,
+    shouldResetFreshDataLayout,
+    initialScrollAtEnd,
+    stylePaddingBottomState,
+    usesBootstrapInitialScroll
+  ]);
   React2.useLayoutEffect(() => {
     var _a4;
     if (didAnchoredEndSpaceAnchorIndexChange) {
@@ -6891,6 +7149,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
   React2.useLayoutEffect(
     () => initializeStateVars(true),
     [
+      dataKey,
       dataVersion,
       memoizedLastItemKeys.join(","),
       numColumnsProp,
@@ -6917,7 +7176,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     state.didColumnsChange = false;
     state.didDataChange = false;
     state.isFirst = false;
-  }, [dataProp, dataVersion, numColumnsProp, nextScrollAxisGap]);
+  }, [dataProp, dataKey, dataVersion, numColumnsProp, nextScrollAxisGap]);
   React2.useLayoutEffect(() => {
     var _a4;
     set$(ctx, "extraData", extraData);
@@ -6970,6 +7229,10 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
   React2.useImperativeHandle(forwardedRef, () => createImperativeHandle(ctx, scheduleImperativeScrollCommit), []);
   React2.useEffect(() => {
     return () => {
+      if (state.queuedFullDrawDistancePrewarm !== void 0) {
+        cancelAnimationFrame(state.queuedFullDrawDistancePrewarm);
+        state.queuedFullDrawDistancePrewarm = void 0;
+      }
       for (const timeout of state.timeouts) {
         clearTimeout(timeout);
       }
@@ -7022,7 +7285,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       onScroll: onScrollHandler,
       recycleItems,
       refreshControl: refreshControlElement ? stylePaddingTopState > 0 ? React2__namespace.cloneElement(refreshControlElement, {
-        progressViewOffset: ((_o = refreshControlElement.props.progressViewOffset) != null ? _o : 0) + stylePaddingTopState
+        progressViewOffset: ((_q = refreshControlElement.props.progressViewOffset) != null ? _q : 0) + stylePaddingTopState
       }) : refreshControlElement : onRefresh && /* @__PURE__ */ React2__namespace.createElement(
         ReactNative.RefreshControl,
         {
@@ -7033,7 +7296,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       ),
       refScrollView: combinedRef,
       renderScrollComponent,
-      scrollAdjustHandler: (_p = refState.current) == null ? void 0 : _p.scrollAdjustHandler,
+      scrollAdjustHandler: (_r = refState.current) == null ? void 0 : _r.scrollAdjustHandler,
       scrollEventThrottle: 0,
       snapToIndices,
       stickyHeaderIndices,