@legendapp/list 3.0.0-beta.1 → 3.0.0-beta.11

package/{types-YNdphn_A.d.mts → types-1Hgg1rTO.d.mts}

@@ -1,15 +1,57 @@
 import * as React$1 from 'react';
 import { ComponentProps, Key, ReactNode } from 'react';
-import { View, ScrollView, Animated, LayoutRectangle, ScrollViewComponent, ScrollResponderMixin, StyleProp, ViewStyle, NativeSyntheticEvent, NativeScrollEvent, ScrollViewProps } from 'react-native';
+import { View, ScrollView, Animated, LayoutRectangle, ScrollViewProps, Insets, ScrollViewComponent, ScrollResponderMixin, StyleProp, ViewStyle, NativeSyntheticEvent, NativeScrollEvent } from 'react-native';
 import Reanimated from 'react-native-reanimated';
 
 type AnimatedValue = number;
 
-type ListenerType = "numContainers" | "numContainersPooled" | `containerItemKey${number}` | `containerItemData${number}` | `containerPosition${number}` | `containerColumn${number}` | `containerSticky${number}` | `containerStickyOffset${number}` | "containersDidLayout" | "extraData" | "numColumns" | "lastItemKeys" | "totalSize" | "alignItemsPaddingTop" | "lastPositionUpdate" | "stylePaddingTop" | "scrollAdjust" | "scrollAdjustUserOffset" | "scrollAdjustPending" | "scrollingTo" | "headerSize" | "footerSize" | "maintainVisibleContentPosition" | "debugRawScroll" | "debugComputedScroll" | "otherAxisSize" | "snapToOffsets" | "scrollSize" | "activeStickyIndex";
+type ListenerType = "activeStickyIndex" | "alignItemsPaddingTop" | "debugComputedScroll" | "debugRawScroll" | "extraData" | "footerSize" | "headerSize" | "lastItemKeys" | "lastPositionUpdate" | "maintainVisibleContentPosition" | "numColumns" | "numContainers" | "numContainersPooled" | "otherAxisSize" | "readyToRender" | "scrollAdjust" | "scrollAdjustPending" | "scrollAdjustUserOffset" | "scrollSize" | "snapToOffsets" | "stylePaddingTop" | "totalSize" | `containerColumn${number}` | `containerItemData${number}` | `containerItemKey${number}` | `containerPosition${number}` | `containerSticky${number}` | `containerStickyOffset${number}`;
+type LegendListListenerType = Extract<ListenerType, "activeStickyIndex" | "footerSize" | "headerSize" | "lastItemKeys" | "lastPositionUpdate" | "numContainers" | "numContainersPooled" | "otherAxisSize" | "readyToRender" | "snapToOffsets" | "totalSize">;
+type ListenerTypeValueMap = {
+    activeStickyIndex: number;
+    alignItemsPaddingTop: number;
+    animatedScrollY: any;
+    debugComputedScroll: number;
+    debugRawScroll: number;
+    extraData: any;
+    footerSize: number;
+    headerSize: number;
+    lastItemKeys: string[];
+    lastPositionUpdate: number;
+    maintainVisibleContentPosition: boolean;
+    numColumns: number;
+    numContainers: number;
+    numContainersPooled: number;
+    otherAxisSize: number;
+    readyToRender: boolean;
+    scrollAdjust: number;
+    scrollAdjustPending: number;
+    scrollAdjustUserOffset: number;
+    scrollSize: {
+        width: number;
+        height: number;
+    };
+    snapToOffsets: number[];
+    stylePaddingTop: number;
+    totalSize: number;
+} & {
+    [K in ListenerType as K extends `containerItemKey${number}` ? K : never]: string;
+} & {
+    [K in ListenerType as K extends `containerItemData${number}` ? K : never]: any;
+} & {
+    [K in ListenerType as K extends `containerPosition${number}` ? K : never]: number;
+} & {
+    [K in ListenerType as K extends `containerColumn${number}` ? K : never]: number;
+} & {
+    [K in ListenerType as K extends `containerSticky${number}` ? K : never]: boolean;
+} & {
+    [K in ListenerType as K extends `containerStickyOffset${number}` ? K : never]: number;
+};
 interface StateContext {
-    internalState: InternalState | undefined;
+    animatedScrollY: AnimatedValue;
+    columnWrapperStyle: ColumnWrapperStyle | undefined;
+    contextNum: number;
     listeners: Map<ListenerType, Set<(value: any) => void>>;
-    values: Map<ListenerType, any>;
     mapViewabilityCallbacks: Map<string, ViewabilityCallback>;
     mapViewabilityValues: Map<string, ViewToken>;
     mapViewabilityAmountCallbacks: Map<number, ViewabilityAmountCallback>;
@@ -21,22 +63,29 @@ interface StateContext {
         previousStart: number;
         previousEnd: number;
     }>;
-    columnWrapperStyle: ColumnWrapperStyle | undefined;
+    positionListeners: Map<string, Set<(value: any) => void>>;
+    state: InternalState;
+    values: Map<ListenerType, any>;
     viewRefs: Map<number, React$1.RefObject<View>>;
-    animatedScrollY: AnimatedValue;
 }
 
 declare class ScrollAdjustHandler {
     private appliedAdjust;
     private pendingAdjust;
-    private context;
-    private mounted;
+    private ctx;
     constructor(ctx: StateContext);
     requestAdjust(add: number): void;
-    setMounted(): void;
     getAdjust(): number;
+    commitPendingAdjust(): void;
 }
 
