@legendapp/list 3.4.0 → 3.5.0

package/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 3.5.0
+
+- Feat: Add `scrollElement` so web lists can share an ancestor element's scrollbar
+- Fix: Stopping scrolling keeps rows prepared in the last scroll direction instead of shifting the render buffer backward.
+- Perf: Single-column lists do less layout work during initial rendering and scrolling when item sizes and data are unchanged.
+
 ## 3.4.0
 
 - Feat: Add `onReady`, called after each initial placement and scroll cycle completes, including cycles restarted by a `dataKey` change.

package/README.md

@@ -112,6 +112,39 @@ export default LegendListExample
 
 ---
 
+### Sharing a scrollbar on the web
+
+React DOM lists can use an ancestor element's scrollbar with `scrollElement`:
+
+```tsx
+import { LegendList } from "@legendapp/list/react";
+import { useState } from "react";
+
+function History({ swaps, renderSwap }) {
+    const [scrollElement, setScrollElement] = useState<HTMLDivElement | null>(null);
+
+    return (
+        <div ref={setScrollElement} style={{ height: 600, overflow: "auto" }}>
+            <ProfileHeader />
+            <LegendList
+                data={swaps}
+                renderItem={renderSwap}
+                keyExtractor={(swap) => swap.id}
+                scrollElement={scrollElement}
+            />
+        </div>
+    );
+}
+```
+
+Use a state-backed callback ref so the list receives the element after mounting and whenever it changes. `null` waits for an external element; `undefined` keeps the default list-owned scrollbar. The element must be an ancestor of the list. Keep the list's own height unconstrained so its content contributes to the parent's scroll range.
+
+Multiple lists can share the same element, including lists in separate columns. Each uses the owner's viewport on the scroll axis and its own width/height on the cross axis. Content above the list is accounted for automatically, including preceding content that resizes. `scrollToIndex`, `scrollToOffset`, and `scrollToEnd` remain list-relative and move the shared owner.
+
+`maintainVisibleContentPosition` anchors changes to the list's own rows; it does not freeze the layout of surrounding content. An offscreen list does not pull the owner back into view to apply a measurement correction.
+
+`useWindowScroll` continues to use the browser window. Both modes share the same web implementation; `scrollElement` takes precedence when provided. As with window scrolling, external mode does not configure the owner's scrollbar styling or CSS snapping. It is not supported with `renderScrollComponent`.
+
 ## How to Build
 
 1. `bun i`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@legendapp/list",
-  "version": "3.4.0",
+  "version": "3.5.0",
   "description": "Legend List is a drop-in replacement for FlatList with much better performance and supporting dynamically sized items.",
   "sideEffects": false,
   "private": false,

package/react-native.js

@@ -935,8 +935,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");
 }
 
@@ -949,6 +955,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;
@@ -1177,6 +1186,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);
@@ -1237,6 +1247,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);
     }
   }
@@ -1850,6 +1861,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 = Platform.OS === "web" && isUserScrollEvent && newScroll < prevScroll && !!(state.maintainingScrollAtEnd || state.pendingMaintainScrollAtEnd);
   if (didCancelMaintainScrollAtEnd) {
     finishMaintainScrollAtEnd(ctx);
@@ -1929,10 +1943,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 {
@@ -1944,11 +1958,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;
@@ -1960,13 +1974,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;
@@ -1980,8 +1994,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");
@@ -3319,6 +3334,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;
@@ -3599,7 +3615,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 {
@@ -3615,6 +3631,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;
@@ -3729,6 +3750,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);
@@ -4291,7 +4316,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) {
@@ -4357,7 +4382,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,
@@ -4391,14 +4416,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
     );
@@ -4407,7 +4432,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,
@@ -4459,7 +4484,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);
       }
     };
@@ -4486,7 +4511,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 {
@@ -4496,8 +4525,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;
@@ -4626,7 +4655,7 @@ function calculateItemsInView(ctx, params = {}) {
             nextTop = top;
           }
         }
-        if (visibleRange.startNoBuffer !== null) {
+        if (startBuffered !== null) {
           if (top <= scrollBottomBuffered) {
             endBuffered = i;
             if (scrollBottomBuffered > totalSize) {
@@ -4637,6 +4666,8 @@ function calculateItemsInView(ctx, params = {}) {
           } else {
             foundEnd = true;
           }
+        } else if (top > scrollBottomBuffered) {
+          foundEnd = true;
         }
       }
     }
@@ -4654,6 +4685,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 = [];
@@ -4677,7 +4714,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) => {
@@ -4693,7 +4732,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);
@@ -4715,8 +4754,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);
@@ -4725,8 +4764,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
@@ -4853,19 +4892,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);
   });
 }
 
