@legendapp/list 3.0.0-beta.36 → 3.0.0-beta.38

package/index.native.mjs

@@ -1,6 +1,7 @@
 import * as React2 from 'react';
-import React2__default, { useReducer, useEffect, createContext, useRef, useState, useMemo, useCallback, useLayoutEffect, useImperativeHandle, memo, forwardRef, useContext } from 'react';
-import { Animated, View as View$1, Text as Text$1, Platform, StyleSheet as StyleSheet$1, RefreshControl, Dimensions, unstable_batchedUpdates } from 'react-native';
+import React2__default, { useReducer, useEffect, createContext, useRef, useState, useMemo, useCallback, useLayoutEffect, useImperativeHandle, useContext } from 'react';
+import * as ReactNative from 'react-native';
+import { Animated, View as View$1, Text as Text$1, Platform, StyleSheet as StyleSheet$1, RefreshControl, Dimensions } from 'react-native';
 import { useSyncExternalStore } from 'use-sync-external-store/shim';
 
 // src/components/LegendList.tsx
@@ -320,7 +321,7 @@ function useValue$(key, params) {
   }, []);
   return animValue;
 }
-var typedMemo = memo;
+var typedMemo = React2.memo;
 var getComponent = (Component) => {
   if (React2.isValidElement(Component)) {
     return Component;
@@ -612,8 +613,8 @@ function useOnLayoutSync({
 }
 var Platform2 = Platform;
 var PlatformAdjustBreaksScroll = Platform2.OS === "android";
-var typedForwardRef = forwardRef;
-var typedMemo2 = memo;
+var typedForwardRef = React2.forwardRef;
+var typedMemo2 = React2.memo;
 
 // src/utils/isInMVCPActiveMode.native.ts
 function isInMVCPActiveMode(state) {
@@ -891,7 +892,7 @@ function SnapWrapper({ ScrollComponent, ...props }) {
   return /* @__PURE__ */ React2.createElement(ScrollComponent, { ...props, snapToOffsets });
 }
 var LayoutView = ({ onLayoutChange, refView, ...rest }) => {
-  const ref = refView != null ? refView : useRef();
+  const ref = refView != null ? refView : useRef(null);
   const { onLayout } = useOnLayoutSync({ onLayoutChange, ref });
   return /* @__PURE__ */ React2.createElement(View$1, { ...rest, onLayout, ref });
 };
@@ -918,8 +919,8 @@ var ListComponent = typedMemo2(function ListComponent2({
   updateItemSize: updateItemSize2,
   refScrollView,
   renderScrollComponent,
+  onLayoutFooter,
   scrollAdjustHandler,
-  onLayoutHeader,
   snapToIndices,
   stickyHeaderConfig,
   stickyHeaderIndices,
@@ -943,6 +944,21 @@ var ListComponent = typedMemo2(function ListComponent2({
       set$(ctx, "footerSize", 0);
     }
   }, [ListHeaderComponent, ListFooterComponent, ctx]);
+  const onLayoutHeader = useCallback(
+    (rect) => {
+      const size = rect[horizontal ? "width" : "height"];
+      set$(ctx, "headerSize", size);
+    },
+    [ctx, horizontal]
+  );
+  const onLayoutFooterInternal = useCallback(
+    (rect, fromLayoutEffect) => {
+      const size = rect[horizontal ? "width" : "height"];
+      set$(ctx, "footerSize", size);
+      onLayoutFooter == null ? void 0 : onLayoutFooter(rect, fromLayoutEffect);
+    },
+    [ctx, horizontal, onLayoutFooter]
+  );
   return /* @__PURE__ */ React2.createElement(
     SnapOrScroll,
     {
@@ -978,17 +994,7 @@ var ListComponent = typedMemo2(function ListComponent2({
         waitForInitialLayout
       }
     ),
-    ListFooterComponent && /* @__PURE__ */ React2.createElement(
-      LayoutView,
-      {
-        onLayoutChange: (layout) => {
-          const size = layout[horizontal ? "width" : "height"];
-          set$(ctx, "footerSize", size);
-        },
-        style: ListFooterComponentStyle
-      },
-      getComponent(ListFooterComponent)
-    ),
+    ListFooterComponent && /* @__PURE__ */ React2.createElement(LayoutView, { onLayoutChange: onLayoutFooterInternal, style: ListFooterComponentStyle }, getComponent(ListFooterComponent)),
     IS_DEV && ENABLE_DEVMODE
   );
 });
@@ -996,19 +1002,12 @@ var ListComponent = typedMemo2(function ListComponent2({
 // src/core/calculateOffsetForIndex.ts
 function calculateOffsetForIndex(ctx, index) {
   const state = ctx.state;
-  let position = 0;
-  if (index !== void 0) {
-    position = state.positions[index] || 0;
-    const paddingTop = peek$(ctx, "stylePaddingTop");
-    if (paddingTop) {
-      position += paddingTop;
-    }
-    const headerSize = peek$(ctx, "headerSize");
-    if (headerSize) {
-      position += headerSize;
-    }
-  }
-  return position;
+  return index !== void 0 ? state.positions[index] || 0 : 0;
+}
+
+// src/core/getTopOffsetAdjustment.ts
+function getTopOffsetAdjustment(ctx) {
+  return (peek$(ctx, "stylePaddingTop") || 0) + (peek$(ctx, "headerSize") || 0);
 }
 
 // src/utils/getId.ts
@@ -1116,10 +1115,20 @@ function calculateOffsetWithOffsetPosition(ctx, offsetParam, params) {
   if (viewOffset) {
     offset -= viewOffset;
   }
+  if (index !== void 0) {
+    const topOffsetAdjustment = getTopOffsetAdjustment(ctx);
+    if (topOffsetAdjustment) {
+      offset += topOffsetAdjustment;
+    }
+  }
   if (viewPosition !== void 0 && index !== void 0) {
     const itemSize = getItemSize(ctx, getId(state, index), index, state.props.data[index]);
     const trailingInset = getContentInsetEnd(state);
     offset -= viewPosition * (state.scrollLength - trailingInset - itemSize);
+    if (index === state.props.data.length - 1) {
+      const footerSize = peek$(ctx, "footerSize") || 0;
+      offset += footerSize;
+    }
   }
   return offset;
 }
@@ -1573,7 +1582,8 @@ function ensureInitialAnchor(ctx) {
     return;
   }
   const availableSpace = Math.max(0, scrollLength - size);
-  const desiredOffset = calculateOffsetForIndex(ctx, anchor.index) - ((_a3 = anchor.viewOffset) != null ? _a3 : 0) - ((_b = anchor.viewPosition) != null ? _b : 0) * availableSpace;
+  const topOffsetAdjustment = getTopOffsetAdjustment(ctx);
+  const desiredOffset = calculateOffsetForIndex(ctx, anchor.index) + topOffsetAdjustment - ((_a3 = anchor.viewOffset) != null ? _a3 : 0) - ((_b = anchor.viewPosition) != null ? _b : 0) * availableSpace;
   const clampedDesiredOffset = clampScrollOffset(ctx, desiredOffset, anchor);
   const delta = clampedDesiredOffset - scroll;
   if (Math.abs(delta) <= INITIAL_ANCHOR_TOLERANCE) {
@@ -2290,6 +2300,8 @@ function maybeUpdateViewabilityCallback(ctx, configId, containerId, viewToken) {
   const cb = ctx.mapViewabilityCallbacks.get(key);
   cb == null ? void 0 : cb(viewToken);
 }
+var unstableBatchedUpdates = ReactNative.unstable_batchedUpdates;
+var batchedUpdates = typeof unstableBatchedUpdates === "function" ? unstableBatchedUpdates : (fn) => fn();
 
 // src/utils/checkAllSizesKnown.ts
 function isNullOrUndefined2(value) {
@@ -2542,7 +2554,7 @@ function handleStickyRecycling(ctx, stickyArray, scroll, drawDistance, currentSt
 }
 function calculateItemsInView(ctx, params = {}) {
   const state = ctx.state;
-  unstable_batchedUpdates(() => {
+  batchedUpdates(() => {
     var _a3, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
     const {
       columns,
@@ -3481,20 +3493,69 @@ function createColumnWrapperStyle(contentContainerStyle) {
   }
 }
 
+// src/utils/hasActiveMVCPAnchorLock.ts
+function hasActiveMVCPAnchorLock(state) {
+  const lock = state.mvcpAnchorLock;
+  if (!lock) {
+    return false;
+  }
+  if (Date.now() > lock.expiresAt) {
+    state.mvcpAnchorLock = void 0;
+    return false;
+  }
+  return true;
+}
+
 // src/utils/createImperativeHandle.ts
 function createImperativeHandle(ctx) {
   const state = ctx.state;
+  const IMPERATIVE_SCROLL_SETTLE_MAX_WAIT_MS = 800;
+  const IMPERATIVE_SCROLL_SETTLE_STABLE_FRAMES = 2;
+  let imperativeScrollToken = 0;
+  const isSettlingAfterDataChange = () => !!state.didDataChange || !!state.didColumnsChange || state.queuedMVCPRecalculate !== void 0 || state.ignoreScrollFromMVCP !== void 0 || hasActiveMVCPAnchorLock(state);
+  const runWhenSettled = (token, run) => {
+    const startedAt = Date.now();
+    let stableFrames = 0;
+    const check = () => {
+      if (token !== imperativeScrollToken) {
+        return;
+      }
+      if (isSettlingAfterDataChange()) {
+        stableFrames = 0;
+      } else {
+        stableFrames += 1;
+      }
+      const timedOut = Date.now() - startedAt >= IMPERATIVE_SCROLL_SETTLE_MAX_WAIT_MS;
+      if (stableFrames >= IMPERATIVE_SCROLL_SETTLE_STABLE_FRAMES || timedOut) {
+        run();
+        return;
+      }
+      requestAnimationFrame(check);
+    };
+    requestAnimationFrame(check);
+  };
   const runScrollWithPromise = (run) => new Promise((resolve) => {
     var _a3;
+    const token = ++imperativeScrollToken;
     (_a3 = state.pendingScrollResolve) == null ? void 0 : _a3.call(state);
     state.pendingScrollResolve = resolve;
-    const didStartScroll = run();
-    if (!didStartScroll || !state.scrollingTo) {
-      if (state.pendingScrollResolve === resolve) {
-        state.pendingScrollResolve = void 0;
+    const runNow = () => {
+      if (token !== imperativeScrollToken) {
+        return;
+      }
+      const didStartScroll = run();
+      if (!didStartScroll || !state.scrollingTo) {
+        if (state.pendingScrollResolve === resolve) {
+          state.pendingScrollResolve = void 0;
+        }
+        resolve();
       }
-      resolve();
+    };
+    if (isSettlingAfterDataChange()) {
+      runWhenSettled(token, runNow);
+      return;
     }
+    runNow();
   });
   const scrollIndexIntoView = (options) => {
     if (state) {
@@ -3804,7 +3865,7 @@ var LegendList = typedMemo2(
   })
 );
 var LegendListInner = typedForwardRef(function LegendListInner2(props, forwardedRef) {
-  var _a3, _b, _c, _d;
+  var _a3, _b, _c, _d, _e;
   const {
     alignItemsAtEnd = false,
     alwaysRender,
@@ -3893,7 +3954,6 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
   const maintainVisibleContentPositionConfig = normalizeMaintainVisibleContentPosition(
     maintainVisibleContentPositionProp
   );
-  const [renderNum, setRenderNum] = useState(0);
   const initialScrollProp = initialScrollAtEnd ? { index: Math.max(0, dataProp.length - 1), viewOffset: -stylePaddingBottomState, viewPosition: 1 } : initialScrollIndexProp || initialScrollOffsetProp ? typeof initialScrollIndexProp === "object" ? {
     index: initialScrollIndexProp.index || 0,
     viewOffset: initialScrollIndexProp.viewOffset || (initialScrollIndexProp.viewPosition === 1 ? -stylePaddingBottomState : 0),
@@ -3934,7 +3994,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     );
   }
   const useWindowScrollResolved = Platform2.OS === "web" && !!useWindowScroll && !renderScrollComponent;
-  const refState = useRef();
+  const refState = useRef(void 0);
   const hasOverrideItemLayout = !!overrideItemLayout;
   const prevHasOverrideItemLayout = useRef(hasOverrideItemLayout);
   if (!refState.current) {
@@ -4098,6 +4158,11 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       true
     );
   }
+  const resolveInitialScrollOffset = useCallback((initialScroll) => {
+    const baseOffset = initialScroll.index !== void 0 ? calculateOffsetForIndex(ctx, initialScroll.index) : 0;
+    const resolvedOffset = calculateOffsetWithOffsetPosition(ctx, baseOffset, initialScroll);
+    return clampScrollOffset(ctx, resolvedOffset, initialScroll);
+  }, []);
   const initialContentOffset = useMemo(() => {
     var _a4;
     let value;
@@ -4115,9 +4180,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       if (initialScroll.contentOffset !== void 0) {
         value = initialScroll.contentOffset;
       } else {
-        const baseOffset = initialScroll.index !== void 0 ? calculateOffsetForIndex(ctx, initialScroll.index) : 0;
-        const resolvedOffset = calculateOffsetWithOffsetPosition(ctx, baseOffset, initialScroll);
-        const clampedOffset = clampScrollOffset(ctx, resolvedOffset, initialScroll);
+        const clampedOffset = resolveInitialScrollOffset(initialScroll);
         const updatedInitialScroll = { ...initialScroll, contentOffset: clampedOffset };
         refState.current.initialScroll = updatedInitialScroll;
         state.initialScroll = updatedInitialScroll;
@@ -4131,7 +4194,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       setInitialRenderState(ctx, { didInitialScroll: true });
     }
     return value;
-  }, [renderNum]);
+  }, []);
   if (isFirstLocal || didDataChangeLocal || numColumnsProp !== peek$(ctx, "numColumns")) {
     refState.current.lastBatchingAction = Date.now();
     if (!keyExtractorProp && !isFirstLocal && didDataChangeLocal) {
@@ -4145,32 +4208,45 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       set$(ctx, "totalSize", 0);
     }
   }
-  const onLayoutHeader = useCallback((rect, fromLayoutEffect) => {
-    const { initialScroll } = refState.current;
-    const size = rect[horizontal ? "width" : "height"];
-    set$(ctx, "headerSize", size);
-    if ((initialScroll == null ? void 0 : initialScroll.index) !== void 0) {
-      if (IsNewArchitecture && Platform2.OS !== "android") {
-        if (fromLayoutEffect) {
-          setRenderNum((v) => v + 1);
-        }
-      } else {
-        setTimeout(doInitialScroll, 17);
-      }
-    }
-  }, []);
   const doInitialScroll = useCallback(() => {
     const { initialScroll, didFinishInitialScroll, queuedInitialLayout, scrollingTo } = state;
     if (initialScroll && !queuedInitialLayout && !didFinishInitialScroll && !scrollingTo) {
+      const offset = resolveInitialScrollOffset(initialScroll);
+      const updatedInitialScroll = { ...initialScroll, contentOffset: offset };
+      refState.current.initialScroll = updatedInitialScroll;
+      state.initialScroll = updatedInitialScroll;
       scrollTo(ctx, {
         animated: false,
-        index: initialScroll == null ? void 0 : initialScroll.index,
+        index: initialScroll.index,
         isInitialScroll: true,
-        offset: initialContentOffset,
+        offset,
         precomputedWithViewOffset: true
       });
     }
-  }, [initialContentOffset]);
+  }, []);
+  const onLayoutFooter = useCallback(
+    (layout) => {
+      if (!initialScrollAtEnd) {
+        return;
+      }
+      const { initialScroll } = state;
+      if (!initialScroll) {
+        return;
+      }
+      const lastIndex = Math.max(0, dataProp.length - 1);
+      if (initialScroll.index !== lastIndex || initialScroll.viewPosition !== 1) {
+        return;
+      }
+      const footerSize = layout[horizontal ? "width" : "height"];
+      const viewOffset = -stylePaddingBottomState - footerSize;
+      if (initialScroll.viewOffset !== viewOffset) {
+        const updatedInitialScroll = { ...initialScroll, viewOffset };
+        refState.current.initialScroll = updatedInitialScroll;
+        state.initialScroll = updatedInitialScroll;
+      }
+    },
+    [dataProp.length, horizontal, initialScrollAtEnd, stylePaddingBottomState]
+  );
   const onLayoutChange = useCallback((layout) => {
     doInitialScroll();
     handleLayout(ctx, layout, setCanRender);
@@ -4270,6 +4346,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     []
   );
   const onScrollHandler = useStickyScrollHandler(stickyHeaderIndices, horizontal, ctx, fns.onScroll);
+  const refreshControlElement = refreshControl;
   return /* @__PURE__ */ React2.createElement(React2.Fragment, null, /* @__PURE__ */ React2.createElement(
     ListComponent,
     {
@@ -4284,13 +4361,13 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       ListEmptyComponent: dataProp.length === 0 ? ListEmptyComponent : void 0,
       ListHeaderComponent,
       onLayout,
-      onLayoutHeader,
+      onLayoutFooter,
       onMomentumScrollEnd: fns.onMomentumScrollEnd,
       onScroll: onScrollHandler,
       recycleItems,
-      refreshControl: refreshControl ? stylePaddingTopState > 0 ? React2.cloneElement(refreshControl, {
-        progressViewOffset: (refreshControl.props.progressViewOffset || 0) + stylePaddingTopState
-      }) : refreshControl : onRefresh && /* @__PURE__ */ React2.createElement(
+      refreshControl: refreshControlElement ? stylePaddingTopState > 0 ? React2.cloneElement(refreshControlElement, {
+        progressViewOffset: ((_d = refreshControlElement.props.progressViewOffset) != null ? _d : 0) + stylePaddingTopState
+      }) : refreshControlElement : onRefresh && /* @__PURE__ */ React2.createElement(
         RefreshControl,
         {
           onRefresh,
@@ -4300,7 +4377,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       ),
       refScrollView: combinedRef,
       renderScrollComponent,
-      scrollAdjustHandler: (_d = refState.current) == null ? void 0 : _d.scrollAdjustHandler,
+      scrollAdjustHandler: (_e = refState.current) == null ? void 0 : _e.scrollAdjustHandler,
       scrollEventThrottle: 0,
       snapToIndices,
       stickyHeaderIndices,

package/keyboard-test.d.ts

@@ -0,0 +1,204 @@
+import * as React from 'react';
+import { ScrollViewComponent, ScrollResponderMixin, Insets as Insets$1, ScrollViewProps } from 'react-native';
+import { KeyboardChatScrollViewProps } from 'react-native-keyboard-controller';
+import { AnimatedLegendListProps } from '@legendapp/list/reanimated';
+
+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 = {
+    activeStickyIndex: number;
+    animatedScrollY: any;
+    debugComputedScroll: number;
+    debugRawScroll: number;
+    extraData: any;
+    footerSize: number;
+    headerSize: number;
+    lastItemKeys: string[];
+    lastPositionUpdate: number;
+    maintainVisibleContentPosition: MaintainVisibleContentPositionNormalized;
+    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 `containerSpan${number}` ? K : never]: number;
+} & {
+    [K in ListenerType as K extends `containerSticky${number}` ? K : never]: boolean;
+};
+
+interface Insets {
+    top: number;
+    left: number;
+    bottom: number;
+    right: number;
+}
+interface MaintainVisibleContentPositionNormalized<ItemT = any> {
+    data: boolean;
+    size: boolean;
+    shouldRestorePosition?: (item: ItemT, index: number, data: readonly ItemT[]) => boolean;
+}
+type LegendListState = {
+    activeStickyIndex: number;
+    contentLength: number;
+    data: readonly any[];
+    elementAtIndex: (index: number) => any;
+    end: number;
+    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;
+    positionByKey: (key: string) => number | undefined;
+    scroll: number;
+    scrollLength: number;
+    scrollVelocity: number;
+    sizeAtIndex: (index: number) => number;
+    sizes: Map<string, number>;
+    start: number;
+    startBuffered: number;
+};
+type LegendListRef$1 = {
+    /**
+     * Displays the scroll indicators momentarily.
+     */
+    flashScrollIndicators(): void;
+    /**
+     * Returns the native ScrollView component reference.
+     */
+    getNativeScrollRef(): any;
+    /**
+     * Returns the scroll responder instance for handling scroll events.
+     */
+    getScrollableNode(): any;
+    /**
+     * Returns the ScrollResponderMixin for advanced scroll handling.
+     */
+    getScrollResponder(): any;
+    /**
+     * Returns the internal state of the scroll virtualization.
+     */
+    getState(): LegendListState;
+    /**
+     * Scrolls a specific index into view.
+     * @param params - Parameters for scrolling.
+     * @param params.animated - If true, animates the scroll. Default: true.
+     * @param params.index - The index to scroll to.
+     */
+    scrollIndexIntoView(params: {
+        animated?: boolean | undefined;
+        index: number;
+    }): Promise<void>;
+    /**
+     * Scrolls a specific index into view.
+     * @param params - Parameters for scrolling.
+     * @param params.animated - If true, animates the scroll. Default: true.
+     * @param params.item - The item to scroll to.
+     */
+    scrollItemIntoView(params: {
+        animated?: boolean | undefined;
+        item: any;
+    }): Promise<void>;
+    /**
+     * 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;
+    }): Promise<void>;
+    /**
+     * Scrolls to a specific index in the list.
+     * @param params - Parameters for scrolling.
+     * @param params.animated - If true, animates the scroll. Default: true.
+     * @param params.index - The index to scroll to.
+     * @param params.viewOffset - Offset from the target position.
+     * @param params.viewPosition - Position of the item in the viewport (0 to 1).
+     */
+    scrollToIndex(params: {
+        animated?: boolean | undefined;
+        index: number;
+        viewOffset?: number | undefined;
+        viewPosition?: number | undefined;
+    }): Promise<void>;
+    /**
+     * Scrolls to a specific item in the list.
+     * @param params - Parameters for scrolling.
+     * @param params.animated - If true, animates the scroll. Default: true.
+     * @param params.item - The item to scroll to.
+     * @param params.viewOffset - Offset from the target position.
+     * @param params.viewPosition - Position of the item in the viewport (0 to 1).
+     */
+    scrollToItem(params: {
+        animated?: boolean | undefined;
+        item: any;
+        viewOffset?: number | undefined;
+        viewPosition?: number | undefined;
+    }): Promise<void>;
+    /**
+     * Scrolls to a specific offset in pixels.
+     * @param params - Parameters for scrolling.
+     * @param params.offset - The pixel offset to scroll to.
+     * @param params.animated - If true, animates the scroll. Default: true.
+     */
+    scrollToOffset(params: {
+        offset: number;
+        animated?: boolean | undefined;
+    }): Promise<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 | ((val: number) => number)): void;
+    /**
+     * Sets whether scroll processing is enabled.
+     * @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.
+     */
+    reportContentInset(inset?: Partial<Insets> | null): void;
+};
+
+type LegendListRef = Omit<LegendListRef$1, "getNativeScrollRef" | "getScrollResponder" | "reportContentInset"> & {
+    getNativeScrollRef(): React.ElementRef<typeof ScrollViewComponent>;
+    getScrollResponder(): ScrollResponderMixin;
+    reportContentInset(inset?: Partial<Insets$1> | null): void;
+};
+
+type KeyboardChatScrollViewPropsUnique = Omit<KeyboardChatScrollViewProps, keyof ScrollViewProps | "inverted" | "ScrollViewComponent">;
+declare const KeyboardAvoidingLegendList: <ItemT>(props: Omit<AnimatedLegendListProps<ItemT>, "renderScrollComponent"> & KeyboardChatScrollViewPropsUnique & React.RefAttributes<LegendListRef>) => React.ReactNode;
+
+export { KeyboardAvoidingLegendList };

package/keyboard-test.js

@@ -0,0 +1,34 @@
+'use strict';
+
+var React = require('react');
+var reactNativeKeyboardController = require('react-native-keyboard-controller');
+var reanimated = require('@legendapp/list/reanimated');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespace(React);
+
+// src/integrations/keyboard-test.tsx
+var typedForwardRef = React.forwardRef;
+var KeyboardAvoidingLegendList = typedForwardRef(function KeyboardAvoidingLegendList2(props, forwardedRef) {
+  const memoList = React.useCallback((listProps) => /* @__PURE__ */ React__namespace.createElement(reactNativeKeyboardController.KeyboardChatScrollView, { ...listProps }), []);
+  return /* @__PURE__ */ React__namespace.createElement(reanimated.AnimatedLegendList, { ref: forwardedRef, renderScrollComponent: memoList, ...props });
+});
+
+exports.KeyboardAvoidingLegendList = KeyboardAvoidingLegendList;

package/keyboard-test.mjs

@@ -0,0 +1,13 @@
+import * as React from 'react';
+import { useCallback, forwardRef } from 'react';
+import { KeyboardChatScrollView } from 'react-native-keyboard-controller';
+import { AnimatedLegendList } from '@legendapp/list/reanimated';
+
+// src/integrations/keyboard-test.tsx
+var typedForwardRef = forwardRef;
+var KeyboardAvoidingLegendList = typedForwardRef(function KeyboardAvoidingLegendList2(props, forwardedRef) {
+  const memoList = useCallback((listProps) => /* @__PURE__ */ React.createElement(KeyboardChatScrollView, { ...listProps }), []);
+  return /* @__PURE__ */ React.createElement(AnimatedLegendList, { ref: forwardedRef, renderScrollComponent: memoList, ...props });
+});
+
+export { KeyboardAvoidingLegendList };

package/keyboard.d.ts

@@ -1,4 +1,4 @@
-import * as React$1 from 'react';
+import * as React from 'react';
 import { ScrollViewComponent, ScrollResponderMixin, Insets as Insets$1 } from 'react-native';
 import { ScrollEvent, ScrollHandlerProcessed } from 'react-native-reanimated';
 import { AnimatedLegendListProps } from '@legendapp/list/reanimated';
@@ -204,6 +204,6 @@ declare const KeyboardAvoidingLegendList: <ItemT>(props: Omit<AnimatedLegendList
     onScroll?: KeyboardOnScrollHandler;
     contentInset?: Insets$1 | undefined;
     safeAreaInsetBottom?: number;
-} & React$1.RefAttributes<LegendListRef>) => React$1.ReactNode;
+} & React.RefAttributes<LegendListRef>) => React.ReactElement | null;
 
 export { KeyboardAvoidingLegendList };