+type BaseSharedValue<T = number> = {
+    get: () => T;
+};
+type StylesAsSharedValue<Style> = {
+    [key in keyof Style]: Style[key] | BaseSharedValue<Style[key]>;
+};
+
 type BaseScrollViewProps<TScrollView> = Omit<TScrollView, "contentOffset" | "maintainVisibleContentPosition" | "stickyHeaderIndices" | "removeClippedSubviews" | "children" | "onScroll">;
 interface DataModeProps<ItemT, TItemType extends string | undefined> {
     /**
@@ -70,11 +119,6 @@ interface LegendListSpecificProps<ItemT, TItemType extends string | undefined> {
      * @default false
      */
     alignItemsAtEnd?: boolean;
-    /**
-     * If true, enables using average sizes for performance optimization.
-     * @default true
-     */
-    enableAverages?: boolean;
     /**
      * Style applied to each column's wrapper view.
      */
@@ -317,100 +361,109 @@ interface ThresholdSnapshot {
     atThreshold: boolean;
 }
 interface ScrollTarget {
-    offset: number;
-    index?: number;
-    viewOffset?: number;
-    viewPosition?: number;
     animated?: boolean;
+    index?: number;
     isInitialScroll?: boolean;
+    itemSize?: number;
+    offset: number;
     precomputedWithViewOffset?: boolean;
+    viewOffset?: number;
+    viewPosition?: number;
 }
 interface InternalState {
-    positions: Map<string, number>;
+    activeStickyIndex: number | undefined;
+    adjustingFromInitialMount?: number;
+    animFrameCheckFinishedScroll?: any;
+    averageSizes: Record<string, {
+        num: number;
+        avg: number;
+    }>;
     columns: Map<string, number>;
-    sizes: Map<string, number>;
-    sizesKnown: Map<string, number>;
     containerItemKeys: Set<string>;
     containerItemTypes: Map<number, string>;
-    isStartReached: boolean;
-    isEndReached: boolean;
-    isAtEnd: boolean;
-    isAtStart: boolean;
-    hasScrolled?: boolean;
-    scrollLength: number;
-    startBuffered: number;
-    startBufferedId?: string;
-    startNoBuffer: number;
+    dataChangeNeedsScrollUpdate: boolean;
+    didColumnsChange?: boolean;
+    didDataChange?: boolean;
+    didFinishInitialScroll?: boolean;
+    didContainersLayout?: boolean;
+    enableScrollForNextCalculateItemsInView: boolean;
     endBuffered: number;
     endNoBuffer: number;
+    endReachedSnapshot: ThresholdSnapshot | undefined;
     firstFullyOnScreenIndex: number;
-    idsInView: string[];
-    scrollPending: number;
-    scroll: number;
-    scrollTime: number;
-    scrollPrev: number;
-    scrollPrevTime: number;
-    scrollAdjustHandler: ScrollAdjustHandler;
-    triggerCalculateItemsInView?: (params?: {
-        doMVCP?: boolean;
-        dataChanged?: boolean;
-        forceFullItemPositions?: boolean;
-    }) => void;
-    maintainingScrollAtEnd?: boolean;
-    totalSize: number;
-    otherAxisSize?: number;
-    timeouts: Set<number>;
-    timeoutSizeMessage: any;
-    nativeMarginTop: number;
-    indexByKey: Map<string, number>;
+    hasScrolled?: boolean;
     idCache: string[];
-    viewabilityConfigCallbackPairs: ViewabilityConfigCallbackPairs<any> | undefined;
-    scrollHistory: Array<{
-        scroll: number;
-        time: number;
-    }>;
-    lastScrollAdjustForHistory?: number;
-    startReachedSnapshot: ThresholdSnapshot | undefined;
-    endReachedSnapshot: ThresholdSnapshot | undefined;
-    scrollForNextCalculateItemsInView: {
-        top: number;
-        bottom: number;
-    } | undefined;
-    enableScrollForNextCalculateItemsInView: boolean;
-    minIndexSizeChanged: number | undefined;
-    queuedInitialLayout?: boolean | undefined;
-    queuedCalculateItemsInView: number | undefined;
-    dataChangeNeedsScrollUpdate: boolean;
-    previousData?: readonly unknown[];
-    didColumnsChange?: boolean;
-    didDataChange?: boolean;
-    isFirst?: boolean;
-    lastBatchingAction: number;
+    idsInView: string[];
     ignoreScrollFromMVCP?: {
         lt?: number;
         gt?: number;
     };
     ignoreScrollFromMVCPIgnored?: boolean;
     ignoreScrollFromMVCPTimeout?: any;
-    needsOtherAxisSize?: boolean;
-    averageSizes: Record<string, {
-        num: number;
-        avg: number;
-    }>;
-    refScroller: React.RefObject<ScrollView>;
-    loadStartTime: number;
-    initialScroll: ScrollIndexWithOffsetAndContentOffset | undefined;
+    indexByKey: Map<string, number>;
     initialAnchor?: InitialScrollAnchor;
+    initialScroll: ScrollIndexWithOffsetAndContentOffset | undefined;
+    isAtEnd: boolean;
+    isAtStart: boolean;
+    isEndReached: boolean | null;
+    isFirst?: boolean;
+    isStartReached: boolean | null;
+    lastBatchingAction: number;
     lastLayout: LayoutRectangle | undefined;
-    timeoutSetPaddingTop?: any;
-    activeStickyIndex: number | undefined;
-    stickyContainers: Map<number, number>;
-    stickyContainerPool: Set<number>;
-    scrollProcessingEnabled: boolean;
+    lastScrollAdjustForHistory?: number;
+    loadStartTime: number;
+    maintainingScrollAtEnd?: boolean;
+    minIndexSizeChanged: number | undefined;
+    nativeMarginTop: number;
+    needsOtherAxisSize?: boolean;
+    otherAxisSize?: number;
     pendingTotalSize?: number;
-    adjustingFromInitialMount?: number;
+    positions: Map<string, number>;
+    previousData?: readonly unknown[];
+    queuedCalculateItemsInView: number | undefined;
+    queuedInitialLayout?: boolean | undefined;
+    refScroller: React.RefObject<ScrollView>;
+    scroll: number;
+    scrollAdjustHandler: ScrollAdjustHandler;
+    scrollForNextCalculateItemsInView: {
+        top: number | null;
+        bottom: number | null;
+    } | undefined;
+    scrollHistory: Array<{
+        scroll: number;
+        time: number;
+    }>;
+    scrollingTo?: ScrollTarget | 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;
+    startReachedSnapshot: ThresholdSnapshot | 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<any> | undefined;
     props: {
         alignItemsAtEnd: boolean;
+        animatedProps: StylesAsSharedValue<ScrollViewProps>;
+        contentInset: Insets | undefined;
         data: readonly any[];
         dataVersion: Key | undefined;
         estimatedItemSize: number | undefined;
@@ -418,10 +471,13 @@ interface InternalState {
         getFixedItemSize: LegendListProps["getFixedItemSize"];
         getItemType: LegendListProps["getItemType"];
         horizontal: boolean;
+        initialContainerPoolRatio: number;
+        itemsAreEqual: LegendListProps["itemsAreEqual"];
         keyExtractor: LegendListProps["keyExtractor"];
         maintainScrollAtEnd: boolean | MaintainScrollAtEndOptions;
         maintainScrollAtEndThreshold: number | undefined;
         maintainVisibleContentPosition: boolean;
+        numColumns: number;
         onEndReached: LegendListProps["onEndReached"];
         onEndReachedThreshold: number | null | undefined;
         onItemSizeChanged: LegendListProps["onItemSizeChanged"];
@@ -431,36 +487,32 @@ interface InternalState {
         onStartReachedThreshold: number | null | undefined;
         onStickyHeaderChange: LegendListProps["onStickyHeaderChange"];
         recycleItems: boolean;
-        suggestEstimatedItemSize: boolean;
-        stylePaddingBottom: number | undefined;
         renderItem: LegendListProps["renderItem"];
         scrollBuffer: number;
-        numColumns: number;
-        initialContainerPoolRatio: number;
-        stylePaddingTop: number | undefined;
         snapToIndices: number[] | undefined;
-        stickyIndicesSet: Set<number>;
         stickyIndicesArr: number[];
-        itemsAreEqual: LegendListProps["itemsAreEqual"];
-        enableAverages: boolean;
+        stickyIndicesSet: Set<number>;
+        stylePaddingBottom: number | undefined;
+        stylePaddingTop: number | undefined;
+        suggestEstimatedItemSize: boolean;
     };
 }
 interface ViewableRange<T> {
-    startBuffered: number;
-    start: number;
-    endBuffered: number;
     end: number;
+    endBuffered: number;
     items: T[];
+    start: number;
+    startBuffered: number;
 }
 interface LegendListRenderItemProps<ItemT, TItemType extends string | number | undefined = string | number | undefined> {
-    item: ItemT;
-    type: TItemType;
-    index: number;
     data: readonly ItemT[];
     extraData: any;
+    index: number;
+    item: ItemT;
+    type: TItemType;
 }
-type ScrollState = {
-    activeStickyIndex: number | undefined;
+type LegendListState = {
+    activeStickyIndex: number;
     contentLength: number;
     data: readonly any[];
     elementAtIndex: (index: number) => View | null | undefined;
@@ -468,6 +520,8 @@ type ScrollState = {
     endBuffered: number;
     isAtEnd: boolean;
     isAtStart: 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;
     positions: Map<string, number>;
     scroll: number;
@@ -497,7 +551,7 @@ type LegendListRef = {
     /**
      * Returns the internal state of the scroll virtualization.
      */
-    getState(): ScrollState;
+    getState(): LegendListState;
     /**
      * Scrolls a specific index into view.
      * @param params - Parameters for scrolling.
@@ -571,7 +625,7 @@ type LegendListRef = {
      * @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;
+    setVisibleContentAnchorOffset(value: number | ((val: number) => number)): void;
     /**
      * Sets whether scroll processing is enabled.
      * @param enabled - If true, scroll processing is enabled.
@@ -579,22 +633,22 @@ type LegendListRef = {
     setScrollProcessingEnabled(enabled: boolean): void;
 };
 interface ViewToken<ItemT = any> {
-    item: ItemT;
-    key: string;
+    containerId: number;
     index: number;
     isViewable: boolean;
-    containerId: number;
+    item: ItemT;
+    key: string;
 }
 interface ViewAmountToken<ItemT = any> extends ViewToken<ItemT> {
-    sizeVisible: number;
-    size: number;
-    percentVisible: number;
     percentOfScroller: number;
+    percentVisible: number;
     scrollSize: number;
+    size: number;
+    sizeVisible: number;
 }
 interface ViewabilityConfigCallbackPair<ItemT = any> {
-    viewabilityConfig: ViewabilityConfig;
     onViewableItemsChanged?: OnViewableItemsChanged<ItemT>;
+    viewabilityConfig: ViewabilityConfig;
 }
 type ViewabilityConfigCallbackPairs<ItemT> = ViewabilityConfigCallbackPair<ItemT>[];
 type OnViewableItemsChanged<ItemT> = ((info: {
@@ -633,10 +687,10 @@ interface ViewabilityConfig {
 type ViewabilityCallback<ItemT = any> = (viewToken: ViewToken<ItemT>) => void;
 type ViewabilityAmountCallback<ItemT = any> = (viewToken: ViewAmountToken<ItemT>) => void;
 interface LegendListRecyclingState<T> {
-    item: T;
-    prevItem: T | undefined;
     index: number;
+    item: T;
     prevIndex: number | undefined;
+    prevItem: T | undefined;
 }
 type TypedForwardRef = <T, P = {}>(render: (props: P, ref: React.Ref<T>) => React.ReactNode) => (props: P & React.RefAttributes<T>) => React.ReactNode;
 declare const typedForwardRef: TypedForwardRef;
@@ -667,4 +721,4 @@ type GetRenderedItemResult<ItemT> = {
 };
 type GetRenderedItem = (key: string) => GetRenderedItemResult<any> | null;
 
-export { type ColumnWrapperStyle as C, type GetRenderedItemResult as G, type InternalState as I, type LegendListProps as L, type MaintainScrollAtEndOptions as M, type OnViewableItemsChanged as O, type ScrollTarget as S, type ThresholdSnapshot as T, type ViewabilityCallback as V, type LegendListRef as a, type ViewabilityAmountCallback as b, type LegendListRecyclingState as c, type LegendListPropsBase as d, type ViewableRange as e, type LegendListRenderItemProps as f, type ScrollState as g, type ViewToken as h, type ViewAmountToken as i, type ViewabilityConfigCallbackPair as j, type ViewabilityConfigCallbackPairs as k, type ViewabilityConfig as l, type TypedForwardRef as m, type TypedMemo as n, typedMemo as o, type ScrollIndexWithOffset as p, type ScrollIndexWithOffsetPosition as q, type ScrollIndexWithOffsetAndContentOffset as r, type InitialScrollAnchor as s, typedForwardRef as t, type GetRenderedItem as u };
+export { type ColumnWrapperStyle as C, type GetRenderedItemResult as G, type InternalState as I, type LegendListProps as L, type MaintainScrollAtEndOptions as M, type OnViewableItemsChanged as O, type ScrollTarget as S, type ThresholdSnapshot as T, type ViewabilityCallback as V, type LegendListRef as a, type ViewabilityAmountCallback as b, type LegendListRecyclingState as c, type LegendListPropsBase as d, type ViewableRange as e, type LegendListRenderItemProps as f, type LegendListState as g, type ViewToken as h, type ViewAmountToken as i, type ViewabilityConfigCallbackPair as j, type ViewabilityConfigCallbackPairs as k, type ViewabilityConfig as l, type TypedForwardRef as m, type TypedMemo as n, typedMemo as o, type ScrollIndexWithOffset as p, type ScrollIndexWithOffsetPosition as q, type ScrollIndexWithOffsetAndContentOffset as r, type InitialScrollAnchor as s, typedForwardRef as t, type GetRenderedItem as u };