@legendapp/list 3.0.0-beta.32 → 3.0.0-beta.34

package/keyboard.mjs

@@ -1,8 +1,8 @@
 import * as React from 'react';
-import { forwardRef, useRef, useState, useCallback, useEffect, useMemo } from 'react';
+import { useRef, useState, useMemo, useCallback, useEffect, forwardRef } from 'react';
 import { StyleSheet, Platform } from 'react-native';
 import { useKeyboardHandler } from 'react-native-keyboard-controller';
-import { useAnimatedRef, useSharedValue, useAnimatedScrollHandler, runOnJS, useAnimatedProps, useAnimatedStyle } from 'react-native-reanimated';
+import { useAnimatedRef, useSharedValue, isWorkletFunction, useAnimatedScrollHandler, runOnJS, useComposedEventHandler, useAnimatedProps, useAnimatedStyle } from 'react-native-reanimated';
 import { AnimatedLegendList } from '@legendapp/list/reanimated';
 
 // src/integrations/keyboard.tsx
@@ -28,6 +28,7 @@ var useCombinedRef = (...refs) => {
   }, refs);
   return callback;
 };
+var typedForwardRef = forwardRef;
 
 // src/integrations/keyboard.tsx
 var clampProgress = (progress) => {
@@ -53,7 +54,7 @@ var calculateKeyboardTargetOffset = (startOffset, keyboardHeight, isOpening, pro
   const delta = (isOpening ? keyboardHeight : -keyboardHeight) * normalizedProgress;
   return Math.max(0, startOffset + delta);
 };
-var KeyboardAvoidingLegendList = forwardRef(function KeyboardAvoidingLegendList2(props, forwardedRef) {
+var KeyboardAvoidingLegendList = typedForwardRef(function KeyboardAvoidingLegendList2(props, forwardedRef) {
   const {
     contentContainerStyle: contentContainerStyleProp,
     contentInset: contentInsetProp,
@@ -74,7 +75,7 @@ var KeyboardAvoidingLegendList = forwardRef(function KeyboardAvoidingLegendList2
   const scrollOffsetY = useSharedValue(0);
   const animatedOffsetY = useSharedValue(null);
   const scrollOffsetAtKeyboardStart = useSharedValue(0);
-  const mode = useSharedValue("idle");
+  const animationMode = useSharedValue("idle");
   const keyboardInset = useSharedValue(0);
   const keyboardHeight = useSharedValue(0);
   const contentLength = useSharedValue(0);
@@ -85,17 +86,33 @@ var KeyboardAvoidingLegendList = forwardRef(function KeyboardAvoidingLegendList2
   const isKeyboardOpen = useSharedValue(false);
   const keyboardInsetRef = useRef(0);
   const [alignItemsAtEndMinSize, setAlignItemsAtEndMinSize] = useState(void 0);
+  const onScrollValue = onScrollProp;
+  const onScrollCallback = typeof onScrollValue === "function" ? onScrollValue : void 0;
+  const onScrollProcessed = onScrollValue && typeof onScrollValue === "object" && "workletEventHandler" in onScrollValue ? onScrollValue : null;
+  const onScrollCallbackIsWorklet = useMemo(
+    () => onScrollCallback ? isWorkletFunction(onScrollCallback) : false,
+    [onScrollCallback]
+  );
   const scrollHandler = useAnimatedScrollHandler(
     (event) => {
-      if (mode.get() !== "running" || didInteractive.get()) {
+      if (animationMode.get() !== "running" || didInteractive.get()) {
         scrollOffsetY.set(event.contentOffset[horizontal ? "x" : "y"]);
       }
-      if (onScrollProp) {
-        runOnJS(onScrollProp)(event);
+      if (onScrollCallback) {
+        if (onScrollCallbackIsWorklet) {
+          onScrollCallback(event);
+        } else {
+          runOnJS(onScrollCallback)(event);
+        }
       }
     },
-    [onScrollProp, horizontal]
+    [horizontal, onScrollCallback, onScrollCallbackIsWorklet]
   );
+  const composedScrollHandler = useComposedEventHandler([
+    scrollHandler,
+    onScrollProcessed
+  ]);
+  const finalScrollHandler = onScrollProcessed ? composedScrollHandler : scrollHandler;
   const setScrollProcessingEnabled = useCallback(
     (enabled) => {
       var _a;
@@ -163,19 +180,39 @@ var KeyboardAvoidingLegendList = forwardRef(function KeyboardAvoidingLegendList2
   useEffect(() => {
     updateAlignItemsAtEndMinSize();
   }, [updateAlignItemsAtEndMinSize]);
+  const getEffectiveKeyboardHeightFromInset = useCallback(
+    (nextKeyboardInset) => {
+      "worklet";
+      return calculateEffectiveKeyboardHeight(
+        nextKeyboardInset,
+        contentLength.get(),
+        scrollLength.get(),
+        alignItemsAtEnd
+      );
+    },
+    [alignItemsAtEnd, contentLength, scrollLength]
+  );
+  const getEffectiveKeyboardHeightFromEvent = useCallback(
+    (eventHeight) => {
+      "worklet";
+      const nextKeyboardInset = calculateKeyboardInset(eventHeight, safeAreaInsetBottom);
+      return getEffectiveKeyboardHeightFromInset(nextKeyboardInset);
+    },
+    [getEffectiveKeyboardHeightFromInset, safeAreaInsetBottom]
+  );
   useKeyboardHandler(
     // biome-ignore assist/source/useSortedKeys: prefer start/move/end
     {
       onStart: (event) => {
         "worklet";
-        mode.set("running");
+        animationMode.set("running");
         const progress = clampProgress(event.progress);
         if (isKeyboardOpen.get() && progress >= 1 && event.height > 0) {
           return;
         }
         if (!didInteractive.get()) {
           if (event.height > 0) {
-            keyboardHeight.set(event.height - safeAreaInsetBottom);
+            keyboardHeight.set(calculateKeyboardInset(event.height, safeAreaInsetBottom));
           }
           const vIsOpening = progress > 0;
           isOpening.set(vIsOpening);
@@ -188,15 +225,7 @@ var KeyboardAvoidingLegendList = forwardRef(function KeyboardAvoidingLegendList2
           const vScrollOffset = scrollOffsetY.get();
           scrollOffsetAtKeyboardStart.set(vScrollOffset);
           if (isIos) {
-            const vContentLength = contentLength.get();
-            const vScrollLength = scrollLength.get();
-            const vKeyboardHeight = keyboardHeight.get();
-            const vEffectiveKeyboardHeight = calculateEffectiveKeyboardHeight(
-              vKeyboardHeight,
-              vContentLength,
-              vScrollLength,
-              alignItemsAtEnd
-            );
+            const vEffectiveKeyboardHeight = getEffectiveKeyboardHeightFromInset(keyboardHeight.get());
             const targetOffset = Math.max(
               0,
               vIsOpening ? vScrollOffset + vEffectiveKeyboardHeight : vScrollOffset - vEffectiveKeyboardHeight
@@ -213,10 +242,10 @@ var KeyboardAvoidingLegendList = forwardRef(function KeyboardAvoidingLegendList2
       },
       onInteractive: (event) => {
         "worklet";
-        if (mode.get() !== "running") {
+        if (animationMode.get() !== "running") {
           runOnJS(setScrollProcessingEnabled)(false);
         }
-        mode.set("running");
+        animationMode.set("running");
         if (!didInteractive.get()) {
           didInteractive.set(true);
         }
@@ -225,13 +254,7 @@ var KeyboardAvoidingLegendList = forwardRef(function KeyboardAvoidingLegendList2
           keyboardInset.set(newInset);
         }
         if (shouldUpdateAlignItemsAtEndMinSize.get() && !horizontal && alignItemsAtEnd) {
-          const vKeyboardHeight = calculateKeyboardInset(event.height, safeAreaInsetBottom);
-          const vEffectiveKeyboardHeight = calculateEffectiveKeyboardHeight(
-            vKeyboardHeight,
-            contentLength.get(),
-            scrollLength.get(),
-            alignItemsAtEnd
-          );
+          const vEffectiveKeyboardHeight = getEffectiveKeyboardHeightFromEvent(event.height);
           runOnJS(updateAlignItemsAtEndMinSize)(vEffectiveKeyboardHeight);
         }
       },
@@ -241,13 +264,7 @@ var KeyboardAvoidingLegendList = forwardRef(function KeyboardAvoidingLegendList2
         if (isAndroid) {
           if (!didInteractive.get()) {
             const progress = clampProgress(event.progress);
-            const vKeyboardHeight = keyboardHeight.get();
-            const vEffectiveKeyboardHeight = calculateEffectiveKeyboardHeight(
-              vKeyboardHeight,
-              contentLength.get(),
-              scrollLength.get(),
-              alignItemsAtEnd
-            );
+            const vEffectiveKeyboardHeight = getEffectiveKeyboardHeightFromInset(keyboardHeight.get());
             const targetOffset = calculateKeyboardTargetOffset(
               scrollOffsetAtKeyboardStart.get(),
               vEffectiveKeyboardHeight,
@@ -263,30 +280,18 @@ var KeyboardAvoidingLegendList = forwardRef(function KeyboardAvoidingLegendList2
           }
         }
         if (!horizontal && alignItemsAtEnd && !vIsOpening && shouldUpdateAlignItemsAtEndMinSize.get()) {
-          const vKeyboardHeight = calculateKeyboardInset(event.height, safeAreaInsetBottom);
-          const vEffectiveKeyboardHeight = calculateEffectiveKeyboardHeight(
-            vKeyboardHeight,
-            contentLength.get(),
-            scrollLength.get(),
-            alignItemsAtEnd
-          );
+          const vEffectiveKeyboardHeight = getEffectiveKeyboardHeightFromEvent(event.height);
           runOnJS(updateAlignItemsAtEndMinSize)(vEffectiveKeyboardHeight);
         }
       },
       onEnd: (event) => {
         "worklet";
         const wasInteractive = didInteractive.get();
-        const vMode = mode.get();
-        mode.set("idle");
+        const vMode = animationMode.get();
+        animationMode.set("idle");
         if (vMode === "running") {
           const progress = clampProgress(event.progress);
-          const vKeyboardHeight = keyboardHeight.get();
-          const vEffectiveKeyboardHeight = calculateEffectiveKeyboardHeight(
-            vKeyboardHeight,
-            contentLength.get(),
-            scrollLength.get(),
-            alignItemsAtEnd
-          );
+          const vEffectiveKeyboardHeight = getEffectiveKeyboardHeightFromInset(keyboardHeight.get());
           const vIsOpening = isOpening.get();
           if (!wasInteractive) {
             const targetOffset = calculateKeyboardTargetOffset(
@@ -315,7 +320,18 @@ var KeyboardAvoidingLegendList = forwardRef(function KeyboardAvoidingLegendList2
         }
       }
     },
-    [alignItemsAtEnd, horizontal, safeAreaInsetBottom, scrollViewRef]
+    [
+      alignItemsAtEnd,
+      clearAlignItemsAtEndMinSize,
+      getEffectiveKeyboardHeightFromEvent,
+      getEffectiveKeyboardHeightFromInset,
+      horizontal,
+      reportContentInset,
+      safeAreaInsetBottom,
+      scrollViewRef,
+      setScrollProcessingEnabled,
+      updateAlignItemsAtEndMinSize
+    ]
   );
   const animatedProps = useAnimatedProps(() => {
     "worklet";
@@ -348,7 +364,7 @@ var KeyboardAvoidingLegendList = forwardRef(function KeyboardAvoidingLegendList2
       marginBottom: keyboardInset.get()
     }),
     [styleProp, keyboardInset]
-  ) : void 0;
+  ) : styleProp;
   const contentContainerStyle = useMemo(() => {
     if (alignItemsAtEndMinSize === void 0) {
       return contentContainerStyleProp;
@@ -365,7 +381,7 @@ var KeyboardAvoidingLegendList = forwardRef(function KeyboardAvoidingLegendList2
       contentContainerStyle,
       keyboardDismissMode: "interactive",
       onMetricsChange: handleMetricsChange,
-      onScroll: scrollHandler,
+      onScroll: finalScrollHandler,
       ref: combinedRef,
       refScrollView: scrollViewRef,
       scrollIndicatorInsets: { bottom: 0, top: 0 },
@@ -374,4 +390,4 @@ var KeyboardAvoidingLegendList = forwardRef(function KeyboardAvoidingLegendList2
   );
 });
 
-export { KeyboardAvoidingLegendList, KeyboardAvoidingLegendList as LegendList };
+export { KeyboardAvoidingLegendList };

package/{index.d.mts → list-react-native.d.ts}

@@ -1,10 +1,14 @@
 import * as React$1 from 'react';
-import { Key, ComponentProps, ReactNode, Dispatch, SetStateAction } from 'react';
-import { View, LayoutRectangle, Insets, ScrollView, ScrollViewProps, Animated, StyleProp, ViewStyle, NativeSyntheticEvent, NativeScrollEvent, ScrollViewComponent, ScrollResponderMixin } from 'react-native';
-import Reanimated from 'react-native-reanimated';
+import { Key, ReactNode, ReactElement, Dispatch, SetStateAction } from 'react';
+import { ScrollViewProps, NativeSyntheticEvent as NativeSyntheticEvent$1, NativeScrollEvent as NativeScrollEvent$1, ScrollView, StyleProp as StyleProp$1, ViewStyle as ViewStyle$1, ScrollViewComponent, ScrollResponderMixin, Insets as Insets$1, View } from 'react-native';
 
 type AnimatedValue = number;
 
+type LooseMeasureCallback = (x: number, y: number, width: number, height: number, pageX: number, pageY: number) => void;
+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">;
 type ListenerTypeValueMap = {
@@ -65,7 +69,7 @@ interface StateContext {
     positionListeners: Map<string, Set<(value: any) => void>>;
     state: InternalState;
     values: Map<ListenerType, any>;
-    viewRefs: Map<number, React$1.RefObject<View>>;
+    viewRefs: Map<number, React$1.RefObject<LooseView>>;
 }
 
 declare class ScrollAdjustHandler {
@@ -85,6 +89,62 @@ type StylesAsSharedValue<Style> = {
     [key in keyof Style]: Style[key] | BaseSharedValue<Style[key]>;
 };
 
+interface Insets {
+    top: number;
+    left: number;
+    bottom: number;
+    right: number;
+}
+interface LayoutRectangle {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+interface NativeScrollEvent {
+    contentOffset: {
+        x: number;
+        y: number;
+    };
+    contentSize: {
+        width: number;
+        height: number;
+    };
+    layoutMeasurement: {
+        width: number;
+        height: number;
+    };
+    contentInset: Insets;
+    zoomScale: number;
+}
+interface NativeSyntheticEvent<T> {
+    nativeEvent: T;
+}
+type ViewStyle = Record<string, unknown>;
+type StyleProp<T> = T | T[] | null | undefined | false;
+interface ScrollEventTargetLike {
+    addEventListener(type: string, listener: (...args: any[]) => void): void;
+    removeEventListener(type: string, listener: (...args: any[]) => void): void;
+}
+interface ScrollableNodeLike {
+    scrollLeft?: number;
+    scrollTop?: number;
+}
+interface LegendListScrollerRef {
+    flashScrollIndicators(): void;
+    getCurrentScrollOffset?(): number;
+    getScrollEventTarget(): ScrollEventTargetLike | null;
+    getScrollableNode(): ScrollableNodeLike | null;
+    getScrollResponder(): unknown;
+    scrollTo(options: {
+        animated?: boolean;
+        x?: number;
+        y?: number;
+    }): void;
+    scrollToEnd(options?: {
+        animated?: boolean;
+    }): void;
+}
 type BaseScrollViewProps<TScrollView> = Omit<TScrollView, "contentOffset" | "maintainVisibleContentPosition" | "stickyHeaderIndices" | "removeClippedSubviews" | "children" | "onScroll">;
 interface DataModeProps<ItemT, TItemType extends string | undefined> {
     /**
@@ -241,6 +301,11 @@ interface LegendListSpecificProps<ItemT, TItemType extends string | undefined> {
      * - true enables both behaviors; false disables both.
      */
     maintainVisibleContentPosition?: boolean | MaintainVisibleContentPositionConfig<ItemT>;
+    /**
+     * Web only: when true, listens to window/body scrolling instead of rendering a scrollable list container.
+     * @default false
+     */
+    useWindowScroll?: boolean;
     /**
      * Number of columns to render items in.
      * @default 1
@@ -311,7 +376,7 @@ interface LegendListSpecificProps<ItemT, TItemType extends string | undefined> {
     /**
      * Ref to the underlying ScrollView component.
      */
-    refScrollView?: React.Ref<ScrollView>;
+    refScrollView?: React.Ref<any>;
     /**
      * If true, shows a refresh indicator.
      * @default false
@@ -322,7 +387,7 @@ interface LegendListSpecificProps<ItemT, TItemType extends string | undefined> {
      * Note: When using `stickyHeaderIndices`, you must provide an Animated ScrollView component.
      * @default (props) => <ScrollView {...props} />
      */
-    renderScrollComponent?: (props: ScrollViewProps) => React.ReactElement<ScrollViewProps>;
+    renderScrollComponent?: (props: any) => React.ReactElement | null;
     /**
      * This will log a suggested estimatedItemSize.
      * @required
@@ -366,7 +431,8 @@ interface LegendListSpecificProps<ItemT, TItemType extends string | undefined> {
     getFixedItemSize?: (item: ItemT, index: number, type: TItemType) => number | undefined;
     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 Reanimated.ScrollView>, TItemType extends string | undefined = string | undefined> = BaseScrollViewProps<TScrollView> & LegendListSpecificProps<ItemT, TItemType> & (DataModeProps<ItemT, TItemType> | ChildrenModeProps);
+type LegendListPropsBase<ItemT, TScrollViewProps = Record<string, any>, TItemType extends string | undefined = string | undefined> = BaseScrollViewProps<TScrollViewProps> & LegendListSpecificProps<ItemT, TItemType> & (DataModeProps<ItemT, TItemType> | ChildrenModeProps);
+type LegendListPropsInternal = LegendListSpecificProps<any, string | undefined> & DataModeProps<any, string | undefined>;
 interface MaintainVisibleContentPositionConfig<ItemT = any> {
     data?: boolean;
     size?: boolean;
@@ -410,7 +476,6 @@ interface LegendListMetrics {
     headerSize: number;
     footerSize: number;
 }
-type LegendListProps<ItemT = any> = LegendListPropsBase<ItemT, ComponentProps<typeof ScrollView>>;
 interface ThresholdSnapshot {
     scrollPosition: number;
     contentSize?: number;
@@ -435,10 +500,11 @@ interface InternalState {
         num: number;
         avg: number;
     }>;
-    columns: Map<string, number>;
-    columnSpans: Map<string, 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;
@@ -485,12 +551,13 @@ interface InternalState {
     needsOtherAxisSize?: boolean;
     otherAxisSize?: number;
     pendingTotalSize?: number;
-    positions: Map<string, number>;
+    pendingScrollResolve?: (() => void) | undefined;
+    positions: Array<number | undefined>;
     previousData?: readonly unknown[];
     queuedCalculateItemsInView: number | undefined;
     queuedMVCPRecalculate?: number;
     queuedInitialLayout?: boolean | undefined;
-    refScroller: React.RefObject<ScrollView>;
+    refScroller: React.RefObject<LegendListScrollerRef | null>;
     scroll: number;
     scrollAdjustHandler: ScrollAdjustHandler;
     scrollForNextCalculateItemsInView: {
@@ -514,6 +581,7 @@ interface InternalState {
     startBuffered: number;
     startBufferedId?: string;
     startNoBuffer: number;
+    startReachedSnapshotDataChangeEpoch: number | undefined;
     startReachedSnapshot: ThresholdSnapshot | undefined;
     stickyContainerPool: Set<number>;
     stickyContainers: Map<number, number>;
@@ -530,7 +598,7 @@ interface InternalState {
     viewabilityConfigCallbackPairs: ViewabilityConfigCallbackPairs<any> | undefined;
     props: {
         alignItemsAtEnd: boolean;
-        animatedProps: StylesAsSharedValue<ScrollViewProps>;
+        animatedProps: StylesAsSharedValue<Record<string, any>>;
         alwaysRender: AlwaysRenderConfig | undefined;
         alwaysRenderIndicesArr: number[];
         alwaysRenderIndicesSet: Set<number>;
@@ -539,34 +607,38 @@ interface InternalState {
         dataVersion: Key | undefined;
         drawDistance: number;
         estimatedItemSize: number | undefined;
-        getEstimatedItemSize: LegendListProps["getEstimatedItemSize"];
-        getFixedItemSize: LegendListProps["getFixedItemSize"];
-        getItemType: LegendListProps["getItemType"];
+        getEstimatedItemSize: LegendListPropsInternal["getEstimatedItemSize"];
+        getFixedItemSize: LegendListPropsInternal["getFixedItemSize"];
+        getItemType: LegendListPropsInternal["getItemType"];
         horizontal: boolean;
         initialContainerPoolRatio: number;
-        itemsAreEqual: LegendListProps["itemsAreEqual"];
-        keyExtractor: LegendListProps["keyExtractor"];
+        itemsAreEqual: LegendListPropsInternal["itemsAreEqual"];
+        keyExtractor: LegendListPropsInternal["keyExtractor"];
         maintainScrollAtEnd: boolean | MaintainScrollAtEndOptions;
         maintainScrollAtEndThreshold: number | undefined;
         maintainVisibleContentPosition: MaintainVisibleContentPositionNormalized;
         numColumns: number;
-        onEndReached: LegendListProps["onEndReached"];
+        onEndReached: LegendListPropsInternal["onEndReached"];
         onEndReachedThreshold: number | null | undefined;
-        onItemSizeChanged: LegendListProps["onItemSizeChanged"];
-        onLoad: LegendListProps["onLoad"];
-        onScroll: LegendListProps["onScroll"];
-        onStartReached: LegendListProps["onStartReached"];
+        onItemSizeChanged: LegendListPropsInternal["onItemSizeChanged"];
+        onLoad: LegendListPropsInternal["onLoad"];
+        onScroll: LegendListPropsInternal["onScroll"];
+        onStartReached: LegendListPropsInternal["onStartReached"];
         onStartReachedThreshold: number | null | undefined;
-        onStickyHeaderChange: LegendListProps["onStickyHeaderChange"];
-        overrideItemLayout: LegendListProps["overrideItemLayout"];
+        onStickyHeaderChange: LegendListPropsInternal["onStickyHeaderChange"];
+        overrideItemLayout: LegendListPropsInternal["overrideItemLayout"];
         recycleItems: boolean;
-        renderItem: LegendListProps["renderItem"];
+        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<T> {
@@ -583,11 +655,11 @@ interface LegendListRenderItemProps<ItemT, TItemType extends string | number | u
     item: ItemT;
     type: TItemType;
 }
-type LegendListState = {
+type LegendListState$1 = {
     activeStickyIndex: number;
     contentLength: number;
     data: readonly any[];
-    elementAtIndex: (index: number) => View | null | undefined;
+    elementAtIndex: (index: number) => any;
     end: number;
     endBuffered: number;
     isAtEnd: boolean;
@@ -595,7 +667,7 @@ type LegendListState = {
     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>;
+    positionByKey: (key: string) => number | undefined;
     scroll: number;
     scrollLength: number;
     scrollVelocity: number;
@@ -604,7 +676,7 @@ type LegendListState = {
     start: number;
     startBuffered: number;
 };
-type LegendListRef = {
+type LegendListRef$1 = {
     /**
      * Displays the scroll indicators momentarily.
      */
@@ -612,7 +684,7 @@ type LegendListRef = {
     /**
      * Returns the native ScrollView component reference.
      */
-    getNativeScrollRef(): React.ElementRef<typeof ScrollViewComponent>;
+    getNativeScrollRef(): any;
     /**
      * Returns the scroll responder instance for handling scroll events.
      */
@@ -620,11 +692,11 @@ type LegendListRef = {
     /**
      * Returns the ScrollResponderMixin for advanced scroll handling.
      */
-    getScrollResponder(): ScrollResponderMixin;
+    getScrollResponder(): any;
     /**
      * Returns the internal state of the scroll virtualization.
      */
-    getState(): LegendListState;
+    getState(): LegendListState$1;
     /**
      * Scrolls a specific index into view.
      * @param params - Parameters for scrolling.
@@ -634,7 +706,7 @@ type LegendListRef = {
     scrollIndexIntoView(params: {
         animated?: boolean | undefined;
         index: number;
-    }): void;
+    }): Promise<void>;
     /**
      * Scrolls a specific index into view.
      * @param params - Parameters for scrolling.
@@ -644,7 +716,7 @@ type LegendListRef = {
     scrollItemIntoView(params: {
         animated?: boolean | undefined;
         item: any;
-    }): void;
+    }): Promise<void>;
     /**
      * Scrolls to the end of the list.
      * @param options - Options for scrolling.
@@ -654,7 +726,7 @@ type LegendListRef = {
     scrollToEnd(options?: {
         animated?: boolean | undefined;
         viewOffset?: number | undefined;
-    }): void;
+    }): Promise<void>;
     /**
      * Scrolls to a specific index in the list.
      * @param params - Parameters for scrolling.
@@ -668,7 +740,7 @@ type LegendListRef = {
         index: number;
         viewOffset?: number | undefined;
         viewPosition?: number | undefined;
-    }): void;
+    }): Promise<void>;
     /**
      * Scrolls to a specific item in the list.
      * @param params - Parameters for scrolling.
@@ -682,7 +754,7 @@ type LegendListRef = {
         item: any;
         viewOffset?: number | undefined;
         viewPosition?: number | undefined;
-    }): void;
+    }): Promise<void>;
     /**
      * Scrolls to a specific offset in pixels.
      * @param params - Parameters for scrolling.
@@ -692,7 +764,7 @@ type LegendListRef = {
     scrollToOffset(params: {
         offset: number;
         animated?: boolean | undefined;
-    }): void;
+    }): Promise<void>;
     /**
      * Sets or adds to the offset of the visible content anchor.
      * @param value - The offset to set or add.
@@ -704,6 +776,14 @@ type LegendListRef = {
      * @param enabled - If true, scroll processing is enabled.
      */
     setScrollProcessingEnabled(enabled: boolean): void;
+    /**
+     * Clears internal virtualization caches.
+     * @param options - Cache clearing options.
+     * @param options.mode - `sizes` clears measurement caches. `full` also clears key/position caches.
+     */
+    clearCaches(options?: {
+        mode?: "sizes" | "full";
+    }): void;
     /**
      * Reports an externally measured content inset. Pass null/undefined to clear.
      * Values are merged on top of props/animated/native insets.
@@ -799,9 +879,23 @@ type GetRenderedItemResult<ItemT> = {
 };
 type GetRenderedItem = (key: string) => GetRenderedItemResult<any> | null;
 
-declare const LegendList: (<T>(props: LegendListProps<T> & React$1.RefAttributes<LegendListRef>) => React$1.ReactNode) & {
-    displayName?: string;
+type LegendListPropsOverrides<ItemT, TItemType extends string | undefined> = Omit<LegendListPropsBase<ItemT, ScrollViewProps, TItemType>, "onScroll" | "refScrollView" | "renderScrollComponent" | "ListHeaderComponentStyle" | "ListFooterComponentStyle"> & {
+    onScroll?: (event: NativeSyntheticEvent$1<NativeScrollEvent$1>) => void;
+    refScrollView?: React.Ref<ScrollView>;
+    renderScrollComponent?: (props: ScrollViewProps) => ReactElement<ScrollViewProps>;
+    ListHeaderComponentStyle?: StyleProp$1<ViewStyle$1> | undefined;
+    ListFooterComponentStyle?: StyleProp$1<ViewStyle$1> | undefined;
 };
+type LegendListProps<ItemT = any, TItemType extends string | undefined = string | undefined> = LegendListPropsOverrides<ItemT, TItemType>;
+type LegendListRef = Omit<LegendListRef$1, "getNativeScrollRef" | "getScrollResponder" | "reportContentInset"> & {
+    getNativeScrollRef(): React.ElementRef<typeof ScrollViewComponent>;
+    getScrollResponder(): ScrollResponderMixin;
+    reportContentInset(inset?: Partial<Insets$1> | null): void;
+};
+type LegendListState = Omit<LegendListState$1, "elementAtIndex"> & {
+    elementAtIndex: (index: number) => View | null | undefined;
+};
+type LegendListComponent = <ItemT = any>(props: LegendListProps<ItemT> & React.RefAttributes<LegendListRef>) => React.ReactElement | null;
 
 declare function useViewability<ItemT = any>(callback: ViewabilityCallback<ItemT>, configId?: string): void;
 declare function useViewabilityAmount<ItemT = any>(callback: ViewabilityAmountCallback<ItemT>): void;
@@ -814,4 +908,6 @@ declare function useListScrollSize(): {
 };
 declare function useSyncLayout(): () => void;
 
-export { type AlwaysRenderConfig, type ColumnWrapperStyle, type GetRenderedItem, type GetRenderedItemResult, type InitialScrollAnchor, type InternalState, LegendList, type LegendListMetrics, type LegendListProps, type LegendListPropsBase, type LegendListRecyclingState, type LegendListRef, type LegendListRenderItemProps, type LegendListState, type MaintainScrollAtEndOptions, type MaintainVisibleContentPositionConfig, type MaintainVisibleContentPositionNormalized, type OnViewableItemsChanged, type ScrollIndexWithOffset, type ScrollIndexWithOffsetAndContentOffset, type ScrollIndexWithOffsetPosition, type ScrollTarget, type StickyHeaderConfig, type ThresholdSnapshot, 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 };
+declare const LegendList: LegendListComponent;
+
+export { type AlwaysRenderConfig, type BaseScrollViewProps, type ColumnWrapperStyle, type GetRenderedItem, type GetRenderedItemResult, type InitialScrollAnchor, type Insets, type InternalState, type LayoutRectangle, LegendList, type LegendListComponent, type LegendListMetrics, type LegendListProps, type LegendListPropsBase, type LegendListRecyclingState, type LegendListRef, type LegendListRenderItemProps, type LegendListScrollerRef, type LegendListState, type MaintainScrollAtEndOptions, type MaintainVisibleContentPositionConfig, type MaintainVisibleContentPositionNormalized, type NativeScrollEvent, type NativeSyntheticEvent, type OnViewableItemsChanged, type ScrollEventTargetLike, type ScrollIndexWithOffset, type ScrollIndexWithOffsetAndContentOffset, type ScrollIndexWithOffsetPosition, type ScrollTarget, 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 };