@react-native-ohos/flash-list 1.8.3 → 2.1.1-rc.1

package/dist/recyclerview/hooks/useMappingHelper.js

@@ -0,0 +1,15 @@
+import { useCallback } from "react";
+import { useRecyclerViewContext } from "../RecyclerViewContextProvider";
+/**
+ * Returns a function that can help create a mapping key for the items.
+ * Useful when doing .map on items to create a list of components.
+ * Using this ensures that performance is optimal for FlashList
+ */
+export const useMappingHelper = () => {
+    const recyclerViewContext = useRecyclerViewContext();
+    const getMappingKey = useCallback((itemKey, index) => {
+        return recyclerViewContext ? index : itemKey;
+    }, [recyclerViewContext]);
+    return { getMappingKey };
+};
+//# sourceMappingURL=useMappingHelper.js.map

package/dist/recyclerview/hooks/useMappingHelper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useMappingHelper.js","sourceRoot":"","sources":["../../../src/recyclerview/hooks/useMappingHelper.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,OAAO,CAAC;AAEpC,OAAO,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAC;AAExE;;;;GAIG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,GAAG,EAAE;IACnC,MAAM,mBAAmB,GAAG,sBAAsB,EAAE,CAAC;IACrD,MAAM,aAAa,GAAG,WAAW,CAC/B,CAAC,OAAiC,EAAE,KAAa,EAAE,EAAE;QACnD,OAAO,mBAAmB,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,OAAO,CAAC;IAC/C,CAAC,EACD,CAAC,mBAAmB,CAAC,CACtB,CAAC;IAEF,OAAO,EAAE,aAAa,EAAE,CAAC;AAC3B,CAAC,CAAC"}

package/dist/recyclerview/hooks/useOnLoad.d.ts

@@ -0,0 +1,25 @@
+import { RecyclerViewManager } from "../RecyclerViewManager";
+/**
+ * Hook to track when the RecyclerView has loaded its items and notify when loading is complete.
+ * Similar to FlashList's onLoad functionality, this hook tracks the time it takes to render
+ * the initial set of items in the RecyclerView and provides performance metrics.
+ *
+ * @param recyclerViewManager - The RecyclerViewManager instance managing the list
+ * @param onLoad - Optional callback function that will be called when the list has loaded with timing information
+ * @returns Object containing isLoaded state indicating whether the list has completed initial rendering
+ */
+export declare const useOnListLoad: <T>(recyclerViewManager: RecyclerViewManager<T>, onLoad?: (info: {
+    elapsedTimeInMs: number;
+}) => void) => {
+    isLoaded: boolean;
+};
+/**
+ * Core hook that detects when a RecyclerView has completed its initial layout.
+ * This hook monitors the RecyclerViewManager and triggers the provided callback
+ * once the first layout is complete.
+ *
+ * @param recyclerViewManager - The RecyclerViewManager instance to monitor
+ * @param onLoad - Callback function that will be called once when the first layout is complete
+ */
+export declare const useOnLoad: <T>(recyclerViewManager: RecyclerViewManager<T>, onLoad: () => void) => void;
+//# sourceMappingURL=useOnLoad.d.ts.map

package/dist/recyclerview/hooks/useOnLoad.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useOnLoad.d.ts","sourceRoot":"","sources":["../../../src/recyclerview/hooks/useOnLoad.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAK7D;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa,GAAI,CAAC,EAC7B,qBAAqB,mBAAmB,CAAC,CAAC,CAAC,EAC3C,SAAS,CAAC,IAAI,EAAE;IAAE,eAAe,EAAE,MAAM,CAAA;CAAE,KAAK,IAAI,KACnD;IAAE,QAAQ,EAAE,OAAO,CAAA;CAsCrB,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,SAAS,GAAI,CAAC,EACzB,qBAAqB,mBAAmB,CAAC,CAAC,CAAC,EAC3C,QAAQ,MAAM,IAAI,SAUnB,CAAC"}

package/dist/recyclerview/hooks/useOnLoad.js

