@legendapp/list 0.5.8 → 0.6.0

package/index.mjs

@@ -1,12 +1,11 @@
-import * as React5 from 'react';
-import React5__default, { forwardRef, useRef, useMemo, useCallback, useImperativeHandle, useEffect, useState } from 'react';
-import { Platform, StyleSheet, ScrollView, Animated, View, Dimensions, useAnimatedValue } from 'react-native';
+import * as React4 from 'react';
+import React4__default, { forwardRef, useRef, useMemo, useCallback, useImperativeHandle, useSyncExternalStore, useEffect, useState } from 'react';
+import { Animated, ScrollView, View, Dimensions, StyleSheet, useAnimatedValue as useAnimatedValue$1 } from 'react-native';
 
 // src/LegendList.tsx
-var USE_CONTENT_INSET = Platform.OS === "ios";
-var ContextState = React5.createContext(null);
+var ContextState = React4.createContext(null);
 function StateProvider({ children }) {
-  const [value] = React5.useState(() => ({
+  const [value] = React4.useState(() => ({
     listeners: /* @__PURE__ */ new Map(),
     values: /* @__PURE__ */ new Map(),
     mapViewabilityCallbacks: /* @__PURE__ */ new Map(),
@@ -14,18 +13,18 @@ function StateProvider({ children }) {
     mapViewabilityAmountCallbacks: /* @__PURE__ */ new Map(),
     mapViewabilityAmountValues: /* @__PURE__ */ new Map()
   }));
-  return /* @__PURE__ */ React5.createElement(ContextState.Provider, { value }, children);
+  return /* @__PURE__ */ React4.createElement(ContextState.Provider, { value }, children);
 }
 function useStateContext() {
-  return React5.useContext(ContextState);
+  return React4.useContext(ContextState);
 }
 function use$(signalName) {
-  const ctx = React5.useContext(ContextState);
-  const [, forceUpdate] = React5.useReducer((x) => x + 1, 0);
-  useMemo(() => {
-    listen$(ctx, signalName, forceUpdate);
-  }, []);
-  return ctx.values.get(signalName);
+  const ctx = React4.useContext(ContextState);
+  const value = useSyncExternalStore(
+    (onStoreChange) => listen$(ctx, signalName, onStoreChange),
+    () => ctx.values.get(signalName)
+  );
+  return value;
 }
 function listen$(ctx, signalName, cb) {
   const { listeners } = ctx;
@@ -53,25 +52,6 @@ function set$(ctx, signalName, value) {
     }
   }
 }
-
-// src/$ScrollView.tsx
-var OFFSET_TEST = 0;
-var $ScrollView = React5.forwardRef(function $ScrollView2(props, ref) {
-  const { style, horizontal, ...rest } = props;
-  const scrollAdjust = use$("scrollAdjust");
-  const adjustProps = {};
-  if (scrollAdjust !== 0) {
-    if (USE_CONTENT_INSET) {
-      adjustProps.contentInset = horizontal ? { left: -scrollAdjust } : { top: -scrollAdjust + OFFSET_TEST };
-    } else {
-      adjustProps.style = horizontal ? { marginLeft: -scrollAdjust } : { marginTop: -scrollAdjust };
-      if (style) {
-        adjustProps.style = StyleSheet.compose(style, adjustProps.style);
-      }
-    }
-  }
-  return /* @__PURE__ */ React5.createElement(ScrollView, { ...rest, style, horizontal, ...adjustProps, ref });
-});
 var Container = ({
   id,
   recycleItems,
@@ -87,31 +67,34 @@ var Container = ({
   const numColumns = use$("numColumns");
   const otherAxisPos = numColumns > 1 ? `${(column - 1) / numColumns * 100}%` : 0;
   const otherAxisSize = numColumns > 1 ? `${1 / numColumns * 100}%` : void 0;
-  const style = horizontal ? {
+  let style = horizontal ? {
     flexDirection: "row",
     position: "absolute",
-    top: visible ? otherAxisPos : -1e7,
+    top: otherAxisPos,
     bottom: numColumns > 1 ? null : 0,
     height: otherAxisSize,
     left: position
   } : {
     position: "absolute",
-    left: visible ? otherAxisPos : -1e7,
+    left: otherAxisPos,
     right: numColumns > 1 ? null : 0,
     width: otherAxisSize,
     top: position
   };
+  {
+    style.opacity = visible ? 1 : 0;
+  }
   const lastItemKey = use$("lastItemKey");
   const itemKey = use$(`containerItemKey${id}`);
   const renderedItem = useMemo(() => itemKey !== void 0 && getRenderedItem(itemKey, id), [itemKey]);
-  return /* @__PURE__ */ React5__default.createElement(
+  return /* @__PURE__ */ React4__default.createElement(
     View,
     {
       style,
       onLayout: (event) => {
         const key = peek$(ctx, `containerItemKey${id}`);
         if (key !== void 0) {
-          const size = event.nativeEvent.layout[horizontal ? "width" : "height"];
+          const size = Math.floor(event.nativeEvent.layout[horizontal ? "width" : "height"] * 8) / 8;
           updateItemSize(id, key, size);
           const otherAxisSize2 = horizontal ? event.nativeEvent.layout.width : event.nativeEvent.layout.height;
           set$(ctx, "otherAxisSize", Math.max(otherAxisSize2, peek$(ctx, "otherAxisSize") || 0));
@@ -124,34 +107,36 @@ var Container = ({
         }
       }
     },
-    /* @__PURE__ */ React5__default.createElement(React5__default.Fragment, { key: recycleItems ? void 0 : itemKey }, renderedItem, renderedItem && ItemSeparatorComponent && itemKey !== lastItemKey && ItemSeparatorComponent)
+    /* @__PURE__ */ React4__default.createElement(React4__default.Fragment, { key: recycleItems ? void 0 : itemKey }, renderedItem, renderedItem && ItemSeparatorComponent && itemKey !== lastItemKey && ItemSeparatorComponent)
   );
 };
+var useAnimatedValue = useAnimatedValue$1 || ((initialValue) => {
+  return useRef(new Animated.Value(initialValue)).current;
+});
 function useValue$(key, getValue, key2) {
   var _a;
   const ctx = useStateContext();
-  const animValue = useAnimatedValue((_a = getValue ? getValue(peek$(ctx, key)) : peek$(ctx, key)) != null ? _a : 0);
+  const animValue = useAnimatedValue((_a = peek$(ctx, key)) != null ? _a : 0);
   useMemo(() => {
-    listen$(ctx, key, (v) => animValue.setValue(getValue ? getValue(v) : v));
+    listen$(ctx, key, (v) => animValue.setValue(v));
   }, []);
   return animValue;
 }
 
 // src/Containers.tsx
-var Containers = React5.memo(function Containers2({
+var Containers = React4.memo(function Containers2({
   horizontal,
   recycleItems,
   ItemSeparatorComponent,
   updateItemSize,
   getRenderedItem
 }) {
-  const ctx = useStateContext();
   const numContainers = use$("numContainersPooled");
-  const animSize = useValue$("totalSize", (v) => v + peek$(ctx, "scrollAdjust"));
+  const animSize = useValue$("totalSize");
   const containers = [];
   for (let i = 0; i < numContainers; i++) {
     containers.push(
-      /* @__PURE__ */ React5.createElement(
+      /* @__PURE__ */ React4.createElement(
         Container,
         {
           id: i,
@@ -166,20 +151,20 @@ var Containers = React5.memo(function Containers2({
     );
   }
   const style = horizontal ? { width: animSize } : { height: animSize };
-  return /* @__PURE__ */ React5.createElement(Animated.View, { style }, containers);
+  return /* @__PURE__ */ React4.createElement(Animated.View, { style }, containers);
 });
 
 // src/ListComponent.tsx
 var getComponent = (Component) => {
-  if (React5.isValidElement(Component)) {
+  if (React4.isValidElement(Component)) {
     return Component;
   }
   if (Component) {
-    return /* @__PURE__ */ React5.createElement(Component, null);
+    return /* @__PURE__ */ React4.createElement(Component, null);
   }
   return null;
 };
-var ListComponent = React5.memo(function ListComponent2({
+var ListComponent = React4.memo(function ListComponent2({
   style,
   contentContainerStyle,
   horizontal,
@@ -197,18 +182,20 @@ var ListComponent = React5.memo(function ListComponent2({
   ListEmptyComponentStyle,
   getRenderedItem,
   updateItemSize,
-  addTotalSize,
   refScroller,
+  maintainVisibleContentPosition,
   ...rest
 }) {
   const ctx = useStateContext();
   const animPaddingTop = useValue$("paddingTop");
   const animScrollAdjust = useValue$("scrollAdjust");
-  return /* @__PURE__ */ React5.createElement(
-    $ScrollView,
+  const additionalSize = { marginTop: animScrollAdjust, paddingTop: animPaddingTop };
+  return /* @__PURE__ */ React4.createElement(
+    ScrollView,
     {
       ...rest,
       style,
+      maintainVisibleContentPosition: maintainVisibleContentPosition ? { minIndexForVisible: 0 } : void 0,
       contentContainerStyle: [
         contentContainerStyle,
         horizontal ? {
@@ -221,13 +208,11 @@ var ListComponent = React5.memo(function ListComponent2({
       contentOffset: initialContentOffset ? horizontal ? { x: initialContentOffset, y: 0 } : { x: 0, y: initialContentOffset } : void 0,
       ref: refScroller
     },
-    alignItemsAtEnd && /* @__PURE__ */ React5.createElement(Animated.View, { style: { height: animPaddingTop } }),
-    ListHeaderComponent && /* @__PURE__ */ React5.createElement(
+    /* @__PURE__ */ React4.createElement(Animated.View, { style: additionalSize }),
+    ListHeaderComponent && /* @__PURE__ */ React4.createElement(
       Animated.View,
       {
-        style: StyleSheet.compose(ListHeaderComponentStyle, {
-          top: animScrollAdjust
-        }),
+        style: ListHeaderComponentStyle,
         onLayout: (event) => {
           const size = event.nativeEvent.layout[horizontal ? "width" : "height"];
           const prevSize = peek$(ctx, "headerSize") || 0;
@@ -238,16 +223,8 @@ var ListComponent = React5.memo(function ListComponent2({
       },
       getComponent(ListHeaderComponent)
     ),
-    ListEmptyComponent && /* @__PURE__ */ React5.createElement(
-      Animated.View,
-      {
-        style: StyleSheet.compose(ListEmptyComponentStyle, {
-          top: animScrollAdjust
-        })
-      },
-      getComponent(ListEmptyComponent)
-    ),
-    /* @__PURE__ */ React5.createElement(
+    ListEmptyComponent && /* @__PURE__ */ React4.createElement(Animated.View, { style: ListEmptyComponentStyle }, getComponent(ListEmptyComponent)),
+    /* @__PURE__ */ React4.createElement(
       Containers,
       {
         horizontal,
@@ -257,9 +234,46 @@ var ListComponent = React5.memo(function ListComponent2({
         updateItemSize
       }
     ),
-    ListFooterComponent && /* @__PURE__ */ React5.createElement(View, { style: ListFooterComponentStyle }, getComponent(ListFooterComponent))
+    ListFooterComponent && /* @__PURE__ */ React4.createElement(View, { style: ListFooterComponentStyle }, getComponent(ListFooterComponent))
   );
 });
+
+// src/ScrollAdjustHandler.ts
+var ScrollAdjustHandler = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+    this.appliedAdjust = 0;
+    this.pendingAdjust = 0;
+    this.busy = false;
+    this.firstAdjust = true;
+    this.context = ctx;
+  }
+  requestAdjust(adjust, onAdjusted) {
+    const oldAdjustTop = peek$(this.context, "scrollAdjust");
+    if (oldAdjustTop === adjust) {
+      return;
+    }
+    this.appliedAdjust = adjust;
+    this.pendingAdjust = adjust;
+    const doAjdust = () => {
+      set$(this.context, "scrollAdjust", this.pendingAdjust);
+      onAdjusted(oldAdjustTop - this.pendingAdjust);
+      this.busy = false;
+    };
+    if (!this.busy) {
+      this.busy = true;
+      if (this.firstAdjust) {
+        this.firstAdjust = false;
+        setTimeout(doAjdust, 50);
+      } else {
+        doAjdust();
+      }
+    }
+  }
+  getAppliedAdjust() {
+    return this.appliedAdjust;
+  }
+};
 var symbolFirst = Symbol();
 function useInit(cb) {
   const refValue = useRef(symbolFirst);
@@ -418,14 +432,13 @@ function maybeUpdateViewabilityCallback(ctx, configId, viewToken) {
 
 // src/LegendList.tsx
 var DEFAULT_DRAW_DISTANCE = 250;
-var INITIAL_SCROLL_ADJUST = 1e4;
 var POSITION_OUT_OF_VIEW = -1e7;
 var DEFAULT_ITEM_SIZE = 100;
 var LegendList = forwardRef(function LegendList2(props, forwardedRef) {
-  return /* @__PURE__ */ React5.createElement(StateProvider, null, /* @__PURE__ */ React5.createElement(LegendListInner, { ...props, ref: forwardedRef }));
+  return /* @__PURE__ */ React4.createElement(StateProvider, null, /* @__PURE__ */ React4.createElement(LegendListInner, { ...props, ref: forwardedRef }));
 });
 var LegendListInner = forwardRef(function LegendListInner2(props, forwardedRef) {
-  var _a, _b, _c, _d, _e, _f;
+  var _a, _b, _c, _d, _e;
   const {
     data,
     initialScrollIndex,
@@ -487,37 +500,38 @@ var LegendListInner = forwardRef(function LegendListInner2(props, forwardedRef)
       } else if (estimatedItemSize) {
         offset = index * estimatedItemSize;
       }
-      return offset + (maintainVisibleContentPosition ? INITIAL_SCROLL_ADJUST : 0);
+      return offset / numColumnsProp;
     }
-    return void 0;
+    return 0;
   };
   const initialContentOffset = initialScrollOffset != null ? initialScrollOffset : useMemo(calculateInitialOffset, []);
   if (!refState.current) {
+    const initialScrollLength = Dimensions.get("window")[horizontal ? "width" : "height"];
     refState.current = {
       sizes: /* @__PURE__ */ new Map(),
       positions: /* @__PURE__ */ new Map(),
       columns: /* @__PURE__ */ new Map(),
       pendingAdjust: 0,
       animFrameLayout: null,
-      animFrameTotalSize: null,
-      isStartReached: true,
+      isStartReached: initialContentOffset < initialScrollLength * onStartReachedThreshold,
       isEndReached: false,
       isAtBottom: false,
       isAtTop: false,
       data,
       idsInFirstRender: void 0,
       hasScrolled: false,
-      scrollLength: Dimensions.get("window")[horizontal ? "width" : "height"],
+      scrollLength: initialScrollLength,
       startBuffered: 0,
       startNoBuffer: 0,
       endBuffered: 0,
       endNoBuffer: 0,
       scroll: initialContentOffset || 0,
       totalSize: 0,
+      totalSizeBelowAnchor: 0,
       timeouts: /* @__PURE__ */ new Set(),
       viewabilityConfigCallbackPairs: void 0,
       renderItem: void 0,
-      scrollAdjustPending: maintainVisibleContentPosition ? INITIAL_SCROLL_ADJUST : 0,
+      scrollAdjustHandler: new ScrollAdjustHandler(ctx),
       nativeMarginTop: 0,
       scrollPrev: 0,
       scrollPrevTime: 0,
@@ -527,54 +541,142 @@ var LegendListInner = forwardRef(function LegendListInner2(props, forwardedRef)
       scrollVelocity: 0,
       contentSize: { width: 0, height: 0 },
       sizesLaidOut: __DEV__ ? /* @__PURE__ */ new Map() : void 0,
-      timeoutSizeMessage: 0
+      timeoutSizeMessage: 0,
+      scrollTimer: void 0,
+      belowAnchorElementPositions: void 0,
+      rowHeights: /* @__PURE__ */ new Map(),
+      startReachedBlockedByTimer: false
     };
     refState.current.idsInFirstRender = new Set(data.map((_, i) => getId(i)));
-    set$(ctx, "scrollAdjust", refState.current.scrollAdjustPending);
+    if (maintainVisibleContentPosition) {
+      if (initialScrollIndex) {
+        refState.current.anchorElement = {
+          coordinate: initialContentOffset,
+          id: getId(initialScrollIndex)
+        };
+      } else if (data.length) {
+        refState.current.anchorElement = {
+          coordinate: initialContentOffset,
+          id: getId(0)
+        };
+      } else {
+        console.warn("[legend-list] maintainVisibleContentPosition was not able to find an anchor element");
+      }
+    }
+    set$(ctx, "scrollAdjust", 0);
   }
-  const adjustScroll = (diff) => {
-    if (maintainVisibleContentPosition && refScroller.current) {
-      refState.current.scrollAdjustPending -= diff;
+  const getAnchorElementIndex = () => {
+    const state = refState.current;
+    if (state.anchorElement) {
+      const el = state.indexByKey.get(state.anchorElement.id);
+      return el;
     }
+    return void 0;
   };
-  const addTotalSize = useCallback((key, add) => {
+  const addTotalSize = useCallback((key, add, totalSizeBelowAnchor) => {
     const state = refState.current;
     const index = key === null ? 0 : state.indexByKey.get(key);
-    const isAbove = key !== null && index < (state.startNoBuffer || 0);
-    const prev = state.totalSize;
+    let isAboveAnchor = false;
+    if (maintainVisibleContentPosition) {
+      if (state.anchorElement && index < getAnchorElementIndex()) {
+        isAboveAnchor = true;
+      }
+    }
+    state.totalSize;
     if (key === null) {
       state.totalSize = add;
+      state.totalSizeBelowAnchor = totalSizeBelowAnchor;
     } else {
       state.totalSize += add;
+      if (isAboveAnchor) {
+        state.totalSizeBelowAnchor += add;
+      }
+    }
+    let applyAdjustValue = void 0;
+    if (maintainVisibleContentPosition) {
+      const newAdjust = state.anchorElement.coordinate - state.totalSizeBelowAnchor;
+      applyAdjustValue = -newAdjust;
+      state.belowAnchorElementPositions = buildElementPositionsBelowAnchor();
+      state.rowHeights.clear();
     }
     const doAdd = () => {
       const totalSize = state.totalSize;
-      state.animFrameTotalSize = null;
-      set$(ctx, "totalSize", totalSize);
+      let resultSize = totalSize;
+      if (applyAdjustValue !== void 0) {
+        resultSize -= applyAdjustValue;
+        refState.current.scrollAdjustHandler.requestAdjust(applyAdjustValue, (diff) => {
+          state.scroll -= diff;
+        });
+      }
+      set$(ctx, "totalSize", resultSize);
       if (alignItemsAtEnd) {
         doUpdatePaddingTop();
       }
     };
-    if (isAbove) {
-      adjustScroll(add);
+    doAdd();
+  }, []);
+  const getRowHeight = (n) => {
+    const { rowHeights } = refState.current;
+    if (numColumnsProp === 1) {
+      const id = getId(n);
+      return getItemSize(id, n, data[n]);
     }
-    if (!prev || key === null) {
-      doAdd();
-    } else if (!state.animFrameTotalSize) {
-      state.animFrameTotalSize = requestAnimationFrame(doAdd);
+    if (rowHeights.has(n)) {
+      return rowHeights.get(n) || 0;
     }
-  }, []);
-  const calculateItemsInView = useCallback((speed = 0) => {
-    var _a2, _b2, _c2;
+    let rowHeight = 0;
+    const startEl = n * numColumnsProp;
+    for (let i = startEl; i < startEl + numColumnsProp; i++) {
+      const id = getId(i);
+      const size = getItemSize(id, i, data[i]);
+      rowHeight = Math.max(rowHeight, size);
+    }
+    rowHeights.set(n, rowHeight);
+    return rowHeight;
+  };
+  const buildElementPositionsBelowAnchor = () => {
+    const state = refState.current;
+    if (!state.anchorElement) {
+      return /* @__PURE__ */ new Map();
+    }
+    let top = state.anchorElement.coordinate;
+    const anchorIndex = state.indexByKey.get(state.anchorElement.id);
+    if (anchorIndex === 0) {
+      return /* @__PURE__ */ new Map();
+    }
+    const map = state.belowAnchorElementPositions || /* @__PURE__ */ new Map();
+    for (let i = anchorIndex - 1; i >= 0; i--) {
+      const id = getId(i);
+      const rowNumber = Math.floor(i / numColumnsProp);
+      if (i % numColumnsProp === 0) {
+        top -= getRowHeight(rowNumber);
+      }
+      map.set(id, top);
+    }
+    return map;
+  };
+  const getElementPositionBelowAchor = (id) => {
+    const state = refState.current;
+    if (!refState.current.belowAnchorElementPositions) {
+      state.belowAnchorElementPositions = buildElementPositionsBelowAnchor();
+    }
+    const res = state.belowAnchorElementPositions.get(id);
+    if (res === void 0) {
+      throw new Error("Undefined position below achor");
+    }
+    return res;
+  };
+  const calculateItemsInView = useCallback((speed) => {
+    var _a2, _b2;
     const state = refState.current;
     const {
       data: data2,
       scrollLength,
       scroll: scrollState,
-      startBuffered: startBufferedState,
+      startBufferedId: startBufferedIdOrig,
       positions,
-      sizes,
-      columns
+      columns,
+      scrollAdjustHandler
     } = state;
     if (state.animFrameLayout) {
       cancelAnimationFrame(state.animFrameLayout);
@@ -584,30 +686,35 @@ var LegendListInner = forwardRef(function LegendListInner2(props, forwardedRef)
       return;
     }
     const topPad = (peek$(ctx, "stylePaddingTop") || 0) + (peek$(ctx, "headerSize") || 0);
-    const scrollAdjustPending = (_a2 = state.scrollAdjustPending) != null ? _a2 : 0;
+    const previousScrollAdjust = scrollAdjustHandler.getAppliedAdjust();
     const scrollExtra = Math.max(-16, Math.min(16, speed)) * 16;
-    const scroll = Math.max(
-      0,
-      scrollState - topPad - (USE_CONTENT_INSET ? scrollAdjustPending : 0) + scrollExtra
-    );
+    const scroll = scrollState - previousScrollAdjust - topPad - scrollExtra;
     const scrollBottom = scroll + scrollLength;
     let startNoBuffer = null;
     let startBuffered = null;
+    let startBufferedId = null;
     let endNoBuffer = null;
     let endBuffered = null;
-    let loopStart = startBufferedState || 0;
-    if (startBufferedState) {
-      for (let i = startBufferedState; i >= 0; i--) {
-        const id = getId(i);
-        const top2 = positions.get(id);
-        if (top2 !== void 0) {
-          const size = getItemSize(id, i, data2[i]);
-          const bottom = top2 + size;
-          if (bottom > scroll - scrollBuffer) {
-            loopStart = i;
-          } else {
-            break;
-          }
+    const originalStartId = startBufferedIdOrig && state.indexByKey.get(startBufferedIdOrig);
+    let loopStart = originalStartId || 0;
+    const anchorElementIndex = getAnchorElementIndex();
+    for (let i = loopStart; i >= 0; i--) {
+      const id = getId(i);
+      let newPosition;
+      if (maintainVisibleContentPosition && anchorElementIndex && i < anchorElementIndex) {
+        newPosition = getElementPositionBelowAchor(id);
+        if (newPosition !== void 0) {
+          positions.set(id, newPosition);
+        }
+      }
+      const top2 = newPosition || positions.get(id);
+      if (top2 !== void 0) {
+        const size = getItemSize(id, i, data2[i]);
+        const bottom = top2 + size;
+        if (bottom > scroll - scrollBuffer) {
+          loopStart = i;
+        } else {
+          break;
         }
       }
     }
@@ -616,13 +723,28 @@ var LegendListInner = forwardRef(function LegendListInner2(props, forwardedRef)
     if (loopStartMod > 0) {
       loopStart -= loopStartMod;
     }
-    let top = loopStart > 0 ? positions.get(getId(loopStart)) : 0;
+    let top = void 0;
     let column = 1;
     let maxSizeInRow = 0;
+    const getInitialTop = (i) => {
+      var _a3;
+      const id = getId(i);
+      let topOffset = 0;
+      if (positions.get(id)) {
+        topOffset = positions.get(id);
+      }
+      if (id === ((_a3 = state.anchorElement) == null ? void 0 : _a3.id)) {
+        topOffset = initialContentOffset || 0;
+      }
+      return topOffset;
+    };
     for (let i = loopStart; i < data2.length; i++) {
       const id = getId(i);
       const size = getItemSize(id, i, data2[i]);
       maxSizeInRow = Math.max(maxSizeInRow, size);
+      if (top === void 0) {
+        top = getInitialTop(i);
+      }
       if (positions.get(id) !== top) {
         positions.set(id, top);
       }
@@ -634,6 +756,7 @@ var LegendListInner = forwardRef(function LegendListInner2(props, forwardedRef)
       }
       if (startBuffered === null && top + size > scroll - scrollBuffer) {
         startBuffered = i;
+        startBufferedId = id;
       }
       if (startNoBuffer !== null) {
         if (top <= scrollBottom) {
@@ -654,6 +777,7 @@ var LegendListInner = forwardRef(function LegendListInner2(props, forwardedRef)
     }
     Object.assign(refState.current, {
       startBuffered,
+      startBufferedId,
       startNoBuffer,
       endBuffered,
       endNoBuffer
@@ -672,7 +796,7 @@ var LegendListInner = forwardRef(function LegendListInner2(props, forwardedRef)
           }
         }
         if (!isContained) {
-          const top2 = (positions.get(id) || 0) + scrollAdjustPending;
+          const top2 = positions.get(id) || 0;
           let furthestIndex = -1;
           let furthestDistance = 0;
           for (let u = 0; u < numContainers; u++) {
@@ -681,7 +805,7 @@ var LegendListInner = forwardRef(function LegendListInner2(props, forwardedRef)
               furthestIndex = u;
               break;
             }
-            const index = (_b2 = refState.current) == null ? void 0 : _b2.indexByKey.get(key);
+            const index = (_a2 = refState.current) == null ? void 0 : _a2.indexByKey.get(key);
             const pos = peek$(ctx, `containerPosition${u}`);
             if (index < startBuffered || index > endBuffered) {
               const distance = Math.abs(pos - top2);
@@ -716,23 +840,23 @@ var LegendListInner = forwardRef(function LegendListInner2(props, forwardedRef)
       }
       for (let i = 0; i < numContainers; i++) {
         const itemKey = peek$(ctx, `containerItemKey${i}`);
-        const itemIndex = (_c2 = refState.current) == null ? void 0 : _c2.indexByKey.get(itemKey);
+        const itemIndex = (_b2 = refState.current) == null ? void 0 : _b2.indexByKey.get(itemKey);
         const item = data2[itemIndex];
         if (item) {
           const id = getId(itemIndex);
           if (itemKey !== id || itemIndex < startBuffered || itemIndex > endBuffered) {
-            const prevPos = peek$(ctx, `containerPosition${i}`) - scrollAdjustPending;
+            const prevPos = peek$(ctx, `containerPosition${i}`);
             const pos = positions.get(id) || 0;
-            const size = sizes.get(id) || 0;
+            const size = getItemSize(id, itemIndex, data2[i]);
             if (pos + size >= scroll && pos <= scrollBottom || prevPos + size >= scroll && prevPos <= scrollBottom) {
               set$(ctx, `containerPosition${i}`, POSITION_OUT_OF_VIEW);
             }
           } else {
-            const pos = (positions.get(id) || 0) + scrollAdjustPending;
+            const pos = positions.get(id) || 0;
             const column2 = columns.get(id) || 1;
             const prevPos = peek$(ctx, `containerPosition${i}`);
             const prevColumn = peek$(ctx, `containerColumn${i}`);
-            if (pos >= 0 && pos !== prevPos) {
+            if (pos > POSITION_OUT_OF_VIEW && pos !== prevPos) {
               set$(ctx, `containerPosition${i}`, pos);
             }
             if (column2 >= 0 && column2 !== prevColumn) {
@@ -804,17 +928,20 @@ var LegendListInner = forwardRef(function LegendListInner2(props, forwardedRef)
       return;
     }
     const { scrollLength, scroll } = refState.current;
-    const scrollAdjust = peek$(ctx, "scrollAdjust") || 0;
-    const distanceFromTop = scroll - scrollAdjust;
+    const distanceFromTop = scroll;
     refState.current.isAtTop = distanceFromTop < 0;
     if (onStartReached) {
-      if (!refState.current.isStartReached) {
+      if (!refState.current.isStartReached && !refState.current.startReachedBlockedByTimer) {
         if (distanceFromTop < onStartReachedThreshold * scrollLength) {
           refState.current.isStartReached = true;
           onStartReached({ distanceFromStart: scroll });
+          refState.current.startReachedBlockedByTimer = true;
+          setTimeout(() => {
+            refState.current.startReachedBlockedByTimer = false;
+          }, 700);
         }
       } else {
-        if (distanceFromTop >= onStartReachedThreshold * scrollLength) {
+        if (distanceFromTop >= 1.3 * onStartReachedThreshold * scrollLength) {
           refState.current.isStartReached = false;
         }
       }
@@ -828,43 +955,36 @@ var LegendListInner = forwardRef(function LegendListInner2(props, forwardedRef)
     }
     refState.current.data = data;
     let totalSize = 0;
+    let totalSizeBelowIndex = 0;
     const indexByKey = /* @__PURE__ */ new Map();
     let column = 1;
     let maxSizeInRow = 0;
     for (let i = 0; i < data.length; i++) {
       const key = getId(i);
       indexByKey.set(key, i);
+    }
+    refState.current.indexByKey = indexByKey;
+    const anchorElementIndex = getAnchorElementIndex();
+    for (let i = 0; i < data.length; i++) {
+      const key = getId(i);
       const size = getItemSize(key, i, data[i]);
       maxSizeInRow = Math.max(maxSizeInRow, size);
-      if (maintainVisibleContentPosition && i < refState.current.startNoBuffer && !refState.current.indexByKey.has(key)) {
-        const size2 = getItemSize(key, i, data[i]);
-        adjustScroll(size2);
-      }
       column++;
       if (column > numColumnsProp) {
+        if (maintainVisibleContentPosition && anchorElementIndex !== void 0 && i < anchorElementIndex) {
+          totalSizeBelowIndex += maxSizeInRow;
+        }
         totalSize += maxSizeInRow;
         column = 1;
         maxSizeInRow = 0;
       }
     }
-    addTotalSize(null, totalSize);
-    if (maintainVisibleContentPosition) {
-      for (const [key, index] of refState.current.indexByKey) {
-        if (index < refState.current.startNoBuffer && !indexByKey.has(key)) {
-          const size = (_a = refState.current.sizes.get(key)) != null ? _a : 0;
-          if (size) {
-            adjustScroll(-size);
-          }
-        }
-      }
-    }
-    refState.current.indexByKey = indexByKey;
+    addTotalSize(null, totalSize, totalSizeBelowIndex);
     if (!isFirst) {
-      refState.current.isEndReached = false;
       const numContainers = peek$(ctx, "numContainers");
       for (let i = 0; i < numContainers; i++) {
         const itemKey = peek$(ctx, `containerItemKey${i}`);
-        if (!keyExtractorProp || itemKey && ((_b = refState.current) == null ? void 0 : _b.indexByKey.get(itemKey)) === void 0) {
+        if (!keyExtractorProp || itemKey && ((_a = refState.current) == null ? void 0 : _a.indexByKey.get(itemKey)) === void 0) {
           set$(ctx, `containerItemKey${i}`, void 0);
           set$(ctx, `containerPosition${i}`, POSITION_OUT_OF_VIEW);
           set$(ctx, `containerColumn${i}`, -1);
@@ -874,10 +994,12 @@ var LegendListInner = forwardRef(function LegendListInner2(props, forwardedRef)
         refState.current.sizes.clear();
         refState.current.positions;
       }
-      calculateItemsInView();
-      doMaintainScrollAtEnd(false);
-      checkAtTop();
-      checkAtBottom();
+      setTimeout(() => {
+        calculateItemsInView(refState.current.scrollVelocity);
+        doMaintainScrollAtEnd(false);
+        checkAtTop();
+        checkAtBottom();
+      }, 0);
     }
   }
   refState.current.renderItem = renderItem;
@@ -886,7 +1008,7 @@ var LegendListInner = forwardRef(function LegendListInner2(props, forwardedRef)
   set$(
     ctx,
     "stylePaddingTop",
-    (_f = (_e = (_c = StyleSheet.flatten(style)) == null ? void 0 : _c.paddingTop) != null ? _e : (_d = StyleSheet.flatten(contentContainerStyle)) == null ? void 0 : _d.paddingTop) != null ? _f : 0
+    (_e = (_d = (_b = StyleSheet.flatten(style)) == null ? void 0 : _b.paddingTop) != null ? _d : (_c = StyleSheet.flatten(contentContainerStyle)) == null ? void 0 : _c.paddingTop) != null ? _e : 0
   );
   const getRenderedItem = useCallback((key, containerId) => {
     var _a2, _b2;
@@ -995,7 +1117,7 @@ var LegendListInner = forwardRef(function LegendListInner2(props, forwardedRef)
     }
     set$(ctx, "numContainers", numContainers);
     set$(ctx, "numContainersPooled", numContainers * 2);
-    calculateItemsInView();
+    calculateItemsInView(refState.current.scrollVelocity);
   });
   const updateItemSize = useCallback((containerId, itemKey, size) => {
     var _a2;
@@ -1006,21 +1128,16 @@ var LegendListInner = forwardRef(function LegendListInner2(props, forwardedRef)
     const state = refState.current;
     const { sizes, indexByKey, idsInFirstRender, columns, sizesLaidOut } = state;
     const index = indexByKey.get(itemKey);
-    const wasInFirstRender = idsInFirstRender.has(itemKey);
-    const prevSize = sizes.get(itemKey) || (wasInFirstRender ? getItemSize(itemKey, index, data2[index]) : 0);
+    const numColumns = peek$(ctx, "numColumns");
+    const row = Math.floor(index / numColumns);
+    const prevSize = getRowHeight(row);
     if (!prevSize || Math.abs(prevSize - size) > 0.5) {
       let diff;
-      const numColumns = peek$(ctx, "numColumns");
       if (numColumns > 1) {
+        const prevMaxSizeInRow = getRowHeight(row);
+        sizes.set(itemKey, size);
         const column = columns.get(itemKey);
         const loopStart = index - (column - 1);
-        let prevMaxSizeInRow = 0;
-        for (let i = loopStart; i < loopStart + numColumns; i++) {
-          const id = getId(i);
-          const size2 = getItemSize(id, i, data2[i]);
-          prevMaxSizeInRow = Math.max(prevMaxSizeInRow, size2);
-        }
-        sizes.set(itemKey, size);
         let nextMaxSizeInRow = 0;
         for (let i = loopStart; i < loopStart + numColumns; i++) {
           const id = getId(i);
@@ -1051,7 +1168,7 @@ var LegendListInner = forwardRef(function LegendListInner2(props, forwardedRef)
           );
         }, 1e3);
       }
-      addTotalSize(itemKey, diff);
+      addTotalSize(itemKey, diff, 0);
       doMaintainScrollAtEnd(true);
       const scrollVelocity = state.scrollVelocity;
       if (!state.animFrameLayout && (Number.isNaN(scrollVelocity) || Math.abs(scrollVelocity) < 1)) {
@@ -1067,18 +1184,12 @@ var LegendListInner = forwardRef(function LegendListInner2(props, forwardedRef)
     }
   }, []);
   const handleScrollDebounced = useCallback((velocity) => {
-    var _a2, _b2;
-    const scrollAdjustPending = (_b2 = (_a2 = refState.current) == null ? void 0 : _a2.scrollAdjustPending) != null ? _b2 : 0;
-    set$(ctx, "scrollAdjust", scrollAdjustPending);
     calculateItemsInView(velocity);
     checkAtBottom();
     checkAtTop();
   }, []);
   const onLayout = useCallback((event) => {
-    let scrollLength = event.nativeEvent.layout[horizontal ? "width" : "height"];
-    if (!USE_CONTENT_INSET) {
-      scrollLength += event.nativeEvent.layout[horizontal ? "x" : "y"];
-    }
+    const scrollLength = event.nativeEvent.layout[horizontal ? "width" : "height"];
     refState.current.scrollLength = scrollLength;
     if (refState.current.hasScrolled) {
       doMaintainScrollAtEnd(false);
@@ -1107,10 +1218,18 @@ var LegendListInner = forwardRef(function LegendListInner2(props, forwardedRef)
       state.contentSize = event.nativeEvent.contentSize;
       const currentTime = performance.now();
       const newScroll = event.nativeEvent.contentOffset[horizontal ? "x" : "y"];
-      state.scrollHistory.push({ scroll: newScroll, time: currentTime });
+      if (!(state.scrollHistory.length === 0 && newScroll === initialContentOffset)) {
+        state.scrollHistory.push({ scroll: newScroll, time: currentTime });
+      }
       if (state.scrollHistory.length > 5) {
         state.scrollHistory.shift();
       }
+      if (state.scrollTimer !== void 0) {
+        clearTimeout(state.scrollTimer);
+      }
+      state.scrollTimer = setTimeout(() => {
+        state.scrollVelocity = 0;
+      }, 500);
       let velocity = 0;
       if (state.scrollHistory.length >= 2) {
         const newest = state.scrollHistory[state.scrollHistory.length - 1];
@@ -1160,7 +1279,7 @@ var LegendListInner = forwardRef(function LegendListInner2(props, forwardedRef)
     },
     []
   );
-  return /* @__PURE__ */ React5.createElement(
+  return /* @__PURE__ */ React4.createElement(
     ListComponent,
     {
       ...rest,
@@ -1173,8 +1292,8 @@ var LegendListInner = forwardRef(function LegendListInner2(props, forwardedRef)
       onLayout,
       recycleItems,
       alignItemsAtEnd,
-      addTotalSize,
       ListEmptyComponent: data.length === 0 ? ListEmptyComponent : void 0,
+      maintainVisibleContentPosition,
       style
     }
   );