@legendapp/list 1.1.4 → 2.0.0-beta.1

package/index.d.mts

@@ -1,29 +1,65 @@
 import * as React$1 from 'react';
 import { ComponentProps, ReactNode, Dispatch, SetStateAction } from 'react';
-import * as react_native from 'react-native';
-import { ScrollView, StyleProp, ViewStyle, ScrollViewProps, NativeSyntheticEvent, NativeScrollEvent, ScrollViewComponent, ScrollResponderMixin } from 'react-native';
-import Animated from 'react-native-reanimated';
-import * as _legendapp_list_reanimated from '@legendapp/list/reanimated';
-import * as _legendapp_list from '@legendapp/list';
-import { LegendListProps as LegendListProps$1, LegendListRenderItemProps as LegendListRenderItemProps$1, LegendListRef as LegendListRef$1 } from '@legendapp/list';
+import { View, Animated, ScrollView, LayoutRectangle, ScrollViewComponent, ScrollResponderMixin, StyleProp, ViewStyle, ScrollViewProps } from 'react-native';
+import Animated$1 from 'react-native-reanimated';
+
+type ListenerType = "numContainers" | "numContainersPooled" | `containerItemKey${number}` | `containerItemData${number}` | `containerPosition${number}` | `containerColumn${number}` | `containerSticky${number}` | `containerStickyOffset${number}` | "containersDidLayout" | "extraData" | "numColumns" | "lastItemKeys" | "totalSize" | "alignItemsPaddingTop" | "stylePaddingTop" | "scrollAdjust" | "scrollAdjustUserOffset" | "headerSize" | "footerSize" | "maintainVisibleContentPosition" | "debugRawScroll" | "debugComputedScroll" | "otherAxisSize" | "snapToOffsets" | "scrollSize";
+interface StateContext {
+    listeners: Map<ListenerType, Set<(value: any) => void>>;
+    values: Map<ListenerType, any>;
+    mapViewabilityCallbacks: Map<string, ViewabilityCallback>;
+    mapViewabilityValues: Map<string, ViewToken>;
+    mapViewabilityAmountCallbacks: Map<number, ViewabilityAmountCallback>;
+    mapViewabilityAmountValues: Map<number, ViewAmountToken>;
+    mapViewabilityConfigStates: Map<string, {
+        viewableItems: ViewToken[];
+        start: number;
+        end: number;
+        previousStart: number;
+        previousEnd: number;
+    }>;
+    columnWrapperStyle: ColumnWrapperStyle | undefined;
+    viewRefs: Map<number, React$1.RefObject<View>>;
+    animatedScrollY: Animated.Value;
+}
 
 declare class ScrollAdjustHandler {
-    private ctx;
     private appliedAdjust;
-    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;
+    private mounted;
+    constructor(ctx: StateContext);
+    requestAdjust(add: number): void;
+    setMounted(): void;
 }
 