@@ -0,0 +1,67 @@
+import { useEffect, useMemo, useRef, useState } from "react";
+import { useUnmountAwareAnimationFrame } from "./useUnmountAwareCallbacks";
+// import { ToastAndroid } from "react-native";
+/**
+ * Hook to track when the RecyclerView has loaded its items and notify when loading is complete.
+ * Similar to FlashList's onLoad functionality, this hook tracks the time it takes to render
+ * the initial set of items in the RecyclerView and provides performance metrics.
+ *
+ * @param recyclerViewManager - The RecyclerViewManager instance managing the list
+ * @param onLoad - Optional callback function that will be called when the list has loaded with timing information
+ * @returns Object containing isLoaded state indicating whether the list has completed initial rendering
+ */
+export const useOnListLoad = (recyclerViewManager, onLoad) => {
+    const loadStartTimeRef = useRef(Date.now());
+    const [isLoaded, setIsLoaded] = useState(false);
+    const dataLength = recyclerViewManager.getDataLength();
+    // const dataCollector = useRef<number[]>([]);
+    const { requestAnimationFrame } = useUnmountAwareAnimationFrame();
+    // Track render cycles by collecting elapsed time on each render
+    // useEffect(() => {
+    //   const elapsedTimeInMs = Date.now() - loadStartTimeRef.current;
+    //   dataCollector.current?.push(elapsedTimeInMs);
+    // });
+    useMemo(() => {
+        loadStartTimeRef.current = Date.now();
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [dataLength]);
+    useOnLoad(recyclerViewManager, () => {
+        const elapsedTimeInMs = Date.now() - loadStartTimeRef.current;
+        // Commented code below was used for debugging purposes
+        // to display all collected timing data points
+        // const dataCollectorString = dataCollector.current
+        //   ?.map((value) => value.toString())
+        //   .join(", ");
+        // ToastAndroid?.show(
+        //   `onLoad called after ${dataCollectorString}`,
+        //   ToastAndroid.SHORT
+        // );
+        // console.log("----------> dataCollector", dataCollectorString);
+        // console.log("----------> FlashList v2 load in", `${elapsedTimeInMs} ms`);
+        requestAnimationFrame(() => {
+            recyclerViewManager.isFirstPaintOnUiComplete = true;
+            onLoad === null || onLoad === void 0 ? void 0 : onLoad({ elapsedTimeInMs });
+            setIsLoaded(true);
+        });
+    });
+    return { isLoaded };
+};
+/**
+ * Core hook that detects when a RecyclerView has completed its initial layout.
+ * This hook monitors the RecyclerViewManager and triggers the provided callback
+ * once the first layout is complete.
+ *
+ * @param recyclerViewManager - The RecyclerViewManager instance to monitor
+ * @param onLoad - Callback function that will be called once when the first layout is complete
+ */
+export const useOnLoad = (recyclerViewManager, onLoad) => {
+    const isLoaded = useRef(false);
+    useEffect(() => {
+        // Only trigger onLoad callback once when first layout is complete
+        if (recyclerViewManager.getIsFirstLayoutComplete() && !isLoaded.current) {
+            isLoaded.current = true;
+            onLoad();
+        }
+    });
+};
+//# sourceMappingURL=useOnLoad.js.map

package/dist/recyclerview/hooks/useOnLoad.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useOnLoad.js","sourceRoot":"","sources":["../../../src/recyclerview/hooks/useOnLoad.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAI7D,OAAO,EAAE,6BAA6B,EAAE,MAAM,4BAA4B,CAAC;AAC3E,+CAA+C;AAE/C;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,CAC3B,mBAA2C,EAC3C,MAAoD,EAC7B,EAAE;IACzB,MAAM,gBAAgB,GAAG,MAAM,CAAS,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC;IACpD,MAAM,CAAC,QAAQ,EAAE,WAAW,CAAC,GAAG,QAAQ,CAAU,KAAK,CAAC,CAAC;IACzD,MAAM,UAAU,GAAG,mBAAmB,CAAC,aAAa,EAAE,CAAC;IACvD,8CAA8C;IAC9C,MAAM,EAAE,qBAAqB,EAAE,GAAG,6BAA6B,EAAE,CAAC;IAClE,gEAAgE;IAChE,oBAAoB;IACpB,mEAAmE;IACnE,kDAAkD;IAClD,MAAM;IAEN,OAAO,CAAC,GAAG,EAAE;QACX,gBAAgB,CAAC,OAAO,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QACtC,uDAAuD;IACzD,CAAC,EAAE,CAAC,UAAU,CAAC,CAAC,CAAC;IAEjB,SAAS,CAAC,mBAAmB,EAAE,GAAG,EAAE;QAClC,MAAM,eAAe,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,gBAAgB,CAAC,OAAO,CAAC;QAC9D,uDAAuD;QACvD,8CAA8C;QAC9C,oDAAoD;QACpD,uCAAuC;QACvC,iBAAiB;QACjB,sBAAsB;QACtB,kDAAkD;QAClD,uBAAuB;QACvB,KAAK;QACL,iEAAiE;QACjE,4EAA4E;QAC5E,qBAAqB,CAAC,GAAG,EAAE;YACzB,mBAAmB,CAAC,wBAAwB,GAAG,IAAI,CAAC;YACpD,MAAM,aAAN,MAAM,uBAAN,MAAM,CAAG,EAAE,eAAe,EAAE,CAAC,CAAC;YAC9B,WAAW,CAAC,IAAI,CAAC,CAAC;QACpB,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,OAAO,EAAE,QAAQ,EAAE,CAAC;AACtB,CAAC,CAAC;AAEF;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,CACvB,mBAA2C,EAC3C,MAAkB,EAClB,EAAE;IACF,MAAM,QAAQ,GAAG,MAAM,CAAU,KAAK,CAAC,CAAC;IACxC,SAAS,CAAC,GAAG,EAAE;QACb,kEAAkE;QAClE,IAAI,mBAAmB,CAAC,wBAAwB,EAAE,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE,CAAC;YACxE,QAAQ,CAAC,OAAO,GAAG,IAAI,CAAC;YACxB,MAAM,EAAE,CAAC;QACX,CAAC;IACH,CAAC,CAAC,CAAC;AACL,CAAC,CAAC"}

package/dist/recyclerview/hooks/useRecyclerViewController.d.ts

@@ -0,0 +1,28 @@
+import { RefObject } from "react";
+import { FlashListRef } from "../../FlashListRef";
+import { CompatScroller } from "../components/CompatScroller";
+import { RecyclerViewManager } from "../RecyclerViewManager";
+import { ScrollAnchorRef } from "../components/ScrollAnchor";
+/**
+ * Comprehensive hook that manages RecyclerView scrolling behavior and provides
+ * imperative methods for controlling the RecyclerView.
+ *
+ * This hook combines content offset management and scroll handling functionality:
+ * 1. Provides imperative methods for scrolling and measurement
+ * 2. Handles initial scroll position when the list first loads
+ * 3. Maintains visible content position during updates
+ * 4. Manages scroll anchors for chat-like applications
+ *
+ * @param recyclerViewManager - The RecyclerViewManager instance that handles core functionality
+ * @param ref - The ref to expose the imperative methods
+ * @param scrollViewRef - Reference to the scrollable container component
+ * @param scrollAnchorRef - Reference to the scroll anchor component
+ * @param props - The RecyclerViewProps containing configuration
+ */
+export declare function useRecyclerViewController<T>(recyclerViewManager: RecyclerViewManager<T>, ref: React.Ref<FlashListRef<T>>, scrollViewRef: RefObject<CompatScroller>, scrollAnchorRef: React.RefObject<ScrollAnchorRef>): {
+    applyOffsetCorrection: () => void;
+    computeFirstVisibleIndexForOffsetCorrection: () => void;
+    applyInitialScrollIndex: () => void;
+    handlerMethods: FlashListRef<T>;
+};
+//# sourceMappingURL=useRecyclerViewController.d.ts.map

package/dist/recyclerview/hooks/useRecyclerViewController.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRecyclerViewController.d.ts","sourceRoot":"","sources":["../../../src/recyclerview/hooks/useRecyclerViewController.tsx"],"names":[],"mappings":"AAAA,OAAO,EACL,SAAS,EAMV,MAAM,OAAO,CAAC;AAGf,OAAO,EAKL,YAAY,EACb,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAG7D,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAO7D;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,yBAAyB,CAAC,CAAC,EACzC,mBAAmB,EAAE,mBAAmB,CAAC,CAAC,CAAC,EAC3C,GAAG,EAAE,KAAK,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,EAC/B,aAAa,EAAE,SAAS,CAAC,cAAc,CAAC,EACxC,eAAe,EAAE,KAAK,CAAC,SAAS,CAAC,eAAe,CAAC;;;;;EAwkBlD"}

package/dist/recyclerview/hooks/useRecyclerViewController.js

@@ -0,0 +1,507 @@
+import { useCallback, useImperativeHandle, useMemo, useRef, useState, } from "react";
+import { I18nManager } from "react-native";
+import { adjustOffsetForRTL } from "../utils/adjustOffsetForRTL";
+import { PlatformConfig } from "../../native/config/PlatformHelper";
+import { WarningMessages } from "../../errors/WarningMessages";
+import { useUnmountFlag } from "./useUnmountFlag";
+import { useUnmountAwareTimeout } from "./useUnmountAwareCallbacks";
+/**
+ * Comprehensive hook that manages RecyclerView scrolling behavior and provides
+ * imperative methods for controlling the RecyclerView.
+ *
+ * This hook combines content offset management and scroll handling functionality:
+ * 1. Provides imperative methods for scrolling and measurement
+ * 2. Handles initial scroll position when the list first loads
+ * 3. Maintains visible content position during updates
+ * 4. Manages scroll anchors for chat-like applications
+ *
+ * @param recyclerViewManager - The RecyclerViewManager instance that handles core functionality
+ * @param ref - The ref to expose the imperative methods
+ * @param scrollViewRef - Reference to the scrollable container component
+ * @param scrollAnchorRef - Reference to the scroll anchor component
+ * @param props - The RecyclerViewProps containing configuration
+ */
+export function useRecyclerViewController(recyclerViewManager, ref, scrollViewRef, scrollAnchorRef) {
+    const isUnmounted = useUnmountFlag();
+    const [_, setRenderId] = useState(0);
+    const pauseOffsetCorrection = useRef(false);
+    const initialScrollCompletedRef = useRef(false);
+    const lastDataLengthRef = useRef(recyclerViewManager.getDataLength());
+    const { setTimeout } = useUnmountAwareTimeout();
+    // Track the first visible item for maintaining scroll position
+    const firstVisibleItemKey = useRef(undefined);
+    const firstVisibleItemLayout = useRef(undefined);
+    // Queue to store callbacks that should be executed after scroll offset updates
+    const pendingScrollCallbacks = useRef([]);
+    // Handle initial scroll position when the list first loads
+    //   useOnLoad(recyclerViewManager, () => {
+    //   });
+    /**
+     * Updates the scroll offset and calls the provided callback
+     * after the update has been applied and the component has re-rendered.
+     *
+     * @param offset - The new scroll offset to apply
+     * @param callback - Optional callback to execute after the update is applied
+     */
+    const updateScrollOffsetWithCallback = useCallback((offset, callback) => {
+        // Attempt to update the scroll offset in the RecyclerViewManager
+        // This returns undefined if no update is needed
+        if (recyclerViewManager.updateScrollOffset(offset) !== undefined) {
+            // It will be executed after the next render
+            pendingScrollCallbacks.current.push(callback);
+            // Trigger a re-render to apply the scroll offset update
+            setRenderId((prev) => prev + 1);
+        }
+        else {
+            // No update needed, execute callback immediately
+            callback();
+        }
+    }, [recyclerViewManager]);
+    const computeFirstVisibleIndexForOffsetCorrection = useCallback(() => {
+        if (recyclerViewManager.getIsFirstLayoutComplete() &&
+            recyclerViewManager.hasStableDataKeys() &&
+            recyclerViewManager.getDataLength() > 0 &&
+            recyclerViewManager.shouldMaintainVisibleContentPosition()) {
+            // Update the tracked first visible item
+            const firstVisibleIndex = Math.max(0, recyclerViewManager.computeVisibleIndices().startIndex);
+            if (firstVisibleIndex !== undefined && firstVisibleIndex >= 0) {
+                firstVisibleItemKey.current =
+                    recyclerViewManager.getDataKey(firstVisibleIndex);
+                firstVisibleItemLayout.current = {
+                    ...recyclerViewManager.getLayout(firstVisibleIndex),
+                };
+            }
+        }
+    }, [recyclerViewManager]);
+    /**
+     * Maintains the visible content position when the list updates.
+     * This is particularly useful for chat applications where we want to keep
+     * the user's current view position when new messages are added.
+     */
+    const applyOffsetCorrection = useCallback(() => {
+        var _a, _b, _c;
+        const { horizontal, data } = recyclerViewManager.props;
+        // Execute all pending callbacks from previous scroll offset updates
+        // This ensures any scroll operations that were waiting for render are completed
+        const callbacks = pendingScrollCallbacks.current;
+        pendingScrollCallbacks.current = [];
+        callbacks.forEach((callback) => callback());
+        const currentDataLength = recyclerViewManager.getDataLength();
+        if (recyclerViewManager.getIsFirstLayoutComplete() &&
+            recyclerViewManager.hasStableDataKeys() &&
+            currentDataLength > 0 &&
+            recyclerViewManager.shouldMaintainVisibleContentPosition()) {
+            const hasDataChanged = currentDataLength !== lastDataLengthRef.current;
+            // If we have a tracked first visible item, maintain its position
+            if (firstVisibleItemKey.current) {
+                const currentIndexOfFirstVisibleItem = (_a = recyclerViewManager
+                    .getEngagedIndices()
+                    .findValue((index) => recyclerViewManager.getDataKey(index) ===
+                    firstVisibleItemKey.current)) !== null && _a !== void 0 ? _a : (hasDataChanged
+                    ? data === null || data === void 0 ? void 0 : data.findIndex((item, index) => recyclerViewManager.getDataKey(index) ===
+                        firstVisibleItemKey.current)
+                    : undefined);
+                if (currentIndexOfFirstVisibleItem !== undefined &&
+                    currentIndexOfFirstVisibleItem >= 0) {
+                    // Calculate the difference in position and apply the offset
+                    const diff = horizontal
+                        ? recyclerViewManager.getLayout(currentIndexOfFirstVisibleItem).x -
+                            firstVisibleItemLayout.current.x
+                        : recyclerViewManager.getLayout(currentIndexOfFirstVisibleItem).y -
+                            firstVisibleItemLayout.current.y;
+                    firstVisibleItemLayout.current = {
+                        ...recyclerViewManager.getLayout(currentIndexOfFirstVisibleItem),
+                    };
+                    if (diff !== 0 &&
+                        !pauseOffsetCorrection.current &&
+                        !recyclerViewManager.animationOptimizationsEnabled) {
+                        // console.log("diff", diff, firstVisibleItemKey.current);
+                        if (PlatformConfig.supportsOffsetCorrection) {
+                            // console.log("scrollBy", diff);
+                            (_b = scrollAnchorRef.current) === null || _b === void 0 ? void 0 : _b.scrollBy(diff);
+                        }
+                        else {
+                            const scrollToParams = horizontal
+                                ? {
+                                    x: recyclerViewManager.getAbsoluteLastScrollOffset() + diff,
+                                    animated: false,
+                                }
+                                : {
+                                    y: recyclerViewManager.getAbsoluteLastScrollOffset() + diff,
+                                    animated: false,
+                                };
+                            (_c = scrollViewRef.current) === null || _c === void 0 ? void 0 : _c.scrollTo(scrollToParams);
+                        }
+                        if (hasDataChanged) {
+                            updateScrollOffsetWithCallback(recyclerViewManager.getAbsoluteLastScrollOffset() + diff, () => { });
+                            recyclerViewManager.ignoreScrollEvents = true;
+                            setTimeout(() => {
+                                recyclerViewManager.ignoreScrollEvents = false;
+                            }, 100);
+                        }
+                    }
+                }
+            }
+            computeFirstVisibleIndexForOffsetCorrection();
+        }
+        lastDataLengthRef.current = recyclerViewManager.getDataLength();
+    }, [
+        recyclerViewManager,
+        scrollAnchorRef,
+        scrollViewRef,
+        setTimeout,
+        updateScrollOffsetWithCallback,
+        computeFirstVisibleIndexForOffsetCorrection,
+    ]);
+    const handlerMethods = useMemo(() => {
+        return {
+            get props() {
+                return recyclerViewManager.props;
+            },
+            /**
+             * Scrolls the list to a specific offset position.
+             * Handles RTL layouts and first item offset adjustments.
+             */
+            scrollToOffset: ({ offset, animated, skipFirstItemOffset = true, }) => {
+                const { horizontal } = recyclerViewManager.props;
+                if (scrollViewRef.current) {
+                    // Adjust offset for RTL layouts in horizontal mode
+                    if (I18nManager.isRTL && horizontal) {
+                        // eslint-disable-next-line no-param-reassign
+                        offset =
+                            adjustOffsetForRTL(offset, recyclerViewManager.getChildContainerDimensions().width, recyclerViewManager.getWindowSize().width) +
+                                (skipFirstItemOffset
+                                    ? recyclerViewManager.firstItemOffset
+                                    : -recyclerViewManager.firstItemOffset);
+                    }
+                    // Calculate the final offset including first item offset if needed
+                    const adjustedOffset = offset +
+                        (skipFirstItemOffset ? 0 : recyclerViewManager.firstItemOffset);
+                    const scrollTo = horizontal
+                        ? { x: adjustedOffset, y: 0 }
+                        : { x: 0, y: adjustedOffset };
+                    scrollViewRef.current.scrollTo({
+                        ...scrollTo,
+                        animated,
+                    });
+                }
+            },
+            clearLayoutCacheOnUpdate: () => {
+                recyclerViewManager.markLayoutManagerDirty();
+            },
+            // Expose native scroll view methods
+            flashScrollIndicators: () => {
+                scrollViewRef.current.flashScrollIndicators();
+            },
+            getNativeScrollRef: () => {
+                return scrollViewRef.current;
+            },
+            getScrollResponder: () => {
+                return scrollViewRef.current.getScrollResponder();
+            },
+            getScrollableNode: () => {
+                return scrollViewRef.current.getScrollableNode();
+            },
+            /**
+             * Scrolls to the end of the list.
+             */
+            scrollToEnd: async ({ animated } = {}) => {
+                const { data } = recyclerViewManager.props;
+                if (data && data.length > 0) {
+                    const lastIndex = data.length - 1;
+                    if (!recyclerViewManager.getEngagedIndices().includes(lastIndex)) {
+                        await handlerMethods.scrollToIndex({
+                            index: lastIndex,
+                            animated,
+                        });
+                    }
+                }
+                setTimeout(() => {
+                    var _a;
+                    (_a = scrollViewRef.current) === null || _a === void 0 ? void 0 : _a.scrollToEnd({ animated });
+                }, 0);
+            },
+            /**
+             * Scrolls to the beginning of the list.
+             */
+            scrollToTop: ({ animated } = {}) => {
+                handlerMethods.scrollToOffset({
+                    offset: 0,
+                    animated,
+                });
+            },
+            /**
+             * Scrolls to a specific index in the list.
+             * Supports viewPosition and viewOffset for precise positioning.
+             * Returns a Promise that resolves when the scroll is complete.
+             */
+            scrollToIndex: ({ index, animated, viewPosition, viewOffset, }) => {
+                return new Promise((resolve) => {
+                    const { horizontal } = recyclerViewManager.props;
+                    if (scrollViewRef.current &&
+                        index >= 0 &&
+                        index < recyclerViewManager.getDataLength()) {
+                        // Pause the scroll offset adjustments
+                        pauseOffsetCorrection.current = true;
+                        recyclerViewManager.setOffsetProjectionEnabled(false);
+                        const getFinalOffset = () => {
+                            const layout = recyclerViewManager.getLayout(index);
+                            const offset = horizontal ? layout.x : layout.y;
+                            let finalOffset = offset;
+                            // take viewPosition etc into account
+                            if (viewPosition !== undefined || viewOffset !== undefined) {
+                                const containerSize = horizontal
+                                    ? recyclerViewManager.getWindowSize().width
+                                    : recyclerViewManager.getWindowSize().height;
+                                const itemSize = horizontal ? layout.width : layout.height;
+                                if (viewPosition !== undefined) {
+                                    // viewPosition: 0 = top, 0.5 = center, 1 = bottom
+                                    finalOffset =
+                                        offset - (containerSize - itemSize) * viewPosition;
+                                }
+                                if (viewOffset !== undefined) {
+                                    finalOffset += viewOffset;
+                                }
+                            }
+                            return finalOffset + recyclerViewManager.firstItemOffset;
+                        };
+                        const lastAbsoluteScrollOffset = recyclerViewManager.getAbsoluteLastScrollOffset();
+                        const bufferForScroll = horizontal
+                            ? recyclerViewManager.getWindowSize().width
+                            : recyclerViewManager.getWindowSize().height;
+                        const bufferForCompute = bufferForScroll * 2;
+                        const getStartScrollOffset = () => {
+                            let lastScrollOffset = lastAbsoluteScrollOffset;
+                            const finalOffset = getFinalOffset();
+                            if (finalOffset > lastScrollOffset) {
+                                lastScrollOffset = Math.max(finalOffset - bufferForCompute, lastScrollOffset);
+                                recyclerViewManager.setScrollDirection("forward");
+                            }
+                            else {
+                                lastScrollOffset = Math.min(finalOffset + bufferForCompute, lastScrollOffset);
+                                recyclerViewManager.setScrollDirection("backward");
+                            }
+                            return lastScrollOffset;
+                        };
+                        let initialTargetOffset = getFinalOffset();
+                        let initialStartScrollOffset = getStartScrollOffset();
+                        let finalOffset = initialTargetOffset;
+                        let startScrollOffset = initialStartScrollOffset;
+                        const steps = 5;
+                        /**
+                         * Recursively performs the scroll animation steps.
+                         * This function replaces the async/await loop with callback-based execution.
+                         *
+                         * @param currentStep - The current step in the animation (0 to steps-1)
+                         */
+                        const performScrollStep = (currentStep) => {
+                            // Check if component is unmounted or we've completed all steps
+                            if (isUnmounted.current) {
+                                resolve();
+                                return;
+                            }
+                            else if (currentStep >= steps) {
+                                // All steps completed, perform final scroll
+                                finishScrollToIndex();
+                                return;
+                            }
+                            // Calculate the offset for this step
+                            // For animated scrolls: interpolate from finalOffset to startScrollOffset
+                            // For non-animated: interpolate from startScrollOffset to finalOffset
+                            const nextOffset = animated
+                                ? finalOffset +
+                                    (startScrollOffset - finalOffset) *
+                                        (currentStep / (steps - 1))
+                                : startScrollOffset +
+                                    (finalOffset - startScrollOffset) *
+                                        (currentStep / (steps - 1));
+                            // Update scroll offset with a callback to continue to the next step
+                            updateScrollOffsetWithCallback(nextOffset, () => {
+                                // Check if the index is still valid after the update
+                                if (index >= recyclerViewManager.getDataLength()) {
+                                    // Index out of bounds, scroll to end instead
+                                    handlerMethods.scrollToEnd({ animated });
+                                    resolve(); // Resolve the promise as we're done
+                                    return;
+                                }
+                                // Check if the target position has changed significantly
+                                const newFinalOffset = getFinalOffset();
+                                if ((newFinalOffset < initialTargetOffset &&
+                                    newFinalOffset < initialStartScrollOffset) ||
+                                    (newFinalOffset > initialTargetOffset &&
+                                        newFinalOffset > initialStartScrollOffset)) {
+                                    // Target has moved, recalculate and restart from beginning
+                                    finalOffset = newFinalOffset;
+                                    startScrollOffset = getStartScrollOffset();
+                                    initialTargetOffset = newFinalOffset;
+                                    initialStartScrollOffset = startScrollOffset;
+                                    performScrollStep(0); // Restart from step 0
+                                }
+                                else {
+                                    // Continue to next step
+                                    performScrollStep(currentStep + 1);
+                                }
+                            });
+                        };
+                        /**
+                         * Completes the scroll to index operation by performing the final scroll
+                         * and re-enabling offset correction after a delay.
+                         */
+                        const finishScrollToIndex = () => {
+                            finalOffset = getFinalOffset();
+                            const maxOffset = recyclerViewManager.getMaxScrollOffset();
+                            if (finalOffset > maxOffset) {
+                                finalOffset = maxOffset;
+                            }
+                            if (animated) {
+                                // For animated scrolls, first jump to the start position
+                                // We don't need to add firstItemOffset here as it's already added
+                                handlerMethods.scrollToOffset({
+                                    offset: startScrollOffset,
+                                    animated: false,
+                                    skipFirstItemOffset: true,
+                                });
+                            }
+                            // Perform the final scroll to the target position
+                            handlerMethods.scrollToOffset({
+                                offset: finalOffset,
+                                animated,
+                                skipFirstItemOffset: true,
+                            });
+                            // Re-enable offset correction after a delay
+                            // Longer delay for animated scrolls to allow animation to complete
+                            setTimeout(() => {
+                                pauseOffsetCorrection.current = false;
+                                recyclerViewManager.setOffsetProjectionEnabled(true);
+                                resolve(); // Resolve the promise after re-enabling corrections
+                            }, animated ? 300 : 200);
+                        };
+                        // Start the scroll animation process
+                        performScrollStep(0);
+                    }
+                    else {
+                        // Invalid parameters, resolve immediately
+                        resolve();
+                    }
+                });
+            },
+            /**
+             * Scrolls to a specific item in the list.
+             * Finds the item's index and uses scrollToIndex internally.
+             */
+            scrollToItem: ({ item, animated, viewPosition, viewOffset, }) => {
+                const { data } = recyclerViewManager.props;
+                if (scrollViewRef.current && data) {
+                    // Find the index of the item in the data array
+                    const index = data.findIndex((dataItem) => dataItem === item);
+                    if (index >= 0) {
+                        handlerMethods.scrollToIndex({
+                            index,
+                            animated,
+                            viewPosition,
+                            viewOffset,
+                        });
+                    }
+                }
+            },
+            // Utility methods for measuring header height / top padding
+            getFirstItemOffset: () => {
+                return recyclerViewManager.firstItemOffset;
+            },
+            getWindowSize: () => {
+                return recyclerViewManager.getWindowSize();
+            },
+            getLayout: (index) => {
+                return recyclerViewManager.tryGetLayout(index);
+            },
+            getAbsoluteLastScrollOffset: () => {
+                return recyclerViewManager.getAbsoluteLastScrollOffset();
+            },
+            getChildContainerDimensions: () => {
+                return recyclerViewManager.getChildContainerDimensions();
+            },
+            recordInteraction: () => {
+                recyclerViewManager.recordInteraction();
+            },
+            computeVisibleIndices: () => {
+                return recyclerViewManager.computeVisibleIndices();
+            },
+            getFirstVisibleIndex: () => {
+                return recyclerViewManager.computeVisibleIndices().startIndex;
+            },
+            recomputeViewableItems: () => {
+                recyclerViewManager.recomputeViewableItems();
+            },
+            /**
+             * Disables item recycling in preparation for layout animations.
+             */
+            prepareForLayoutAnimationRender: () => {
+                if (!recyclerViewManager.props.keyExtractor) {
+                    console.warn(WarningMessages.keyExtractorNotDefinedForAnimation);
+                }
+                recyclerViewManager.animationOptimizationsEnabled = true;
+            },
+        };
+    }, [
+        recyclerViewManager,
+        scrollViewRef,
+        setTimeout,
+        isUnmounted,
+        updateScrollOffsetWithCallback,
+    ]);
+    const applyInitialScrollIndex = useCallback(() => {
+        var _a, _b, _c;
+        const { horizontal, data, initialScrollIndexParams } = recyclerViewManager.props;
+        const initialScrollIndex = (_a = recyclerViewManager.getInitialScrollIndex()) !== null && _a !== void 0 ? _a : -1;
+        const dataLength = (_b = data === null || data === void 0 ? void 0 : data.length) !== null && _b !== void 0 ? _b : 0;
+        if (initialScrollIndex >= 0 &&
+            initialScrollIndex < dataLength &&
+            !initialScrollCompletedRef.current &&
+            recyclerViewManager.getIsFirstLayoutComplete()) {
+            // Use setTimeout to ensure that we keep trying to scroll on first few renders
+            setTimeout(() => {
+                initialScrollCompletedRef.current = true;
+                pauseOffsetCorrection.current = false;
+            }, 100);
+            pauseOffsetCorrection.current = true;
+            const additionalOffset = (_c = initialScrollIndexParams === null || initialScrollIndexParams === void 0 ? void 0 : initialScrollIndexParams.viewOffset) !== null && _c !== void 0 ? _c : 0;
+            const offset = horizontal
+                ? recyclerViewManager.getLayout(initialScrollIndex).x + additionalOffset
+                : recyclerViewManager.getLayout(initialScrollIndex).y +
+                    additionalOffset;
+            handlerMethods.scrollToOffset({
+                offset,
+                animated: false,
+                skipFirstItemOffset: false,
+            });
+            setTimeout(() => {
+                handlerMethods.scrollToOffset({
+                    offset,
+                    animated: false,
+                    skipFirstItemOffset: false,
+                });
+            }, 0);
+        }
+    }, [handlerMethods, recyclerViewManager, setTimeout]);
+    // Expose imperative methods through the ref
+    useImperativeHandle(ref, () => {
+        const imperativeApi = { ...scrollViewRef.current, ...handlerMethods };
+        // Without this the props getter from handlerMethods is evaluated during spread and
+        // future updates to props are not reflected in the ref
+        Object.defineProperty(imperativeApi, "props", {
+            get() {
+                return recyclerViewManager.props;
+            },
+            enumerable: true,
+            configurable: true,
+        });
+        return imperativeApi;
+    }, [handlerMethods, scrollViewRef, recyclerViewManager]);
+    return {
+        applyOffsetCorrection,
+        computeFirstVisibleIndexForOffsetCorrection,
+        applyInitialScrollIndex,
+        handlerMethods,
+    };
+}
+//# sourceMappingURL=useRecyclerViewController.js.map