@legendapp/list 1.1.4 → 2.0.0-next.1

package/index.d.mts

@@ -1,26 +1,29 @@
 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 { View, 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';
+
+type ListenerType = "numContainers" | "numContainersPooled" | `containerItemKey${number}` | `containerItemData${number}` | `containerPosition${number}` | `containerColumn${number}` | "containersDidLayout" | "extraData" | "numColumns" | "lastItemKeys" | "totalSize" | "alignItemsPaddingTop" | "stylePaddingTop" | "scrollAdjust" | "scrollAdjustUserOffset" | "headerSize" | "footerSize" | "maintainVisibleContentPosition" | "debugRawScroll" | "debugComputedScroll" | "otherAxisSize" | "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>;
+    columnWrapperStyle: ColumnWrapperStyle | undefined;
+    viewRefs: Map<number, React$1.RefObject<View>>;
+}
 
 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"> & {
@@ -235,29 +238,18 @@ interface ColumnWrapperStyle {
     gap?: number;
     columnGap?: number;
 }
-type AnchoredPosition = {
-    type: "top" | "bottom";
-    relativeCoordinate: number;
-    top: number;
-};
 type LegendListProps<ItemT> = LegendListPropsBase<ItemT, Omit<ComponentProps<typeof ScrollView>, "scrollEventThrottle">>;
 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>;
     pendingAdjust: number;
     isStartReached: boolean;
     isEndReached: boolean;
     isAtEnd: boolean;
     isAtStart: boolean;
-    data: readonly any[];
     hasScrolled?: boolean;
     scrollLength: number;
     startBuffered: number;
@@ -265,28 +257,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>;
+    idCache: Map<number, string>;
     viewabilityConfigCallbackPairs: ViewabilityConfigCallbackPairs | undefined;
-    renderItem: ((props: LegendListRenderItemProps<any>) => ReactNode) | React.ComponentType<LegendListRenderItemProps<any>>;
     scrollHistory: Array<{
         scroll: number;
         time: number;
     }>;
-    scrollTimer: Timer | undefined;
     startReachedBlockedByTimer: boolean;
     endReachedBlockedByTimer: boolean;
     scrollForNextCalculateItemsInView: {
@@ -298,8 +289,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 +301,57 @@ 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: ScrollIndexWithOffsetPosition | undefined;
+    props: {
+        alignItemsAtEnd: boolean;
+        data: readonly any[];
+        estimatedItemSize: number | undefined;
+        getEstimatedItemSize: ((index: number, item: any) => number) | undefined;
+        horizontal: boolean;
+        keyExtractor: ((item: any, index: number) => string) | undefined;
+        maintainScrollAtEnd: boolean;
+        maintainScrollAtEndThreshold: number | undefined;
+        maintainVisibleContentPosition: boolean;
+        onEndReached: (((info: {
+            distanceFromEnd: number;
+        }) => void) | null | undefined) | undefined;
+        onEndReachedThreshold: number | null | undefined;
+        onItemSizeChanged: ((info: {
+            size: number;
+            previous: number;
+            index: number;
+            itemKey: string;
+            itemData: any;
+        }) => void) | undefined;
+        onLoad: ((info: {
+            elapsedTimeInMs: number;
+        }) => void) | undefined;
+        onScroll: ((event: NativeSyntheticEvent<NativeScrollEvent>) => void) | undefined;
+        onStartReached: (((info: {
+            distanceFromStart: number;
+        }) => void) | null | undefined) | undefined;
+        onStartReachedThreshold: number | null | undefined;
+        suggestEstimatedItemSize: boolean;
+        stylePaddingBottom: number | undefined;
+        renderItem: ((props: LegendListRenderItemProps<any>) => ReactNode) | React.ComponentType<LegendListRenderItemProps<any>>;
+        initialScroll: {
+            index: number;
+            viewOffset?: number;
+            viewPosition?: number;
+        } | undefined;
+        scrollBuffer: number;
+        viewabilityConfigCallbackPairs: ViewabilityConfigCallbackPairs | undefined;
+        numColumns: number;
+        initialContainerPoolRatio: number;
+        stylePaddingTop: number | undefined;
+    };
 }
 interface ViewableRange<T> {
     startBuffered: number;
@@ -428,6 +465,12 @@ 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;
 };
 interface ViewToken<ItemT = any> {
     item: ItemT;
@@ -500,6 +543,12 @@ type ScrollIndexWithOffsetPosition = {
     viewOffset?: number;
     viewPosition?: number;
 };
+type GetRenderedItemResult<ItemT> = {
+    index: 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;
@@ -526,9 +575,9 @@ declare const LegendList: <T>(props: Omit<Omit<react_native.ScrollViewProps, "sc
     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;
+    ListFooterComponentStyle?: react_native.StyleProp<react_native.ViewStyle> | undefined;
     ListHeaderComponent?: React$1.ComponentType<any> | React$1.ReactElement | null | undefined;
-    ListHeaderComponentStyle?: react_native.StyleProp<ViewStyle> | undefined;
+    ListHeaderComponentStyle?: react_native.StyleProp<react_native.ViewStyle> | undefined;
     maintainScrollAtEnd?: boolean;
     maintainScrollAtEndThreshold?: number;
     maintainVisibleContentPosition?: boolean;
@@ -565,13 +614,13 @@ declare const LegendList: <T>(props: Omit<Omit<react_native.ScrollViewProps, "sc
     }) => void;
 } & React$1.RefAttributes<LegendListRef>) => React$1.ReactNode;
 