-type LegendListPropsBase<ItemT, TScrollView extends ComponentProps<typeof ScrollView> | ComponentProps<typeof Animated.ScrollView>> = Omit<TScrollView, "contentOffset" | "contentInset" | "maintainVisibleContentPosition" | "stickyHeaderIndices" | "removeClippedSubviews" | "children"> & {
+type BaseScrollViewProps<TScrollView> = Omit<TScrollView, "contentOffset" | "contentInset" | "maintainVisibleContentPosition" | "stickyHeaderIndices" | "removeClippedSubviews" | "children">;
+interface DataModeProps<ItemT, TItemType extends string | undefined> {
+    /**
+     * Array of items to render in the list.
+     * @required when using data mode
+     */
+    data: ReadonlyArray<ItemT>;
+    /**
+     * Function or React component to render each item in the list.
+     * Can be either:
+     * - A function: (props: LegendListRenderItemProps<ItemT>) => ReactNode
+     * - A React component: React.ComponentType<LegendListRenderItemProps<ItemT>>
+     * @required when using data mode
+     */
+    renderItem: ((props: LegendListRenderItemProps<ItemT, TItemType>) => ReactNode) | React.ComponentType<LegendListRenderItemProps<ItemT, TItemType>>;
+    children?: never;
+}
+interface ChildrenModeProps {
+    /**
+     * React children elements to render as list items.
+     * Each child will be treated as an individual list item.
+     * @required when using children mode
+     */
+    children: ReactNode;
+    data?: never;
+    renderItem?: never;
+}
+interface LegendListSpecificProps<ItemT, TItemType extends string | undefined> {
     /**
      * If true, aligns items at the end of the list.
      * @default false
@@ -33,11 +69,6 @@ type LegendListPropsBase<ItemT, TScrollView extends ComponentProps<typeof Scroll
      * 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
@@ -65,7 +96,7 @@ type LegendListPropsBase<ItemT, TScrollView extends ComponentProps<typeof Scroll
      * 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;
+    getEstimatedItemSize?: (index: number, item: ItemT, type: TItemType) => number;
     /**
      * Ratio of initial container pool size to data length (e.g., 0.5 for half).
      * @default 2
@@ -83,7 +114,6 @@ type LegendListPropsBase<ItemT, TScrollView extends ComponentProps<typeof Scroll
     initialScrollIndex?: number | {
         index: number;
         viewOffset?: number | undefined;
-        viewPosition?: number | undefined;
     };
     /**
      * Component to render between items, receiving the leading item as prop.
@@ -119,7 +149,7 @@ type LegendListPropsBase<ItemT, TScrollView extends ComponentProps<typeof Scroll
      * If true, auto-scrolls to end when new items are added.
      * @default false
      */
-    maintainScrollAtEnd?: boolean;
+    maintainScrollAtEnd?: boolean | MaintainScrollAtEndOptions;
     /**
      * Distance threshold in percentage of screen size to trigger maintainScrollAtEnd.
      * @default 0.1
@@ -174,7 +204,7 @@ type LegendListPropsBase<ItemT, TScrollView extends ComponentProps<typeof Scroll
     /**
      * Called when the viewability of items changes.
      */
-    onViewableItemsChanged?: OnViewableItemsChanged | undefined;
+    onViewableItemsChanged?: OnViewableItemsChanged<ItemT> | undefined;
     /**
      * Offset in pixels for the refresh indicator.
      * @default 0
@@ -194,14 +224,6 @@ type LegendListPropsBase<ItemT, TScrollView extends ComponentProps<typeof Scroll
      * @default false
      */
     refreshing?: boolean;
-    /**
-     * Function or React component to render each item in the list.
-     * Can be either:
-     * - A function: (props: LegendListRenderItemProps<ItemT>) => ReactNode
-     * - A React component: React.ComponentType<LegendListRenderItemProps<ItemT>>
-     * @required
-     */
-    renderItem?: ((props: LegendListRenderItemProps<ItemT>) => ReactNode) | React.ComponentType<LegendListRenderItemProps<ItemT>>;
     /**
      * Render custom ScrollView component.
      * @default (props) => <ScrollView {...props} />
@@ -220,7 +242,7 @@ type LegendListPropsBase<ItemT, TScrollView extends ComponentProps<typeof Scroll
     /**
      * Pairs of viewability configs and their callbacks for tracking visibility.
      */
-    viewabilityConfigCallbackPairs?: ViewabilityConfigCallbackPairs | undefined;
+    viewabilityConfigCallbackPairs?: ViewabilityConfigCallbackPairs<ItemT> | undefined;
     /**
      * If true, delays rendering until initial layout is complete.
      * @default false
@@ -229,35 +251,42 @@ type LegendListPropsBase<ItemT, TScrollView extends ComponentProps<typeof Scroll
     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 stickyIndices={[0]} will cause the first child to be fixed to the top of the scroll view.
+     * Not supported in conjunction with horizontal={true}.
+     * @default undefined
+     */
+    stickyIndices?: number[];
+    getItemType?: (item: ItemT, index: number) => TItemType;
+    getFixedItemSize?: (index: number, item: ItemT, type: TItemType) => number;
+    itemsAreEqual?: (itemPrevious: ItemT, item: ItemT, index: number, data: readonly ItemT[]) => boolean;
+}
+type LegendListPropsBase<ItemT, TScrollView extends ComponentProps<typeof ScrollView> | ComponentProps<typeof Animated.ScrollView> | ComponentProps<typeof Animated$1.ScrollView>, TItemType extends string | undefined = string | undefined> = BaseScrollViewProps<TScrollView> & LegendListSpecificProps<ItemT, TItemType> & (DataModeProps<ItemT, TItemType> | ChildrenModeProps);
+interface MaintainScrollAtEndOptions {
+    onLayout?: boolean;
+    onItemLayout?: boolean;
+    onDataChange?: boolean;
+}
 interface ColumnWrapperStyle {
     rowGap?: number;
     gap?: number;
     columnGap?: number;
 }
-type AnchoredPosition = {
-    type: "top" | "bottom";
-    relativeCoordinate: number;
-    top: number;
-};
-type LegendListProps<ItemT> = LegendListPropsBase<ItemT, Omit<ComponentProps<typeof ScrollView>, "scrollEventThrottle">>;
+type LegendListProps<ItemT = any> = LegendListPropsBase<ItemT, ComponentProps<typeof ScrollView>>;
 interface InternalState {
-    anchorElement?: {
-        id: string;
-        coordinate: number;
-    };
-    belowAnchorElementPositions?: Map<string, number>;
-    rowHeights: Map<number, number>;
     positions: Map<string, number>;
     columns: Map<string, number>;
     sizes: Map<string, number>;
     sizesKnown: Map<string, number>;
+    containerItemKeys: Set<string>;
+    containerItemTypes: Map<number, string>;
     pendingAdjust: number;
     isStartReached: boolean;
     isEndReached: boolean;
     isAtEnd: boolean;
     isAtStart: boolean;
-    data: readonly any[];
     hasScrolled?: boolean;
     scrollLength: number;
     startBuffered: number;
@@ -265,28 +294,27 @@ interface InternalState {
     startNoBuffer: number;
     endBuffered: number;
     endNoBuffer: number;
+    firstFullyOnScreenIndex: number;
+    idsInView: string[];
     scrollPending: number;
     scroll: number;
     scrollTime: number;
     scrollPrev: number;
     scrollPrevTime: number;
-    scrollVelocity: number;
     scrollAdjustHandler: ScrollAdjustHandler;
     maintainingScrollAtEnd?: boolean;
     totalSize: number;
-    totalSizeBelowAnchor: number;
     otherAxisSize?: number;
     timeouts: Set<number>;
     timeoutSizeMessage: any;
     nativeMarginTop: number;
     indexByKey: Map<string, number>;
-    viewabilityConfigCallbackPairs: ViewabilityConfigCallbackPairs | undefined;
-    renderItem: ((props: LegendListRenderItemProps<any>) => ReactNode) | React.ComponentType<LegendListRenderItemProps<any>>;
+    idCache: Map<number, string>;
+    viewabilityConfigCallbackPairs: ViewabilityConfigCallbackPairs<any> | undefined;
     scrollHistory: Array<{
         scroll: number;
         time: number;
     }>;
-    scrollTimer: Timer | undefined;
     startReachedBlockedByTimer: boolean;
     endReachedBlockedByTimer: boolean;
     scrollForNextCalculateItemsInView: {
@@ -298,8 +326,11 @@ interface InternalState {
     queuedInitialLayout?: boolean | undefined;
     queuedCalculateItemsInView: number | undefined;
     lastBatchingAction: number;
-    ignoreScrollFromCalcTotal?: boolean;
-    disableScrollJumpsFrom?: number;
+    ignoreScrollFromMVCP?: {
+        lt?: number;
+        gt?: number;
+    };
+    ignoreScrollFromMVCPTimeout?: any;
     scrollingTo?: {
         offset: number;
         index?: number;
@@ -307,14 +338,61 @@ interface InternalState {
         viewPosition?: number;
         animated?: boolean;
     } | undefined;
-    previousTotalSize?: number;
     needsOtherAxisSize?: boolean;
     averageSizes: Record<string, {
         num: number;
         avg: number;
     }>;
-    onScroll: ((event: NativeSyntheticEvent<NativeScrollEvent>) => void) | undefined;
-    stylePaddingBottom?: number;
+    refScroller: React.RefObject<ScrollView>;
+    loadStartTime: number;
+    initialScroll: ScrollIndexWithOffset | undefined;
+    lastLayout: LayoutRectangle | undefined;
+    queuedItemSizeUpdates: {
+        itemKey: string;
+        sizeObj: {
+            width: number;
+            height: number;
+        };
+    }[];
+    queuedItemSizeUpdatesWaiting?: boolean;
+    timeoutSetPaddingTop?: any;
+    activeStickyIndex: number | undefined;
+    stickyContainers: Map<number, number>;
+    stickyContainerPool: Set<number>;
+    scrollProcessingEnabled: boolean;
+    props: {
+        alignItemsAtEnd: boolean;
+        data: readonly any[];
+        estimatedItemSize: number | undefined;
+        getEstimatedItemSize: LegendListProps["getEstimatedItemSize"];
+        getFixedItemSize: LegendListProps["getFixedItemSize"];
+        getItemType: LegendListProps["getItemType"];
+        horizontal: boolean;
+        keyExtractor: LegendListProps["keyExtractor"];
+        maintainScrollAtEnd: boolean | MaintainScrollAtEndOptions;
+        maintainScrollAtEndThreshold: number | undefined;
+        maintainVisibleContentPosition: boolean;
+        onEndReached: LegendListProps["onEndReached"];
+        onEndReachedThreshold: number | null | undefined;
+        onItemSizeChanged: LegendListProps["onItemSizeChanged"];
+        onLoad: LegendListProps["onLoad"];
+        onScroll: LegendListProps["onScroll"];
+        onStartReached: LegendListProps["onStartReached"];
+        onStartReachedThreshold: number | null | undefined;
+        recycleItems: boolean;
+        suggestEstimatedItemSize: boolean;
+        stylePaddingBottom: number | undefined;
+        renderItem: LegendListProps["renderItem"];
+        initialScroll: ScrollIndexWithOffset | undefined;
+        scrollBuffer: number;
+        numColumns: number;
+        initialContainerPoolRatio: number;
+        stylePaddingTop: number | undefined;
+        snapToIndices: number[] | undefined;
+        stickyIndicesSet: Set<number>;
+        stickyIndicesArr: number[];
+        itemsAreEqual: LegendListProps["itemsAreEqual"];
+    };
 }
 interface ViewableRange<T> {
     startBuffered: number;
@@ -323,23 +401,28 @@ interface ViewableRange<T> {
     end: number;
     items: T[];
 }
-interface LegendListRenderItemProps<ItemT> {
+interface LegendListRenderItemProps<ItemT, TItemType extends string | number | undefined = string | number | undefined> {
     item: ItemT;
+    type: TItemType;
     index: number;
+    data: readonly ItemT[];
     extraData: any;
 }
 type ScrollState = {
     contentLength: number;
+    data: readonly any[];
     end: number;
     endBuffered: number;
     isAtEnd: boolean;
     isAtStart: boolean;
+    positionAtIndex: (index: number) => number;
+    positions: Map<string, number>;
     scroll: number;
     scrollLength: number;
+    sizeAtIndex: (index: number) => number;
+    sizes: Map<string, number>;
     start: number;
     startBuffered: number;
-    sizes: Map<string, number>;
-    sizeAtIndex: (index: number) => number;
 };
 type LegendListRef = {
     /**
@@ -386,9 +469,11 @@ type LegendListRef = {
      * Scrolls to the end of the list.
      * @param options - Options for scrolling.
      * @param options.animated - If true, animates the scroll. Default: true.
+     * @param options.viewOffset - Offset from the target position.
      */
     scrollToEnd(options?: {
         animated?: boolean | undefined;
+        viewOffset?: number | undefined;
     }): void;
     /**
      * Scrolls to a specific index in the list.
@@ -428,6 +513,17 @@ type LegendListRef = {
         offset: number;
         animated?: boolean | undefined;
     }): void;
+    /**
+     * Sets or adds to the offset of the visible content anchor.
+     * @param value - The offset to set or add.
+     * @param animated - If true, uses Animated to animate the change.
+     */
+    setVisibleContentAnchorOffset(value: number | ((value: number) => number)): void;
+    /**
+     * Sets whether scroll processing is enabled.
+     * @param enabled - If true, scroll processing is enabled.
+     */
+    setScrollProcessingEnabled(enabled: boolean): void;
 };
 interface ViewToken<ItemT = any> {
     item: ItemT;
@@ -443,14 +539,14 @@ interface ViewAmountToken<ItemT = any> extends ViewToken<ItemT> {
     percentOfScroller: number;
     scrollSize: number;
 }
-interface ViewabilityConfigCallbackPair {
+interface ViewabilityConfigCallbackPair<ItemT> {
     viewabilityConfig: ViewabilityConfig;
-    onViewableItemsChanged?: OnViewableItemsChanged;
+    onViewableItemsChanged?: OnViewableItemsChanged<ItemT>;
 }
-type ViewabilityConfigCallbackPairs = ViewabilityConfigCallbackPair[];
-type OnViewableItemsChanged = ((info: {
-    viewableItems: Array<ViewToken>;
-    changed: Array<ViewToken>;
+type ViewabilityConfigCallbackPairs<ItemT> = ViewabilityConfigCallbackPair<ItemT>[];
+type OnViewableItemsChanged<ItemT> = ((info: {
+    viewableItems: Array<ViewToken<ItemT>>;
+    changed: Array<ViewToken<ItemT>>;
 }) => void) | null;
 interface ViewabilityConfig {
     /**
@@ -481,8 +577,8 @@ interface ViewabilityConfig {
      */
     waitForInteraction?: boolean | undefined;
 }
-type ViewabilityCallback = (viewToken: ViewToken) => void;
-type ViewabilityAmountCallback = (viewToken: ViewAmountToken) => void;
+type ViewabilityCallback<ItemT = any> = (viewToken: ViewToken<ItemT>) => void;
+type ViewabilityAmountCallback<ItemT = any> = (viewToken: ViewAmountToken<ItemT>) => void;
 interface LegendListRecyclingState<T> {
     item: T;
     prevItem: T | undefined;
@@ -491,276 +587,30 @@ interface LegendListRecyclingState<T> {
 }
 type TypedForwardRef = <T, P = {}>(render: (props: P, ref: React.Ref<T>) => React.ReactNode) => (props: P & React.RefAttributes<T>) => React.ReactNode;
 declare const typedForwardRef: TypedForwardRef;
-type TypedMemo = <T extends React.ComponentType<any>>(Component: T, propsAreEqual?: (prevProps: Readonly<ComponentProps<T>>, nextProps: Readonly<ComponentProps<T>>) => boolean) => T & {
+type TypedMemo = <T extends React.ComponentType<any>>(Component: T, propsAreEqual?: (prevProps: Readonly<React.JSXElementConstructor<T>>, nextProps: Readonly<React.JSXElementConstructor<T>>) => boolean) => T & {
     displayName?: string;
 };
 declare const typedMemo: TypedMemo;
-type ScrollIndexWithOffsetPosition = {
+interface ScrollIndexWithOffset {
+    index: number;
+    viewOffset: number;
+}
+interface ScrollIndexWithOffsetPosition extends ScrollIndexWithOffset {
+    viewPosition: number;
+}
+type GetRenderedItemResult<ItemT> = {
     index: number;
-    viewOffset?: number;
-    viewPosition?: number;
+    item: ItemT;
+    renderedItem: React.ReactNode;
 };
+type GetRenderedItem = (key: string) => GetRenderedItemResult<any> | null;
 
-declare const LegendList: <T>(props: Omit<Omit<react_native.ScrollViewProps, "scrollEventThrottle">, "contentOffset" | "contentInset" | "maintainVisibleContentPosition" | "stickyHeaderIndices" | "removeClippedSubviews" | "children"> & {
-    alignItemsAtEnd?: boolean;
-    columnWrapperStyle?: ColumnWrapperStyle;
-    data: readonly T[];
-    drawDistance?: number;
-    estimatedItemSize?: number;
-    estimatedListSize?: {
-        height: number;
-        width: number;
-    };
-    extraData?: any;
-    getEstimatedItemSize?: ((index: number, item: T) => number) | undefined;
-    initialContainerPoolRatio?: number | undefined;
-    initialScrollOffset?: number;
-    initialScrollIndex?: number | {
-        index: number;
-        viewOffset?: number | undefined;
-        viewPosition?: number | 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<ViewStyle> | undefined;
-    ListHeaderComponent?: React$1.ComponentType<any> | React$1.ReactElement | null | undefined;
-    ListHeaderComponentStyle?: react_native.StyleProp<ViewStyle> | undefined;
-    maintainScrollAtEnd?: boolean;
-    maintainScrollAtEndThreshold?: number;
-    maintainVisibleContentPosition?: boolean;
-    numColumns?: number;
-    onEndReached?: ((info: {
-        distanceFromEnd: number;
-    }) => void) | null | undefined;
-    onEndReachedThreshold?: number | null | undefined;
-    onItemSizeChanged?: ((info: {
-        size: number;
-        previous: number;
-        index: number;
-        itemKey: string;
-        itemData: T;
-    }) => void) | undefined;
-    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?: React$1.ComponentType<LegendListRenderItemProps<T>> | ((props: LegendListRenderItemProps<T>) => React$1.ReactNode) | undefined;
-    renderScrollComponent?: (props: react_native.ScrollViewProps) => React$1.ReactElement<react_native.ScrollViewProps>;
-    suggestEstimatedItemSize?: boolean;
-    viewabilityConfig?: ViewabilityConfig;
-    viewabilityConfigCallbackPairs?: ViewabilityConfigCallbackPairs | undefined;
-    waitForInitialLayout?: boolean;
-    onLoad?: (info: {
-        elapsedTimeInMs: number;
-    }) => void;
-} & React$1.RefAttributes<LegendListRef>) => React$1.ReactNode;
-
-interface LazyLegendListProps<ItemT, ListT> extends Omit<LegendListProps$1<ItemT>, "data" | "keyExtractor" | "renderItem"> {
-    children?: React$1.ReactNode | undefined;
-    LegendList?: ListT;
-}
-declare const LazyLegendList: <ItemT, ListT extends (<T>(props: Omit<Omit<react_native.ScrollViewProps, "scrollEventThrottle">, "contentOffset" | "contentInset" | "maintainVisibleContentPosition" | "stickyHeaderIndices" | "removeClippedSubviews" | "children"> & {
-    alignItemsAtEnd?: boolean;
-    columnWrapperStyle?: _legendapp_list.ColumnWrapperStyle;
-    data: readonly T[];
-    drawDistance?: number;
-    estimatedItemSize?: number;
-    estimatedListSize?: {
-        height: number;
-        width: number;
-    };
-    extraData?: any;
-    getEstimatedItemSize?: ((index: number, item: T) => number) | undefined;
-    initialContainerPoolRatio?: number | undefined;
-    initialScrollOffset?: number;
-    initialScrollIndex?: number | {
-        index: number;
-        viewOffset?: number | undefined;
-        viewPosition?: number | 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;
-    maintainVisibleContentPosition?: boolean;
-    numColumns?: number;
-    onEndReached?: ((info: {
-        distanceFromEnd: number;
-    }) => void) | null | undefined;
-    onEndReachedThreshold?: number | null | undefined;
-    onItemSizeChanged?: ((info: {
-        size: number;
-        previous: number;
-        index: number;
-        itemKey: string;
-        itemData: T;
-    }) => void) | undefined;
-    onRefresh?: () => void;
-    onStartReached?: ((info: {
-        distanceFromStart: number;
-    }) => void) | null | undefined;
-    onStartReachedThreshold?: number | null | undefined;
-    onViewableItemsChanged?: _legendapp_list.OnViewableItemsChanged | undefined;
-    progressViewOffset?: number;
-    recycleItems?: boolean;
-    refScrollView?: React$1.Ref<react_native.ScrollView>;
-    refreshing?: boolean;
-    renderItem?: React$1.ComponentType<LegendListRenderItemProps$1<T>> | ((props: LegendListRenderItemProps$1<T>) => React$1.ReactNode) | undefined;
-    renderScrollComponent?: (props: react_native.ScrollViewProps) => React$1.ReactElement<react_native.ScrollViewProps>;
-    suggestEstimatedItemSize?: boolean;
-    viewabilityConfig?: _legendapp_list.ViewabilityConfig;
-    viewabilityConfigCallbackPairs?: _legendapp_list.ViewabilityConfigCallbackPairs | undefined;
-    waitForInitialLayout?: boolean;
-    onLoad?: (info: {
-        elapsedTimeInMs: number;
-    }) => void;
-} & React$1.RefAttributes<LegendListRef$1>) => React$1.ReactNode) | react_native.Animated.AnimatedComponent<(<T>(props: Omit<Omit<react_native.ScrollViewProps, "scrollEventThrottle">, "contentOffset" | "contentInset" | "maintainVisibleContentPosition" | "stickyHeaderIndices" | "removeClippedSubviews" | "children"> & {
-    alignItemsAtEnd?: boolean;
-    columnWrapperStyle?: _legendapp_list.ColumnWrapperStyle;
-    data: readonly T[];
-    drawDistance?: number;
-    estimatedItemSize?: number;
-    estimatedListSize?: {
-        height: number;
-        width: number;
-    };
-    extraData?: any;
-    getEstimatedItemSize?: ((index: number, item: T) => number) | undefined;
-    initialContainerPoolRatio?: number | undefined;
-    initialScrollOffset?: number;
-    initialScrollIndex?: number | {
-        index: number;
-        viewOffset?: number | undefined;
-        viewPosition?: number | 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;
-    maintainVisibleContentPosition?: boolean;
-    numColumns?: number;
-    onEndReached?: ((info: {
-        distanceFromEnd: number;
-    }) => void) | null | undefined;
-    onEndReachedThreshold?: number | null | undefined;
-    onItemSizeChanged?: ((info: {
-        size: number;
-        previous: number;
-        index: number;
-        itemKey: string;
-        itemData: T;
-    }) => void) | undefined;
-    onRefresh?: () => void;
-    onStartReached?: ((info: {
-        distanceFromStart: number;
-    }) => void) | null | undefined;
-    onStartReachedThreshold?: number | null | undefined;
-    onViewableItemsChanged?: _legendapp_list.OnViewableItemsChanged | undefined;
-    progressViewOffset?: number;
-    recycleItems?: boolean;
-    refScrollView?: React$1.Ref<react_native.ScrollView>;
-    refreshing?: boolean;
-    renderItem?: React$1.ComponentType<LegendListRenderItemProps$1<T>> | ((props: LegendListRenderItemProps$1<T>) => React$1.ReactNode) | undefined;
-    renderScrollComponent?: (props: react_native.ScrollViewProps) => React$1.ReactElement<react_native.ScrollViewProps>;
-    suggestEstimatedItemSize?: boolean;
-    viewabilityConfig?: _legendapp_list.ViewabilityConfig;
-    viewabilityConfigCallbackPairs?: _legendapp_list.ViewabilityConfigCallbackPairs | undefined;
-    waitForInitialLayout?: boolean;
-    onLoad?: (info: {
-        elapsedTimeInMs: number;
-    }) => void;
-} & React$1.RefAttributes<LegendListRef$1>) => React$1.ReactNode)> | (<ItemT_1>(props: _legendapp_list_reanimated.AnimatedLegendListProps<ItemT_1> & {
-    ref?: React$1.Ref<LegendListRef$1>;
-}) => React$1.ReactElement | null) = <T>(props: Omit<Omit<react_native.ScrollViewProps, "scrollEventThrottle">, "contentOffset" | "contentInset" | "maintainVisibleContentPosition" | "stickyHeaderIndices" | "removeClippedSubviews" | "children"> & {
-    alignItemsAtEnd?: boolean;
-    columnWrapperStyle?: _legendapp_list.ColumnWrapperStyle;
-    data: readonly T[];
-    drawDistance?: number;
-    estimatedItemSize?: number;
-    estimatedListSize?: {
-        height: number;
-        width: number;
-    };
-    extraData?: any;
-    getEstimatedItemSize?: ((index: number, item: T) => number) | undefined;
-    initialContainerPoolRatio?: number | undefined;
-    initialScrollOffset?: number;
-    initialScrollIndex?: number | {
-        index: number;
-        viewOffset?: number | undefined;
-        viewPosition?: number | 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;
-    maintainVisibleContentPosition?: boolean;
-    numColumns?: number;
-    onEndReached?: ((info: {
-        distanceFromEnd: number;
-    }) => void) | null | undefined;
-    onEndReachedThreshold?: number | null | undefined;
-    onItemSizeChanged?: ((info: {
-        size: number;
-        previous: number;
-        index: number;
-        itemKey: string;
-        itemData: T;
-    }) => void) | undefined;
-    onRefresh?: () => void;
-    onStartReached?: ((info: {
-        distanceFromStart: number;
-    }) => void) | null | undefined;
-    onStartReachedThreshold?: number | null | undefined;
-    onViewableItemsChanged?: _legendapp_list.OnViewableItemsChanged | undefined;
-    progressViewOffset?: number;
-    recycleItems?: boolean;
-    refScrollView?: React$1.Ref<react_native.ScrollView>;
-    refreshing?: boolean;
-    renderItem?: React$1.ComponentType<LegendListRenderItemProps$1<T>> | ((props: LegendListRenderItemProps$1<T>) => React$1.ReactNode) | undefined;
-    renderScrollComponent?: (props: react_native.ScrollViewProps) => React$1.ReactElement<react_native.ScrollViewProps>;
-    suggestEstimatedItemSize?: boolean;
-    viewabilityConfig?: _legendapp_list.ViewabilityConfig;
-    viewabilityConfigCallbackPairs?: _legendapp_list.ViewabilityConfigCallbackPairs | undefined;
-    waitForInitialLayout?: boolean;
-    onLoad?: (info: {
-        elapsedTimeInMs: number;
-    }) => void;
-} & React$1.RefAttributes<LegendListRef$1>) => React$1.ReactNode>(props: LazyLegendListProps<ItemT, ListT> & React$1.RefAttributes<LegendListRef$1>) => React$1.ReactNode;
+declare const LegendList: (<T>(props: LegendListProps<T> & React$1.RefAttributes<LegendListRef>) => React$1.ReactNode) & {
+    displayName?: string;
+};
 
-declare function useViewability(callback: ViewabilityCallback, configId?: string): void;
-declare function useViewabilityAmount(callback: ViewabilityAmountCallback): void;
+declare function useViewability<ItemT = any>(callback: ViewabilityCallback<ItemT>, configId?: string): void;
+declare function useViewabilityAmount<ItemT = any>(callback: ViewabilityAmountCallback<ItemT>): void;
 declare function useRecyclingEffect(effect: (info: LegendListRecyclingState<unknown>) => void | (() => void)): void;
 declare function useRecyclingState<ItemT>(valueOrFun: ((info: LegendListRecyclingState<ItemT>) => ItemT) | ItemT): readonly [ItemT | null, Dispatch<SetStateAction<ItemT>>];
 declare function useIsLastItem(): boolean;
@@ -768,5 +618,6 @@ declare function useListScrollSize(): {
     width: number;
     height: number;
 };
+declare function useSyncLayout(): () => void;
 
-export { type AnchoredPosition, type ColumnWrapperStyle, type InternalState, LazyLegendList, type LazyLegendListProps, LegendList, type LegendListProps, type LegendListPropsBase, type LegendListRecyclingState, type LegendListRef, type LegendListRenderItemProps, type OnViewableItemsChanged, type ScrollIndexWithOffsetPosition, type ScrollState, type TypedForwardRef, type TypedMemo, type ViewAmountToken, type ViewToken, type ViewabilityAmountCallback, type ViewabilityCallback, type ViewabilityConfig, type ViewabilityConfigCallbackPair, type ViewabilityConfigCallbackPairs, type ViewableRange, typedForwardRef, typedMemo, useIsLastItem, useListScrollSize, useRecyclingEffect, useRecyclingState, useViewability, useViewabilityAmount };
+export { type ColumnWrapperStyle, type GetRenderedItem, type GetRenderedItemResult, type InternalState, LegendList, type LegendListProps, type LegendListPropsBase, type LegendListRecyclingState, type LegendListRef, type LegendListRenderItemProps, type MaintainScrollAtEndOptions, type OnViewableItemsChanged, type ScrollIndexWithOffset, type ScrollIndexWithOffsetPosition, type ScrollState, type TypedForwardRef, type TypedMemo, type ViewAmountToken, type ViewToken, type ViewabilityAmountCallback, type ViewabilityCallback, type ViewabilityConfig, type ViewabilityConfigCallbackPair, type ViewabilityConfigCallbackPairs, type ViewableRange, typedForwardRef, typedMemo, useIsLastItem, useListScrollSize, useRecyclingEffect, useRecyclingState, useSyncLayout, useViewability, useViewabilityAmount };