@legendapp/list 1.0.0-beta.26 → 1.0.0-beta.27

package/index.d.ts

@@ -10,52 +10,132 @@ declare class ScrollAdjustHandler {
     private busy;
     private context;
     private isPaused;
+    private isDisabled;
     constructor(ctx: any);
     private doAjdust;
     requestAdjust(adjust: number, onAdjusted: (diff: number) => void): void;
     getAppliedAdjust(): number;
     pauseAdjust(): void;
+    setDisableAdjust(disable: boolean): void;
     unPauseAdjust(): boolean;
 }
 
 type LegendListPropsBase<ItemT, TScrollView extends ComponentProps<typeof ScrollView> | ComponentProps<typeof Animated.ScrollView>> = Omit<TScrollView, "contentOffset" | "contentInset" | "maintainVisibleContentPosition" | "stickyHeaderIndices"> & {
+    /**
+      * If true, aligns items at the end of the list.
+      * @default false
+      */
+    alignItemsAtEnd?: boolean;
+    /**
+     * Style applied to each column's wrapper view.
+     */
+    columnWrapperStyle?: ColumnWrapperStyle;
+    /**
+     * Array of items to render in the list.
+     * @required
+     */
     data: ReadonlyArray<ItemT>;
+    /**
+     * Distance in pixels to pre-render items ahead of the visible area.
+     * @default 250
+     */
+    drawDistance?: number;
+    /**
+     * Estimated size of each item in pixels; sufficient for most cases. If
+     * you leave this blank, a warning should appear and you will get
+     * a suggested size.
+     * @required
+     * @default undefined
+     */
+    estimatedItemSize?: number;
+    /**
+     * Extra data to trigger re-rendering when changed.
+     */
+    extraData?: any;
+    /**
+     * In case you have distinct item sizes, you can provide a function to get the size of an item.
+     * Use instead of FlatList's getItemLayout or FlashList overrideItemLayout if you want to have accurate initialScrollOffset, you should provide this function
+     */
+    getEstimatedItemSize?: (index: number, item: ItemT) => number;
+    /**
+     * Ratio of initial container pool size to data length (e.g., 0.5 for half).
+     * @default 1
+     */
+    initialContainerPoolRatio?: number | undefined;
+    /**
+     * Initial scroll position in pixels.
+     * @default 0
+     */
     initialScrollOffset?: number;
+    /**
+     * Index to scroll to initially.
+     * @default 0
+     */
     initialScrollIndex?: number;
-    drawDistance?: number;
-    recycleItems?: boolean;
-    onEndReachedThreshold?: number | null | undefined;
-    onStartReachedThreshold?: number | null | undefined;
+    /**
+     * Component to render between items, receiving the leading item as prop.
+     */
+    ItemSeparatorComponent?: React.ComponentType<{
+        leadingItem: ItemT;
+    }>;
+    /**
+     * Function to extract a unique key for each item.
+     */
+    keyExtractor?: (item: ItemT, index: number) => string;
+    /**
+     * Component or element to render when the list is empty.
+     */
+    ListEmptyComponent?: React.ComponentType<any> | React.ReactElement | null | undefined;
+    /**
+     * Component or element to render below the list.
+     */
+    ListFooterComponent?: React.ComponentType<any> | React.ReactElement | null | undefined;
+    /**
+     * Style for the footer component.
+     */
+    ListFooterComponentStyle?: StyleProp<ViewStyle> | undefined;
+    /**
+     * Component or element to render above the list.
+     */
+    ListHeaderComponent?: React.ComponentType<any> | React.ReactElement | null | undefined;
+    /**
+     * Style for the header component.
+     */
+    ListHeaderComponentStyle?: StyleProp<ViewStyle> | undefined;
+    /**
+     * If true, auto-scrolls to end when new items are added.
+     * @default false
+     */
     maintainScrollAtEnd?: boolean;
+    /**
+     * Distance threshold in pixels to trigger maintainScrollAtEnd.
+     * @default 100
+     */
     maintainScrollAtEndThreshold?: number;
-    alignItemsAtEnd?: boolean;
+    /**
+     * If true, maintains visibility of content during scroll (e.g., after insertions).
+     * @default false
+     */
     maintainVisibleContentPosition?: boolean;
+    /**
+     * Number of columns to render items in.
+     * @default 1
+     */
     numColumns?: number;
-    columnWrapperStyle?: ColumnWrapperStyle;
-    refScrollView?: React.Ref<ScrollView>;
-    waitForInitialLayout?: boolean;
-    initialContainerPoolRatio?: number | undefined;
-    estimatedItemSize?: number;
-    getEstimatedItemSize?: (index: number, item: ItemT) => number;
-    onStartReached?: ((info: {
-        distanceFromStart: number;
-    }) => void) | null | undefined;
+    /**
+     * Called when scrolling reaches the end within onEndReachedThreshold.
+     */
     onEndReached?: ((info: {
         distanceFromEnd: number;
     }) => void) | null | undefined;
-    keyExtractor?: (item: ItemT, index: number) => string;
-    renderItem?: (props: LegendListRenderItemProps<ItemT>) => ReactNode;
-    ListHeaderComponent?: React.ComponentType<any> | React.ReactElement | null | undefined;
-    ListHeaderComponentStyle?: StyleProp<ViewStyle> | undefined;
-    ListFooterComponent?: React.ComponentType<any> | React.ReactElement | null | undefined;
-    ListFooterComponentStyle?: StyleProp<ViewStyle> | undefined;
-    ListEmptyComponent?: React.ComponentType<any> | React.ReactElement | null | undefined;
-    ItemSeparatorComponent?: React.ComponentType<{
-        leadingItem: ItemT;
-    }>;
-    viewabilityConfigCallbackPairs?: ViewabilityConfigCallbackPairs | undefined;
-    viewabilityConfig?: ViewabilityConfig;
-    onViewableItemsChanged?: OnViewableItemsChanged | undefined;
+    /**
+     * How close to the end (in fractional units of visible length) to trigger onEndReached.
+     * @default 0.5
+     */
+    onEndReachedThreshold?: number | null | undefined;
+    /**
+     * Called when an item's size changes.
+     */
     onItemSizeChanged?: (info: {
         size: number;
         previous: number;
@@ -63,15 +143,67 @@ type LegendListPropsBase<ItemT, TScrollView extends ComponentProps<typeof Scroll
         itemKey: string;
         itemData: ItemT;
     }) => void;
+    /**
+     * Function to call when the user pulls to refresh.
+     */
+    onRefresh?: () => void;
+    /**
+     * Called when scrolling reaches the start within onStartReachedThreshold.
+     */
+    onStartReached?: ((info: {
+        distanceFromStart: number;
+    }) => void) | null | undefined;
+    /**
+     * How close to the start (in fractional units of visible length) to trigger onStartReached.
+     * @default 0.5
+     */
+    onStartReachedThreshold?: number | null | undefined;
+    /**
+     * Called when the viewability of items changes.
+     */
+    onViewableItemsChanged?: OnViewableItemsChanged | undefined;
+    /**
+     * Offset in pixels for the refresh indicator.
+     * @default 0
+     */
+    progressViewOffset?: number;
+    /**
+     * If true, recycles item views for better performance.
+     * @default false
+     */
+    recycleItems?: boolean;
+    /**
+     * Ref to the underlying ScrollView component.
+     */
+    refScrollView?: React.Ref<ScrollView>;
+    /**
+     * If true, shows a refresh indicator.
+     * @default false
+     */
+    refreshing?: boolean;
+    /**
+     * Function to render each item in the list.
+     * @required
+     */
+    renderItem?: (props: LegendListRenderItemProps<ItemT>) => ReactNode;
     /**
      * Render custom ScrollView component.
      * @default (props) => <ScrollView {...props} />
      */
     renderScrollComponent?: (props: ScrollViewProps) => React.ReactElement<ScrollViewProps>;
-    extraData?: any;
-    refreshing?: boolean;
-    onRefresh?: () => void;
-    progressViewOffset?: number;
+    /**
+     * Configuration for determining item viewability.
+     */
+    viewabilityConfig?: ViewabilityConfig;
+    /**
+     * Pairs of viewability configs and their callbacks for tracking visibility.
+     */
+    viewabilityConfigCallbackPairs?: ViewabilityConfigCallbackPairs | undefined;
+    /**
+     * If true, delays rendering until initial layout is complete.
+     * @default false
+     */
+    waitForInitialLayout?: boolean;
 };
 interface ColumnWrapperStyle {
     rowGap?: number;
@@ -151,6 +283,7 @@ interface ViewableRange<T> {
 interface LegendListRenderItemProps<ItemT> {
     item: ItemT;
     index: number;
+    extraData: any;
     useViewability: (configId: string, callback: ViewabilityCallback) => void;
     useViewabilityAmount: (callback: ViewabilityAmountCallback) => void;
     useRecyclingEffect: (effect: (info: LegendListRecyclingState<ItemT>) => void | (() => void)) => void;
@@ -158,35 +291,63 @@ interface LegendListRenderItemProps<ItemT> {
 }
 type LegendListRef = {
     /**
-     * Displays the scroll indicators momentarily.
-     */
+         * Displays the scroll indicators momentarily.
+         */
     flashScrollIndicators(): void;
+    /**
+     * Returns the native ScrollView component reference.
+     */
     getNativeScrollRef(): React.ElementRef<typeof ScrollViewComponent>;
-    getScrollResponder(): ScrollResponderMixin;
+    /**
+     * Returns the scroll responder instance for handling scroll events.
+     */
     getScrollableNode(): any;
     /**
-     * A helper function that scrolls to the end of the scrollview;
-     * If this is a vertical ScrollView, it scrolls to the bottom.
-     * If this is a horizontal ScrollView scrolls to the right.
-     *
-     * The options object has an animated prop, that enables the scrolling animation or not.
-     * The animated prop defaults to true
+     * Returns the ScrollResponderMixin for advanced scroll handling.
+     */
+    getScrollResponder(): ScrollResponderMixin;
+    /**
+     * Scrolls to the end of the list.
+     * @param options - Options for scrolling.
+     * @param options.animated - If true, animates the scroll. Default: true.
      */
     scrollToEnd(options?: {
         animated?: boolean | undefined;
     }): void;
+    /**
+     * Scrolls to a specific index in the list.
+     * @param params - Parameters for scrolling.
+     * @param params.animated - If true, animates the scroll. Default: true.
+     * @param params.index - The index to scroll to.
+     * @param params.viewOffset - Offset from the target position.
+     * @param params.viewPosition - Position of the item in the viewport (0 to 1).
+     */
     scrollToIndex(params: {
         animated?: boolean | undefined;
         index: number;
         viewOffset?: number | undefined;
         viewPosition?: number | undefined;
     }): void;
+    /**
+     * Scrolls to a specific item in the list.
+     * @param params - Parameters for scrolling.
+     * @param params.animated - If true, animates the scroll. Default: true.
+     * @param params.item - The item to scroll to.
+     * @param params.viewOffset - Offset from the target position.
+     * @param params.viewPosition - Position of the item in the viewport (0 to 1).
+     */
     scrollToItem(params: {
         animated?: boolean | undefined;
         item: any;
         viewOffset?: number | undefined;
         viewPosition?: number | undefined;
     }): void;
+    /**
+     * Scrolls to a specific offset in pixels.
+     * @param params - Parameters for scrolling.
+     * @param params.offset - The pixel offset to scroll to.
+     * @param params.animated - If true, animates the scroll. Default: true.
+     */
     scrollToOffset(params: {
         offset: number;
         animated?: boolean | undefined;
@@ -260,43 +421,33 @@ type TypedMemo = <T extends React.ComponentType<any>>(Component: T, propsAreEqua
 declare const typedMemo: TypedMemo;
 
 declare const LegendList: <T>(props: Omit<react_native.ScrollViewProps, "maintainVisibleContentPosition" | "stickyHeaderIndices" | "contentInset" | "contentOffset"> & {
+    alignItemsAtEnd?: boolean;
+    columnWrapperStyle?: ColumnWrapperStyle;
     data: readonly T[];
+    drawDistance?: number;
+    estimatedItemSize?: number;
+    extraData?: any;
+    getEstimatedItemSize?: ((index: number, item: T) => number) | undefined;
+    initialContainerPoolRatio?: number | undefined;
     initialScrollOffset?: number;
     initialScrollIndex?: number;
-    drawDistance?: number;
-    recycleItems?: boolean;
-    onEndReachedThreshold?: number | null | undefined;
-    onStartReachedThreshold?: number | null | undefined;
+    ItemSeparatorComponent?: React$1.ComponentType<{
+        leadingItem: T;
+    }> | undefined;
+    keyExtractor?: ((item: T, index: number) => string) | undefined;
+    ListEmptyComponent?: React$1.ComponentType<any> | React$1.ReactElement | null | undefined;
+    ListFooterComponent?: React$1.ComponentType<any> | React$1.ReactElement | null | undefined;
+    ListFooterComponentStyle?: react_native.StyleProp<react_native.ViewStyle> | undefined;
+    ListHeaderComponent?: React$1.ComponentType<any> | React$1.ReactElement | null | undefined;
+    ListHeaderComponentStyle?: react_native.StyleProp<react_native.ViewStyle> | undefined;
     maintainScrollAtEnd?: boolean;
     maintainScrollAtEndThreshold?: number;
-    alignItemsAtEnd?: boolean;
     maintainVisibleContentPosition?: boolean;
     numColumns?: number;
-    columnWrapperStyle?: ColumnWrapperStyle;
-    refScrollView?: React$1.Ref<ScrollView>;
-    waitForInitialLayout?: boolean;
-    initialContainerPoolRatio?: number | undefined;
-    estimatedItemSize?: number;
-    getEstimatedItemSize?: ((index: number, item: T) => number) | undefined;
-    onStartReached?: ((info: {
-        distanceFromStart: number;
-    }) => void) | null | undefined;
     onEndReached?: ((info: {
         distanceFromEnd: number;
     }) => void) | null | undefined;
-    keyExtractor?: ((item: T, index: number) => string) | undefined;
-    renderItem?: ((props: LegendListRenderItemProps<T>) => React$1.ReactNode) | undefined;
-    ListHeaderComponent?: React$1.ComponentType<any> | React$1.ReactElement | null | undefined;
-    ListHeaderComponentStyle?: react_native.StyleProp<react_native.ViewStyle> | undefined;
-    ListFooterComponent?: React$1.ComponentType<any> | React$1.ReactElement | null | undefined;
-    ListFooterComponentStyle?: react_native.StyleProp<react_native.ViewStyle> | undefined;
-    ListEmptyComponent?: React$1.ComponentType<any> | React$1.ReactElement | null | undefined;
-    ItemSeparatorComponent?: React$1.ComponentType<{
-        leadingItem: T;
-    }> | undefined;
-    viewabilityConfigCallbackPairs?: ViewabilityConfigCallbackPairs | undefined;
-    viewabilityConfig?: ViewabilityConfig;
-    onViewableItemsChanged?: OnViewableItemsChanged | undefined;
+    onEndReachedThreshold?: number | null | undefined;
     onItemSizeChanged?: ((info: {
         size: number;
         previous: number;
@@ -304,11 +455,21 @@ declare const LegendList: <T>(props: Omit<react_native.ScrollViewProps, "maintai
         itemKey: string;
         itemData: T;
     }) => void) | undefined;
-    renderScrollComponent?: (props: react_native.ScrollViewProps) => React$1.ReactElement<react_native.ScrollViewProps>;
-    extraData?: any;
-    refreshing?: boolean;
     onRefresh?: () => void;
+    onStartReached?: ((info: {
+        distanceFromStart: number;
+    }) => void) | null | undefined;
+    onStartReachedThreshold?: number | null | undefined;
+    onViewableItemsChanged?: OnViewableItemsChanged | undefined;
     progressViewOffset?: number;
+    recycleItems?: boolean;
+    refScrollView?: React$1.Ref<ScrollView>;
+    refreshing?: boolean;
+    renderItem?: ((props: LegendListRenderItemProps<T>) => React$1.ReactNode) | undefined;
+    renderScrollComponent?: (props: react_native.ScrollViewProps) => React$1.ReactElement<react_native.ScrollViewProps>;
+    viewabilityConfig?: ViewabilityConfig;
+    viewabilityConfigCallbackPairs?: ViewabilityConfigCallbackPairs | undefined;
+    waitForInitialLayout?: boolean;
 } & React$1.RefAttributes<LegendListRef>) => React$1.ReactNode;
 
 declare function useViewability(configId: string, callback: ViewabilityCallback): void;

package/index.js

@@ -571,6 +571,7 @@ var ScrollAdjustHandler = class {
     this.appliedAdjust = 0;
     this.busy = false;
     this.isPaused = false;
+    this.isDisabled = false;
     this.context = ctx;
   }
   doAjdust() {
@@ -578,6 +579,9 @@ var ScrollAdjustHandler = class {
     this.busy = false;
   }
   requestAdjust(adjust, onAdjusted) {
+    if (this.isDisabled) {
+      return;
+    }
     const oldAdjustTop = peek$(this.context, "scrollAdjust");
     if (oldAdjustTop === adjust) {
       return;
@@ -595,6 +599,9 @@ var ScrollAdjustHandler = class {
   pauseAdjust() {
     this.isPaused = true;
   }
+  setDisableAdjust(disable) {
+    this.isDisabled = disable;
+  }
   // return true if it was paused
   unPauseAdjust() {
     if (this.isPaused) {
@@ -869,18 +876,6 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     return 0;
   };
   const initialContentOffset = initialScrollOffset != null ? initialScrollOffset : React6.useMemo(calculateOffsetForIndex, []);
-  if (reactNative.Platform.OS === "web") {
-    React6.useEffect(() => {
-      var _a2;
-      if (initialContentOffset) {
-        (_a2 = refScroller.current) == null ? void 0 : _a2.scrollTo({
-          x: horizontal ? initialContentOffset : 0,
-          y: horizontal ? 0 : initialContentOffset,
-          animated: false
-        });
-      }
-    }, []);
-  }
   if (!refState.current) {
     const initialScrollLength = reactNative.Dimensions.get("window")[horizontal ? "width" : "height"];
     refState.current = {
@@ -1523,6 +1518,20 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     addTotalSize(null, totalSize, totalSizeBelowIndex);
   };
   const isFirst = !refState.current.renderItem;
+  const memoizedLastItemKeys = React6.useMemo(() => {
+    if (!dataProp.length) return /* @__PURE__ */ new Set();
+    return new Set(
+      Array.from({ length: Math.min(numColumnsProp, dataProp.length) }, (_, i) => getId(dataProp.length - 1 - i))
+    );
+  }, [dataProp.length, numColumnsProp, dataProp.slice(-numColumnsProp).toString()]);
+  const initalizeStateVars = () => {
+    set$(ctx, "lastItemKeys", memoizedLastItemKeys);
+    set$(ctx, "numColumns", numColumnsProp);
+    set$(ctx, "stylePaddingTop", stylePaddingTop);
+  };
+  if (isFirst) {
+    initalizeStateVars();
+  }
   if (isFirst || didDataChange || numColumnsProp !== peek$(ctx, "numColumns")) {
     refState.current.lastBatchingAction = Date.now();
     if (!keyExtractorProp && !isFirst && didDataChange) {
@@ -1532,30 +1541,19 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     calcTotalSizesAndPositions({ forgetPositions: false });
   }
   React6.useEffect(() => {
-    checkResetContainers(
-      /*isFirst*/
-      isFirst
-    );
+    const didAllocateContainers = doInitialAllocateContainers();
+    if (!didAllocateContainers) {
+      checkResetContainers(
+        /*isFirst*/
+        isFirst
+      );
+    }
   }, [isFirst, dataProp, numColumnsProp]);
   React6.useEffect(() => {
     set$(ctx, "extraData", extraData);
   }, [extraData]);
   refState.current.renderItem = renderItem;
-  const memoizedLastItemKeys = React6.useMemo(() => {
-    if (!dataProp.length) return [];
-    return new Set(
-      Array.from({ length: Math.min(numColumnsProp, dataProp.length) }, (_, i) => getId(dataProp.length - 1 - i))
-    );
-  }, [dataProp.length, numColumnsProp, dataProp.slice(-numColumnsProp).toString()]);
   const stylePaddingTop = (_d = (_c = (_a = reactNative.StyleSheet.flatten(style)) == null ? void 0 : _a.paddingTop) != null ? _c : (_b = reactNative.StyleSheet.flatten(contentContainerStyle)) == null ? void 0 : _b.paddingTop) != null ? _d : 0;
-  const initalizeStateVars = () => {
-    set$(ctx, "lastItemKeys", memoizedLastItemKeys);
-    set$(ctx, "numColumns", numColumnsProp);
-    set$(ctx, "stylePaddingTop", stylePaddingTop);
-  };
-  if (isFirst) {
-    initalizeStateVars();
-  }
   React6.useEffect(initalizeStateVars, [memoizedLastItemKeys, numColumnsProp, stylePaddingTop]);
   const getRenderedItem = React6.useCallback((key) => {
     var _a2, _b2;
@@ -1583,6 +1581,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     const renderedItem = (_b2 = (_a2 = refState.current).renderItem) == null ? void 0 : _b2.call(_a2, {
       item: data[index],
       index,
+      extraData: peek$(ctx, "extraData"),
       useViewability: useViewability2,
       useViewabilityAmount: useViewabilityAmount2,
       useRecyclingEffect: useRecyclingEffect2,
@@ -1593,9 +1592,9 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
   const doInitialAllocateContainers = () => {
     var _a2;
     const state = refState.current;
-    const scrollLength = state.scrollLength;
-    if (scrollLength > 0 && !peek$(ctx, "numContainers")) {
-      const averageItemSize = (_a2 = estimatedItemSize != null ? estimatedItemSize : getEstimatedItemSize == null ? void 0 : getEstimatedItemSize(0, dataProp[0])) != null ? _a2 : DEFAULT_ITEM_SIZE;
+    const { scrollLength, data } = state;
+    if (scrollLength > 0 && data.length > 0 && !peek$(ctx, "numContainers")) {
+      const averageItemSize = (_a2 = estimatedItemSize != null ? estimatedItemSize : getEstimatedItemSize == null ? void 0 : getEstimatedItemSize(0, data[0])) != null ? _a2 : DEFAULT_ITEM_SIZE;
       const numContainers = Math.ceil((scrollLength + scrollBuffer * 2) / averageItemSize) * numColumnsProp;
       for (let i = 0; i < numContainers; i++) {
         set$(ctx, `containerPosition${i}`, ANCHORED_POSITION_OUT_OF_VIEW);
@@ -1610,6 +1609,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       } else {
         calculateItemsInView();
       }
+      return true;
     }
   };
   useInit(() => {
@@ -1688,20 +1688,26 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     if (needsCalculate) {
       const scrollVelocity = state.scrollVelocity;
       if ((Number.isNaN(scrollVelocity) || Math.abs(scrollVelocity) < 1) && (!waitForInitialLayout || state.numPendingInitialLayout < 0)) {
+        const setDidLayout = () => {
+          set$(ctx, "containersDidLayout", true);
+          if (reactNative.Platform.OS === "web") {
+            setTimeout(() => {
+              state.scrollAdjustHandler.setDisableAdjust(false);
+            }, 32);
+          }
+        };
         if (Date.now() - state.lastBatchingAction < 500) {
           state.queuedCalculateItemsInView = requestAnimationFrame(() => {
             state.queuedCalculateItemsInView = void 0;
             calculateItemsInView();
             if (needsUpdateContainersDidLayout) {
-              set$(ctx, "containersDidLayout", true);
+              setDidLayout();
             }
           });
         } else {
           calculateItemsInView();
           if (needsUpdateContainersDidLayout) {
-            queueMicrotask(() => {
-              set$(ctx, "containersDidLayout", true);
-            });
+            queueMicrotask(setDidLayout);
           }
         }
       }
@@ -1713,6 +1719,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     const didChange = scrollLength !== state.scrollLength;
     state.scrollLength = scrollLength;
     state.lastBatchingAction = Date.now();
+    state.scrollForNextCalculateItemsInView = void 0;
     doInitialAllocateContainers();
     doMaintainScrollAtEnd(false);
     doUpdatePaddingTop();
@@ -1797,39 +1804,39 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
         let firstIndexScrollPostion = firstIndexOffset - viewOffset;
         const diff = Math.abs(state.scroll - firstIndexScrollPostion);
         const needsReanchoring = maintainVisibleContentPosition && diff > 100;
+        state.scrollForNextCalculateItemsInView = void 0;
         if (needsReanchoring) {
           const id = getId(index);
           state.anchorElement = { id, coordinate: firstIndexOffset };
           (_a2 = state.belowAnchorElementPositions) == null ? void 0 : _a2.clear();
           state.positions.clear();
           calcTotalSizesAndPositions({ forgetPositions: true });
-          state.scrollForNextCalculateItemsInView = void 0;
           state.startBufferedId = id;
           state.minIndexSizeChanged = index;
           firstIndexScrollPostion = firstIndexOffset - viewOffset + state.scrollAdjustHandler.getAppliedAdjust();
         }
-        state.scrollAdjustHandler.pauseAdjust();
+        state.scrollAdjustHandler.setDisableAdjust(true);
         setTimeout(
           () => {
-            const wasAdjusted = state.scrollAdjustHandler.unPauseAdjust();
-            if (wasAdjusted) {
-              refState.current.scrollVelocity = 0;
-              refState.current.scrollHistory = [];
-              calculateItemsInView();
-            }
+            state.scrollAdjustHandler.setDisableAdjust(false);
+            calculateItemsInView();
           },
-          animated ? 1e3 : 50
+          animated ? 150 : 50
         );
         if (viewPosition) {
           firstIndexScrollPostion -= viewPosition * (state.scrollLength - getItemSize(getId(index), index, state.data[index]));
         }
         const offset = horizontal ? { x: firstIndexScrollPostion, y: 0 } : { x: 0, y: firstIndexScrollPostion };
-        if (maintainVisibleContentPosition) {
-          setTimeout(() => {
+        refScroller.current.scrollTo({ ...offset, animated });
+        const totalSizeWithScrollAdjust = peek$(ctx, "totalSizeWithScrollAdjust");
+        if (maintainVisibleContentPosition && totalSizeWithScrollAdjust - firstIndexScrollPostion < state.scrollLength) {
+          const doScrollTo = () => {
             refScroller.current.scrollTo({ ...offset, animated });
-          }, 50);
-        } else {
-          refScroller.current.scrollTo({ ...offset, animated });
+          };
+          setTimeout(doScrollTo, animated ? 150 : 50);
+          if (animated) {
+            setTimeout(doScrollTo, 350);
+          }
         }
       };
       return {
@@ -1854,6 +1861,42 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     },
     []
   );
+  if (reactNative.Platform.OS === "web") {
+    React6.useEffect(() => {
+      var _a2, _b2;
+      if (initialContentOffset) {
+        (_a2 = refState.current) == null ? void 0 : _a2.scrollAdjustHandler.setDisableAdjust(true);
+        (_b2 = refScroller.current) == null ? void 0 : _b2.scrollTo({
+          x: horizontal ? initialContentOffset : 0,
+          y: horizontal ? 0 : initialContentOffset,
+          animated: false
+        });
+        setTimeout(() => {
+          var _a3;
+          (_a3 = refState.current) == null ? void 0 : _a3.scrollAdjustHandler.setDisableAdjust(false);
+        }, 0);
+      }
+    }, []);
+  }
+  if (isFirst) {
+    refState.current.scrollAdjustHandler.setDisableAdjust(true);
+  }
+  React6.useEffect(() => {
+    refState.current.scrollAdjustHandler.setDisableAdjust(false);
+    if (initialContentOffset) {
+      const doScrollTo = () => {
+        var _a2;
+        (_a2 = refScroller.current) == null ? void 0 : _a2.scrollTo({
+          x: horizontal ? initialContentOffset : 0,
+          y: horizontal ? 0 : initialContentOffset,
+          animated: false
+        });
+        calculateItemsInView();
+      };
+      setTimeout(doScrollTo, 32);
+      setTimeout(doScrollTo, 300);
+    }
+  }, []);
   return /* @__PURE__ */ React6__namespace.createElement(React6__namespace.Fragment, null, /* @__PURE__ */ React6__namespace.createElement(
     ListComponent,
     {