-interface LazyLegendListProps<ItemT, ListT> extends Omit<LegendListProps$1<ItemT>, "data" | "keyExtractor" | "renderItem"> {
+interface LazyLegendListProps<ItemT, ListT> extends Omit<LegendListProps<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;
+    columnWrapperStyle?: ColumnWrapperStyle;
     data: readonly T[];
     drawDistance?: number;
     estimatedItemSize?: number;
@@ -617,23 +666,23 @@ declare const LazyLegendList: <ItemT, ListT extends (<T>(props: Omit<Omit<react_
         distanceFromStart: number;
     }) => void) | null | undefined;
     onStartReachedThreshold?: number | null | undefined;
-    onViewableItemsChanged?: _legendapp_list.OnViewableItemsChanged | undefined;
+    onViewableItemsChanged?: 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;
+    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?: _legendapp_list.ViewabilityConfig;
-    viewabilityConfigCallbackPairs?: _legendapp_list.ViewabilityConfigCallbackPairs | undefined;
+    viewabilityConfig?: ViewabilityConfig;
+    viewabilityConfigCallbackPairs?: 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"> & {
+} & React$1.RefAttributes<LegendListRef>) => 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;
+    columnWrapperStyle?: ColumnWrapperStyle;
     data: readonly T[];
     drawDistance?: number;
     estimatedItemSize?: number;
@@ -679,25 +728,25 @@ declare const LazyLegendList: <ItemT, ListT extends (<T>(props: Omit<Omit<react_
         distanceFromStart: number;
     }) => void) | null | undefined;
     onStartReachedThreshold?: number | null | undefined;
-    onViewableItemsChanged?: _legendapp_list.OnViewableItemsChanged | undefined;
+    onViewableItemsChanged?: 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;
+    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?: _legendapp_list.ViewabilityConfig;
-    viewabilityConfigCallbackPairs?: _legendapp_list.ViewabilityConfigCallbackPairs | undefined;
+    viewabilityConfig?: ViewabilityConfig;
+    viewabilityConfigCallbackPairs?: 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.RefAttributes<LegendListRef>) => React$1.ReactNode)> | (<ItemT_1>(props: _legendapp_list_reanimated.AnimatedLegendListProps<ItemT_1> & {
+    ref?: React$1.Ref<LegendListRef>;
 }) => React$1.ReactElement | null) = <T>(props: Omit<Omit<react_native.ScrollViewProps, "scrollEventThrottle">, "contentOffset" | "contentInset" | "maintainVisibleContentPosition" | "stickyHeaderIndices" | "removeClippedSubviews" | "children"> & {
     alignItemsAtEnd?: boolean;
-    columnWrapperStyle?: _legendapp_list.ColumnWrapperStyle;
+    columnWrapperStyle?: ColumnWrapperStyle;
     data: readonly T[];
     drawDistance?: number;
     estimatedItemSize?: number;
@@ -743,21 +792,21 @@ declare const LazyLegendList: <ItemT, ListT extends (<T>(props: Omit<Omit<react_
         distanceFromStart: number;
     }) => void) | null | undefined;
     onStartReachedThreshold?: number | null | undefined;
-    onViewableItemsChanged?: _legendapp_list.OnViewableItemsChanged | undefined;
+    onViewableItemsChanged?: 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;
+    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?: _legendapp_list.ViewabilityConfig;
-    viewabilityConfigCallbackPairs?: _legendapp_list.ViewabilityConfigCallbackPairs | undefined;
+    viewabilityConfig?: ViewabilityConfig;
+    viewabilityConfigCallbackPairs?: 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;
+} & React$1.RefAttributes<LegendListRef>) => React$1.ReactNode>(props: LazyLegendListProps<ItemT, ListT> & React$1.RefAttributes<LegendListRef>) => React$1.ReactNode;
 
 declare function useViewability(callback: ViewabilityCallback, configId?: string): void;
 declare function useViewabilityAmount(callback: ViewabilityAmountCallback): void;
@@ -769,4 +818,4 @@ declare function useListScrollSize(): {
     height: number;
 };
 
-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, 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 };