@legendapp/list 3.4.0 → 3.6.0

package/react-native.web.js

@@ -901,8 +901,14 @@ function scheduleFullDrawDistancePrewarm(ctx) {
     return;
   }
   state.scheduledWork.frame(() => {
-    var _a3;
-    return (_a3 = state.triggerCalculateItemsInView) == null ? void 0 : _a3.call(state);
+    var _a3, _b, _c;
+    if (state.props.hasExternalScroll && !hasActiveInitialScroll(state) && !state.scrollingTo && !state.pendingNativeMVCPAdjust) {
+      const offset = (_b = (_a3 = state.refScroller.current) == null ? void 0 : _a3.getRawScrollOffset) == null ? void 0 : _b.call(_a3);
+      if (offset !== void 0) {
+        state.scroll = state.scrollPending = state.props.horizontal ? toLogicalHorizontalOffset(state, offset, state.totalSize) : offset;
+      }
+    }
+    (_c = state.triggerCalculateItemsInView) == null ? void 0 : _c.call(state);
   }, "fullDrawDistancePrewarm");
 }
 
@@ -915,6 +921,9 @@ function resetInitialRenderState(ctx, {
   if (resetLayout) {
     state.didContainersLayout = false;
     state.queuedInitialLayout = false;
+    state.scrollBufferDirection = void 0;
+    state.scrollHistory.length = 0;
+    state.scheduledWork.cancel("renderRangeProjection");
     state.edgeReachedGate = void 0;
     state.isStartReached = null;
     state.isEndReached = null;
@@ -1141,6 +1150,7 @@ function setSize(ctx, itemKey, size, notifyTotalSize = true) {
   const previousSize = sizes.get(itemKey);
   const diff = previousSize !== void 0 ? size - previousSize : size;
   if (diff !== 0) {
+    state.positionsAreCurrent = false;
     addTotalSize(ctx, itemKey, diff, notifyTotalSize);
   }
   sizes.set(itemKey, size);
@@ -1201,6 +1211,7 @@ function getKnownOrFixedSize(ctx, key, index, data, resolved) {
     const fixedSize = (resolved == null ? void 0 : resolved.didResolveFixedItemSize) ? resolved.fixedItemSize : getFixedItemSize(data, index, itemType);
     if (fixedSize !== void 0) {
       size = fixedSize + ctx.scrollAxisGap;
+      state.positionsAreCurrent = false;
       state.sizesKnown.set(key, size);
     }
   }
@@ -1274,10 +1285,17 @@ function getItemSizeAtIndex(ctx, index) {
 }
 
 // src/core/calculateOffsetWithOffsetPosition.ts
+function getViewPositionOffset(availableSpace, viewPosition, viewPositionFallback) {
+  let alignment = viewPosition;
+  if (availableSpace < 0 && viewPositionFallback !== void 0) {
+    alignment = viewPositionFallback === "start" ? 0 : 1;
+  }
+  return -alignment * availableSpace;
+}
 function calculateOffsetWithOffsetPosition(ctx, offsetParam, params) {
   var _a3;
   const state = ctx.state;
-  const { index, viewOffset, viewPosition } = params;
+  const { index, viewOffset, viewPosition, viewPositionFallback } = params;
   let offset = offsetParam;
   if (viewOffset) {
     offset -= viewOffset;
@@ -1298,7 +1316,8 @@ function calculateOffsetWithOffsetPosition(ctx, offsetParam, params) {
     const measuredItemSize = isOutOfBounds ? fallbackEstimatedSize : getItemSize(ctx, getId(state, index), index, state.props.data[index]);
     const itemSize = Math.max(0, measuredItemSize - (isOutOfBounds ? 0 : ctx.scrollAxisGap));
     const trailingInset = getContentInsetEnd(ctx);
-    offset -= viewPosition * (state.scrollLength - trailingInset - itemSize);
+    const availableSpace = state.scrollLength - trailingInset - itemSize;
+    offset += getViewPositionOffset(availableSpace, viewPosition, viewPositionFallback);
   }
   return offset;
 }
@@ -1645,15 +1664,27 @@ function prepareMVCP(ctx, dataChanged, adjustmentSource) {
           anchorPositionForLock = newPosition;
         }
       }
-      if (scrollingToViewPosition && scrollingToViewPosition > 0) {
+      if (scrollingTo && scrollingToViewPosition !== void 0 && (scrollingToViewPosition > 0 || scrollingTo.viewPositionFallback)) {
         const newSize = getItemSize(ctx, targetId, scrollTarget, state.props.data[scrollTarget]);
-        const prevSize = scrollingTo == null ? void 0 : scrollingTo.itemSize;
+        const prevSize = scrollingTo.itemSize;
         if (newSize !== void 0 && prevSize !== void 0 && newSize !== prevSize) {
-          const diff = newSize - prevSize;
-          if (diff !== 0) {
-            positionDiff += diff * scrollingToViewPosition;
-            scrollingTo.itemSize = newSize;
+          if (scrollingTo.viewPositionFallback) {
+            const viewport = state.scrollLength - getContentInsetEnd(ctx);
+            const previousSpace = viewport - Math.max(0, prevSize - ctx.scrollAxisGap);
+            const nextSpace = viewport - Math.max(0, newSize - ctx.scrollAxisGap);
+            positionDiff += getViewPositionOffset(
+              nextSpace,
+              scrollingToViewPosition,
+              scrollingTo.viewPositionFallback
+            ) - getViewPositionOffset(
+              previousSpace,
+              scrollingToViewPosition,
+              scrollingTo.viewPositionFallback
+            );
+          } else {
+            positionDiff += (newSize - prevSize) * scrollingToViewPosition;
           }
+          scrollingTo.itemSize = newSize;
         }
       }
       updateAnchorLock(state, {
@@ -1782,6 +1813,9 @@ function updateScroll(ctx, newScroll, forceUpdate, options) {
   state.scrollTime = currentTime;
   const scrollDelta = Math.abs(newScroll - prevScroll);
   const isUserScrollEvent = !!(options == null ? void 0 : options.fromNativeScrollEvent) && scrollDelta > 0.1 && !adjustChanged && scrollingTo === void 0 && !state.pendingNativeMVCPAdjust;
+  if (isUserScrollEvent) {
+    state.scrollBufferDirection = newScroll > prevScroll ? 1 : -1;
+  }
   const didCancelMaintainScrollAtEnd = isUserScrollEvent && newScroll < prevScroll && !!(state.maintainingScrollAtEnd || state.pendingMaintainScrollAtEnd);
   if (didCancelMaintainScrollAtEnd) {
     finishMaintainScrollAtEnd(ctx);
@@ -1861,10 +1895,10 @@ function finishMaintainScrollAtEnd(ctx) {
   }
 }
 function doMaintainScrollAtEnd(ctx, options) {
-  var _a3, _b, _c, _d, _e, _f;
+  var _a3, _b, _c, _d, _e, _f, _g, _h;
   const state = ctx.state;
   let didMaintain = false;
-  if (state.isDragging) {
+  if (state.isDragging || ((_b = (_a3 = state.refScroller.current) == null ? void 0 : _a3.isScrollInRange) == null ? void 0 : _b.call(_a3)) === false) {
     finishMaintainScrollAtEnd(ctx);
   } else {
     const {
@@ -1876,11 +1910,11 @@ function doMaintainScrollAtEnd(ctx, options) {
     const immediate = (options == null ? void 0 : options.immediate) && Platform.OS === "web" && !(maintainScrollAtEnd == null ? void 0 : maintainScrollAtEnd.animated);
     const isWithinMaintainScrollAtEndThreshold = peek$(ctx, "isWithinMaintainScrollAtEndThreshold");
     const isReplayingPendingMaintain = !!state.pendingMaintainScrollAtEnd;
-    const shouldMaintainScrollAtEnd = !!(!((_a3 = ctx.scrollRequestTracker) == null ? void 0 : _a3.isWaitingToRun()) && (!state.scrollingTo || state.scrollingTo.isScrollToEnd) && (isWithinMaintainScrollAtEndThreshold || isReplayingPendingMaintain || ((_b = state.scrollingTo) == null ? void 0 : _b.isScrollToEnd)) && maintainScrollAtEnd && didFinishInitialScroll);
+    const shouldMaintainScrollAtEnd = !!(!((_c = ctx.scrollRequestTracker) == null ? void 0 : _c.isWaitingToRun()) && (!state.scrollingTo || state.scrollingTo.isScrollToEnd) && (isWithinMaintainScrollAtEndThreshold || isReplayingPendingMaintain || ((_d = state.scrollingTo) == null ? void 0 : _d.isScrollToEnd)) && maintainScrollAtEnd && didFinishInitialScroll);
     if (shouldMaintainScrollAtEnd && !state.scrollingTo) {
       const scroller = state.refScroller.current;
-      const nativeMax = (_c = scroller == null ? void 0 : scroller.getMaxScrollOffset) == null ? void 0 : _c.call(scroller);
-      const observed = (_d = scroller == null ? void 0 : scroller.getCurrentScrollOffset) == null ? void 0 : _d.call(scroller);
+      const nativeMax = (_e = scroller == null ? void 0 : scroller.getMaxScrollOffset) == null ? void 0 : _e.call(scroller);
+      const observed = (_f = scroller == null ? void 0 : scroller.getCurrentScrollOffset) == null ? void 0 : _f.call(scroller);
       if (nativeMax !== void 0 && observed !== void 0 && nativeMax < state.scroll - 1 && Math.abs(observed - nativeMax) <= 1) {
         state.pendingMaintainScrollAtEnd = true;
         state.scrollPending = observed;
@@ -1892,13 +1926,13 @@ function doMaintainScrollAtEnd(ctx, options) {
     } else if (pendingNativeMVCPAdjust) {
       state.pendingMaintainScrollAtEnd = shouldMaintainScrollAtEnd;
     } else if (shouldMaintainScrollAtEnd && (state.scrollingTo || state.pendingScrollResolve)) {
-      if (immediate && ((_e = state.scrollingTo) == null ? void 0 : _e.isScrollToEnd) && !state.scrollingTo.animated) {
+      if (immediate && ((_g = state.scrollingTo) == null ? void 0 : _g.isScrollToEnd) && !state.scrollingTo.animated) {
         state.pendingMaintainScrollAtEnd = false;
         ctx.scrollToEnd({ animated: false });
         didMaintain = true;
       } else {
         state.pendingMaintainScrollAtEnd = true;
-        (_f = state.maintainingScrollAtEnd) != null ? _f : state.maintainingScrollAtEnd = maintainScrollAtEnd.animated ? "pending-animated" : "pending-instant";
+        (_h = state.maintainingScrollAtEnd) != null ? _h : state.maintainingScrollAtEnd = maintainScrollAtEnd.animated ? "pending-animated" : "pending-instant";
       }
     } else if (shouldMaintainScrollAtEnd && didContainersLayout) {
       state.pendingMaintainScrollAtEnd = false;
@@ -1912,8 +1946,9 @@ function doMaintainScrollAtEnd(ctx, options) {
         const scrollAtRequest = state.scroll;
         state.maintainingScrollAtEnd = pendingState;
         const run = () => {
+          var _a4, _b2;
           if (state.maintainingScrollAtEnd === pendingState) {
-            if (state.isDragging) {
+            if (state.isDragging || ((_b2 = (_a4 = state.refScroller.current) == null ? void 0 : _a4.isScrollInRange) == null ? void 0 : _b2.call(_a4)) === false) {
               finishMaintainScrollAtEnd(ctx);
             } else {
               const isStillWithinThreshold = peek$(ctx, "isWithinMaintainScrollAtEndThreshold");
@@ -2299,7 +2334,8 @@ function scrollToIndex(ctx, {
   animated = true,
   forceScroll,
   isInitialScroll,
-  viewPosition
+  viewPosition,
+  viewPositionFallback
 }) {
   const state = ctx.state;
   const { data } = state.props;
@@ -2319,7 +2355,8 @@ function scrollToIndex(ctx, {
     itemSize,
     offset: firstIndexOffset,
     viewOffset,
-    viewPosition: viewPosition != null ? viewPosition : 0
+    viewPosition: viewPosition != null ? viewPosition : 0,
+    viewPositionFallback
   });
 }
 
@@ -2339,6 +2376,7 @@ function dispatchInitialScroll(ctx, params) {
     precomputedWithViewOffset: true,
     viewOffset: target.viewOffset,
     viewPosition: target.viewPosition,
+    viewPositionFallback: target.viewPositionFallback,
     waitForInitialScrollCompletionFrame: waitForCompletionFrame
   });
 }
@@ -2673,7 +2711,7 @@ function createRetargetedBottomAlignedInitialScroll(options) {
   };
 }
 function areEquivalentBootstrapInitialScrollTargets(current, next) {
-  return current.index === next.index && current.preserveForBottomPadding === next.preserveForBottomPadding && current.preserveForFooterLayout === next.preserveForFooterLayout && current.viewOffset === next.viewOffset && current.viewPosition === next.viewPosition;
+  return current.index === next.index && current.preserveForBottomPadding === next.preserveForBottomPadding && current.preserveForFooterLayout === next.preserveForFooterLayout && current.viewOffset === next.viewOffset && current.viewPosition === next.viewPosition && current.viewPositionFallback === next.viewPositionFallback;
 }
 function clearPendingInitialScrollFooterLayout(ctx, options) {
   const { dataLength, stylePaddingEnd, target } = options;
@@ -2888,7 +2926,7 @@ function handleBootstrapInitialScrollFooterLayout(ctx, options) {
       preserveForFooterLayout: shouldPreserveInitialScrollForFooterLayout(initialScroll),
       stylePaddingEnd
     });
-    const didTargetChange = initialScroll.index !== updatedInitialScroll.index || initialScroll.viewPosition !== updatedInitialScroll.viewPosition || initialScroll.viewOffset !== updatedInitialScroll.viewOffset;
+    const didTargetChange = initialScroll.index !== updatedInitialScroll.index || initialScroll.viewPosition !== updatedInitialScroll.viewPosition || initialScroll.viewPositionFallback !== updatedInitialScroll.viewPositionFallback || initialScroll.viewOffset !== updatedInitialScroll.viewOffset;
     if (!didTargetChange) {
       clearPendingInitialScrollFooterLayout(ctx, {
         dataLength,
@@ -3356,6 +3394,7 @@ function handleInitialScrollDataChange(ctx, options) {
 
 // src/core/resetLayoutCachesForDataChange.ts
 function resetLayoutCachesForDataChange(state) {
+  state.positionsAreCurrent = false;
   state.indexByKey.clear();
   state.idCache.length = 0;
   state.positions.length = 0;
@@ -3636,7 +3675,7 @@ function updateItemPositions(ctx, dataChanged, {
   scrollBottomBuffered: -1,
   startIndex: 0
 }) {
-  var _a3, _b, _c, _d, _e;
+  var _a3, _b, _c, _d, _e, _f;
   const state = ctx.state;
   const hasPositionListeners = ctx.positionListeners.size > 0;
   const {
@@ -3652,6 +3691,11 @@ function updateItemPositions(ctx, dataChanged, {
   const dataLength = data.length;
   const numColumns = (_a3 = peek$(ctx, "numColumns")) != null ? _a3 : 1;
   const hasColumns = numColumns > 1;
+  const canReuseEstimates = !doMVCP || !state.didContainersLayout && Object.keys(state.averageSizes).length === 0;
+  if (state.positionsAreCurrent && !dataChanged && !forceFullUpdate && state.positionRecalculationStartIndex === void 0 && !scrollingTo && !hasColumns && !snapToIndices && positions.length === dataLength && canReuseEstimates) {
+    return;
+  }
+  state.positionsAreCurrent = false;
   const indexByKeyForChecking = IS_DEV ? /* @__PURE__ */ new Map() : void 0;
   const extraData = peek$(ctx, "extraData");
   const layoutConfig = overrideItemLayout ? { span: 1 } : void 0;
@@ -3766,6 +3810,10 @@ function updateItemPositions(ctx, dataChanged, {
   }
   if (!didBreakEarly) {
     updateTotalSize(ctx);
+    state.positionsAreCurrent = !hasColumns;
+    if (startIndex <= ((_f = state.positionRecalculationStartIndex) != null ? _f : -1)) {
+      state.positionRecalculationStartIndex = void 0;
+    }
   }
   if (snapToIndices) {
     updateSnapToOffsets(ctx);
@@ -4328,7 +4376,7 @@ function handleStickyRecycling(ctx, stickyArray, scroll, drawDistance, currentSt
 }
 function trackVisibleRange(range, i, top, size, scroll, scrollBottom) {
   let didPassVisibleEnd = false;
-  if (range.startNoBuffer === null && top + size > scroll) {
+  if (range.startNoBuffer === null && top + size > scroll && top <= scrollBottom) {
     range.startNoBuffer = i;
   }
   if (range.firstFullyOnScreenIndex === void 0 && top >= scroll - 10 && top <= scrollBottom) {
@@ -4394,7 +4442,7 @@ function findFirstVisibleIndexInCachedRange(ctx, scroll) {
   return null;
 }
 function updateViewabilityForCachedRange(ctx, viewabilityConfigCallbackPairs, scrollLength, scroll, scrollBottom) {
-  var _a3, _b;
+  var _a3, _b, _c, _d;
   const state = ctx.state;
   const {
     endBuffered,
@@ -4428,14 +4476,14 @@ function updateViewabilityForCachedRange(ctx, viewabilityConfigCallbackPairs, sc
     startNoBuffer: visibleRange.startNoBuffer
   });
   maybeEmitFirstVisibleItemChanged(state, visibleRange.startNoBuffer);
-  if (visibleRange.startNoBuffer !== null && visibleRange.endNoBuffer !== null) {
+  if (state.props.hasExternalScroll || visibleRange.startNoBuffer !== null && visibleRange.endNoBuffer !== null) {
     updateViewableItems(
       state,
       ctx,
       viewabilityConfigCallbackPairs,
       scrollLength,
-      visibleRange.startNoBuffer,
-      visibleRange.endNoBuffer,
+      (_c = visibleRange.startNoBuffer) != null ? _c : 0,
+      (_d = visibleRange.endNoBuffer) != null ? _d : -1,
       startBuffered,
       endBuffered
     );
@@ -4444,7 +4492,7 @@ function updateViewabilityForCachedRange(ctx, viewabilityConfigCallbackPairs, sc
 function calculateItemsInView(ctx, params = {}) {
   const state = ctx.state;
   batchedUpdates(() => {
-    var _a3, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u;
+    var _a3, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y;
     const {
       columns,
       containerItemKeys,
@@ -4496,7 +4544,7 @@ function calculateItemsInView(ctx, params = {}) {
       scrollAdjustPending = (_a4 = peek$(ctx, "scrollAdjustPending")) != null ? _a4 : 0;
       scrollAdjustPad = scrollAdjustPending - topPad;
       scroll = Math.round(nextScrollState + scrollExtra + scrollAdjustPad);
-      if (scroll + scrollLength > totalSize) {
+      if (!state.props.hasExternalScroll && scroll + scrollLength > totalSize) {
         scroll = Math.max(0, totalSize - scrollLength);
       }
     };
@@ -4523,7 +4571,11 @@ function calculateItemsInView(ctx, params = {}) {
     let stickyState = dataChanged ? void 0 : resolveStickyState();
     let scrollBufferTop = drawDistance;
     let scrollBufferBottom = drawDistance;
-    if (speed > 0 || speed === 0 && scroll < Math.max(50, drawDistance)) {
+    if (speed !== 0) {
+      state.scrollBufferDirection = speed > 0 ? 1 : -1;
+    }
+    const bufferForward = state.scrollBufferDirection === 1 || state.scrollBufferDirection === void 0 && scroll < Math.max(50, drawDistance);
+    if (bufferForward) {
       scrollBufferTop = drawDistance * 0.5;
       scrollBufferBottom = drawDistance * 1.5;
     } else {
@@ -4533,8 +4585,8 @@ function calculateItemsInView(ctx, params = {}) {
     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);
+      const scrollStart = state.props.hasExternalScroll ? scroll : Math.max(0, scroll);
+      const overscrollBeforeContent = state.props.hasExternalScroll ? 0 : Math.max(0, -nativeScrollState);
       scrollBottom = Math.max(scrollStart, scroll + scrollLength + overscrollBeforeContent);
       scrollTopBuffered = scrollStart - scrollBufferTop + projectedBufferAdjustment;
       scrollBottomBuffered = scrollBottom + scrollBufferBottom + projectedBufferAdjustment;
@@ -4663,7 +4715,7 @@ function calculateItemsInView(ctx, params = {}) {
             nextTop = top;
           }
         }
-        if (visibleRange.startNoBuffer !== null) {
+        if (startBuffered !== null) {
           if (top <= scrollBottomBuffered) {
             endBuffered = i;
             if (scrollBottomBuffered > totalSize) {
@@ -4674,6 +4726,8 @@ function calculateItemsInView(ctx, params = {}) {
           } else {
             foundEnd = true;
           }
+        } else if (top > scrollBottomBuffered) {
+          foundEnd = true;
         }
       }
     }
@@ -4691,6 +4745,12 @@ function calculateItemsInView(ctx, params = {}) {
         bottom: nextBottom,
         top: nextTop
       };
+    } else if (enableScrollForNextCalculateItemsInView && state.props.hasExternalScroll) {
+      if (scrollBottomBuffered < 0) {
+        state.scrollForNextCalculateItemsInView = { bottom: 0, top: null };
+      } else if (scrollTopBuffered > totalSize) {
+        state.scrollForNextCalculateItemsInView = { bottom: null, top: totalSize };
+      }
     }
     let numContainers = prevNumContainers;
     const pendingRemoval = [];
@@ -4714,7 +4774,9 @@ function calculateItemsInView(ctx, params = {}) {
     }
     const hasScrollTargetPinnedRange = scrollTargetPinnedStart <= scrollTargetPinnedEnd;
     const isPinnedRenderIndex = (index) => alwaysRenderIndicesSet.has(index) || hasScrollTargetPinnedRange && index >= scrollTargetPinnedStart && index <= scrollTargetPinnedEnd;
-    if (startBuffered !== null && endBuffered !== null) {
+    if (startBuffered !== null && endBuffered !== null || alwaysRenderIndicesArr.length || hasScrollTargetPinnedRange) {
+      const allocationStart = startBuffered != null ? startBuffered : 0;
+      const allocationEnd = endBuffered != null ? endBuffered : -1;
       const needNewContainers = [];
       const needNewContainersSet = /* @__PURE__ */ new Set();
       const addPinnedIndex = (index) => {
@@ -4730,7 +4792,7 @@ function calculateItemsInView(ctx, params = {}) {
           }
         }
       };
-      for (let i = startBuffered; i <= endBuffered; i++) {
+      for (let i = allocationStart; i <= allocationEnd; i++) {
         const id = (_m = idCache[i]) != null ? _m : getId(state, i);
         if (!containerItemKeys.has(id)) {
           needNewContainersSet.add(i);
@@ -4752,8 +4814,8 @@ function calculateItemsInView(ctx, params = {}) {
           (_n = stickyState == null ? void 0 : stickyState.currentStickyIdx) != null ? _n : -1,
           needNewContainers,
           needNewContainersSet,
-          startBuffered,
-          endBuffered
+          allocationStart,
+          allocationEnd
         );
       } else if (previousStickyIndex !== -1) {
         set$(ctx, "activeStickyIndex", -1);
@@ -4762,8 +4824,8 @@ function calculateItemsInView(ctx, params = {}) {
         const availableContainerAllocations = findAvailableContainers(
           ctx,
           needNewContainers,
-          startBuffered,
-          endBuffered,
+          allocationStart,
+          allocationEnd,
           pendingRemoval,
           protectedContainerKeys,
           // Initial end alignment has no scroll velocity yet. Keep its
@@ -4890,19 +4952,19 @@ function calculateItemsInView(ctx, params = {}) {
         handleInitialScrollLayoutReady(ctx);
       }
     }
-    if (viewabilityConfigCallbackPairs && visibleRange.startNoBuffer !== null && visibleRange.endNoBuffer !== null) {
+    if (viewabilityConfigCallbackPairs && (state.props.hasExternalScroll || visibleRange.startNoBuffer !== null && visibleRange.endNoBuffer !== null)) {
       updateViewableItems(
         ctx.state,
         ctx,
         viewabilityConfigCallbackPairs,
         scrollLength,
-        visibleRange.startNoBuffer,
-        visibleRange.endNoBuffer,
-        startBuffered != null ? startBuffered : visibleRange.startNoBuffer,
-        endBuffered != null ? endBuffered : visibleRange.endNoBuffer
+        (_u = visibleRange.startNoBuffer) != null ? _u : 0,
+        (_v = visibleRange.endNoBuffer) != null ? _v : -1,
+        (_w = startBuffered != null ? startBuffered : visibleRange.startNoBuffer) != null ? _w : 0,
+        (_x = endBuffered != null ? endBuffered : visibleRange.endNoBuffer) != null ? _x : -1
       );
     }
-    (_u = stickyState == null ? void 0 : stickyState.finishCalculateItemsInView) == null ? void 0 : _u.call(stickyState);
+    (_y = stickyState == null ? void 0 : stickyState.finishCalculateItemsInView) == null ? void 0 : _y.call(stickyState);
   });
 }
 
@@ -5181,6 +5243,7 @@ function updateOneItemSize(ctx, itemKey, sizeObj, resolvedMeasurementItem, notif
   const rawSize = horizontal ? sizeObj.width : sizeObj.height;
   const prevSizeKnown = sizesKnown.get(itemKey);
   const size = Math.round(rawSize) ;
+  if (prevSizeKnown !== size) state.positionsAreCurrent = false;
   sizesKnown.set(itemKey, size);
   if (fixedItemSize === void 0 && size > 0) {
     itemType != null ? itemType : itemType = getItemType ? (_b = getItemType(itemData, index)) != null ? _b : "" : "";
@@ -5601,10 +5664,19 @@ function useOnLayoutSync({
   measureInLayoutEffect = true,
   onLayoutProp,
   onLayoutChange,
-  webLayoutResync
+  webLayoutResync,
+  webExternalScroll = false
 }, deps) {
+  const onExternalLayout = React3.useCallback(
+    (event) => {
+      onLayoutChange(event.nativeEvent.layout, false);
+      onLayoutProp == null ? void 0 : onLayoutProp(event);
+    },
+    [onLayoutChange, onLayoutProp]
+  );
   React3.useLayoutEffect(() => {
     var _a3, _b;
+    if (webExternalScroll) return;
     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;
@@ -5642,8 +5714,8 @@ function useOnLayoutSync({
         emit(toLayout(rectObserved), false);
       }
     });
-  }, [measureInLayoutEffect, ...deps || []]);
-  return {};
+  }, [measureInLayoutEffect, webExternalScroll, ...deps || []]);
+  return webExternalScroll ? { onLayout: onExternalLayout } : {};
 }
 function toLayout(rect) {
   if (!rect) {
@@ -6205,94 +6277,121 @@ function useRafCoalescer(callback) {
   return coalescer;
 }
 
-// src/components/webConstants.ts
-var LEGEND_LIST_CONTENT_CONTAINER_CLASS = "legend-list-content-container";
-var LEGEND_LIST_SCROLLBAR_X_HIDDEN_CLASS = "legend-list-scrollbar-x-hidden";
-var LEGEND_LIST_SCROLLBAR_Y_HIDDEN_CLASS = "legend-list-scrollbar-y-hidden";
-
 // src/components/webScrollUtils.ts
-function getDocumentScrollerNode() {
-  if (typeof document === "undefined") {
-    return null;
-  }
-  return document.scrollingElement || document.documentElement || document.body;
+function isWindowTarget(target) {
+  return typeof window !== "undefined" && target === window;
 }
-function getWindowScrollPosition() {
-  var _a3, _b, _c, _d;
-  if (typeof window === "undefined") {
-    return { x: 0, y: 0 };
+function getScrollPosition(target) {
+  var _a3, _b, _c, _d, _e, _f;
+  if (isWindowTarget(target)) {
+    return { x: (_b = (_a3 = target.scrollX) != null ? _a3 : target.pageXOffset) != null ? _b : 0, y: (_d = (_c = target.scrollY) != null ? _c : target.pageYOffset) != null ? _d : 0 };
   }
-  return {
-    x: (_b = (_a3 = window.scrollX) != null ? _a3 : window.pageXOffset) != null ? _b : 0,
-    y: (_d = (_c = window.scrollY) != null ? _c : window.pageYOffset) != null ? _d : 0
-  };
+  return { x: (_e = target == null ? void 0 : target.scrollLeft) != null ? _e : 0, y: (_f = target == null ? void 0 : target.scrollTop) != null ? _f : 0 };
 }
-function getElementDocumentPosition(element, scroll) {
-  var _a3, _b;
+function getElementScrollPosition(element, target) {
+  var _a3, _b, _c, _d, _e, _f;
   const rect = element == null ? void 0 : element.getBoundingClientRect();
+  const scroll = getScrollPosition(target);
+  const parent = target && !isWindowTarget(target) ? target : null;
+  const parentRect = parent == null ? void 0 : parent.getBoundingClientRect();
   return {
-    left: ((_a3 = rect == null ? void 0 : rect.left) != null ? _a3 : 0) + scroll.x,
-    top: ((_b = rect == null ? void 0 : rect.top) != null ? _b : 0) + scroll.y
+    left: ((_a3 = rect == null ? void 0 : rect.left) != null ? _a3 : 0) - ((_b = parentRect == null ? void 0 : parentRect.left) != null ? _b : 0) - ((_c = parent == null ? void 0 : parent.clientLeft) != null ? _c : 0) + scroll.x,
+    top: ((_d = rect == null ? void 0 : rect.top) != null ? _d : 0) - ((_e = parentRect == null ? void 0 : parentRect.top) != null ? _e : 0) - ((_f = parent == null ? void 0 : parent.clientTop) != null ? _f : 0) + scroll.y
   };
 }
 function getContentSize2(content) {
   var _a3, _b;
-  return {
-    height: (_a3 = content == null ? void 0 : content.scrollHeight) != null ? _a3 : 0,
-    width: (_b = content == null ? void 0 : content.scrollWidth) != null ? _b : 0
-  };
+  return { height: (_a3 = content == null ? void 0 : content.scrollHeight) != null ? _a3 : 0, width: (_b = content == null ? void 0 : content.scrollWidth) != null ? _b : 0 };
 }
-function getScrollContentSize(scrollElement, contentElement, isWindowScroll) {
-  return getContentSize2(isWindowScroll ? contentElement : scrollElement);
+function getScrollContentSize(scrollElement, contentElement, externalTarget) {
+  return getContentSize2(externalTarget !== void 0 ? contentElement : scrollElement);
 }
-function getLayoutMeasurement(scrollElement, isWindowScroll, horizontal) {
-  var _a3, _b, _c, _d, _e, _f;
-  if (isWindowScroll && typeof window !== "undefined") {
+function getLayoutMeasurement(scrollElement, externalTarget, horizontal) {
+  var _a3, _b, _c, _d, _e, _f, _g, _h;
+  if (externalTarget !== void 0) {
     const rect = scrollElement == null ? void 0 : scrollElement.getBoundingClientRect();
+    const viewport = isWindowTarget(externalTarget) ? { height: externalTarget.innerHeight, width: externalTarget.innerWidth } : { height: (_a3 = externalTarget == null ? void 0 : externalTarget.clientHeight) != null ? _a3 : 0, width: (_b = externalTarget == null ? void 0 : externalTarget.clientWidth) != null ? _b : 0 };
     return {
-      // In window-scroll mode, use viewport size on the scroll axis.
-      height: horizontal ? (_b = (_a3 = rect == null ? void 0 : rect.height) != null ? _a3 : scrollElement == null ? void 0 : scrollElement.clientHeight) != null ? _b : window.innerHeight : window.innerHeight,
-      // Keep the cross-axis size list-relative to avoid inflating container measurements.
-      width: horizontal ? window.innerWidth : (_d = (_c = rect == null ? void 0 : rect.width) != null ? _c : scrollElement == null ? void 0 : scrollElement.clientWidth) != null ? _d : window.innerWidth
+      height: horizontal ? (_d = (_c = rect == null ? void 0 : rect.height) != null ? _c : scrollElement == null ? void 0 : scrollElement.clientHeight) != null ? _d : 0 : viewport.height,
+      width: horizontal ? viewport.width : (_f = (_e = rect == null ? void 0 : rect.width) != null ? _e : scrollElement == null ? void 0 : scrollElement.clientWidth) != null ? _f : 0
     };
   }
-  return {
-    height: (_e = scrollElement == null ? void 0 : scrollElement.clientHeight) != null ? _e : 0,
-    width: (_f = scrollElement == null ? void 0 : scrollElement.clientWidth) != null ? _f : 0
-  };
+  return { height: (_g = scrollElement == null ? void 0 : scrollElement.clientHeight) != null ? _g : 0, width: (_h = scrollElement == null ? void 0 : scrollElement.clientWidth) != null ? _h : 0 };
 }
 function clampOffset(offset, maxOffset) {
   return Math.max(0, Math.min(offset, maxOffset));
 }
-function getAxisSize(size, horizontal) {
-  return horizontal ? size.width : size.height;
-}
 function getMaxOffset(contentSize, layoutMeasurement, horizontal) {
-  return Math.max(0, getAxisSize(contentSize, horizontal) - getAxisSize(layoutMeasurement, horizontal));
+  const axis = horizontal ? "width" : "height";
+  return Math.max(0, contentSize[axis] - layoutMeasurement[axis]);
 }
-function resolveScrollableNode(scrollElement, isWindowScroll) {
-  return isWindowScroll ? getDocumentScrollerNode() || scrollElement : scrollElement;
+function resolveScrollableNode(scrollElement, externalTarget) {
+  if (isWindowTarget(externalTarget)) {
+    return document.scrollingElement || document.documentElement || document.body;
+  }
+  return externalTarget === void 0 ? scrollElement : externalTarget;
 }
-function resolveScrollEventTarget(scrollElement, isWindowScroll) {
-  return isWindowScroll && typeof window !== "undefined" ? window : scrollElement;
+function resolveScrollEventTarget(scrollElement, externalTarget) {
+  return externalTarget === void 0 ? scrollElement : externalTarget;
 }
-function getLayoutRectangle(element, isWindowScroll, horizontal) {
-  const rect = element.getBoundingClientRect();
-  const scroll = getWindowScrollPosition();
-  return {
-    height: isWindowScroll && typeof window !== "undefined" && !horizontal ? window.innerHeight : rect.height,
-    width: isWindowScroll && typeof window !== "undefined" && horizontal ? window.innerWidth : rect.width,
-    x: isWindowScroll ? rect.left + scroll.x : rect.left,
-    y: isWindowScroll ? rect.top + scroll.y : rect.top
-  };
+function getLayoutRectangle(element, externalTarget, horizontal) {
+  if (externalTarget === void 0) {
+    const rect = element.getBoundingClientRect();
+    return { height: rect.height, width: rect.width, x: rect.left, y: rect.top };
+  }
+  const { left, top } = getElementScrollPosition(element, externalTarget);
+  const { height, width } = getLayoutMeasurement(element, externalTarget, horizontal);
+  return { height, width, x: left, y: top };
 }
-function resolveWindowScrollTarget({ clampedOffset, horizontal, listPos, scroll }) {
+function resolveExternalScrollOffset({
+  clampedOffset,
+  horizontal,
+  listPos,
+  scroll
+}) {
   return {
     left: horizontal ? listPos.left + clampedOffset : scroll.x,
     top: horizontal ? scroll.y : listPos.top + clampedOffset
   };
 }
 
+// src/components/observeScrollLayout.ts
+function observeScrollLayout(element, owner, onLayout) {
+  if (owner === null) return;
+  const resizeObserver = new ResizeObserver(onLayout);
+  const mutationObserver = owner === void 0 ? void 0 : new MutationObserver(observe);
+  function observe() {
+    resizeObserver.disconnect();
+    mutationObserver == null ? void 0 : mutationObserver.disconnect();
+    resizeObserver.observe(element);
+    if (owner !== void 0) {
+      for (let node = element; node && node !== owner; node = node.parentElement) {
+        const parent = node.parentElement;
+        if (parent) {
+          resizeObserver.observe(parent);
+          mutationObserver == null ? void 0 : mutationObserver.observe(parent, { childList: true });
+        }
+        for (let sibling = node.previousElementSibling; sibling; sibling = sibling.previousElementSibling) {
+          resizeObserver.observe(sibling);
+        }
+      }
+    }
+    onLayout();
+  }
+  observe();
+  if (isWindowTarget(owner)) owner.addEventListener("resize", onLayout);
+  return () => {
+    resizeObserver.disconnect();
+    mutationObserver == null ? void 0 : mutationObserver.disconnect();
+    if (isWindowTarget(owner)) owner.removeEventListener("resize", onLayout);
+  };
+}
+
+// src/components/webConstants.ts
+var LEGEND_LIST_CONTENT_CONTAINER_CLASS = "legend-list-content-container";
+var LEGEND_LIST_SCROLLBAR_X_HIDDEN_CLASS = "legend-list-scrollbar-x-hidden";
+var LEGEND_LIST_SCROLLBAR_Y_HIDDEN_CLASS = "legend-list-scrollbar-y-hidden";
+
 // src/components/ListComponentScrollView.tsx
 var SCROLLBAR_HIDDEN_STYLE_ID = "legend-list-scrollbar-axis-hidden-style";
 var SCROLL_END_FALLBACK_MS = 200;
@@ -6351,6 +6450,7 @@ var ListComponentScrollView = React3.forwardRef(function ListComponentScrollView
   showsVerticalScrollIndicator = true,
   refreshControl,
   useWindowScroll = false,
+  scrollElement: externalScrollElement,
   onLayout,
   ...props
 }, ref) {
@@ -6359,31 +6459,38 @@ var ListComponentScrollView = React3.forwardRef(function ListComponentScrollView
   const [anchoredEndSpaceSize] = useArr$(["anchoredEndSpaceSize"]);
   const scrollRef = React3.useRef(null);
   const contentRef = React3.useRef(null);
-  const isWindowScroll = useWindowScroll;
+  const externalTarget = externalScrollElement === void 0 && useWindowScroll ? typeof window === "undefined" ? null : window : externalScrollElement;
+  const isWindowScroll = isWindowTarget(externalTarget);
+  const isExternalScroll = externalTarget !== void 0;
   const getScrollTarget = React3.useCallback(
-    () => resolveScrollEventTarget(scrollRef.current, isWindowScroll),
-    [isWindowScroll]
+    () => resolveScrollEventTarget(scrollRef.current, externalTarget),
+    [externalTarget]
   );
   const getMaxScrollOffset = React3.useCallback(() => {
     const scrollElement = scrollRef.current;
-    const contentSize = getScrollContentSize(scrollElement, contentRef.current, isWindowScroll);
-    const layoutMeasurement = getLayoutMeasurement(scrollElement, isWindowScroll, horizontal);
+    const contentSize = getScrollContentSize(scrollElement, contentRef.current, externalTarget);
+    const layoutMeasurement = getLayoutMeasurement(scrollElement, externalTarget, horizontal);
     return getMaxOffset(contentSize, layoutMeasurement, horizontal);
-  }, [horizontal, isWindowScroll]);
+  }, [externalTarget, horizontal]);
+  const getRawScrollOffset = React3.useCallback(() => {
+    var _a4;
+    const element = scrollRef.current;
+    if (isExternalScroll) {
+      const scroll = getScrollPosition(externalTarget);
+      const listPos = getElementScrollPosition(element, externalTarget);
+      return horizontal ? scroll.x - listPos.left : scroll.y - listPos.top;
+    }
+    return (_a4 = horizontal ? element == null ? void 0 : element.scrollLeft : element == null ? void 0 : element.scrollTop) != null ? _a4 : 0;
+  }, [externalTarget, horizontal, isExternalScroll]);
+  const isScrollInRange = React3.useCallback(() => {
+    if (!isExternalScroll) return true;
+    const offset = getRawScrollOffset();
+    return offset >= -1 && offset <= getMaxScrollOffset() + 1;
+  }, [getMaxScrollOffset, getRawScrollOffset, isExternalScroll]);
   const getCurrentScrollOffset = React3.useCallback(() => {
-    const scrollElement = scrollRef.current;
-    if (isWindowScroll) {
-      const maxOffset = getMaxScrollOffset();
-      const scroll = getWindowScrollPosition();
-      const listPos = getElementDocumentPosition(scrollElement, scroll);
-      const rawOffset = horizontal ? scroll.x - listPos.left : scroll.y - listPos.top;
-      return clampOffset(rawOffset, maxOffset);
-    }
-    if (!scrollElement) {
-      return 0;
-    }
-    return horizontal ? scrollElement.scrollLeft : scrollElement.scrollTop;
-  }, [getMaxScrollOffset, horizontal, isWindowScroll]);
+    const offset = getRawScrollOffset();
+    return isExternalScroll ? clampOffset(offset, getMaxScrollOffset()) : offset;
+  }, [getMaxScrollOffset, getRawScrollOffset, isExternalScroll]);
   const scrollToLocalOffset = React3.useCallback(
     (offset, animated) => {
       const scrollElement = scrollRef.current;
@@ -6395,10 +6502,10 @@ var ListComponentScrollView = React3.forwardRef(function ListComponentScrollView
       const clampedOffset = clampOffset(offset, maxOffset);
       const behavior = animated ? "smooth" : "auto";
       const options = { behavior };
-      if (isWindowScroll) {
-        const scroll = getWindowScrollPosition();
-        const listPos = getElementDocumentPosition(scrollElement, scroll);
-        const { left, top } = resolveWindowScrollTarget({
+      if (isExternalScroll) {
+        const scroll = getScrollPosition(externalTarget);
+        const listPos = getElementScrollPosition(scrollElement, externalTarget);
+        const { left, top } = resolveExternalScrollOffset({
           clampedOffset,
           horizontal,
           listPos,
@@ -6413,7 +6520,7 @@ var ListComponentScrollView = React3.forwardRef(function ListComponentScrollView
       }
       target.scrollTo(options);
     },
-    [getMaxScrollOffset, getScrollTarget, horizontal, isWindowScroll]
+    [externalTarget, getMaxScrollOffset, getScrollTarget, horizontal, isExternalScroll]
   );
   React3.useImperativeHandle(ref, () => {
     const api = {
@@ -6421,11 +6528,14 @@ var ListComponentScrollView = React3.forwardRef(function ListComponentScrollView
         var _a4;
         return (_a4 = scrollRef.current) == null ? void 0 : _a4.getBoundingClientRect();
       },
+      getContentNode: () => contentRef.current,
       getCurrentScrollOffset,
       getMaxScrollOffset,
-      getScrollableNode: () => resolveScrollableNode(scrollRef.current, isWindowScroll),
-      getScrollEventTarget: () => getScrollTarget(),
-      getScrollResponder: () => resolveScrollableNode(scrollRef.current, isWindowScroll),
+      getRawScrollOffset,
+      getScrollableNode: () => resolveScrollableNode(scrollRef.current, externalTarget),
+      getScrollEventTarget: getScrollTarget,
+      getScrollResponder: () => resolveScrollableNode(scrollRef.current, externalTarget),
+      isScrollInRange,
       isWindowScroll: () => isWindowScroll,
       scrollBy: (x, y) => {
         const target = getScrollTarget();
@@ -6449,14 +6559,24 @@ var ListComponentScrollView = React3.forwardRef(function ListComponentScrollView
       }
     };
     return api;
-  }, [getCurrentScrollOffset, getMaxScrollOffset, getScrollTarget, horizontal, isWindowScroll, scrollToLocalOffset]);
+  }, [
+    externalTarget,
+    getCurrentScrollOffset,
+    getRawScrollOffset,
+    getMaxScrollOffset,
+    isScrollInRange,
+    getScrollTarget,
+    horizontal,
+    isWindowScroll,
+    scrollToLocalOffset
+  ]);
   const emitScroll = React3.useCallback(() => {
     if (!onScroll2 || !scrollRef.current) {
       return;
     }
     const contentSize = getContentSize2(contentRef.current);
-    const layoutMeasurement = getLayoutMeasurement(scrollRef.current, isWindowScroll, horizontal);
-    const offset = getCurrentScrollOffset();
+    const layoutMeasurement = getLayoutMeasurement(scrollRef.current, externalTarget, horizontal);
+    const offset = getRawScrollOffset();
     const scrollEvent = {
       nativeEvent: {
         contentOffset: {
@@ -6474,7 +6594,7 @@ var ListComponentScrollView = React3.forwardRef(function ListComponentScrollView
       }
     };
     onScroll2(scrollEvent);
-  }, [getCurrentScrollOffset, horizontal, isWindowScroll, onScroll2]);
+  }, [externalTarget, getRawScrollOffset, horizontal, onScroll2]);
   const scrollEventCoalescer = useRafCoalescer(emitScroll);
   const scrollEndFallbackRef = React3.useRef(void 0);
   const emitScrollEnd = React3.useCallback(() => {
@@ -6536,14 +6656,14 @@ var ListComponentScrollView = React3.forwardRef(function ListComponentScrollView
       const delta = horizontal ? event.deltaX || (event.shiftKey ? event.deltaY : 0) : event.deltaY;
       if (delta < 0 && !event.ctrlKey && !event.defaultPrevented && (ctx.state.maintainingScrollAtEnd || ctx.state.pendingMaintainScrollAtEnd)) {
         const offset = getCurrentScrollOffset();
-        if (interruptMaintainScrollAtEnd(ctx)) {
+        if (interruptMaintainScrollAtEnd(ctx) && isScrollInRange()) {
           scrollToLocalOffset(offset, false);
         }
       }
     };
     target.addEventListener("wheel", onWheel, { passive: true });
     return () => target.removeEventListener("wheel", onWheel);
-  }, [ctx, getCurrentScrollOffset, getScrollTarget, horizontal, scrollToLocalOffset]);
+  }, [ctx, getCurrentScrollOffset, getScrollTarget, horizontal, isScrollInRange, scrollToLocalOffset]);
   React3.useEffect(() => {
     const doScroll = () => {
       if (contentOffset) {
@@ -6551,44 +6671,28 @@ var ListComponentScrollView = React3.forwardRef(function ListComponentScrollView
       }
     };
     doScroll();
-    requestAnimationFrame(doScroll);
+    const frame = requestAnimationFrame(doScroll);
+    return () => cancelAnimationFrame(frame);
   }, [contentOffset == null ? void 0 : contentOffset.x, contentOffset == null ? void 0 : contentOffset.y, horizontal, scrollToLocalOffset]);
   React3.useLayoutEffect(() => {
-    if (!onLayout || !scrollRef.current) return;
     const element = scrollRef.current;
-    const fireLayout = () => {
-      onLayout({
-        nativeEvent: {
-          layout: getLayoutRectangle(element, isWindowScroll, horizontal)
-        }
-      });
-    };
-    fireLayout();
-    const resizeObserver = new ResizeObserver(() => {
-      fireLayout();
-    });
-    resizeObserver.observe(element);
-    const onWindowResize = () => {
-      fireLayout();
-    };
-    if (isWindowScroll && typeof window !== "undefined" && typeof window.addEventListener === "function") {
-      window.addEventListener("resize", onWindowResize);
-    }
-    return () => {
-      resizeObserver.disconnect();
-      if (isWindowScroll && typeof window !== "undefined" && typeof window.removeEventListener === "function") {
-        window.removeEventListener("resize", onWindowResize);
+    if (!onLayout || !element) return;
+    return observeScrollLayout(element, externalTarget, () => {
+      if (isExternalScroll && !ctx.state.lastLayout && !ctx.state.initialScroll) {
+        ctx.state.scroll = ctx.state.scrollPending = getRawScrollOffset();
       }
-    };
-  }, [isWindowScroll, onLayout]);
-  const hiddenScrollIndicatorClassName = !isWindowScroll && (horizontal ? !showsHorizontalScrollIndicator && LEGEND_LIST_SCROLLBAR_X_HIDDEN_CLASS : !showsVerticalScrollIndicator && LEGEND_LIST_SCROLLBAR_Y_HIDDEN_CLASS);
+      onLayout({ nativeEvent: { layout: getLayoutRectangle(element, externalTarget, horizontal) } });
+      if (isExternalScroll) emitScroll();
+    });
+  }, [ctx, emitScroll, externalTarget, getRawScrollOffset, horizontal, isExternalScroll, onLayout]);
+  const hiddenScrollIndicatorClassName = !isExternalScroll && (horizontal ? !showsHorizontalScrollIndicator && LEGEND_LIST_SCROLLBAR_X_HIDDEN_CLASS : !showsVerticalScrollIndicator && LEGEND_LIST_SCROLLBAR_Y_HIDDEN_CLASS);
   React3.useLayoutEffect(() => {
     if (hiddenScrollIndicatorClassName) {
       ensureScrollbarHiddenStyle();
     }
   }, [hiddenScrollIndicatorClassName]);
   const scrollViewStyle = {
-    ...isWindowScroll ? {} : {
+    ...isExternalScroll ? {} : {
       overflow: "auto",
       overflowX: horizontal ? "auto" : showsHorizontalScrollIndicator ? "auto" : "hidden",
       overflowY: horizontal ? showsVerticalScrollIndicator ? "auto" : "hidden" : "auto",
@@ -6623,11 +6727,10 @@ var ListComponentScrollView = React3.forwardRef(function ListComponentScrollView
     scrollEventThrottle: _scrollEventThrottle,
     ScrollComponent: _ScrollComponent,
     snapToOffsets,
-    useWindowScroll: _useWindowScroll,
     className: scrollViewClassNameProp,
     ...webProps
   } = props;
-  const snapOffsets = !isWindowScroll ? getFiniteSnapOffsets(snapToOffsets) : [];
+  const snapOffsets = !isExternalScroll ? getFiniteSnapOffsets(snapToOffsets) : [];
   if (snapOffsets.length > 0) {
     scrollViewStyle.scrollSnapType = horizontal ? "x mandatory" : "y mandatory";
     contentStyle.position = (_c = contentStyle.position) != null ? _c : "relative";
@@ -6702,12 +6805,12 @@ function getScrollAdjustAxis(horizontal) {
   };
 }
 function getScrollAdjustTarget(ctx, contentNode) {
-  var _a3, _b, _c;
+  var _a3, _b, _c, _d, _e;
   const scrollView = (_a3 = ctx.state) == null ? void 0 : _a3.refScroller.current;
   const scrollElement = (_c = (_b = scrollView == null ? void 0 : scrollView.getScrollableNode) == null ? void 0 : _b.call(scrollView)) != null ? _c : null;
   let resolvedContentNode = null;
   if (scrollElement) {
-    resolvedContentNode = (contentNode == null ? void 0 : contentNode.isConnected) && contentNode.parentElement === scrollElement ? contentNode : scrollElement.querySelector(`:scope > .${LEGEND_LIST_CONTENT_CONTAINER_CLASS}`);
+    resolvedContentNode = (_e = (_d = scrollView == null ? void 0 : scrollView.getContentNode) == null ? void 0 : _d.call(scrollView)) != null ? _e : (contentNode == null ? void 0 : contentNode.isConnected) && contentNode.parentElement === scrollElement ? contentNode : scrollElement.querySelector(`:scope > .${LEGEND_LIST_CONTENT_CONTAINER_CLASS}`);
   }
   return scrollElement ? { contentNode: resolvedContentNode, scrollElement } : null;
 }
@@ -6722,6 +6825,7 @@ function ScrollAdjust() {
   const temporaryPaddingRef = React3__namespace.useRef(void 0);
   const contentNodeRef = React3__namespace.useRef(null);
   const callback = React3__namespace.useCallback(() => {
+    var _a3, _b, _c;
     const scrollAdjust = peek$(ctx, "scrollAdjust");
     const scrollAdjustUserOffset = peek$(ctx, "scrollAdjustUserOffset");
     const scrollOffset = (scrollAdjust || 0) + (scrollAdjustUserOffset || 0);
@@ -6732,17 +6836,21 @@ function ScrollAdjust() {
         const horizontal = !!ctx.state.props.horizontal;
         const axis = getScrollAdjustAxis(horizontal);
         const { contentNode, scrollElement: el } = target;
-        const currentScroll = horizontal ? el.scrollLeft : el.scrollTop;
+        const scroller = ctx.state.refScroller.current;
+        const parentScroll = horizontal ? el.scrollLeft : el.scrollTop;
+        const isExternal = ctx.state.props.hasExternalScroll;
+        const currentScroll = (_b = isExternal ? (_a3 = scroller == null ? void 0 : scroller.getCurrentScrollOffset) == null ? void 0 : _a3.call(scroller) : void 0) != null ? _b : parentScroll;
+        const isOutsideList = ((_c = scroller == null ? void 0 : scroller.isScrollInRange) == null ? void 0 : _c.call(scroller)) === false;
         const userOffsetDelta = (scrollAdjustUserOffset || 0) - lastScrollAdjustUserOffsetRef.current;
         const intendedScroll = userOffsetDelta !== 0 ? currentScroll + userOffsetDelta : ctx.state.scroll;
         const scrollDelta = intendedScroll - currentScroll;
-        const shouldScroll = Math.abs(scrollDelta) > 0.01;
+        const shouldScroll = !isOutsideList && Math.abs(scrollDelta) > 0.01;
         const scrollBy = () => scrollAdjustBy(el, axis.x * scrollDelta, axis.y * scrollDelta);
         contentNodeRef.current = contentNode;
         if (shouldScroll && contentNode) {
-          const totalSize = contentNode[axis.contentSizeKey];
+          const totalSize = isExternal ? el[axis.contentSizeKey] : contentNode[axis.contentSizeKey];
           const viewportSize = el[axis.viewportSizeKey];
-          const nextScroll = currentScroll + scrollDelta;
+          const nextScroll = parentScroll + scrollDelta;
           const needsTemporaryPadding = scrollDelta > 0 && !ctx.state.adjustingFromInitialMount && totalSize < nextScroll + viewportSize;
           if (needsTemporaryPadding) {
             const currentInlinePaddingEnd = contentNode.style[axis.paddingEndProp];
@@ -6907,6 +7015,7 @@ var ListComponent = typedMemo(function ListComponent2({
   stickyHeaderConfig,
   stickyHeaderIndices,
   useWindowScroll = false,
+  scrollElement,
   ...rest
 }) {
   const ctx = useStateContext();
@@ -6972,7 +7081,7 @@ var ListComponent = typedMemo(function ListComponent2({
     SnapOrScroll,
     {
       ...rest,
-      ...ScrollComponent === ListComponentScrollView ? { onInternalScrollEnd, useWindowScroll } : {} ,
+      ...ScrollComponent === ListComponentScrollView ? { onInternalScrollEnd, scrollElement, useWindowScroll } : {} ,
       contentContainerStyle: [
         horizontal ? { height: "100%" } : {},
         contentContainerStyle,
@@ -7012,7 +7121,15 @@ var WEB_UNBOUNDED_HEIGHT_CONTAINER_RATIO = 0.9;
 var WEB_UNBOUNDED_HEIGHT_VIEWPORT_RATIO = 0.9;
 function useDevChecksImpl(props) {
   const ctx = useStateContext();
-  const { anchoredEndSpace, childrenMode, keyExtractor, numColumns, renderScrollComponent, useWindowScroll } = props;
+  const {
+    anchoredEndSpace,
+    childrenMode,
+    keyExtractor,
+    numColumns,
+    renderScrollComponent,
+    scrollElement,
+    useWindowScroll
+  } = props;
   const hasAnchoredEndSpace = !!anchoredEndSpace;
   React3.useEffect(() => {
     if (hasAnchoredEndSpace && (numColumns != null ? numColumns : 1) > 1) {
@@ -7023,13 +7140,13 @@ function useDevChecksImpl(props) {
     }
   }, [hasAnchoredEndSpace, numColumns]);
   React3.useEffect(() => {
-    if (useWindowScroll && renderScrollComponent) {
+    if ((useWindowScroll || scrollElement !== void 0) && renderScrollComponent) {
       warnDevOnce(
         "useWindowScrollRenderScrollComponent",
-        "useWindowScroll is not supported when renderScrollComponent is provided."
+        "useWindowScroll and scrollElement are not supported when renderScrollComponent is provided."
       );
     }
-  }, [renderScrollComponent, useWindowScroll]);
+  }, [renderScrollComponent, scrollElement, useWindowScroll]);
   React3.useEffect(() => {
     if (!keyExtractor && !ctx.state.isFirst && ctx.state.didDataChange && !childrenMode) {
       warnDevOnce(
@@ -7041,8 +7158,8 @@ function useDevChecksImpl(props) {
   React3.useEffect(() => {
     const state = ctx.state;
     const dataLength = state.props.data.length;
-    const useWindowScrollResolved = state.props.useWindowScroll;
-    if (useWindowScrollResolved || dataLength < WEB_UNBOUNDED_HEIGHT_MIN_DATA_LENGTH) {
+    const usesExternalScroll = state.props.hasExternalScroll;
+    if (usesExternalScroll || dataLength < WEB_UNBOUNDED_HEIGHT_MIN_DATA_LENGTH) {
       return;
     }
     const warnIfUnboundedOuterSize = () => {
@@ -7206,7 +7323,8 @@ function doInitialAllocateContainers(ctx) {
           calculateItemsInView(ctx, { dataChanged: true, doMVCP: true });
         });
       } else {
-        calculateItemsInView(ctx, { dataChanged: true, doMVCP: true });
+        const reuseInitialPositions = !state.didLoad && state.positionsAreCurrent && !state.didDataChange && !state.didColumnsChange;
+        calculateItemsInView(ctx, { dataChanged: !reuseInitialPositions, doMVCP: true });
       }
     }
     return true;
@@ -7249,12 +7367,14 @@ function handleLayout(ctx, layoutParam, setCanRender) {
     updateContentMetricsState(ctx);
     state.lastBatchingAction = Date.now();
     state.scrollForNextCalculateItemsInView = void 0;
-    if (scrollLength > 0) {
-      doInitialAllocateContainers(ctx);
-    }
-    if (needsCalculate) {
+    const didAllocate = scrollLength > 0 && doInitialAllocateContainers(ctx);
+    if (needsCalculate && (!didAllocate || state.initialScroll)) {
       calculateItemsInView(ctx, { doMVCP: true });
     }
+    const scrollTarget = state.scrollingTo;
+    if (scrollLength !== previousLength && (scrollTarget == null ? void 0 : scrollTarget.viewPositionFallback) && !scrollTarget.isInitialScroll && scrollTarget.index !== void 0) {
+      scrollToIndex(ctx, { ...scrollTarget, forceScroll: true, index: scrollTarget.index });
+    }
     if (didChange || otherAxisSize !== prevOtherAxisSize) {
       set$(ctx, "scrollSize", { height: layout.height, width: layout.width });
     }
@@ -7330,7 +7450,7 @@ function onScroll(ctx, event) {
   state.didFinishInitialScroll && ((_f = state.initialScroll) == null ? void 0 : _f.viewPosition) === 1 && state.scroll > state.scrollLength;
   state.lastNativeScroll = newScroll;
   state.lastNativeScrollTime = Date.now();
-  if (state.scrollingTo && state.scrollingTo.offset >= newScroll) {
+  if (!state.props.hasExternalScroll && state.scrollingTo && state.scrollingTo.offset >= newScroll) {
     const maxOffset = clampScrollOffset(ctx, newScroll, state.scrollingTo);
     if (newScroll !== maxOffset && Math.abs(newScroll - maxOffset) > 1) {
       newScroll = maxOffset;
@@ -8097,6 +8217,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     stickyHeaderIndices: stickyHeaderIndicesProp,
     style: styleProp,
     useWindowScroll = false,
+    scrollElement,
     viewabilityConfig,
     viewabilityConfigCallbackPairs,
     ...rest
@@ -8152,9 +8273,10 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     viewPosition: 1
   } : hasInitialScrollIndex ? typeof initialScrollIndexProp === "object" ? {
     index: (_b = initialScrollIndexProp.index) != null ? _b : 0,
-    preserveForBottomPadding: initialScrollIndexProp.viewOffset === void 0 && initialScrollIndexProp.viewPosition === 1 ? true : void 0,
-    viewOffset: (_c = initialScrollIndexProp.viewOffset) != null ? _c : initialScrollIndexProp.viewPosition === 1 ? getEndAlignedViewOffset(stylePaddingEndState) : 0,
-    viewPosition: (_d = initialScrollIndexProp.viewPosition) != null ? _d : 0
+    preserveForBottomPadding: initialScrollIndexProp.viewOffset === void 0 && initialScrollIndexProp.viewPosition === 1 && initialScrollIndexProp.viewPositionFallback === void 0 ? true : void 0,
+    viewOffset: (_c = initialScrollIndexProp.viewOffset) != null ? _c : initialScrollIndexProp.viewPosition === 1 && initialScrollIndexProp.viewPositionFallback === void 0 ? getEndAlignedViewOffset(stylePaddingEndState) : 0,
+    viewPosition: (_d = initialScrollIndexProp.viewPosition) != null ? _d : 0,
+    viewPositionFallback: initialScrollIndexProp.viewPositionFallback
   } : {
     index: initialScrollIndexProp != null ? initialScrollIndexProp : 0,
     preserveForBottomPadding: shouldBottomAlignNumericInitialScrollIndex ? true : void 0,
@@ -8191,7 +8313,9 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     dataVersion,
     keyExtractor
   ]);
-  const useWindowScrollResolved = !!useWindowScroll && !renderScrollComponent;
+  const scrollElementResolved = !renderScrollComponent ? scrollElement : void 0;
+  const useWindowScrollResolved = !!useWindowScroll && scrollElementResolved === void 0 && !renderScrollComponent;
+  const hasExternalScroll = useWindowScrollResolved || scrollElementResolved !== void 0;
   const refState = React3.useRef(void 0);
   const hasOverrideItemLayout = !!overrideItemLayout;
   const prevHasOverrideItemLayout = React3.useRef(hasOverrideItemLayout);
@@ -8329,6 +8453,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     estimatedItemSize,
     getFixedItemSize: useWrapIfItem(getFixedItemSize),
     getItemType: useWrapIfItem(getItemType),
+    hasExternalScroll,
     hideItemsUntilMeasured: experimental_hideItemsUntilMeasured,
     horizontal: !!horizontal,
     itemsAreEqual,
@@ -8520,8 +8645,9 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
   const { onLayout } = useOnLayoutSync({
     onLayoutChange,
     onLayoutProp,
-    ref: refScroller
+    ref: refScroller,
     // the type of ScrollView doesn't include measure?
+    webExternalScroll: hasExternalScroll
   });
   React3.useLayoutEffect(() => {
     if (snapToIndices) {
@@ -8687,6 +8813,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       refScrollView: combinedRef,
       renderScrollComponent,
       scrollAdjustHandler: (_s = refState.current) == null ? void 0 : _s.scrollAdjustHandler,
+      scrollElement: scrollElementResolved,
       scrollEventThrottle: 0,
       snapToIndices,
       stickyHeaderIndices,