@legendapp/list 3.3.9 → 3.3.11

package/react-native.web.mjs

@@ -959,6 +959,7 @@ function supersedeInitialScroll(ctx) {
 function finishInitialScroll(ctx, options) {
   var _a3, _b, _c;
   const state = ctx.state;
+  const freshDataTransitionEpoch = state.freshDataTransitionEpoch;
   if ((options == null ? void 0 : options.resolvedOffset) !== void 0) {
     syncInitialScrollOffset(state, options.resolvedOffset);
   } else if ((options == null ? void 0 : options.syncObservedOffset) && ((_a3 = state.initialScrollSession) == null ? void 0 : _a3.kind) === "offset") {
@@ -968,9 +969,13 @@ function finishInitialScroll(ctx, options) {
     }
   }
   const complete = () => {
-    var _a4, _b2, _c2, _d, _e;
-    const shouldReleaseDeferredPublicOnScroll = ((_a4 = state.initialScrollSession) == null ? void 0 : _a4.kind) === "bootstrap";
-    const finalScrollOffset = (_d = (_c2 = (_b2 = options == null ? void 0 : options.resolvedOffset) != null ? _b2 : state.scrollPending) != null ? _c2 : state.scroll) != null ? _d : 0;
+    var _a4, _b2, _c2, _d, _e, _f;
+    if (freshDataTransitionEpoch !== state.freshDataTransitionEpoch) {
+      (_a4 = options == null ? void 0 : options.onFinished) == null ? void 0 : _a4.call(options);
+      return;
+    }
+    const shouldReleaseDeferredPublicOnScroll = ((_b2 = state.initialScrollSession) == null ? void 0 : _b2.kind) === "bootstrap";
+    const finalScrollOffset = (_e = (_d = (_c2 = options == null ? void 0 : options.resolvedOffset) != null ? _c2 : state.scrollPending) != null ? _d : state.scroll) != null ? _e : 0;
     initialScrollWatchdog.clear(state);
     if ((options == null ? void 0 : options.preserveTarget) && state.initialScroll) {
       state.clearPreservedInitialScrollOnNextFinish = void 0;
@@ -999,7 +1004,7 @@ function finishInitialScroll(ctx, options) {
     if (shouldReleaseDeferredPublicOnScroll) {
       releaseDeferredPublicOnScroll(ctx, finalScrollOffset);
     }
-    (_e = options == null ? void 0 : options.onFinished) == null ? void 0 : _e.call(options);
+    (_f = options == null ? void 0 : options.onFinished) == null ? void 0 : _f.call(options);
   };
   if (options == null ? void 0 : options.waitForCompletionFrame) {
     requestAnimationFrame(complete);
@@ -1281,153 +1286,21 @@ function clampScrollOffset(ctx, offset, scrollTarget) {
   return clampedOffset;
 }
 
-// src/core/finishScrollTo.ts
-function finishScrollTo(ctx) {
-  var _a3, _b;
-  const state = ctx.state;
-  if (state == null ? void 0 : state.scrollingTo) {
-    cancelScrollCompletionChecks(state);
-    const resolvePendingScroll = state.pendingScrollResolve;
-    state.pendingScrollResolve = void 0;
-    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);
-    }
-    {
-      state.scrollAdjustHandler.commitPendingAdjust(scrollingTo);
-    }
-    if (scrollingTo.isInitialScroll || state.initialScroll) {
-      const isOffsetSession = ((_a3 = state.initialScrollSession) == null ? void 0 : _a3.kind) === "offset";
-      const shouldPreserveResizeTarget = !!scrollingTo.isInitialScroll && !state.clearPreservedInitialScrollOnNextFinish && state.props.data.length > 0 && ((_b = state.initialScroll) == null ? void 0 : _b.viewPosition) === 1;
-      finishInitialScroll(ctx, {
-        onFinished: () => {
-          resolvePendingScroll == null ? void 0 : resolvePendingScroll();
-        },
-        preserveTarget: isOffsetSession && state.props.data.length === 0 || shouldPreserveResizeTarget,
-        recalculateItems: true,
-        schedulePreservedTargetClear: shouldPreserveResizeTarget,
-        syncObservedOffset: isOffsetSession,
-        waitForCompletionFrame: !!scrollingTo.waitForInitialScrollCompletionFrame
-      });
-      return;
-    }
-    recalculateSettledScroll(ctx);
-    resolvePendingScroll == null ? void 0 : resolvePendingScroll();
-  }
-}
-
-// src/core/doScrollTo.ts
-var SCROLL_END_IDLE_MS = 80;
-var SCROLL_END_MAX_MS = 1500;
-var SMOOTH_SCROLL_DURATION_MS = 320;
-var SCROLL_END_TARGET_EPSILON = 1;
-function doScrollTo(ctx, params) {
-  var _a3, _b;
-  const state = ctx.state;
-  const { animated, horizontal, offset } = params;
-  state.scheduledWork.cancel("platformScrollCompletion");
-  const scroller = state.refScroller.current;
-  const node = scroller == null ? void 0 : scroller.getScrollableNode();
-  if (!scroller || !node) {
-    return;
-  }
-  const isAnimated = !!animated;
-  const isHorizontal = !!horizontal;
-  const contentSize = isHorizontal ? getContentSize(ctx) : void 0;
-  const left = isHorizontal ? toNativeHorizontalOffset(state, offset, contentSize) : 0;
-  const top = isHorizontal ? 0 : offset;
-  scroller.scrollTo({ animated: isAnimated, x: left, y: top });
-  if (isAnimated) {
-    const target = (_b = (_a3 = scroller.getScrollEventTarget) == null ? void 0 : _a3.call(scroller)) != null ? _b : null;
-    listenForScrollEnd(ctx, {
-      readOffset: () => scroller.getCurrentScrollOffset(),
-      target,
-      targetOffset: offset
-    });
-  } else {
-    state.scroll = offset;
-    const targetToken = state.scrollingTo;
-    state.scheduledWork.timeout(
-      () => {
-        if (targetToken === state.scrollingTo) {
-          finishScrollTo(ctx);
-        }
-      },
-      100,
-      "platformScrollCompletion"
-    );
-  }
-}
-function listenForScrollEnd(ctx, params) {
-  const { readOffset, target, targetOffset } = params;
-  if (!target) {
-    finishScrollTo(ctx);
-    return;
-  }
-  const supportsScrollEnd = "onscrollend" in target;
-  let idleTimeout;
-  let settled = false;
-  const { scheduledWork, scrollingTo: targetToken } = ctx.state;
-  const maxTimeout = setTimeout(() => finish("max"), SCROLL_END_MAX_MS);
-  const cleanup = () => {
-    target.removeEventListener("scroll", onScroll2);
-    if (supportsScrollEnd) {
-      target.removeEventListener("scrollend", onScrollEnd);
-    }
-    if (idleTimeout !== void 0) {
-      clearTimeout(idleTimeout);
-    }
-    clearTimeout(maxTimeout);
-  };
-  const cancel = () => {
-    if (!settled) {
-      settled = true;
-      cleanup();
-    }
-  };
-  const finish = (reason) => {
-    if (settled) return;
-    if (targetToken !== ctx.state.scrollingTo) {
-      scheduledWork.cancel("platformScrollCompletion");
-      return;
-    }
-    const currentOffset = readOffset();
-    const isNearTarget = Math.abs(currentOffset - targetOffset) <= SCROLL_END_TARGET_EPSILON;
-    if (reason === "scrollend" && !isNearTarget) {
-      return;
-    }
-    scheduledWork.cancel("platformScrollCompletion");
-    finishScrollTo(ctx);
-  };
-  const onScroll2 = () => {
-    if (idleTimeout !== void 0) {
-      clearTimeout(idleTimeout);
-    }
-    idleTimeout = setTimeout(() => finish("idle"), SCROLL_END_IDLE_MS);
-  };
-  const onScrollEnd = () => finish("scrollend");
-  target.addEventListener("scroll", onScroll2);
-  if (supportsScrollEnd) {
-    target.addEventListener("scrollend", onScrollEnd);
-  } else {
-    idleTimeout = setTimeout(() => finish("idle"), SMOOTH_SCROLL_DURATION_MS);
-  }
-  scheduledWork.register("platformScrollCompletion", cancel);
-}
-
 // src/core/scrollRequestTracker.ts
 function getScrollRequestTracker(ctx) {
   if (!ctx.scrollRequestTracker) {
     let currentToken = 0;
-    const start = (resolve) => {
+    let waitingToken;
+    const start = (resolve, isInternal = false) => {
       const state = ctx.state;
+      if (!isInternal && (state.maintainingScrollAtEnd || state.pendingMaintainScrollAtEnd)) {
+        finishMaintainScrollAtEnd(ctx);
+      }
       state.scheduledWork.cancel("imperativeScrollReady");
       const token = ++currentToken;
       settlePendingImperativeScroll(state);
       state.pendingScrollResolve = resolve;
+      waitingToken = token;
       return token;
     };
     const runNow = (token, resolve, run) => {
@@ -1435,6 +1308,7 @@ function getScrollRequestTracker(ctx) {
       if (token !== currentToken) {
         return;
       }
+      waitingToken = void 0;
       const didStartScroll = run();
       if (!didStartScroll || !state.scrollingTo) {
         if (state.pendingScrollResolve === resolve) {
@@ -1445,6 +1319,7 @@ function getScrollRequestTracker(ctx) {
     };
     ctx.scrollRequestTracker = {
       isCurrent: (token) => token === currentToken,
+      isWaitingToRun: () => waitingToken === currentToken && !!ctx.state.pendingScrollResolve,
       runNow,
       runNowIfIdle: (run) => {
         const state = ctx.state;
@@ -1452,7 +1327,7 @@ function getScrollRequestTracker(ctx) {
           return Promise.resolve();
         }
         return new Promise((resolve) => {
-          const token = start(resolve);
+          const token = start(resolve, true);
           runNow(token, resolve, run);
         });
       },
@@ -1486,87 +1361,6 @@ function requestAdjust(ctx, positionDiff, source) {
   }
 }
 
-// src/core/doMaintainScrollAtEnd.ts
-function finishMaintainScrollAtEnd(ctx) {
-  var _a3;
-  const { state } = ctx;
-  const currentPadding = peek$(ctx, "alignItemsAtEndPadding") || 0;
-  const nextPadding = getAlignItemsAtEndPadding(ctx);
-  state.maintainingScrollAtEnd = void 0;
-  state.pendingMaintainScrollAtEnd = false;
-  if (currentPadding !== nextPadding) {
-    set$(ctx, "alignItemsAtEndPadding", nextPadding);
-    state.scrollForNextCalculateItemsInView = void 0;
-    (_a3 = state.triggerCalculateItemsInView) == null ? void 0 : _a3.call(state, { forceFullItemPositions: true });
-    const nextScroll = clampScrollOffset(ctx, state.scroll + nextPadding - currentPadding);
-    requestAdjust(ctx, nextScroll - state.scroll);
-  }
-}
-function doMaintainScrollAtEnd(ctx) {
-  const state = ctx.state;
-  const {
-    didContainersLayout,
-    didFinishInitialScroll,
-    pendingNativeMVCPAdjust,
-    props: { maintainScrollAtEnd }
-  } = state;
-  const isWithinMaintainScrollAtEndThreshold = peek$(ctx, "isWithinMaintainScrollAtEndThreshold");
-  const isReplayingPendingMaintain = !!state.pendingMaintainScrollAtEnd;
-  const shouldMaintainScrollAtEnd = !!((isWithinMaintainScrollAtEndThreshold || isReplayingPendingMaintain) && maintainScrollAtEnd && didFinishInitialScroll);
-  if (shouldMaintainScrollAtEnd && !didContainersLayout) {
-    state.pendingMaintainScrollAtEnd = true;
-    return false;
-  }
-  if (pendingNativeMVCPAdjust) {
-    state.pendingMaintainScrollAtEnd = shouldMaintainScrollAtEnd;
-    return false;
-  }
-  if (shouldMaintainScrollAtEnd && didContainersLayout) {
-    state.pendingMaintainScrollAtEnd = false;
-    const contentSize = getContentSize(ctx);
-    if (contentSize < state.scrollLength) {
-      state.scroll = 0;
-    }
-    if (!state.maintainingScrollAtEnd) {
-      const pendingState = maintainScrollAtEnd.animated ? "pending-animated" : "pending-instant";
-      const activeState = maintainScrollAtEnd.animated ? "animated" : "instant";
-      const scrollAtRequest = state.scroll;
-      state.maintainingScrollAtEnd = pendingState;
-      requestAnimationFrame(() => {
-        if (state.maintainingScrollAtEnd !== pendingState) {
-          return;
-        }
-        const isStillWithinThreshold = peek$(ctx, "isWithinMaintainScrollAtEndThreshold");
-        const didScrollSinceRequest = state.scroll !== scrollAtRequest;
-        if (isReplayingPendingMaintain || isStillWithinThreshold || !didScrollSinceRequest) {
-          state.maintainingScrollAtEnd = activeState;
-          const scrollPromise = getScrollRequestTracker(ctx).runNowIfIdle(
-            () => ctx.scrollToEnd({ animated: maintainScrollAtEnd.animated })
-          );
-          void scrollPromise.then(() => {
-            if (state.maintainingScrollAtEnd !== activeState) {
-              return;
-            }
-            if (state.pendingMaintainScrollAtEnd) {
-              state.maintainingScrollAtEnd = void 0;
-              doMaintainScrollAtEnd(ctx);
-            } else {
-              finishMaintainScrollAtEnd(ctx);
-            }
-          });
-        } else if (state.maintainingScrollAtEnd === pendingState) {
-          finishMaintainScrollAtEnd(ctx);
-        }
-      });
-    } else {
-      state.pendingMaintainScrollAtEnd = true;
-    }
-    return true;
-  }
-  finishMaintainScrollAtEnd(ctx);
-  return false;
-}
-
 // src/core/mvcp.ts
 var MVCP_POSITION_EPSILON = 0.1;
 var MVCP_ANCHOR_LOCK_TTL_MS = 300;
@@ -2004,6 +1798,271 @@ function updateScroll(ctx, newScroll, forceUpdate, options) {
   }
 }
 
+// src/core/doMaintainScrollAtEnd.ts
+function interruptMaintainScrollAtEnd(ctx) {
+  var _a3;
+  const { state } = ctx;
+  const maintaining = state.maintainingScrollAtEnd;
+  const cancelActiveScroll = !!(maintaining === "animated" || maintaining === "instant" || maintaining && ((_a3 = state.scrollingTo) == null ? void 0 : _a3.isScrollToEnd));
+  if (cancelActiveScroll) {
+    cancelImperativeScroll(state);
+  }
+  if (maintaining || state.pendingMaintainScrollAtEnd) {
+    finishMaintainScrollAtEnd(ctx);
+  }
+  return cancelActiveScroll;
+}
+function finishMaintainScrollAtEnd(ctx) {
+  var _a3;
+  const { state } = ctx;
+  const currentPadding = peek$(ctx, "alignItemsAtEndPadding") || 0;
+  const nextPadding = getAlignItemsAtEndPadding(ctx);
+  state.maintainingScrollAtEnd = void 0;
+  state.pendingMaintainScrollAtEnd = false;
+  if (currentPadding !== nextPadding) {
+    set$(ctx, "alignItemsAtEndPadding", nextPadding);
+    state.scrollForNextCalculateItemsInView = void 0;
+    (_a3 = state.triggerCalculateItemsInView) == null ? void 0 : _a3.call(state, { forceFullItemPositions: true });
+    const nextScroll = clampScrollOffset(ctx, state.scroll + nextPadding - currentPadding);
+    requestAdjust(ctx, nextScroll - state.scroll);
+  }
+}
+function doMaintainScrollAtEnd(ctx) {
+  var _a3, _b, _c, _d, _e;
+  const state = ctx.state;
+  const {
+    didContainersLayout,
+    didFinishInitialScroll,
+    pendingNativeMVCPAdjust,
+    props: { maintainScrollAtEnd }
+  } = state;
+  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);
+  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);
+    if (nativeMax !== void 0 && observed !== void 0 && nativeMax < state.scroll - 1 && Math.abs(observed - nativeMax) <= 1) {
+      state.pendingMaintainScrollAtEnd = true;
+      state.scrollPending = observed;
+      updateScroll(ctx, observed, true, { markHasScrolled: false });
+    }
+  }
+  if (shouldMaintainScrollAtEnd && !didContainersLayout) {
+    state.pendingMaintainScrollAtEnd = true;
+    return false;
+  }
+  if (pendingNativeMVCPAdjust) {
+    state.pendingMaintainScrollAtEnd = shouldMaintainScrollAtEnd;
+    return false;
+  }
+  if (shouldMaintainScrollAtEnd && (state.scrollingTo || state.pendingScrollResolve)) {
+    state.pendingMaintainScrollAtEnd = true;
+    (_e = state.maintainingScrollAtEnd) != null ? _e : state.maintainingScrollAtEnd = maintainScrollAtEnd.animated ? "pending-animated" : "pending-instant";
+    return false;
+  }
+  if (shouldMaintainScrollAtEnd && didContainersLayout) {
+    state.pendingMaintainScrollAtEnd = false;
+    const contentSize = getContentSize(ctx);
+    if (contentSize < state.scrollLength) {
+      state.scroll = 0;
+    }
+    if (!state.maintainingScrollAtEnd) {
+      const pendingState = maintainScrollAtEnd.animated ? "pending-animated" : "pending-instant";
+      const activeState = maintainScrollAtEnd.animated ? "animated" : "instant";
+      const scrollAtRequest = state.scroll;
+      state.maintainingScrollAtEnd = pendingState;
+      requestAnimationFrame(() => {
+        if (state.maintainingScrollAtEnd !== pendingState) {
+          return;
+        }
+        const isStillWithinThreshold = peek$(ctx, "isWithinMaintainScrollAtEndThreshold");
+        const didScrollSinceRequest = state.scroll !== scrollAtRequest;
+        if (isReplayingPendingMaintain || isStillWithinThreshold || !didScrollSinceRequest) {
+          if (state.scrollingTo || state.pendingScrollResolve) {
+            state.pendingMaintainScrollAtEnd = true;
+            return;
+          }
+          state.maintainingScrollAtEnd = activeState;
+          const scrollPromise = getScrollRequestTracker(ctx).runNowIfIdle(
+            () => ctx.scrollToEnd({ animated: maintainScrollAtEnd.animated })
+          );
+          void scrollPromise.then(() => {
+            if (state.maintainingScrollAtEnd !== activeState) {
+              return;
+            }
+            if (state.pendingMaintainScrollAtEnd) {
+              state.maintainingScrollAtEnd = void 0;
+              doMaintainScrollAtEnd(ctx);
+            } else {
+              finishMaintainScrollAtEnd(ctx);
+            }
+          });
+        } else if (state.maintainingScrollAtEnd === pendingState) {
+          finishMaintainScrollAtEnd(ctx);
+        }
+      });
+    } else {
+      state.pendingMaintainScrollAtEnd = true;
+    }
+    return true;
+  }
+  finishMaintainScrollAtEnd(ctx);
+  return false;
+}
+
+// src/core/finishScrollTo.ts
+function finishScrollTo(ctx) {
+  var _a3, _b, _c;
+  const state = ctx.state;
+  if (state == null ? void 0 : state.scrollingTo) {
+    cancelScrollCompletionChecks(state);
+    const resolvePendingScroll = ((_a3 = ctx.scrollRequestTracker) == null ? void 0 : _a3.isWaitingToRun()) ? void 0 : state.pendingScrollResolve;
+    if (resolvePendingScroll) {
+      state.pendingScrollResolve = void 0;
+    }
+    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);
+    }
+    {
+      state.scrollAdjustHandler.commitPendingAdjust(scrollingTo);
+    }
+    if (scrollingTo.isInitialScroll || state.initialScroll) {
+      const isOffsetSession = ((_b = state.initialScrollSession) == null ? void 0 : _b.kind) === "offset";
+      const shouldPreserveResizeTarget = !!scrollingTo.isInitialScroll && !state.clearPreservedInitialScrollOnNextFinish && state.props.data.length > 0 && ((_c = state.initialScroll) == null ? void 0 : _c.viewPosition) === 1;
+      finishInitialScroll(ctx, {
+        onFinished: () => {
+          resolvePendingScroll == null ? void 0 : resolvePendingScroll();
+        },
+        preserveTarget: isOffsetSession && state.props.data.length === 0 || shouldPreserveResizeTarget,
+        recalculateItems: true,
+        schedulePreservedTargetClear: shouldPreserveResizeTarget,
+        syncObservedOffset: isOffsetSession,
+        waitForCompletionFrame: !!scrollingTo.waitForInitialScrollCompletionFrame
+      });
+      return;
+    }
+    recalculateSettledScroll(ctx);
+    resolvePendingScroll == null ? void 0 : resolvePendingScroll();
+    if (state.pendingMaintainScrollAtEnd) {
+      state.maintainingScrollAtEnd = void 0;
+      doMaintainScrollAtEnd(ctx);
+    }
+  }
+}
+
+// src/core/doScrollTo.ts
+var SCROLL_END_IDLE_MS = 80;
+var SCROLL_END_MAX_MS = 1500;
+var SMOOTH_SCROLL_DURATION_MS = 320;
+var SCROLL_END_TARGET_EPSILON = 1;
+function doScrollTo(ctx, params) {
+  var _a3, _b, _c, _d, _e, _f;
+  const state = ctx.state;
+  const { animated, horizontal, offset } = params;
+  state.scheduledWork.cancel("platformScrollCompletion");
+  const scroller = state.refScroller.current;
+  const node = scroller == null ? void 0 : scroller.getScrollableNode();
+  if (!scroller || !node) {
+    return;
+  }
+  const isAnimated = !!animated;
+  const isHorizontal = !!horizontal;
+  const contentSize = isHorizontal ? getContentSize(ctx) : void 0;
+  const left = isHorizontal ? toNativeHorizontalOffset(state, offset, contentSize) : 0;
+  const top = isHorizontal ? 0 : offset;
+  scroller.scrollTo({ animated: isAnimated, x: left, y: top });
+  if (isAnimated) {
+    const targetOffset = Math.max(0, Math.min(offset, (_b = (_a3 = scroller.getMaxScrollOffset) == null ? void 0 : _a3.call(scroller)) != null ? _b : offset));
+    if (Math.abs(((_d = (_c = scroller.getCurrentScrollOffset) == null ? void 0 : _c.call(scroller)) != null ? _d : Number.NaN) - targetOffset) <= SCROLL_END_TARGET_EPSILON) {
+      const targetToken = state.scrollingTo;
+      state.scheduledWork.frame(() => {
+        if (targetToken === state.scrollingTo) finishScrollTo(ctx);
+      }, "platformScrollCompletion");
+      return;
+    }
+    const target = (_f = (_e = scroller.getScrollEventTarget) == null ? void 0 : _e.call(scroller)) != null ? _f : null;
+    listenForScrollEnd(ctx, {
+      readOffset: () => scroller.getCurrentScrollOffset(),
+      target,
+      targetOffset
+    });
+  } else {
+    state.scroll = offset;
+    const targetToken = state.scrollingTo;
+    state.scheduledWork.timeout(
+      () => {
+        if (targetToken === state.scrollingTo) {
+          finishScrollTo(ctx);
+        }
+      },
+      100,
+      "platformScrollCompletion"
+    );
+  }
+}
+function listenForScrollEnd(ctx, params) {
+  const { readOffset, target, targetOffset } = params;
+  if (!target) {
+    finishScrollTo(ctx);
+    return;
+  }
+  const supportsScrollEnd = "onscrollend" in target;
+  let idleTimeout;
+  let settled = false;
+  const { scheduledWork, scrollingTo: targetToken } = ctx.state;
+  const maxTimeout = setTimeout(() => finish("max"), SCROLL_END_MAX_MS);
+  const cleanup = () => {
+    target.removeEventListener("scroll", onScroll2);
+    if (supportsScrollEnd) {
+      target.removeEventListener("scrollend", onScrollEnd);
+    }
+    if (idleTimeout !== void 0) {
+      clearTimeout(idleTimeout);
+    }
+    clearTimeout(maxTimeout);
+  };
+  const cancel = () => {
+    if (!settled) {
+      settled = true;
+      cleanup();
+    }
+  };
+  const finish = (reason) => {
+    if (settled) return;
+    if (targetToken !== ctx.state.scrollingTo) {
+      scheduledWork.cancel("platformScrollCompletion");
+      return;
+    }
+    const currentOffset = readOffset();
+    const isNearTarget = Math.abs(currentOffset - targetOffset) <= SCROLL_END_TARGET_EPSILON;
+    if (reason === "scrollend" && !isNearTarget) {
+      return;
+    }
+    scheduledWork.cancel("platformScrollCompletion");
+    finishScrollTo(ctx);
+  };
+  const onScroll2 = () => {
+    if (idleTimeout !== void 0) {
+      clearTimeout(idleTimeout);
+    }
+    idleTimeout = setTimeout(() => finish("idle"), SCROLL_END_IDLE_MS);
+  };
+  const onScrollEnd = () => finish("scrollend");
+  target.addEventListener("scroll", onScroll2);
+  if (supportsScrollEnd) {
+    target.addEventListener("scrollend", onScrollEnd);
+  } else {
+    idleTimeout = setTimeout(() => finish("idle"), SMOOTH_SCROLL_DURATION_MS);
+  }
+  scheduledWork.register("platformScrollCompletion", cancel);
+}
+
 // src/core/scrollTo.ts
 function getAverageSizeSnapshot(state) {
   if (Object.keys(state.averageSizes).length === 0) {
@@ -3199,6 +3258,11 @@ function handleInitialScrollDataChange(ctx, options) {
   const state = ctx.state;
   const previousInitialScrollDataLength = (_b = (_a3 = state.initialScrollSession) == null ? void 0 : _a3.previousDataLength) != null ? _b : 0;
   const shouldUseLatestInitialScroll = dataLength > 0 && (!state.hasHadNonEmptyData || didStartFreshData);
+  if (didStartFreshData) {
+    cancelImperativeScroll(state);
+    state.maintainingScrollAtEnd = void 0;
+    state.pendingMaintainScrollAtEnd = false;
+  }
   if (dataLength > 0) {
     state.hasHadNonEmptyData = true;
   }
@@ -4743,6 +4807,7 @@ function maybeUpdateAnchoredEndSpace(ctx) {
   const nextAnchorIndex = anchoredEndSpace == null ? void 0 : anchoredEndSpace.anchorIndex;
   let nextAnchorKey;
   let isReady = true;
+  let canUpdateSize = true;
   let nextSize = 0;
   if (anchoredEndSpace) {
     const { anchorIndex, anchorMaxSize, anchorOffset = 0 } = anchoredEndSpace;
@@ -4764,25 +4829,30 @@ function maybeUpdateAnchoredEndSpace(ctx) {
       contentBelowAnchor = Math.max(0, contentBelowAnchor - ctx.scrollAxisGap);
       contentBelowAnchor += (ctx.values.get("footerSize") || 0) + getStylePaddingEnd(state.props);
       isReady = !hasUnknownTailSize;
-      nextSize = hasUnknownTailSize ? previousSize || 0 : Math.max(0, state.scrollLength - contentBelowAnchor - anchorOffset);
+      const knownSizeBound = Math.max(0, state.scrollLength - contentBelowAnchor - anchorOffset);
+      nextSize = hasUnknownTailSize ? Math.min(previousSize || 0, knownSizeBound) : knownSizeBound;
     } else if (anchorIndex >= 0) {
       isReady = false;
+      canUpdateSize = false;
     }
   }
   const didSizeChange = previousSize !== nextSize && (previousSize !== void 0 || anchoredEndSpace !== void 0);
   const didEffectiveSizeChange = (previousSize || 0) !== nextSize;
+  const canApplySizeChange = canUpdateSize && (isReady || previousSize !== void 0);
   const didReadyAnchorChange = previousReadyAnchorIndex !== nextAnchorIndex || previousReadyAnchorKey !== nextAnchorKey;
-  if (isReady && (didSizeChange || didReadyAnchorChange)) {
+  const didBecomeReady = isReady && state.anchoredEndSpacePendingReady;
+  state.anchoredEndSpacePendingReady = !isReady;
+  if (canApplySizeChange && didSizeChange) {
+    set$(ctx, "anchoredEndSpaceSize", nextSize);
+    (_a3 = anchoredEndSpace == null ? void 0 : anchoredEndSpace.onSizeChanged) == null ? void 0 : _a3.call(anchoredEndSpace, nextSize);
+  }
+  if (canApplySizeChange && didEffectiveSizeChange) {
+    updateContentMetricsState(ctx);
+    updateScroll(ctx, state.scroll, true, { markHasScrolled: false });
+  }
+  if (isReady && (didSizeChange || didReadyAnchorChange || didBecomeReady)) {
     state.anchoredEndSpaceReadyAnchorIndex = nextAnchorIndex;
     state.anchoredEndSpaceReadyAnchorKey = nextAnchorKey;
-    if (didSizeChange) {
-      set$(ctx, "anchoredEndSpaceSize", nextSize);
-      (_a3 = anchoredEndSpace == null ? void 0 : anchoredEndSpace.onSizeChanged) == null ? void 0 : _a3.call(anchoredEndSpace, nextSize);
-    }
-    if (didEffectiveSizeChange) {
-      updateContentMetricsState(ctx);
-      updateScroll(ctx, state.scroll, true, { markHasScrolled: false });
-    }
     (_b = anchoredEndSpace == null ? void 0 : anchoredEndSpace.onReady) == null ? void 0 : _b.call(anchoredEndSpace, { anchorIndex: nextAnchorIndex, anchorKey: nextAnchorKey, size: nextSize });
   }
   return nextSize;
@@ -5782,7 +5852,9 @@ function sortDOMElements(container, indexByElement) {
           break;
         }
       }
-      if (nextStableElement) {
+      if ("moveBefore" in container && typeof container.moveBefore === "function" && container.isConnected) {
+        container.moveBefore(element, nextStableElement);
+      } else if (nextStableElement) {
         container.insertBefore(element, nextStableElement);
       } else {
         container.appendChild(element);
@@ -5829,13 +5901,18 @@ function findLIS(arr) {
 // src/hooks/useDOMOrder.ts
 function useDOMOrder(ref) {
   const ctx = useStateContext();
-  const debounceRef = useRef(void 0);
   useEffect(() => {
+    let timeoutId;
+    let lastUpdateTime = 0;
+    let delay = 500;
     const unsubscribe = listen$(ctx, "lastPositionUpdate", () => {
-      if (debounceRef.current !== void 0) {
-        clearTimeout(debounceRef.current);
-      }
-      debounceRef.current = setTimeout(() => {
+      const container = ref.current;
+      const now = Date.now();
+      delay = container && "moveBefore" in container && typeof container.moveBefore === "function" && container.isConnected && (now - lastUpdateTime >= 1e3 || timeoutId !== void 0 && delay === 0) && now - ctx.state.scrollTime >= 500 ? 0 : 500;
+      lastUpdateTime = now;
+      clearTimeout(timeoutId);
+      timeoutId = setTimeout(() => {
+        timeoutId = void 0;
         const parent = ref.current;
         if (parent) {
           const indexByElement = /* @__PURE__ */ new Map();
@@ -5848,14 +5925,11 @@ function useDOMOrder(ref) {
           }
           sortDOMElements(parent, indexByElement);
         }
-        debounceRef.current = void 0;
-      }, 500);
+      }, delay);
     });
     return () => {
       unsubscribe();
-      if (debounceRef.current !== void 0) {
-        clearTimeout(debounceRef.current);
-      }
+      clearTimeout(timeoutId);
     };
   }, [ctx]);
 }
@@ -6225,6 +6299,7 @@ var ListComponentScrollView = forwardRef(function ListComponentScrollView2({
         return (_a4 = scrollRef.current) == null ? void 0 : _a4.getBoundingClientRect();
       },
       getCurrentScrollOffset,
+      getMaxScrollOffset,
       getScrollableNode: () => resolveScrollableNode(scrollRef.current, isWindowScroll),
       getScrollEventTarget: () => getScrollTarget(),
       getScrollResponder: () => resolveScrollableNode(scrollRef.current, isWindowScroll),
@@ -6330,6 +6405,22 @@ var ListComponentScrollView = forwardRef(function ListComponentScrollView2({
       scrollEventCoalescer.cancel();
     };
   }, [emitScrollEnd, getScrollTarget, handleScroll, scrollEventCoalescer]);
+  useEffect(() => {
+    const target = getScrollTarget();
+    if (!target) return;
+    const onWheel = (nativeEvent) => {
+      const event = nativeEvent;
+      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)) {
+          scrollToLocalOffset(offset, false);
+        }
+      }
+    };
+    target.addEventListener("wheel", onWheel, { passive: true });
+    return () => target.removeEventListener("wheel", onWheel);
+  }, [ctx, getCurrentScrollOffset, getScrollTarget, horizontal, scrollToLocalOffset]);
   useEffect(() => {
     const doScroll = () => {
       if (contentOffset) {
@@ -6539,8 +6630,11 @@ function ScrollAdjust() {
               window.getComputedStyle(contentNode)[axis.paddingEndProp]
             );
             const temporaryPaddingEnd = `${(currentPaddingEnd || 0) + pad}px`;
-            temporaryPaddingRef.current = { baseline: baselinePaddingEnd, value: temporaryPaddingEnd };
             contentNode.style[axis.paddingEndProp] = temporaryPaddingEnd;
+            temporaryPaddingRef.current = {
+              baseline: baselinePaddingEnd,
+              value: contentNode.style[axis.paddingEndProp]
+            };
             void contentNode.offsetHeight;
             scrollBy();
             if (resetPaddingRafRef.current !== void 0) {
@@ -7278,6 +7372,9 @@ function scrollToEnd(ctx, options) {
     viewOffset: -paddingBottom - footerSize + ((options == null ? void 0 : options.viewOffset) || 0),
     viewPosition: 1
   });
+  if (state.scrollingTo) {
+    state.scrollingTo.isScrollToEnd = true;
+  }
   return true;
 }
 
@@ -7995,6 +8092,8 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
         endReachedSnapshot: void 0,
         firstFullyOnScreenIndex: -1,
         freshDataTransitionEpoch: 0,
+        handledDataChangeEpoch: 0,
+        handledFreshDataTransitionEpoch: 0,
         hasHadNonEmptyData: dataProp.length > 0,
         idCache: [],
         idsInView: [],
@@ -8079,6 +8178,8 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
   if (shouldResetFreshDataLayout) {
     state.freshDataTransitionEpoch += 1;
   }
+  const dataChangeEpoch = state.dataChangeEpoch;
+  const freshDataTransitionEpoch = state.freshDataTransitionEpoch;
   const throttledOnScroll = useThrottledOnScroll(onScrollProp != null ? onScrollProp : noopOnScroll, scrollEventThrottle != null ? scrollEventThrottle : 0);
   const throttleScrollFn = scrollEventThrottle && onScrollProp ? throttledOnScroll : onScrollProp;
   const didAnchoredEndSpaceAnchorIndexChange = !isFirstLocal && !didDataChangeLocal && ((_q = state.props.anchoredEndSpace) == null ? void 0 : _q.anchorIndex) !== (anchoredEndSpace == null ? void 0 : anchoredEndSpace.anchorIndex);
@@ -8201,7 +8302,11 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     useDevChecks(props);
   }
   useLayoutEffect(() => {
-    if (shouldResetFreshDataLayout) {
+    const didDataChange = state.handledDataChangeEpoch !== dataChangeEpoch;
+    const didStartFreshData = state.handledFreshDataTransitionEpoch !== freshDataTransitionEpoch;
+    state.handledDataChangeEpoch = dataChangeEpoch;
+    state.handledFreshDataTransitionEpoch = freshDataTransitionEpoch;
+    if (didStartFreshData) {
       resetInitialRenderState(ctx, {
         resetInitialScroll: !!initialScrollProp,
         resetLayout: true
@@ -8209,8 +8314,8 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     }
     handleInitialScrollDataChange(ctx, {
       dataLength: dataProp.length,
-      didDataChange: didDataChangeLocal,
-      didStartFreshData: shouldResetFreshDataLayout,
+      didDataChange,
+      didStartFreshData,
       initialScrollAtEnd,
       latestInitialScroll: initialScrollProp,
       latestInitialScrollSessionKind: initialScrollUsesOffsetOnly ? "offset" : "bootstrap",
@@ -8220,8 +8325,8 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
   }, [
     dataProp.length,
     dataKey,
-    didDataChangeLocal,
-    shouldResetFreshDataLayout,
+    dataChangeEpoch,
+    freshDataTransitionEpoch,
     initialScrollAtEnd,
     stylePaddingEndState,
     usesBootstrapInitialScroll
@@ -8401,13 +8506,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       onScroll: (event) => onScroll(ctx, event),
       onScrollBeginDrag: (event) => {
         var _a4, _b2;
-        const maintainingScrollAtEnd = state.maintainingScrollAtEnd;
-        if (maintainingScrollAtEnd === "animated" || maintainingScrollAtEnd === "instant") {
-          cancelImperativeScroll(state);
-        }
-        if (maintainingScrollAtEnd) {
-          finishMaintainScrollAtEnd(ctx);
-        }
+        interruptMaintainScrollAtEnd(ctx);
         prepareReachedEdgeForNextUserScroll(ctx);
         (_b2 = (_a4 = state.props).onScrollBeginDrag) == null ? void 0 : _b2.call(_a4, event);
       },