@shopify/flash-list 2.0.0-rc.1 → 2.0.0-rc.3

package/dist/recyclerview/helpers/RenderTimeTracker.js

@@ -27,6 +27,9 @@ var RenderTimeTracker = /** @class */ (function () {
             this.lastTimerStartedAt = -1;
         }
     };
+    RenderTimeTracker.prototype.getRawValue = function () {
+        return this.renderTimeAvgWindow.currentValue;
+    };
     RenderTimeTracker.prototype.getAverageRenderTime = function () {
         if (!PlatformHelper_1.PlatformConfig.trackAverageRenderTimeForOffsetProjection) {
             return this.defaultRenderTime;

package/dist/recyclerview/helpers/RenderTimeTracker.js.map

@@ -1 +1 @@
-{"version":3,"file":"RenderTimeTracker.js","sourceRoot":"","sources":["../../../src/recyclerview/helpers/RenderTimeTracker.ts"],"names":[],"mappings":";;;AAAA,qEAAoE;AACpE,2DAA0D;AAE1D;IAAA;QACU,wBAAmB,GAAG,IAAI,6BAAa,CAAC,CAAC,CAAC,CAAC;QAC3C,uBAAkB,GAAG,CAAC,CAAC,CAAC;QACxB,kBAAa,GAAG,EAAE,CAAC,CAAC,+BAA+B;QACnD,sBAAiB,GAAG,EAAE,CAAC;IA8BjC,CAAC;IA5BC,yCAAa,GAAb;QACE,IAAI,CAAC,+BAAc,CAAC,yCAAyC,EAAE,CAAC;YAC9D,OAAO;QACT,CAAC;QACD,IAAI,IAAI,CAAC,kBAAkB,KAAK,CAAC,CAAC,EAAE,CAAC;YACnC,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QACvC,CAAC;IACH,CAAC;IAED,8CAAkB,GAAlB;QACE,IAAI,CAAC,+BAAc,CAAC,yCAAyC,EAAE,CAAC;YAC9D,OAAO;QACT,CAAC;QACD,IAAI,IAAI,CAAC,kBAAkB,KAAK,CAAC,CAAC,EAAE,CAAC;YACnC,IAAI,CAAC,mBAAmB,CAAC,QAAQ,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,kBAAkB,CAAC,CAAC;YACxE,IAAI,CAAC,kBAAkB,GAAG,CAAC,CAAC,CAAC;QAC/B,CAAC;IACH,CAAC;IAED,gDAAoB,GAApB;QACE,IAAI,CAAC,+BAAc,CAAC,yCAAyC,EAAE,CAAC;YAC9D,OAAO,IAAI,CAAC,iBAAiB,CAAC;QAChC,CAAC;QACD,OAAO,IAAI,CAAC,GAAG,CACb,IAAI,CAAC,aAAa,EAClB,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,mBAAmB,CAAC,YAAY,CAAC,EAAE,EAAE,CAAC,CAChE,CAAC;IACJ,CAAC;IACH,wBAAC;AAAD,CAAC,AAlCD,IAkCC;AAlCY,8CAAiB"}
+{"version":3,"file":"RenderTimeTracker.js","sourceRoot":"","sources":["../../../src/recyclerview/helpers/RenderTimeTracker.ts"],"names":[],"mappings":";;;AAAA,qEAAoE;AACpE,2DAA0D;AAE1D;IAAA;QACU,wBAAmB,GAAG,IAAI,6BAAa,CAAC,CAAC,CAAC,CAAC;QAC3C,uBAAkB,GAAG,CAAC,CAAC,CAAC;QACxB,kBAAa,GAAG,EAAE,CAAC,CAAC,+BAA+B;QACnD,sBAAiB,GAAG,EAAE,CAAC;IAkCjC,CAAC;IAhCC,yCAAa,GAAb;QACE,IAAI,CAAC,+BAAc,CAAC,yCAAyC,EAAE,CAAC;YAC9D,OAAO;QACT,CAAC;QACD,IAAI,IAAI,CAAC,kBAAkB,KAAK,CAAC,CAAC,EAAE,CAAC;YACnC,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QACvC,CAAC;IACH,CAAC;IAED,8CAAkB,GAAlB;QACE,IAAI,CAAC,+BAAc,CAAC,yCAAyC,EAAE,CAAC;YAC9D,OAAO;QACT,CAAC;QACD,IAAI,IAAI,CAAC,kBAAkB,KAAK,CAAC,CAAC,EAAE,CAAC;YACnC,IAAI,CAAC,mBAAmB,CAAC,QAAQ,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,kBAAkB,CAAC,CAAC;YACxE,IAAI,CAAC,kBAAkB,GAAG,CAAC,CAAC,CAAC;QAC/B,CAAC;IACH,CAAC;IAED,uCAAW,GAAX;QACE,OAAO,IAAI,CAAC,mBAAmB,CAAC,YAAY,CAAC;IAC/C,CAAC;IAED,gDAAoB,GAApB;QACE,IAAI,CAAC,+BAAc,CAAC,yCAAyC,EAAE,CAAC;YAC9D,OAAO,IAAI,CAAC,iBAAiB,CAAC;QAChC,CAAC;QACD,OAAO,IAAI,CAAC,GAAG,CACb,IAAI,CAAC,aAAa,EAClB,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,mBAAmB,CAAC,YAAY,CAAC,EAAE,EAAE,CAAC,CAChE,CAAC;IACJ,CAAC;IACH,wBAAC;AAAD,CAAC,AAtCD,IAsCC;AAtCY,8CAAiB"}

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

@@ -1,3 +1,5 @@
+export type LayoutStateSetter<T> = (newValue: T | ((prevValue: T) => T), skipParentLayout?: boolean) => void;
+export type LayoutStateInitialValue<T> = T | (() => T);
 /**
  * Custom hook that combines state management with RecyclerView layout updates.
  * This hook provides a way to manage state that affects the layout of the RecyclerView,
@@ -8,5 +10,5 @@
  *   - The current state value
  *   - A setter function that updates the state and triggers a layout recalculation
  */
-export declare function useLayoutState<T>(initialState: T | (() => T)): [T, (newValue: T | ((prevValue: T) => T)) => void];
+export declare function useLayoutState<T>(initialState: LayoutStateInitialValue<T>): [T, LayoutStateSetter<T>];
 //# sourceMappingURL=useLayoutState.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"useLayoutState.d.ts","sourceRoot":"","sources":["../../../src/recyclerview/hooks/useLayoutState.ts"],"names":[],"mappings":"AAIA;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAC9B,YAAY,EAAE,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,GAC1B,CAAC,CAAC,EAAE,CAAC,QAAQ,EAAE,CAAC,GAAG,CAAC,CAAC,SAAS,EAAE,CAAC,KAAK,CAAC,CAAC,KAAK,IAAI,CAAC,CA6BpD"}
+{"version":3,"file":"useLayoutState.d.ts","sourceRoot":"","sources":["../../../src/recyclerview/hooks/useLayoutState.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,iBAAiB,CAAC,CAAC,IAAI,CACjC,QAAQ,EAAE,CAAC,GAAG,CAAC,CAAC,SAAS,EAAE,CAAC,KAAK,CAAC,CAAC,EACnC,gBAAgB,CAAC,EAAE,OAAO,KACvB,IAAI,CAAC;AAEV,MAAM,MAAM,uBAAuB,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;AAEvD;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAC9B,YAAY,EAAE,uBAAuB,CAAC,CAAC,CAAC,GACvC,CAAC,CAAC,EAAE,iBAAiB,CAAC,CAAC,CAAC,CAAC,CA+B3B"}

package/dist/recyclerview/hooks/useLayoutState.js

@@ -27,15 +27,17 @@ function useLayoutState(initialState) {
      * @param newValue - Either a new state value or a function that receives the previous state
      *                   and returns the new state
      */
-    var setLayoutState = (0, react_1.useCallback)(function (newValue) {
+    var setLayoutState = (0, react_1.useCallback)(function (newValue, skipParentLayout) {
         // Update the state using either the new value or the result of the updater function
         setState(function (prevValue) {
             return typeof newValue === "function"
                 ? newValue(prevValue)
                 : newValue;
         });
-        // Trigger a layout recalculation in the RecyclerView
-        recyclerViewContext === null || recyclerViewContext === void 0 ? void 0 : recyclerViewContext.layout();
+        if (!skipParentLayout) {
+            // Trigger a layout recalculation in the RecyclerView
+            recyclerViewContext === null || recyclerViewContext === void 0 ? void 0 : recyclerViewContext.layout();
+        }
     }, [recyclerViewContext]);
     return [state, setLayoutState];
 }

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

@@ -1 +1 @@
-{"version":3,"file":"useLayoutState.js","sourceRoot":"","sources":["../../../src/recyclerview/hooks/useLayoutState.ts"],"names":[],"mappings":";;AAcA,wCA+BC;;AA7CD,+BAA8C;AAE9C,8EAAwE;AAExE;;;;;;;;;GASG;AACH,SAAgB,cAAc,CAC5B,YAA2B;IAE3B,mDAAmD;IAC7C,IAAA,KAAA,eAAoB,IAAA,gBAAQ,EAAI,YAAY,CAAC,IAAA,EAA5C,KAAK,QAAA,EAAE,QAAQ,QAA6B,CAAC;IACpD,qDAAqD;IACrD,IAAM,mBAAmB,GAAG,IAAA,oDAAsB,GAAE,CAAC;IAErD;;;;;;;OAOG;IACH,IAAM,cAAc,GAAG,IAAA,mBAAW,EAChC,UAAC,QAAmC;QAClC,oFAAoF;QACpF,QAAQ,CAAC,UAAC,SAAS;YACjB,OAAA,OAAO,QAAQ,KAAK,UAAU;gBAC5B,CAAC,CAAE,QAAgC,CAAC,SAAS,CAAC;gBAC9C,CAAC,CAAC,QAAQ;QAFZ,CAEY,CACb,CAAC;QACF,qDAAqD;QACrD,mBAAmB,aAAnB,mBAAmB,uBAAnB,mBAAmB,CAAE,MAAM,EAAE,CAAC;IAChC,CAAC,EACD,CAAC,mBAAmB,CAAC,CACtB,CAAC;IAEF,OAAO,CAAC,KAAK,EAAE,cAAc,CAAC,CAAC;AACjC,CAAC"}
+{"version":3,"file":"useLayoutState.js","sourceRoot":"","sources":["../../../src/recyclerview/hooks/useLayoutState.ts"],"names":[],"mappings":";;AAqBA,wCAiCC;;AAtDD,+BAA8C;AAE9C,8EAAwE;AASxE;;;;;;;;;GASG;AACH,SAAgB,cAAc,CAC5B,YAAwC;IAExC,mDAAmD;IAC7C,IAAA,KAAA,eAAoB,IAAA,gBAAQ,EAAI,YAAY,CAAC,IAAA,EAA5C,KAAK,QAAA,EAAE,QAAQ,QAA6B,CAAC;IACpD,qDAAqD;IACrD,IAAM,mBAAmB,GAAG,IAAA,oDAAsB,GAAE,CAAC;IAErD;;;;;;;OAOG;IACH,IAAM,cAAc,GAAyB,IAAA,mBAAW,EACtD,UAAC,QAAQ,EAAE,gBAAgB;QACzB,oFAAoF;QACpF,QAAQ,CAAC,UAAC,SAAS;YACjB,OAAA,OAAO,QAAQ,KAAK,UAAU;gBAC5B,CAAC,CAAE,QAAgC,CAAC,SAAS,CAAC;gBAC9C,CAAC,CAAC,QAAQ;QAFZ,CAEY,CACb,CAAC;QACF,IAAI,CAAC,gBAAgB,EAAE,CAAC;YACtB,qDAAqD;YACrD,mBAAmB,aAAnB,mBAAmB,uBAAnB,mBAAmB,CAAE,MAAM,EAAE,CAAC;QAChC,CAAC;IACH,CAAC,EACD,CAAC,mBAAmB,CAAC,CACtB,CAAC;IAEF,OAAO,CAAC,KAAK,EAAE,cAAc,CAAC,CAAC;AACjC,CAAC"}

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

@@ -20,7 +20,8 @@ import { ScrollAnchorRef } from "../components/ScrollAnchor";
  * @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>): {
-    applyContentOffset: () => Promise<void>;
+    applyOffsetCorrection: () => void;
+    computeFirstVisibleIndexForOffsetCorrection: () => void;
     applyInitialScrollIndex: () => void;
     handlerMethods: FlashListRef<T>;
 };

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

@@ -1 +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;AAM7D;;;;;;;;;;;;;;;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;;;;EA0elD"}
+{"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;AAM7D;;;;;;;;;;;;;;;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;;;;;EA6iBlD"}

package/dist/recyclerview/hooks/useRecyclerViewController.js

@@ -36,111 +36,121 @@ function useRecyclerViewController(recyclerViewManager, ref, scrollViewRef, scro
     // Track the first visible item for maintaining scroll position
     var firstVisibleItemKey = (0, react_1.useRef)(undefined);
     var firstVisibleItemLayout = (0, react_1.useRef)(undefined);
-    var pendingScrollResolves = (0, react_1.useRef)([]);
+    // Queue to store callbacks that should be executed after scroll offset updates
+    var pendingScrollCallbacks = (0, react_1.useRef)([]);
     // Handle initial scroll position when the list first loads
     //   useOnLoad(recyclerViewManager, () => {
     //   });
     /**
-     * Updates the scroll offset and returns a Promise that resolves
-     * when the update has been applied.
+     * 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
      */
-    var updateScrollOffsetAsync = (0, react_1.useCallback)(function (offset) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-        return tslib_1.__generator(this, function (_a) {
-            return [2 /*return*/, new Promise(function (resolve) {
-                    // TODO: Make sure we don't scroll beyond content size
-                    if (recyclerViewManager.updateScrollOffset(offset) !== undefined) {
-                        // Add the resolve function to the queue
-                        pendingScrollResolves.current.push(resolve);
-                        setRenderId(function (prev) { return prev + 1; });
-                    }
-                    else {
-                        resolve();
-                    }
-                })];
-        });
-    }); }, [recyclerViewManager]);
+    var updateScrollOffsetWithCallback = (0, react_1.useCallback)(function (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(function (prev) { return prev + 1; });
+        }
+        else {
+            // No update needed, execute callback immediately
+            callback();
+        }
+    }, [recyclerViewManager]);
+    var computeFirstVisibleIndexForOffsetCorrection = (0, react_1.useCallback)(function () {
+        var _a = recyclerViewManager.props, data = _a.data, keyExtractor = _a.keyExtractor;
+        if (data && keyExtractor) {
+            // Update the tracked first visible item
+            var firstVisibleIndex = Math.max(0, recyclerViewManager.computeVisibleIndices().startIndex);
+            if (firstVisibleIndex !== undefined && firstVisibleIndex >= 0) {
+                firstVisibleItemKey.current = keyExtractor(data[firstVisibleIndex], firstVisibleIndex);
+                firstVisibleItemLayout.current = tslib_1.__assign({}, 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.
      */
-    var applyContentOffset = (0, react_1.useCallback)(function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-        var _a, horizontal, data, keyExtractor, resolves, currentDataLength, hasDataChanged, currentIndexOfFirstVisibleItem, diff, scrollToParams, firstVisibleIndex;
-        var _b, _c, _d, _e, _f;
-        return tslib_1.__generator(this, function (_g) {
-            _a = recyclerViewManager.props, horizontal = _a.horizontal, data = _a.data, keyExtractor = _a.keyExtractor;
-            resolves = pendingScrollResolves.current;
-            pendingScrollResolves.current = [];
-            resolves.forEach(function (resolve) { return resolve(); });
-            currentDataLength = (_b = data === null || data === void 0 ? void 0 : data.length) !== null && _b !== void 0 ? _b : 0;
-            if (recyclerViewManager.getIsFirstLayoutComplete() &&
-                keyExtractor &&
-                currentDataLength > 0 &&
-                recyclerViewManager.shouldMaintainVisibleContentPosition()) {
-                hasDataChanged = currentDataLength !== lastDataLengthRef.current;
-                // If we have a tracked first visible item, maintain its position
-                if (firstVisibleItemKey.current) {
-                    currentIndexOfFirstVisibleItem = (_c = recyclerViewManager
-                        .getEngagedIndices()
-                        .findValue(function (index) {
-                        return (keyExtractor === null || keyExtractor === void 0 ? void 0 : keyExtractor(data[index], index)) ===
-                            firstVisibleItemKey.current;
-                    })) !== null && _c !== void 0 ? _c : (hasDataChanged
-                        ? data === null || data === void 0 ? void 0 : data.findIndex(function (item, index) {
-                            return (keyExtractor === null || keyExtractor === void 0 ? void 0 : keyExtractor(item, index)) === firstVisibleItemKey.current;
-                        })
-                        : undefined);
-                    if (currentIndexOfFirstVisibleItem !== undefined &&
-                        currentIndexOfFirstVisibleItem >= 0) {
-                        diff = horizontal
-                            ? recyclerViewManager.getLayout(currentIndexOfFirstVisibleItem).x -
-                                firstVisibleItemLayout.current.x
-                            : recyclerViewManager.getLayout(currentIndexOfFirstVisibleItem).y -
-                                firstVisibleItemLayout.current.y;
-                        firstVisibleItemLayout.current = tslib_1.__assign({}, recyclerViewManager.getLayout(currentIndexOfFirstVisibleItem));
-                        if (diff !== 0 && !pauseOffsetCorrection.current) {
-                            // console.log("diff", diff, firstVisibleItemKey.current);
-                            if (PlatformHelper_1.PlatformConfig.supportsOffsetCorrection) {
-                                // console.log("scrollBy", diff);
-                                (_d = scrollAnchorRef.current) === null || _d === void 0 ? void 0 : _d.scrollBy(diff);
-                            }
-                            else {
-                                scrollToParams = horizontal
-                                    ? {
-                                        x: recyclerViewManager.getAbsoluteLastScrollOffset() + diff,
-                                        animated: false,
-                                    }
-                                    : {
-                                        y: recyclerViewManager.getAbsoluteLastScrollOffset() + diff,
-                                        animated: false,
-                                    };
-                                (_e = scrollViewRef.current) === null || _e === void 0 ? void 0 : _e.scrollTo(scrollToParams);
-                            }
-                            if (hasDataChanged) {
-                                updateScrollOffsetAsync(recyclerViewManager.getAbsoluteLastScrollOffset() + diff);
-                                recyclerViewManager.ignoreScrollEvents = true;
-                                setTimeout(function () {
-                                    recyclerViewManager.ignoreScrollEvents = false;
-                                }, 100);
-                            }
+    var applyOffsetCorrection = (0, react_1.useCallback)(function () {
+        var _a, _b, _c, _d, _e;
+        var _f = recyclerViewManager.props, horizontal = _f.horizontal, data = _f.data, keyExtractor = _f.keyExtractor;
+        // Execute all pending callbacks from previous scroll offset updates
+        // This ensures any scroll operations that were waiting for render are completed
+        var callbacks = pendingScrollCallbacks.current;
+        pendingScrollCallbacks.current = [];
+        callbacks.forEach(function (callback) { return callback(); });
+        var currentDataLength = (_a = data === null || data === void 0 ? void 0 : data.length) !== null && _a !== void 0 ? _a : 0;
+        if (recyclerViewManager.getIsFirstLayoutComplete() &&
+            keyExtractor &&
+            currentDataLength > 0 &&
+            recyclerViewManager.shouldMaintainVisibleContentPosition()) {
+            var hasDataChanged = currentDataLength !== lastDataLengthRef.current;
+            // If we have a tracked first visible item, maintain its position
+            if (firstVisibleItemKey.current) {
+                var currentIndexOfFirstVisibleItem = (_b = recyclerViewManager
+                    .getEngagedIndices()
+                    .findValue(function (index) {
+                    return (keyExtractor === null || keyExtractor === void 0 ? void 0 : keyExtractor(data[index], index)) ===
+                        firstVisibleItemKey.current;
+                })) !== null && _b !== void 0 ? _b : (hasDataChanged
+                    ? data === null || data === void 0 ? void 0 : data.findIndex(function (item, index) {
+                        return (keyExtractor === null || keyExtractor === void 0 ? void 0 : keyExtractor(item, index)) === firstVisibleItemKey.current;
+                    })
+                    : undefined);
+                if (currentIndexOfFirstVisibleItem !== undefined &&
+                    currentIndexOfFirstVisibleItem >= 0) {
+                    // Calculate the difference in position and apply the offset
+                    var diff = horizontal
+                        ? recyclerViewManager.getLayout(currentIndexOfFirstVisibleItem).x -
+                            firstVisibleItemLayout.current.x
+                        : recyclerViewManager.getLayout(currentIndexOfFirstVisibleItem).y -
+                            firstVisibleItemLayout.current.y;
+                    firstVisibleItemLayout.current = tslib_1.__assign({}, recyclerViewManager.getLayout(currentIndexOfFirstVisibleItem));
+                    if (diff !== 0 && !pauseOffsetCorrection.current) {
+                        // console.log("diff", diff, firstVisibleItemKey.current);
+                        if (PlatformHelper_1.PlatformConfig.supportsOffsetCorrection) {
+                            // console.log("scrollBy", diff);
+                            (_c = scrollAnchorRef.current) === null || _c === void 0 ? void 0 : _c.scrollBy(diff);
+                        }
+                        else {
+                            var scrollToParams = horizontal
+                                ? {
+                                    x: recyclerViewManager.getAbsoluteLastScrollOffset() + diff,
+                                    animated: false,
+                                }
+                                : {
+                                    y: recyclerViewManager.getAbsoluteLastScrollOffset() + diff,
+                                    animated: false,
+                                };
+                            (_d = scrollViewRef.current) === null || _d === void 0 ? void 0 : _d.scrollTo(scrollToParams);
+                        }
+                        if (hasDataChanged) {
+                            updateScrollOffsetWithCallback(recyclerViewManager.getAbsoluteLastScrollOffset() + diff, function () { });
+                            recyclerViewManager.ignoreScrollEvents = true;
+                            setTimeout(function () {
+                                recyclerViewManager.ignoreScrollEvents = false;
+                            }, 100);
                         }
                     }
                 }
-                firstVisibleIndex = Math.max(0, recyclerViewManager.computeVisibleIndices().startIndex);
-                if (firstVisibleIndex !== undefined && firstVisibleIndex >= 0) {
-                    firstVisibleItemKey.current = keyExtractor(data[firstVisibleIndex], firstVisibleIndex);
-                    firstVisibleItemLayout.current = tslib_1.__assign({}, recyclerViewManager.getLayout(firstVisibleIndex));
-                }
             }
-            lastDataLengthRef.current = (_f = data === null || data === void 0 ? void 0 : data.length) !== null && _f !== void 0 ? _f : 0;
-            return [2 /*return*/];
-        });
-    }); }, [
+            computeFirstVisibleIndexForOffsetCorrection();
+        }
+        lastDataLengthRef.current = (_e = data === null || data === void 0 ? void 0 : data.length) !== null && _e !== void 0 ? _e : 0;
+    }, [
         recyclerViewManager,
         scrollAnchorRef,
         scrollViewRef,
         setTimeout,
-        updateScrollOffsetAsync,
+        updateScrollOffsetWithCallback,
+        computeFirstVisibleIndexForOffsetCorrection,
     ]);
     var handlerMethods = (0, react_1.useMemo)(function () {
         return {
@@ -234,128 +244,158 @@ function useRecyclerViewController(recyclerViewManager, ref, scrollViewRef, scro
             /**
              * 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: function (_a) { return tslib_1.__awaiter(_this, [_a], void 0, function (_b) {
-                var horizontal, getFinalOffset_1, lastAbsoluteScrollOffset_1, bufferForScroll, bufferForCompute_1, getStartScrollOffset, initialTargetOffset, initialStartScrollOffset, finalOffset, startScrollOffset, steps, i, nextOffset, newFinalOffset, maxOffset;
-                var index = _b.index, animated = _b.animated, viewPosition = _b.viewPosition, viewOffset = _b.viewOffset;
-                return tslib_1.__generator(this, function (_c) {
-                    switch (_c.label) {
-                        case 0:
-                            horizontal = recyclerViewManager.props.horizontal;
-                            if (!(scrollViewRef.current &&
-                                index >= 0 &&
-                                index < recyclerViewManager.getDataLength())) return [3 /*break*/, 5];
-                            // Pause the scroll offset adjustments
-                            pauseOffsetCorrection.current = true;
-                            recyclerViewManager.setOffsetProjectionEnabled(false);
-                            getFinalOffset_1 = function () {
-                                var layout = recyclerViewManager.getLayout(index);
-                                var offset = horizontal ? layout.x : layout.y;
-                                var finalOffset = offset;
-                                // take viewPosition etc into account
-                                if (viewPosition !== undefined || viewOffset !== undefined) {
-                                    var containerSize = horizontal
-                                        ? recyclerViewManager.getWindowSize().width
-                                        : recyclerViewManager.getWindowSize().height;
-                                    var 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;
-                                    }
+            scrollToIndex: function (_a) {
+                var index = _a.index, animated = _a.animated, viewPosition = _a.viewPosition, viewOffset = _a.viewOffset;
+                return new Promise(function (resolve) {
+                    var horizontal = recyclerViewManager.props.horizontal;
+                    if (scrollViewRef.current &&
+                        index >= 0 &&
+                        index < recyclerViewManager.getDataLength()) {
+                        // Pause the scroll offset adjustments
+                        pauseOffsetCorrection.current = true;
+                        recyclerViewManager.setOffsetProjectionEnabled(false);
+                        var getFinalOffset_1 = function () {
+                            var layout = recyclerViewManager.getLayout(index);
+                            var offset = horizontal ? layout.x : layout.y;
+                            var finalOffset = offset;
+                            // take viewPosition etc into account
+                            if (viewPosition !== undefined || viewOffset !== undefined) {
+                                var containerSize = horizontal
+                                    ? recyclerViewManager.getWindowSize().width
+                                    : recyclerViewManager.getWindowSize().height;
+                                var itemSize = horizontal ? layout.width : layout.height;
+                                if (viewPosition !== undefined) {
+                                    // viewPosition: 0 = top, 0.5 = center, 1 = bottom
+                                    finalOffset =
+                                        offset - (containerSize - itemSize) * viewPosition;
                                 }
-                                return finalOffset + recyclerViewManager.firstItemOffset;
-                            };
-                            lastAbsoluteScrollOffset_1 = recyclerViewManager.getAbsoluteLastScrollOffset();
-                            bufferForScroll = horizontal
-                                ? recyclerViewManager.getWindowSize().width
-                                : recyclerViewManager.getWindowSize().height;
-                            bufferForCompute_1 = bufferForScroll * 2;
-                            getStartScrollOffset = function () {
-                                var lastScrollOffset = lastAbsoluteScrollOffset_1;
-                                var finalOffset = getFinalOffset_1();
-                                if (finalOffset > lastScrollOffset) {
-                                    lastScrollOffset = Math.max(finalOffset - bufferForCompute_1, lastScrollOffset);
-                                    recyclerViewManager.setScrollDirection("forward");
+                                if (viewOffset !== undefined) {
+                                    finalOffset += viewOffset;
                                 }
-                                else {
-                                    lastScrollOffset = Math.min(finalOffset + bufferForCompute_1, lastScrollOffset);
-                                    recyclerViewManager.setScrollDirection("backward");
-                                }
-                                return lastScrollOffset;
-                            };
-                            initialTargetOffset = getFinalOffset_1();
-                            initialStartScrollOffset = getStartScrollOffset();
-                            finalOffset = initialTargetOffset;
-                            startScrollOffset = initialStartScrollOffset;
-                            steps = 5;
-                            i = 0;
-                            _c.label = 1;
-                        case 1:
-                            if (!(i < steps)) return [3 /*break*/, 4];
-                            if (isUnmounted.current) {
-                                return [2 /*return*/];
                             }
-                            nextOffset = animated
-                                ? finalOffset +
-                                    (startScrollOffset - finalOffset) * (i / (steps - 1))
-                                : startScrollOffset +
-                                    (finalOffset - startScrollOffset) * (i / (steps - 1));
-                            return [4 /*yield*/, updateScrollOffsetAsync(nextOffset)];
-                        case 2:
-                            _c.sent();
-                            // In case some change happens in the middle of this operation
-                            // and the index is out of bounds, scroll to the end
-                            if (index >= recyclerViewManager.getDataLength()) {
-                                handlerMethods.scrollToEnd({ animated: animated });
-                                return [2 /*return*/];
+                            return finalOffset + recyclerViewManager.firstItemOffset;
+                        };
+                        var lastAbsoluteScrollOffset_1 = recyclerViewManager.getAbsoluteLastScrollOffset();
+                        var bufferForScroll = horizontal
+                            ? recyclerViewManager.getWindowSize().width
+                            : recyclerViewManager.getWindowSize().height;
+                        var bufferForCompute_1 = bufferForScroll * 2;
+                        var getStartScrollOffset_1 = function () {
+                            var lastScrollOffset = lastAbsoluteScrollOffset_1;
+                            var finalOffset = getFinalOffset_1();
+                            if (finalOffset > lastScrollOffset) {
+                                lastScrollOffset = Math.max(finalOffset - bufferForCompute_1, lastScrollOffset);
+                                recyclerViewManager.setScrollDirection("forward");
+                            }
+                            else {
+                                lastScrollOffset = Math.min(finalOffset + bufferForCompute_1, lastScrollOffset);
+                                recyclerViewManager.setScrollDirection("backward");
+                            }
+                            return lastScrollOffset;
+                        };
+                        var initialTargetOffset_1 = getFinalOffset_1();
+                        var initialStartScrollOffset_1 = getStartScrollOffset_1();
+                        var finalOffset_1 = initialTargetOffset_1;
+                        var startScrollOffset_1 = initialStartScrollOffset_1;
+                        var steps_1 = 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)
+                         */
+                        var performScrollStep_1 = function (currentStep) {
+                            // Check if component is unmounted or we've completed all steps
+                            if (isUnmounted.current) {
+                                return;
                             }
-                            newFinalOffset = getFinalOffset_1();
-                            if ((newFinalOffset < initialTargetOffset &&
-                                newFinalOffset < initialStartScrollOffset) ||
-                                (newFinalOffset > initialTargetOffset &&
-                                    newFinalOffset > initialStartScrollOffset)) {
-                                finalOffset = newFinalOffset;
-                                startScrollOffset = getStartScrollOffset();
-                                initialTargetOffset = newFinalOffset;
-                                initialStartScrollOffset = startScrollOffset;
-                                i = -1; // Restart compute loop
+                            else if (currentStep >= steps_1) {
+                                // All steps completed, perform final scroll
+                                finishScrollToIndex_1();
+                                return;
                             }
-                            _c.label = 3;
-                        case 3:
-                            i++;
-                            return [3 /*break*/, 1];
-                        case 4:
-                            finalOffset = getFinalOffset_1();
-                            maxOffset = recyclerViewManager.getMaxScrollOffset();
-                            if (finalOffset > maxOffset) {
-                                finalOffset = maxOffset;
+                            // Calculate the offset for this step
+                            // For animated scrolls: interpolate from finalOffset to startScrollOffset
+                            // For non-animated: interpolate from startScrollOffset to finalOffset
+                            var nextOffset = animated
+                                ? finalOffset_1 +
+                                    (startScrollOffset_1 - finalOffset_1) *
+                                        (currentStep / (steps_1 - 1))
+                                : startScrollOffset_1 +
+                                    (finalOffset_1 - startScrollOffset_1) *
+                                        (currentStep / (steps_1 - 1));
+                            // Update scroll offset with a callback to continue to the next step
+                            updateScrollOffsetWithCallback(nextOffset, function () {
+                                // 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: animated });
+                                    resolve(); // Resolve the promise as we're done
+                                    return;
+                                }
+                                // Check if the target position has changed significantly
+                                var newFinalOffset = getFinalOffset_1();
+                                if ((newFinalOffset < initialTargetOffset_1 &&
+                                    newFinalOffset < initialStartScrollOffset_1) ||
+                                    (newFinalOffset > initialTargetOffset_1 &&
+                                        newFinalOffset > initialStartScrollOffset_1)) {
+                                    // Target has moved, recalculate and restart from beginning
+                                    finalOffset_1 = newFinalOffset;
+                                    startScrollOffset_1 = getStartScrollOffset_1();
+                                    initialTargetOffset_1 = newFinalOffset;
+                                    initialStartScrollOffset_1 = startScrollOffset_1;
+                                    performScrollStep_1(0); // Restart from step 0
+                                }
+                                else {
+                                    // Continue to next step
+                                    performScrollStep_1(currentStep + 1);
+                                }
+                            });
+                        };
+                        /**
+                         * Completes the scroll to index operation by performing the final scroll
+                         * and re-enabling offset correction after a delay.
+                         */
+                        var finishScrollToIndex_1 = function () {
+                            finalOffset_1 = getFinalOffset_1();
+                            var maxOffset = recyclerViewManager.getMaxScrollOffset();
+                            if (finalOffset_1 > maxOffset) {
+                                finalOffset_1 = 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,
+                                    offset: startScrollOffset_1,
                                     animated: false,
                                     skipFirstItemOffset: true,
                                 });
                             }
+                            // Perform the final scroll to the target position
                             handlerMethods.scrollToOffset({
-                                offset: finalOffset,
+                                offset: finalOffset_1,
                                 animated: animated,
                                 skipFirstItemOffset: true,
                             });
+                            // Re-enable offset correction after a delay
+                            // Longer delay for animated scrolls to allow animation to complete
                             setTimeout(function () {
                                 pauseOffsetCorrection.current = false;
                                 recyclerViewManager.setOffsetProjectionEnabled(true);
+                                resolve(); // Resolve the promise after re-enabling corrections
                             }, animated ? 300 : 200);
-                            _c.label = 5;
-                        case 5: return [2 /*return*/];
+                        };
+                        // Start the scroll animation process
+                        performScrollStep_1(0);
+                    }
+                    else {
+                        // Invalid parameters, resolve immediately
+                        resolve();
                     }
                 });
-            }); },
+            },
             /**
              * Scrolls to a specific item in the list.
              * Finds the item's index and uses scrollToIndex internally.
@@ -416,7 +456,7 @@ function useRecyclerViewController(recyclerViewManager, ref, scrollViewRef, scro
         scrollViewRef,
         setTimeout,
         isUnmounted,
-        updateScrollOffsetAsync,
+        updateScrollOffsetWithCallback,
     ]);
     var applyInitialScrollIndex = (0, react_1.useCallback)(function () {
         var _a, _b;
@@ -454,6 +494,11 @@ function useRecyclerViewController(recyclerViewManager, ref, scrollViewRef, scro
     (0, react_1.useImperativeHandle)(ref, function () {
         return tslib_1.__assign(tslib_1.__assign({}, scrollViewRef.current), handlerMethods);
     }, [handlerMethods, scrollViewRef]);
-    return { applyContentOffset: applyContentOffset, applyInitialScrollIndex: applyInitialScrollIndex, handlerMethods: handlerMethods };
+    return {
+        applyOffsetCorrection: applyOffsetCorrection,
+        computeFirstVisibleIndexForOffsetCorrection: computeFirstVisibleIndexForOffsetCorrection,
+        applyInitialScrollIndex: applyInitialScrollIndex,
+        handlerMethods: handlerMethods,
+    };
 }
 //# sourceMappingURL=useRecyclerViewController.js.map