@legendapp/list 3.0.0-beta.43 → 3.0.0-beta.45

package/index.d.ts

@@ -8,16 +8,317 @@ interface LooseView {
     measure?: (callback: LooseMeasureCallback) => void;
 }
 
-type ListenerType = "activeStickyIndex" | "debugComputedScroll" | "debugRawScroll" | "extraData" | "footerSize" | "headerSize" | "lastItemKeys" | "lastPositionUpdate" | "maintainVisibleContentPosition" | "numColumns" | "numContainers" | "numContainersPooled" | "otherAxisSize" | "readyToRender" | "scrollAdjust" | "scrollAdjustPending" | "scrollAdjustUserOffset" | "scrollSize" | "snapToOffsets" | "stylePaddingTop" | "totalSize" | `containerColumn${number}` | `containerSpan${number}` | `containerItemData${number}` | `containerItemKey${number}` | `containerPosition${number}` | `containerSticky${number}`;
-type LegendListListenerType = Extract<ListenerType, "activeStickyIndex" | "footerSize" | "headerSize" | "lastItemKeys" | "lastPositionUpdate" | "numContainers" | "numContainersPooled" | "otherAxisSize" | "readyToRender" | "snapToOffsets" | "totalSize">;
+declare class ScrollAdjustHandler {
+    private appliedAdjust;
+    private pendingAdjust;
+    private ctx;
+    constructor(ctx: StateContext);
+    requestAdjust(add: number): void;
+    getAdjust(): number;
+    commitPendingAdjust(scrollTarget: ScrollTarget$1): void;
+}
+
+type BaseSharedValue<T = number> = {
+    get: () => T;
+};
+type StylesAsSharedValue<Style> = {
+    [key in keyof Style]: Style[key] | BaseSharedValue<Style[key]>;
+};
+
+interface ScrollEventTargetLike$1 {
+    addEventListener(type: string, listener: (...args: any[]) => void): void;
+    removeEventListener(type: string, listener: (...args: any[]) => void): void;
+}
+interface ScrollableNodeLike$1 {
+    scrollLeft?: number;
+    scrollTop?: number;
+}
+interface LegendListScrollerRef$1 {
+    flashScrollIndicators(): void;
+    getCurrentScrollOffset?(): number;
+    getScrollEventTarget?(): ScrollEventTargetLike$1 | null;
+    getScrollableNode(): ScrollableNodeLike$1 | null;
+    getScrollResponder(): unknown;
+    scrollTo(options: {
+        animated?: boolean;
+        x?: number;
+        y?: number;
+    }): void;
+    scrollToEnd(options?: {
+        animated?: boolean;
+    }): void;
+}
+interface MaintainVisibleContentPositionNormalized$1<ItemT = any> {
+    data: boolean;
+    size: boolean;
+    shouldRestorePosition?: (item: ItemT, index: number, data: readonly ItemT[]) => boolean;
+}
+interface MaintainScrollAtEndNormalized {
+    animated: boolean;
+    onLayout: boolean;
+    onItemLayout: boolean;
+    onDataChange: boolean;
+}
+interface ThresholdSnapshot$1 {
+    scrollPosition: number;
+    contentSize?: number;
+    dataLength?: number;
+    atThreshold: boolean;
+}
+interface ScrollTarget$1 {
+    averageSizeSnapshot?: Record<string, number>;
+    animated?: boolean;
+    index?: number;
+    isInitialScroll?: boolean;
+    itemSize?: number;
+    offset: number;
+    precomputedWithViewOffset?: boolean;
+    targetOffset?: number;
+    viewOffset?: number;
+    viewPosition?: number;
+}
+type BootstrapInitialScrollSession = {
+    frameHandle?: number;
+    mountFrameCount: number;
+    passCount: number;
+    previousResolvedOffset?: number;
+    scroll: number;
+    seedContentOffset: number;
+    targetIndexSeed?: number;
+    visibleIndices?: readonly number[];
+};
+type InternalScrollTarget = ScrollTarget$1 & {
+    waitForInitialScrollCompletionFrame?: boolean;
+};
+type InitialScrollSessionCompletion = {
+    didDispatchNativeScroll?: boolean;
+    didRetrySilentInitialScroll?: boolean;
+    watchdog?: {
+        startScroll: number;
+        targetOffset: number;
+    };
+};
+interface InternalInitialScrollTarget extends ScrollIndexWithOffsetAndContentOffset$1 {
+    preserveForBottomPadding?: boolean;
+    preserveForFooterLayout?: boolean;
+}
+type InternalInitialScrollSessionBase = {
+    completion?: InitialScrollSessionCompletion;
+    previousDataLength: number;
+};
+type OffsetInitialScrollSession = InternalInitialScrollSessionBase & {
+    kind: "offset";
+};
+type BootstrapOwnedInitialScrollSession = InternalInitialScrollSessionBase & {
+    bootstrap?: BootstrapInitialScrollSession;
+    kind: "bootstrap";
+};
+type InternalInitialScrollSession = OffsetInitialScrollSession | BootstrapOwnedInitialScrollSession;
+type LegendListPropsInternal = LegendListPropsBase$1<any, Record<string, any>, string | undefined> & {
+    data: readonly any[];
+    renderItem: ((props: LegendListRenderItemProps$1<any, string | undefined>) => React.ReactNode) | React.ComponentType<LegendListRenderItemProps$1<any, string | undefined>>;
+};
+interface PendingDataComparison {
+    byIndex: Array<0 | 1 | 2 | undefined>;
+    nextData: readonly unknown[];
+    previousData: readonly unknown[];
+}
+type AverageSizes = Record<string, {
+    num: number;
+    avg: number;
+}>;
+interface InternalState$1 {
+    adjustingFromInitialMount?: number;
+    animFrameCheckFinishedScroll?: any;
+    averageSizes: AverageSizes;
+    columns: Array<number | undefined>;
+    columnSpans: Array<number | undefined>;
+    containerItemKeys: Map<string, number>;
+    containerItemTypes: Map<number, string>;
+    dataChangeEpoch: number;
+    dataChangeNeedsScrollUpdate: boolean;
+    deferredPublicOnScrollEvent?: NativeSyntheticEvent$1<NativeScrollEvent$1>;
+    didColumnsChange?: boolean;
+    didDataChange?: boolean;
+    didFinishInitialScroll?: boolean;
+    didContainersLayout?: boolean;
+    enableScrollForNextCalculateItemsInView: boolean;
+    endBuffered: number;
+    endNoBuffer: number;
+    endReachedSnapshot: ThresholdSnapshot$1 | undefined;
+    firstFullyOnScreenIndex: number;
+    hasScrolled?: boolean;
+    idCache: string[];
+    idsInView: string[];
+    ignoreScrollFromMVCP?: {
+        lt?: number;
+        gt?: number;
+    };
+    ignoreScrollFromMVCPIgnored?: boolean;
+    ignoreScrollFromMVCPTimeout?: any;
+    indexByKey: Map<string, number>;
+    clearPreservedInitialScrollOnNextFinish?: boolean;
+    initialScrollSession?: InternalInitialScrollSession;
+    initialScroll: InternalInitialScrollTarget | undefined;
+    timeoutPreservedInitialScrollClear?: any;
+    isEndReached: boolean | null;
+    isFirst?: boolean;
+    isStartReached: boolean | null;
+    lastBatchingAction: number;
+    lastLayout: LayoutRectangle$1 | undefined;
+    lastScrollAdjustForHistory?: number;
+    lastScrollDelta: number;
+    loadStartTime: number;
+    maintainingScrollAtEnd?: boolean;
+    minIndexSizeChanged: number | undefined;
+    mvcpAnchorLock?: {
+        id: string;
+        position: number;
+        quietPasses: number;
+        expiresAt: number;
+    };
+    contentInsetOverride?: Partial<Insets$1> | null;
+    nativeContentInset?: Insets$1;
+    nativeMarginTop: number;
+    needsOtherAxisSize?: boolean;
+    otherAxisSize?: number;
+    pendingNativeMVCPAdjust?: {
+        amount: number;
+        furthestProgressTowardAmount: number;
+        manualApplied: number;
+        startScroll: number;
+    };
+    pendingMaintainScrollAtEnd?: boolean;
+    pendingDataComparison?: PendingDataComparison;
+    pendingTotalSize?: number;
+    pendingScrollResolve?: (() => void) | undefined;
+    positions: Array<number | undefined>;
+    previousData?: readonly unknown[];
+    queuedCalculateItemsInView: number | undefined;
+    queuedMVCPRecalculate?: number;
+    queuedInitialLayout?: boolean | undefined;
+    reprocessCurrentScroll?: () => void;
+    refScroller: React.RefObject<LegendListScrollerRef$1 | null>;
+    scroll: number;
+    scrollAdjustHandler: ScrollAdjustHandler;
+    scrollForNextCalculateItemsInView: {
+        top: number | null;
+        bottom: number | null;
+    } | undefined;
+    scrollHistory: Array<{
+        scroll: number;
+        time: number;
+    }>;
+    scrollingTo?: InternalScrollTarget | undefined;
+    scrollLastCalculate?: number;
+    scrollLength: number;
+    scrollPending: number;
+    scrollPrev: number;
+    scrollPrevTime: number;
+    scrollProcessingEnabled: boolean;
+    scrollTime: number;
+    sizes: Map<string, number>;
+    sizesKnown: Map<string, number>;
+    startBuffered: number;
+    startBufferedId?: string;
+    startNoBuffer: number;
+    startReachedSnapshotDataChangeEpoch: number | undefined;
+    startReachedSnapshot: ThresholdSnapshot$1 | undefined;
+    stickyContainerPool: Set<number>;
+    stickyContainers: Map<number, number>;
+    timeouts: Set<number>;
+    timeoutSetPaddingTop?: any;
+    timeoutSizeMessage: any;
+    timeoutCheckFinishedScrollFallback?: any;
+    totalSize: number;
+    triggerCalculateItemsInView?: (params?: {
+        doMVCP?: boolean;
+        dataChanged?: boolean;
+        forceFullItemPositions?: boolean;
+    }) => void;
+    viewabilityConfigCallbackPairs: ViewabilityConfigCallbackPairs$1<any> | undefined;
+    props: {
+        alignItemsAtEnd: boolean;
+        animatedProps: StylesAsSharedValue<Record<string, any>>;
+        anchoredEndSpace: AnchoredEndSpaceConfig$1 | undefined;
+        alwaysRender: AlwaysRenderConfig$1 | undefined;
+        alwaysRenderIndicesArr: number[];
+        alwaysRenderIndicesSet: Set<number>;
+        contentInset: Insets$1 | undefined;
+        data: readonly any[];
+        dataVersion: Key | undefined;
+        drawDistance: number;
+        estimatedItemSize: number | undefined;
+        getEstimatedItemSize: LegendListPropsInternal["getEstimatedItemSize"];
+        getFixedItemSize: LegendListPropsInternal["getFixedItemSize"];
+        getItemType: LegendListPropsInternal["getItemType"];
+        horizontal: boolean;
+        initialContainerPoolRatio: number;
+        itemsAreEqual: LegendListPropsInternal["itemsAreEqual"];
+        keyExtractor: LegendListPropsInternal["keyExtractor"];
+        maintainScrollAtEnd: MaintainScrollAtEndNormalized | undefined;
+        maintainScrollAtEndThreshold: number | undefined;
+        maintainVisibleContentPosition: MaintainVisibleContentPositionNormalized$1;
+        numColumns: number;
+        onEndReached: LegendListPropsInternal["onEndReached"];
+        onEndReachedThreshold: number | null | undefined;
+        onItemSizeChanged: LegendListPropsInternal["onItemSizeChanged"];
+        onLoad: LegendListPropsInternal["onLoad"];
+        onScroll: LegendListPropsInternal["onScroll"];
+        onStartReached: LegendListPropsInternal["onStartReached"];
+        onStartReachedThreshold: number | null | undefined;
+        onStickyHeaderChange: LegendListPropsInternal["onStickyHeaderChange"];
+        overrideItemLayout: LegendListPropsInternal["overrideItemLayout"];
+        recycleItems: boolean;
+        renderItem: LegendListPropsInternal["renderItem"];
+        scrollBuffer?: number;
+        snapToIndices: number[] | undefined;
+        positionComponentInternal: React.ComponentType<any> | undefined;
+        stickyPositionComponentInternal: React.ComponentType<any> | undefined;
+        stickyIndicesArr: number[];
+        stickyIndicesSet: Set<number>;
+        stylePaddingBottom: number | undefined;
+        stylePaddingTop: number | undefined;
+        suggestEstimatedItemSize: boolean;
+        useWindowScroll: boolean;
+    };
+}
+interface ViewableRange$1<T> {
+    end: number;
+    endBuffered: number;
+    items: T[];
+    start: number;
+    startBuffered: number;
+}
+type GetRenderedItemResult$1<ItemT> = {
+    index: number;
+    item: ItemT;
+    renderedItem: React.ReactNode;
+};
+type GetRenderedItem$1 = (key: string) => GetRenderedItemResult$1<any> | null;
+type TypedForwardRef$1 = <T, P = {}>(render: (props: P, ref: React.Ref<T>) => React.ReactElement | null) => (props: P & React.RefAttributes<T>) => React.ReactElement | null;
+declare const typedForwardRef: TypedForwardRef$1;
+type TypedMemo$1 = <T extends React.ComponentType<any>>(Component: T, propsAreEqual?: (prevProps: Readonly<React.ComponentProps<T>>, nextProps: Readonly<React.ComponentProps<T>>) => boolean) => T & {
+    displayName?: string;
+};
+declare const typedMemo: TypedMemo$1;
+
+type ListenerType = "activeStickyIndex" | "anchoredEndSpaceSize" | "debugComputedScroll" | "debugRawScroll" | "extraData" | "footerSize" | "headerSize" | "lastItemKeys" | "lastPositionUpdate" | "maintainVisibleContentPosition" | "numColumns" | "numContainers" | "numContainersPooled" | "otherAxisSize" | "readyToRender" | "scrollAdjust" | "scrollAdjustPending" | "scrollAdjustUserOffset" | "scrollSize" | "snapToOffsets" | "stylePaddingTop" | "totalSize" | "isAtEnd" | "isAtStart" | "isNearEnd" | "isNearStart" | "isWithinMaintainScrollAtEndThreshold" | `containerColumn${number}` | `containerSpan${number}` | `containerItemData${number}` | `containerItemKey${number}` | `containerPosition${number}` | `containerSticky${number}`;
+type LegendListListenerType = Extract<ListenerType, "activeStickyIndex" | "anchoredEndSpaceSize" | "footerSize" | "headerSize" | "isAtEnd" | "isAtStart" | "isNearEnd" | "isNearStart" | "isWithinMaintainScrollAtEndThreshold" | "lastItemKeys" | "lastPositionUpdate" | "numContainers" | "numContainersPooled" | "otherAxisSize" | "readyToRender" | "snapToOffsets" | "totalSize">;
 type ListenerTypeValueMap = {
     activeStickyIndex: number;
+    anchoredEndSpaceSize: number;
     animatedScrollY: any;
     debugComputedScroll: number;
     debugRawScroll: number;
     extraData: any;
     footerSize: number;
     headerSize: number;
+    isAtEnd: boolean;
+    isAtStart: boolean;
+    isNearEnd: boolean;
+    isNearStart: boolean;
+    isWithinMaintainScrollAtEndThreshold: boolean;
     lastItemKeys: string[];
     lastPositionUpdate: number;
     maintainVisibleContentPosition: MaintainVisibleContentPositionNormalized$1;
@@ -59,11 +360,13 @@ interface StateContext {
     mapViewabilityAmountCallbacks: Map<number, ViewabilityAmountCallback$1>;
     mapViewabilityAmountValues: Map<number, ViewAmountToken$1>;
     mapViewabilityConfigStates: Map<string, {
-        viewableItems: ViewToken$1[];
-        start: number;
         end: number;
+        endBuffered: number;
         previousStart: number;
         previousEnd: number;
+        start: number;
+        startBuffered: number;
+        viewableItems: ViewToken$1[];
     }>;
     positionListeners: Map<string, Set<(value: any) => void>>;
     state: InternalState$1;
@@ -71,23 +374,6 @@ interface StateContext {
     viewRefs: Map<number, React.RefObject<LooseView | null>>;
 }
 
-declare class ScrollAdjustHandler {
-    private appliedAdjust;
-    private pendingAdjust;
-    private ctx;
-    constructor(ctx: StateContext);
-    requestAdjust(add: number): void;
-    getAdjust(): number;
-    commitPendingAdjust(scrollTarget: ScrollTarget$1): void;
-}
-
-type BaseSharedValue<T = number> = {
-    get: () => T;
-};
-type StylesAsSharedValue<Style> = {
-    [key in keyof Style]: Style[key] | BaseSharedValue<Style[key]>;
-};
-
 interface Insets$1 {
     top: number;
     left: number;
@@ -121,29 +407,6 @@ interface NativeSyntheticEvent$1<T> {
 }
 type ViewStyle$1 = Record<string, unknown>;
 type StyleProp$1<T> = T | T[] | null | undefined | false;
-interface ScrollEventTargetLike$1 {
-    addEventListener(type: string, listener: (...args: any[]) => void): void;
-    removeEventListener(type: string, listener: (...args: any[]) => void): void;
-}
-interface ScrollableNodeLike$1 {
-    scrollLeft?: number;
-    scrollTop?: number;
-}
-interface LegendListScrollerRef$1 {
-    flashScrollIndicators(): void;
-    getCurrentScrollOffset?(): number;
-    getScrollEventTarget(): ScrollEventTargetLike$1 | null;
-    getScrollableNode(): ScrollableNodeLike$1 | null;
-    getScrollResponder(): unknown;
-    scrollTo(options: {
-        animated?: boolean;
-        x?: number;
-        y?: number;
-    }): void;
-    scrollToEnd(options?: {
-        animated?: boolean;
-    }): void;
-}
 type BaseScrollViewProps$1<TScrollView> = Omit<TScrollView, "contentOffset" | "maintainVisibleContentPosition" | "stickyHeaderIndices" | "removeClippedSubviews" | "children" | "onScroll">;
 interface DataModeProps<ItemT, TItemType extends string | undefined> {
     /**
@@ -186,6 +449,11 @@ interface LegendListSpecificProps<ItemT, TItemType extends string | undefined> {
      * Style applied to each column's wrapper view.
      */
     columnWrapperStyle?: ColumnWrapperStyle$1;
+    /**
+     * Version token that forces the list to treat data as updated even when the array reference is stable.
+     * Increment or change this when mutating the data array in place.
+     */
+    dataVersion?: Key;
     /**
      * Distance in pixels to pre-render items ahead of the visible area.
      * @default 250
@@ -209,33 +477,35 @@ interface LegendListSpecificProps<ItemT, TItemType extends string | undefined> {
      * Extra data to trigger re-rendering when changed.
      */
     extraData?: any;
-    /**
-     * Version token that forces the list to treat data as updated even when the array reference is stable.
-     * Increment or change this when mutating the data array in place.
-     */
-    dataVersion?: Key;
     /**
      * 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?: (item: ItemT, index: number, type: TItemType) => number;
     /**
-     * Customize layout for multi-column lists, such as allowing items to span multiple columns.
-     * Similar to FlashList's overrideItemLayout.
+     * In case items always have a fixed size, you can provide a function to return it.
      */
-    overrideItemLayout?: (layout: {
-        span?: number;
-    }, item: ItemT, index: number, maxColumns: number, extraData?: any) => void;
+    getFixedItemSize?: (item: ItemT, index: number, type: TItemType) => number | undefined;
+    /**
+     * Returns a stable item type used for pooling and size estimation.
+     */
+    getItemType?: (item: ItemT, index: number) => TItemType;
+    /**
+     * Component to render between items, receiving the leading item as prop.
+     */
+    ItemSeparatorComponent?: React.ComponentType<{
+        leadingItem: ItemT;
+    }>;
     /**
      * Ratio of initial container pool size to data length (e.g., 0.5 for half).
      * @default 2
      */
     initialContainerPoolRatio?: number | undefined;
     /**
-     * Initial scroll position in pixels.
-     * @default 0
+     * When true, the list initializes scrolled to the last item.
+     * Overrides `initialScrollIndex` and `initialScrollOffset` when data is available.
+     * @default false
      */
-    initialScrollOffset?: number;
+    initialScrollAtEnd?: boolean;
     /**
      * Index to scroll to initially.
      * @default 0
@@ -246,17 +516,14 @@ interface LegendListSpecificProps<ItemT, TItemType extends string | undefined> {
         viewPosition?: number | undefined;
     };
     /**
-     * When true, the list initializes scrolled to the last item.
-     * Overrides `initialScrollIndex` and `initialScrollOffset` when data is available.
-     * @default false
+     * Initial scroll position in pixels.
+     * @default 0
      */
-    initialScrollAtEnd?: boolean;
+    initialScrollOffset?: number;
     /**
-     * Component to render between items, receiving the leading item as prop.
+     * Custom equality function to detect semantically unchanged items.
      */
-    ItemSeparatorComponent?: React.ComponentType<{
-        leadingItem: ItemT;
-    }>;
+    itemsAreEqual?: (itemPrevious: ItemT, item: ItemT, index: number, data: readonly ItemT[]) => boolean;
     /**
      * Function to extract a unique key for each item.
      */
@@ -302,10 +569,9 @@ interface LegendListSpecificProps<ItemT, TItemType extends string | undefined> {
      */
     maintainVisibleContentPosition?: boolean | MaintainVisibleContentPositionConfig$1<ItemT>;
     /**
-     * Web only: when true, listens to window/body scrolling instead of rendering a scrollable list container.
-     * @default false
+     * Keeps an item visually anchored to the start by adding trailing space when the content below it underflows.
      */
-    useWindowScroll?: boolean;
+    anchoredEndSpace?: AnchoredEndSpaceConfig$1;
     /**
      * Number of columns to render items in.
      * @default 1
@@ -332,6 +598,12 @@ interface LegendListSpecificProps<ItemT, TItemType extends string | undefined> {
         itemKey: string;
         itemData: ItemT;
     }) => void;
+    /**
+     * Called after the initial render work completes.
+     */
+    onLoad?: (info: {
+        elapsedTimeInMs: number;
+    }) => void;
     /**
      * Called when list layout metrics change.
      */
@@ -340,6 +612,9 @@ interface LegendListSpecificProps<ItemT, TItemType extends string | undefined> {
      * Function to call when the user pulls to refresh.
      */
     onRefresh?: () => void;
+    /**
+     * Called when the list scrolls.
+     */
     onScroll?: (event: NativeSyntheticEvent$1<NativeScrollEvent$1>) => void;
     /**
      * Called when scrolling reaches the start within onStartReachedThreshold.
@@ -363,6 +638,12 @@ interface LegendListSpecificProps<ItemT, TItemType extends string | undefined> {
      * Called when the viewability of items changes.
      */
     onViewableItemsChanged?: OnViewableItemsChanged$1<ItemT> | undefined;
+    /**
+     * Customize layout for multi-column lists, such as allowing items to span multiple columns.
+     */
+    overrideItemLayout?: (layout: {
+        span?: number;
+    }, item: ItemT, index: number, maxColumns: number, extraData?: any) => void;
     /**
      * Offset in pixels for the refresh indicator.
      * @default 0
@@ -388,6 +669,10 @@ interface LegendListSpecificProps<ItemT, TItemType extends string | undefined> {
      * @default (props) => <ScrollView {...props} />
      */
     renderScrollComponent?: (props: any) => React.ReactElement | null;
+    /**
+     * Array of item indices to use as snap points.
+     */
+    snapToIndices?: number[];
     /**
      * This will log a suggested estimatedItemSize.
      * @required
@@ -402,15 +687,6 @@ interface LegendListSpecificProps<ItemT, TItemType extends string | undefined> {
      * Pairs of viewability configs and their callbacks for tracking visibility.
      */
     viewabilityConfigCallbackPairs?: ViewabilityConfigCallbackPairs$1<ItemT> | undefined;
-    /**
-     * If true, delays rendering until initial layout is complete.
-     * @default false
-     */
-    waitForInitialLayout?: boolean;
-    onLoad?: (info: {
-        elapsedTimeInMs: number;
-    }) => void;
-    snapToIndices?: number[];
     /**
      * Array of child indices determining which children get docked to the top of the screen when scrolling.
      * For example, passing stickyHeaderIndices={[0]} will cause the first child to be fixed to the top of the scroll view.
@@ -427,21 +703,24 @@ interface LegendListSpecificProps<ItemT, TItemType extends string | undefined> {
      * @default undefined
      */
     stickyHeaderConfig?: StickyHeaderConfig$1;
-    getItemType?: (item: ItemT, index: number) => TItemType;
-    getFixedItemSize?: (item: ItemT, index: number, type: TItemType) => number | undefined;
-    itemsAreEqual?: (itemPrevious: ItemT, item: ItemT, index: number, data: readonly ItemT[]) => boolean;
+    /**
+     * Web only: when true, listens to window/body scrolling instead of rendering a scrollable list container.
+     * @default false
+     */
+    useWindowScroll?: boolean;
 }
 type LegendListPropsBase$1<ItemT, TScrollViewProps = Record<string, any>, TItemType extends string | undefined = string | undefined> = BaseScrollViewProps$1<TScrollViewProps> & LegendListSpecificProps<ItemT, TItemType> & (DataModeProps<ItemT, TItemType> | ChildrenModeProps);
-type LegendListPropsInternal = LegendListSpecificProps<any, string | undefined> & DataModeProps<any, string | undefined>;
 interface MaintainVisibleContentPositionConfig$1<ItemT = any> {
     data?: boolean;
     size?: boolean;
     shouldRestorePosition?: (item: ItemT, index: number, data: readonly ItemT[]) => boolean;
 }
-interface MaintainVisibleContentPositionNormalized$1<ItemT = any> {
-    data: boolean;
-    size: boolean;
-    shouldRestorePosition?: (item: ItemT, index: number, data: readonly ItemT[]) => boolean;
+interface AnchoredEndSpaceConfig$1 {
+    anchorIndex: number;
+    anchorOffset?: number;
+    anchorMaxSize?: number;
+    includeInEndInset?: boolean;
+    onSizeChanged?: (size: number) => void;
 }
 interface StickyHeaderConfig$1 {
     /**
@@ -488,197 +767,6 @@ interface LegendListMetrics$1 {
     headerSize: number;
     footerSize: number;
 }
-interface ThresholdSnapshot$1 {
-    scrollPosition: number;
-    contentSize?: number;
-    dataLength?: number;
-    atThreshold: boolean;
-}
-interface ScrollTarget$1 {
-    animated?: boolean;
-    index?: number;
-    isInitialScroll?: boolean;
-    itemSize?: number;
-    offset: number;
-    precomputedWithViewOffset?: boolean;
-    targetOffset?: number;
-    viewOffset?: number;
-    viewPosition?: number;
-}
-interface InternalState$1 {
-    activeStickyIndex: number | undefined;
-    adjustingFromInitialMount?: number;
-    animFrameCheckFinishedScroll?: any;
-    averageSizes: Record<string, {
-        num: number;
-        avg: number;
-    }>;
-    columns: Array<number | undefined>;
-    columnSpans: Array<number | undefined>;
-    containerItemKeys: Map<string, number>;
-    containerItemTypes: Map<number, string>;
-    dataChangeEpoch: number;
-    dataChangeNeedsScrollUpdate: boolean;
-    didColumnsChange?: boolean;
-    didDataChange?: boolean;
-    didFinishInitialScroll?: boolean;
-    didContainersLayout?: boolean;
-    enableScrollForNextCalculateItemsInView: boolean;
-    endBuffered: number;
-    endNoBuffer: number;
-    endReachedSnapshot: ThresholdSnapshot$1 | undefined;
-    firstFullyOnScreenIndex: number;
-    hasScrolled?: boolean;
-    idCache: string[];
-    idsInView: string[];
-    ignoreScrollFromMVCP?: {
-        lt?: number;
-        gt?: number;
-    };
-    ignoreScrollFromMVCPIgnored?: boolean;
-    ignoreScrollFromMVCPTimeout?: any;
-    indexByKey: Map<string, number>;
-    initialAnchor?: InitialScrollAnchor$1;
-    initialNativeScrollWatchdog?: {
-        startScroll: number;
-        targetOffset: number;
-    };
-    initialScrollLastDidFinish: boolean;
-    initialScrollLastTarget: ScrollIndexWithOffsetAndContentOffset$1 | undefined;
-    initialScrollLastTargetUsesOffset: boolean;
-    initialScrollPreviousDataLength: number;
-    initialScrollRetryLastLength: number | undefined;
-    initialScrollRetryWindowUntil: number;
-    initialScroll: ScrollIndexWithOffsetAndContentOffset$1 | undefined;
-    initialScrollUsesOffset: boolean;
-    isAtEnd: boolean;
-    isAtStart: boolean;
-    isEndReached: boolean | null;
-    isFirst?: boolean;
-    isStartReached: boolean | null;
-    lastBatchingAction: number;
-    lastLayout: LayoutRectangle$1 | undefined;
-    lastScrollAdjustForHistory?: number;
-    lastScrollDelta: number;
-    loadStartTime: number;
-    maintainingScrollAtEnd?: boolean;
-    minIndexSizeChanged: number | undefined;
-    mvcpAnchorLock?: {
-        id: string;
-        position: number;
-        quietPasses: number;
-        expiresAt: number;
-    };
-    contentInsetOverride?: Partial<Insets$1> | null;
-    nativeContentInset?: Insets$1;
-    nativeMarginTop: number;
-    needsOtherAxisSize?: boolean;
-    otherAxisSize?: number;
-    pendingNativeMVCPAdjust?: {
-        amount: number;
-        furthestProgressTowardAmount: number;
-        manualApplied: number;
-        startScroll: number;
-    };
-    pendingMaintainScrollAtEnd?: boolean;
-    pendingTotalSize?: number;
-    pendingScrollResolve?: (() => void) | undefined;
-    positions: Array<number | undefined>;
-    previousData?: readonly unknown[];
-    queuedCalculateItemsInView: number | undefined;
-    queuedMVCPRecalculate?: number;
-    queuedInitialLayout?: boolean | undefined;
-    refScroller: React.RefObject<LegendListScrollerRef$1 | null>;
-    scroll: number;
-    scrollAdjustHandler: ScrollAdjustHandler;
-    scrollForNextCalculateItemsInView: {
-        top: number | null;
-        bottom: number | null;
-    } | undefined;
-    scrollHistory: Array<{
-        scroll: number;
-        time: number;
-    }>;
-    scrollingTo?: ScrollTarget$1 | undefined;
-    scrollLastCalculate?: number;
-    scrollLength: number;
-    scrollPending: number;
-    scrollPrev: number;
-    scrollPrevTime: number;
-    scrollProcessingEnabled: boolean;
-    scrollTime: number;
-    sizes: Map<string, number>;
-    sizesKnown: Map<string, number>;
-    startBuffered: number;
-    startBufferedId?: string;
-    startNoBuffer: number;
-    startReachedSnapshotDataChangeEpoch: number | undefined;
-    startReachedSnapshot: ThresholdSnapshot$1 | undefined;
-    stickyContainerPool: Set<number>;
-    stickyContainers: Map<number, number>;
-    timeouts: Set<number>;
-    timeoutSetPaddingTop?: any;
-    timeoutSizeMessage: any;
-    timeoutCheckFinishedScrollFallback?: any;
-    totalSize: number;
-    triggerCalculateItemsInView?: (params?: {
-        doMVCP?: boolean;
-        dataChanged?: boolean;
-        forceFullItemPositions?: boolean;
-    }) => void;
-    viewabilityConfigCallbackPairs: ViewabilityConfigCallbackPairs$1<any> | undefined;
-    props: {
-        alignItemsAtEnd: boolean;
-        animatedProps: StylesAsSharedValue<Record<string, any>>;
-        alwaysRender: AlwaysRenderConfig$1 | undefined;
-        alwaysRenderIndicesArr: number[];
-        alwaysRenderIndicesSet: Set<number>;
-        contentInset: Insets$1 | undefined;
-        data: readonly any[];
-        dataVersion: Key | undefined;
-        drawDistance: number;
-        estimatedItemSize: number | undefined;
-        getEstimatedItemSize: LegendListPropsInternal["getEstimatedItemSize"];
-        getFixedItemSize: LegendListPropsInternal["getFixedItemSize"];
-        getItemType: LegendListPropsInternal["getItemType"];
-        horizontal: boolean;
-        initialContainerPoolRatio: number;
-        itemsAreEqual: LegendListPropsInternal["itemsAreEqual"];
-        keyExtractor: LegendListPropsInternal["keyExtractor"];
-        maintainScrollAtEnd: MaintainScrollAtEndNormalized | undefined;
-        maintainScrollAtEndThreshold: number | undefined;
-        maintainVisibleContentPosition: MaintainVisibleContentPositionNormalized$1;
-        numColumns: number;
-        onEndReached: LegendListPropsInternal["onEndReached"];
-        onEndReachedThreshold: number | null | undefined;
-        onItemSizeChanged: LegendListPropsInternal["onItemSizeChanged"];
-        onLoad: LegendListPropsInternal["onLoad"];
-        onScroll: LegendListPropsInternal["onScroll"];
-        onStartReached: LegendListPropsInternal["onStartReached"];
-        onStartReachedThreshold: number | null | undefined;
-        onStickyHeaderChange: LegendListPropsInternal["onStickyHeaderChange"];
-        overrideItemLayout: LegendListPropsInternal["overrideItemLayout"];
-        recycleItems: boolean;
-        renderItem: LegendListPropsInternal["renderItem"];
-        scrollBuffer?: number;
-        snapToIndices: number[] | undefined;
-        positionComponentInternal: React.ComponentType<any> | undefined;
-        stickyPositionComponentInternal: React.ComponentType<any> | undefined;
-        stickyIndicesArr: number[];
-        stickyIndicesSet: Set<number>;
-        stylePaddingBottom: number | undefined;
-        stylePaddingTop: number | undefined;
-        suggestEstimatedItemSize: boolean;
-        useWindowScroll: boolean;
-    };
-}
-interface ViewableRange$1<T> {
-    end: number;
-    endBuffered: number;
-    items: T[];
-    start: number;
-    startBuffered: number;
-}
 interface LegendListRenderItemProps$1<ItemT, TItemType extends string | number | undefined = string | number | undefined> {
     data: readonly ItemT[];
     extraData: any;
@@ -695,8 +783,11 @@ type LegendListState$1 = {
     endBuffered: number;
     isAtEnd: boolean;
     isAtStart: boolean;
+    isNearEnd: boolean;
+    isNearStart: boolean;
     isEndReached: boolean;
     isStartReached: boolean;
+    isWithinMaintainScrollAtEndThreshold: boolean;
     listen: <T extends LegendListListenerType>(listenerType: T, callback: (value: ListenerTypeValueMap[T]) => void) => () => void;
     listenToPosition: (key: string, callback: (value: number) => void) => () => void;
     positionAtIndex: (index: number) => number;
@@ -842,10 +933,15 @@ interface ViewabilityConfigCallbackPair$1<ItemT = any> {
     viewabilityConfig: ViewabilityConfig$1;
 }
 type ViewabilityConfigCallbackPairs$1<ItemT> = ViewabilityConfigCallbackPair$1<ItemT>[];
-type OnViewableItemsChanged$1<ItemT> = ((info: {
-    viewableItems: Array<ViewToken$1<ItemT>>;
+interface OnViewableItemsChangedInfo$1<ItemT> {
     changed: Array<ViewToken$1<ItemT>>;
-}) => void) | null;
+    end: number;
+    endBuffered: number;
+    start: number;
+    startBuffered: number;
+    viewableItems: Array<ViewToken$1<ItemT>>;
+}
+type OnViewableItemsChanged$1<ItemT> = ((info: OnViewableItemsChangedInfo$1<ItemT>) => void) | null;
 interface ViewabilityConfig$1 {
     /**
      * A unique ID to identify this viewability config
@@ -883,12 +979,6 @@ interface LegendListRecyclingState$1<T> {
     prevIndex: number | undefined;
     prevItem: T | undefined;
 }
-type TypedForwardRef$1 = <T, P = {}>(render: (props: P, ref: React.Ref<T>) => React.ReactElement | null) => (props: P & React.RefAttributes<T>) => React.ReactElement | null;
-declare const typedForwardRef: TypedForwardRef$1;
-type TypedMemo$1 = <T extends React.ComponentType<any>>(Component: T, propsAreEqual?: (prevProps: Readonly<React.ComponentProps<T>>, nextProps: Readonly<React.ComponentProps<T>>) => boolean) => T & {
-    displayName?: string;
-};
-declare const typedMemo: TypedMemo$1;
 interface ScrollIndexWithOffset$1 {
     index: number;
     viewOffset?: number;
@@ -900,17 +990,12 @@ interface ScrollIndexWithOffsetPosition$1 extends ScrollIndexWithOffset$1 {
 interface ScrollIndexWithOffsetAndContentOffset$1 extends ScrollIndexWithOffsetPosition$1 {
     contentOffset?: number;
 }
+/** @deprecated Kept for backwards compatibility. Use `ScrollIndexWithOffsetPosition`. */
 interface InitialScrollAnchor$1 extends ScrollIndexWithOffsetPosition$1 {
     attempts?: number;
     lastDelta?: number;
     settledTicks?: number;
 }
-type GetRenderedItemResult$1<ItemT> = {
-    index: number;
-    item: ItemT;
-    renderedItem: React.ReactNode;
-};
-type GetRenderedItem$1 = (key: string) => GetRenderedItemResult$1<any> | null;
 
 /** @deprecated Use `@legendapp/list/react-native` or `@legendapp/list/react` for strict typing */
 type Insets = Insets$1;
@@ -937,6 +1022,8 @@ type LegendListPropsBase<ItemT, TScrollViewProps = Record<string, any>, TItemTyp
 /** @deprecated Use `@legendapp/list/react-native` or `@legendapp/list/react` for strict typing */
 type MaintainVisibleContentPositionConfig<ItemT = any> = MaintainVisibleContentPositionConfig$1<ItemT>;
 /** @deprecated Use `@legendapp/list/react-native` or `@legendapp/list/react` for strict typing */
+type AnchoredEndSpaceConfig = AnchoredEndSpaceConfig$1;
+/** @deprecated Use `@legendapp/list/react-native` or `@legendapp/list/react` for strict typing */
 type MaintainVisibleContentPositionNormalized<ItemT = any> = MaintainVisibleContentPositionNormalized$1<ItemT>;
 /** @deprecated Use `@legendapp/list/react-native` or `@legendapp/list/react` for strict typing */
 type StickyHeaderConfig = StickyHeaderConfig$1;
@@ -973,6 +1060,8 @@ type ViewabilityConfigCallbackPair<ItemT = any> = ViewabilityConfigCallbackPair$
 /** @deprecated Use `@legendapp/list/react-native` or `@legendapp/list/react` for strict typing */
 type ViewabilityConfigCallbackPairs<ItemT> = ViewabilityConfigCallbackPairs$1<ItemT>;
 /** @deprecated Use `@legendapp/list/react-native` or `@legendapp/list/react` for strict typing */
+type OnViewableItemsChangedInfo<ItemT> = OnViewableItemsChangedInfo$1<ItemT>;
+/** @deprecated Use `@legendapp/list/react-native` or `@legendapp/list/react` for strict typing */
 type OnViewableItemsChanged<ItemT> = OnViewableItemsChanged$1<ItemT>;
 /** @deprecated Use `@legendapp/list/react-native` or `@legendapp/list/react` for strict typing */
 type ViewabilityConfig = ViewabilityConfig$1;
@@ -992,7 +1081,7 @@ type ScrollIndexWithOffset = ScrollIndexWithOffset$1;
 type ScrollIndexWithOffsetPosition = ScrollIndexWithOffsetPosition$1;
 /** @deprecated Use `@legendapp/list/react-native` or `@legendapp/list/react` for strict typing */
 type ScrollIndexWithOffsetAndContentOffset = ScrollIndexWithOffsetAndContentOffset$1;
-/** @deprecated Use `@legendapp/list/react-native` or `@legendapp/list/react` for strict typing */
+/** @deprecated Use `ScrollIndexWithOffsetPosition`, or `@legendapp/list/react-native` / `@legendapp/list/react` for strict typing */
 type InitialScrollAnchor = InitialScrollAnchor$1;
 /** @deprecated Use `@legendapp/list/react-native` or `@legendapp/list/react` for strict typing */
 type GetRenderedItemResult<ItemT> = GetRenderedItemResult$1<ItemT>;
@@ -1235,4 +1324,4 @@ declare function useSyncLayout(): () => void;
 /** @deprecated Use `@legendapp/list/react-native` or `@legendapp/list/react` for strict typing */
 declare const LegendList: LegendListComponent;
 
-export { type AccessibilityActionEvent, type AccessibilityRole, type AccessibilityState, type AccessibilityValue, type AlwaysRenderConfig, type BaseScrollViewProps, type ColorValue, type ColumnWrapperStyle, type GestureResponderEvent, type GetRenderedItem, type GetRenderedItemResult, type InitialScrollAnchor, type Insets, type InternalState, type LayoutChangeEvent, type LayoutRectangle, LegendList, type LegendListComponent, type LegendListMetrics, type LegendListProps, type LegendListPropsBase, type LegendListRecyclingState, type LegendListRef, type LegendListRenderItemProps, type LegendListScrollerRef, type LegendListState, type LooseAccessibilityActionEvent, type LooseAccessibilityRole, type LooseAccessibilityState, type LooseAccessibilityValue, type LooseColorValue, type LooseGestureResponderEvent, type LoosePointerEvent, type LooseRefreshControlProps, type LooseRole, type LooseScrollViewProps, type MaintainScrollAtEndOnOptions, type MaintainScrollAtEndOptions, type MaintainVisibleContentPositionConfig, type MaintainVisibleContentPositionNormalized, type NativeScrollEvent, type NativeSyntheticEvent, type OnViewableItemsChanged, type PointProp, type PointerEvent, type RefreshControlProps, type Role, type ScrollEventTargetLike, type ScrollIndexWithOffset, type ScrollIndexWithOffsetAndContentOffset, type ScrollIndexWithOffsetPosition, type ScrollTarget, type ScrollViewPropsLoose, type ScrollableNodeLike, type StickyHeaderConfig, type StyleProp, type ThresholdSnapshot, type TypedForwardRef, type TypedMemo, type ViewAmountToken, type ViewStyle, type ViewToken, type ViewabilityAmountCallback, type ViewabilityCallback, type ViewabilityConfig, type ViewabilityConfigCallbackPair, type ViewabilityConfigCallbackPairs, type ViewableRange, typedForwardRef, typedMemo, useIsLastItem, useListScrollSize, useRecyclingEffect, useRecyclingState, useSyncLayout, useViewability, useViewabilityAmount };
+export { type AccessibilityActionEvent, type AccessibilityRole, type AccessibilityState, type AccessibilityValue, type AlwaysRenderConfig, type AnchoredEndSpaceConfig, type BaseScrollViewProps, type ColorValue, type ColumnWrapperStyle, type GestureResponderEvent, type GetRenderedItem, type GetRenderedItemResult, type InitialScrollAnchor, type Insets, type InternalState, type LayoutChangeEvent, type LayoutRectangle, LegendList, type LegendListComponent, type LegendListMetrics, type LegendListProps, type LegendListPropsBase, type LegendListRecyclingState, type LegendListRef, type LegendListRenderItemProps, type LegendListScrollerRef, type LegendListState, type LooseAccessibilityActionEvent, type LooseAccessibilityRole, type LooseAccessibilityState, type LooseAccessibilityValue, type LooseColorValue, type LooseGestureResponderEvent, type LoosePointerEvent, type LooseRefreshControlProps, type LooseRole, type LooseScrollViewProps, type MaintainScrollAtEndOnOptions, type MaintainScrollAtEndOptions, type MaintainVisibleContentPositionConfig, type MaintainVisibleContentPositionNormalized, type NativeScrollEvent, type NativeSyntheticEvent, type OnViewableItemsChanged, type OnViewableItemsChangedInfo, type PointProp, type PointerEvent, type RefreshControlProps, type Role, type ScrollEventTargetLike, type ScrollIndexWithOffset, type ScrollIndexWithOffsetAndContentOffset, type ScrollIndexWithOffsetPosition, type ScrollTarget, type ScrollViewPropsLoose, type ScrollableNodeLike, type StickyHeaderConfig, type StyleProp, type ThresholdSnapshot, type TypedForwardRef, type TypedMemo, type ViewAmountToken, type ViewStyle, type ViewToken, type ViewabilityAmountCallback, type ViewabilityCallback, type ViewabilityConfig, type ViewabilityConfigCallbackPair, type ViewabilityConfigCallbackPairs, type ViewableRange, typedForwardRef, typedMemo, useIsLastItem, useListScrollSize, useRecyclingEffect, useRecyclingState, useSyncLayout, useViewability, useViewabilityAmount };