@@ -5160,6 +5199,7 @@ function updateOneItemSize(ctx, itemKey, sizeObj, resolvedMeasurementItem, notif
     return 0;
   }
   const size = Platform.OS === "web" ? Math.round(rawSize) : roundSize(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 : "" : "";
@@ -6260,6 +6300,7 @@ var ListComponent = typedMemo(function ListComponent2({
   stickyHeaderConfig,
   stickyHeaderIndices,
   useWindowScroll = false,
+  scrollElement,
   ...rest
 }) {
   const ctx = useStateContext();
@@ -6325,7 +6366,7 @@ var ListComponent = typedMemo(function ListComponent2({
     SnapOrScroll,
     {
       ...rest,
-      ...Platform.OS === "web" ? ScrollComponent === ListComponentScrollView ? { onInternalScrollEnd, useWindowScroll } : {} : { onScrollBeginDrag: onInternalScrollBeginDrag, onScrollEndDrag: onInternalScrollEndDrag },
+      ...Platform.OS === "web" ? ScrollComponent === ListComponentScrollView ? { onInternalScrollEnd, scrollElement, useWindowScroll } : {} : { onScrollBeginDrag: onInternalScrollBeginDrag, onScrollEndDrag: onInternalScrollEndDrag },
       contentContainerStyle: [
         horizontal ? { height: "100%" } : {},
         contentContainerStyle,
@@ -6365,7 +6406,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;
   React2.useEffect(() => {
     if (hasAnchoredEndSpace && (numColumns != null ? numColumns : 1) > 1) {
@@ -6376,13 +6425,13 @@ function useDevChecksImpl(props) {
     }
   }, [hasAnchoredEndSpace, numColumns]);
   React2.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]);
   React2.useEffect(() => {
     if (!keyExtractor && !ctx.state.isFirst && ctx.state.didDataChange && !childrenMode) {
       warnDevOnce(
@@ -6394,8 +6443,8 @@ function useDevChecksImpl(props) {
   React2.useEffect(() => {
     const state = ctx.state;
     const dataLength = state.props.data.length;
-    const useWindowScrollResolved = state.props.useWindowScroll;
-    if (Platform.OS !== "web" || useWindowScrollResolved || dataLength < WEB_UNBOUNDED_HEIGHT_MIN_DATA_LENGTH) {
+    const usesExternalScroll = state.props.hasExternalScroll;
+    if (Platform.OS !== "web" || usesExternalScroll || dataLength < WEB_UNBOUNDED_HEIGHT_MIN_DATA_LENGTH) {
       return;
     }
     const warnIfUnboundedOuterSize = () => {
@@ -6559,7 +6608,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;
@@ -6598,10 +6648,8 @@ 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 });
     }
     if (didChange || otherAxisSize !== prevOtherAxisSize) {
@@ -6683,7 +6731,7 @@ function onScroll(ctx, event) {
   }
   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;
@@ -7466,6 +7514,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     stickyHeaderIndices: stickyHeaderIndicesProp,
     style: styleProp,
     useWindowScroll = false,
+    scrollElement,
     viewabilityConfig,
     viewabilityConfigCallbackPairs,
     ...rest
@@ -7560,7 +7609,9 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     dataVersion,
     keyExtractor
   ]);
-  const useWindowScrollResolved = Platform.OS === "web" && !!useWindowScroll && !renderScrollComponent;
+  const scrollElementResolved = Platform.OS === "web" && !renderScrollComponent ? scrollElement : void 0;
+  const useWindowScrollResolved = Platform.OS === "web" && !!useWindowScroll && scrollElementResolved === void 0 && !renderScrollComponent;
+  const hasExternalScroll = useWindowScrollResolved || scrollElementResolved !== void 0;
   const refState = React2.useRef(void 0);
   const hasOverrideItemLayout = !!overrideItemLayout;
   const prevHasOverrideItemLayout = React2.useRef(hasOverrideItemLayout);
@@ -7698,6 +7749,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     estimatedItemSize,
     getFixedItemSize: useWrapIfItem(getFixedItemSize),
     getItemType: useWrapIfItem(getItemType),
+    hasExternalScroll,
     hideItemsUntilMeasured: experimental_hideItemsUntilMeasured,
     horizontal: !!horizontal,
     itemsAreEqual,
@@ -7894,9 +7946,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
   const { onLayout } = useOnLayoutSync({
     onLayoutChange,
     onLayoutProp,
-    ref: refScroller
-    // the type of ScrollView doesn't include measure?
-  });
+    ref: refScroller});
   React2.useLayoutEffect(() => {
     if (snapToIndices) {
       updateSnapToOffsets(ctx);
@@ -8064,6 +8114,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,