@onekeyfe/react-native-pager-view 3.0.171 → 3.0.172

package/android/src/main/java/com/reactnativepagerview/CollapsiblePagerHost.kt

@@ -139,6 +139,34 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
   private var syntheticPageRestore = false
   private var resumeTransitionSource: Int? = null
   private val pendingPageRestores = HashSet<String>()
+  private class PageRestoreRequest(view: View, val pageIndex: Int, val generation: Int) {
+    val view = WeakReference(view)
+  }
+  private val pageRestoreRequests = HashMap<String, PageRestoreRequest>()
+
+  private fun registerPageRestore(key: String, view: View, pageIndex: Int): PageRestoreRequest? {
+    if (!nativeSmoothHeaderScrollEnabled) return null
+    val previous = pageRestoreRequests[key]?.view?.get()
+    if (previous is NativeScrollerViewport && previous !== view) previous.host.cancelPendingScrollRestore()
+    ownedScrollerRestoreRequests.remove(key)
+    return PageRestoreRequest(view, pageIndex, attachmentGeneration).also {
+      pageRestoreRequests[key] = it
+      pendingPageRestores.add(key)
+    }
+  }
+
+  private fun isCurrentPageRestore(key: String, request: PageRestoreRequest?): Boolean =
+    !nativeSmoothHeaderScrollEnabled || (request != null && pageRestoreRequests[key] === request &&
+      key in pendingPageRestores && request.generation == attachmentGeneration &&
+      pageKey(request.pageIndex) == key)
+
+  private fun clearPageRestoreForView(key: String, view: View, request: PageRestoreRequest? = null) {
+    if (request != null && pageRestoreRequests[key] !== request) return
+    if (pageRestoreRequests[key]?.view?.get() !== view) return
+    pageRestoreRequests.remove(key)
+    pendingPageRestores.remove(key)
+    ownedScrollerRestoreRequests.remove(key)
+  }
   private var observedRecyclerView: RecyclerView? = null
   private var observedRecyclerKey: String? = null
   private var observedScrollListener: RecyclerView.OnScrollListener? = null
@@ -200,6 +228,18 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
   var headerOffsetPx = 0
     private set
   var pageKeys: List<String> = emptyList()
+    set(value) {
+      if (field == value) return
+      pageRestoreRequests.entries.toList().forEach { (key, request) ->
+        if ((value.getOrNull(request.pageIndex) ?: "page-${request.pageIndex}") != key) {
+          (request.view.get() as? NativeScrollerViewport)?.host?.cancelPendingScrollRestore()
+          pageRestoreRequests.remove(key)
+          pendingPageRestores.remove(key)
+          ownedScrollerRestoreRequests.remove(key)
+        }
+      }
+      field = value
+    }
   var retainedPages: String = "[]"
   var onHeaderOffsetChanged: (() -> Unit)? = null
   var nativeSmoothHeaderScrollEnabled = false
@@ -388,6 +428,9 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
   fun removeAllReactChildren() {
     releaseRefreshForeground()
     detachPrimaryScrollObserver()
+    pageRestoreRequests.clear()
+    pendingPageRestores.clear()
+    ownedScrollerRestoreRequests.clear()
     // Weak keys may disappear after size is read; Collection.toArray tolerates this.
     for (recycler in originalRecyclerPadding.keys.toTypedArray()) {
       restoreRecyclerInsets(recycler)
@@ -917,13 +960,11 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
     val key = pageKey(pageIndex)
     if (ownedScrollerKeys[scroller] == key) return
     ownedScrollerKeys[scroller] = key
-    if (nativeSmoothHeaderScrollEnabled) {
-      pendingPageRestores.add(key)
-      ownedScrollerRestoreRequests[key] = WeakReference(scroller) to null
-    }
+    val restoreRequest = registerPageRestore(key, scroller, pageIndex)
+    if (nativeSmoothHeaderScrollEnabled) ownedScrollerRestoreRequests[key] = WeakReference(scroller) to null
     val generation = attachmentGeneration
     postForCurrentAttachment {
-      if (ownedScrollerKeys[scroller] == key && generation == attachmentGeneration &&
+      if (isCurrentPageRestore(key, restoreRequest) && ownedScrollerKeys[scroller] == key && generation == attachmentGeneration &&
         scroller.isAttachedToWindow && (!nativeSmoothHeaderScrollEnabled ||
           (key in pendingPageRestores && ownedScrollerRestoreRequests[key]?.first?.get() === scroller))) {
         offsetDiag("owned-restore-before", scroller, key)
@@ -942,6 +983,7 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
     scroller.stopMotion()
     scroller.host.cancelPendingScrollRestore()
     ownedScrollerKeys.remove(scroller)?.let { key ->
+      clearPageRestoreForView(key, scroller)
       if (ownedScrollerRestoreRequests[key]?.first?.get() === scroller) ownedScrollerRestoreRequests.remove(key)
     }
     publishConsumedOffset(scroller, remove = true)
@@ -982,8 +1024,7 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
       val request = ownedScrollerRestoreRequests[key]
       if (request == null || request.first.get() !== scroller || request.second != attachmentGeneration ||
         scroller.width <= 0 || scroller.height <= 0 || scroller.host.hasPendingScrollRestore()) return
-      pendingPageRestores.remove(key)
-      ownedScrollerRestoreRequests.remove(key)
+      clearPageRestoreForView(key, scroller)
     }
     if (observedOwnedScroller !== scroller || observedOwnedScrollerKey != key ||
       key != currentPageKey() || transitionHeaderOffsets != null || syntheticPageRestore) return
@@ -1059,13 +1100,18 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
     val key = pageKey(pageIndex)
     if (restoredRecyclerKeys[recycler] != key) {
       restoredRecyclerKeys[recycler] = key
-      if (nativeSmoothHeaderScrollEnabled) pendingPageRestores.add(key)
+      val restoreRequest = registerPageRestore(key, recycler, pageIndex)
       val generation = attachmentGeneration
       recycler.post {
+        if (!isCurrentPageRestore(key, restoreRequest)) {
+          offsetDiag("post-skip-cancelled-page=$pageIndex", recycler, key)
+          return@post
+        }
         if (!isAttachedToWindow || generation != attachmentGeneration ||
           restoredRecyclerKeys[recycler] != key ||
           originalRecyclerPadding[recycler] !== original) {
           if (restoredRecyclerKeys[recycler] == key) restoredRecyclerKeys.remove(recycler)
+          clearPageRestoreForView(key, recycler, restoreRequest)
           return@post
         }
         val saved = transitionPageOffsets?.get(key) ?: pageOffsets[key] ?: 0
@@ -1073,10 +1119,12 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
         offsetDiag("recycler-restore-before-saved=$saved", recycler, key)
         if (nativeSmoothHeaderScrollEnabled && (recycler.height <= 0 || recycler.childCount == 0)) {
           restoredRecyclerKeys.remove(recycler)
+          if (pageRestoreRequests[key] === restoreRequest) pageRestoreRequests.remove(key)
           return@post
         }
         if (saved != current) recycler.scrollBy(0, saved - current)
-        pendingPageRestores.remove(key)
+        if (nativeSmoothHeaderScrollEnabled) clearPageRestoreForView(key, recycler, restoreRequest)
+        else pendingPageRestores.remove(key)
         offsetDiag("recycler-restore-after", recycler, key)
       }
     }
@@ -1123,13 +1171,18 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
     val key = pageKey(pageIndex)
     if (restoredScrollerKeys[scroller] != key) {
       restoredScrollerKeys[scroller] = key
-      if (nativeSmoothHeaderScrollEnabled) pendingPageRestores.add(key)
+      val restoreRequest = registerPageRestore(key, scroller, pageIndex)
       val generation = attachmentGeneration
       scroller.post {
+        if (!isCurrentPageRestore(key, restoreRequest)) {
+          offsetDiag("post-skip-cancelled-page=$pageIndex", scroller, key)
+          return@post
+        }
         if (!isAttachedToWindow || generation != attachmentGeneration ||
           restoredScrollerKeys[scroller] != key ||
           originalScrollerPadding[scroller] !== original) {
           if (restoredScrollerKeys[scroller] == key) restoredScrollerKeys.remove(scroller)
+          clearPageRestoreForView(key, scroller, restoreRequest)
           return@post
         }
         val saved = transitionPageOffsets?.get(key) ?: pageOffsets[key] ?: 0
@@ -1137,10 +1190,12 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
         if (nativeSmoothHeaderScrollEnabled &&
           (scroller.height <= 0 || (scroller.getChildAt(0)?.height ?: 0) <= 0)) {
           restoredScrollerKeys.remove(scroller)
+          if (pageRestoreRequests[key] === restoreRequest) pageRestoreRequests.remove(key)
           return@post
         }
         if (scroller.scrollY != saved) scroller.scrollTo(scroller.scrollX, saved)
-        pendingPageRestores.remove(key)
+        if (nativeSmoothHeaderScrollEnabled) clearPageRestoreForView(key, scroller, restoreRequest)
+        else pendingPageRestores.remove(key)
         offsetDiag("scrollview-restore-after", scroller, key)
       }
     }
@@ -1200,7 +1255,7 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
     publishConsumedOffset(recycler, remove = true)
     val original = originalRecyclerPadding.remove(recycler) ?: return
     updateRecyclerPaddingOwnership(recycler, original)
-    restoredRecyclerKeys.remove(recycler)
+    restoredRecyclerKeys.remove(recycler)?.let { clearPageRestoreForView(it, recycler) }
     recycler.clipToPadding = original.clipToPadding
     recycler.setPadding(original.left, original.top, original.right, original.bottom)
   }
@@ -1208,7 +1263,7 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
   private fun restoreNativeScrollerInsets(scroller: ScrollView) {
     val original = originalScrollerPadding.remove(scroller) ?: return
     updateScrollerPaddingOwnership(scroller, original)
-    restoredScrollerKeys.remove(scroller)
+    restoredScrollerKeys.remove(scroller)?.let { clearPageRestoreForView(it, scroller) }
     if (scroller is ReactScrollView) {
       val state = scroller.reactScrollViewScrollState
       scroller.setScrollAwayPaddingEnabledUnstable(
@@ -1583,6 +1638,7 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
     if (type == ViewCompat.TYPE_TOUCH) pendingRefreshPull = null
     nestedScrollingParentHelper.onNestedScrollAccepted(child, target, axes, type)
     if (type == ViewCompat.TYPE_TOUCH) {
+      pageRestoreRequests.remove(currentPageKey())
       pendingPageRestores.remove(currentPageKey())
       ownedScrollerRestoreRequests.remove(currentPageKey())
     }
@@ -1705,6 +1761,9 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
     nestedNativeGestureStarted = false
     viewTreeObserver.removeOnPreDrawListener(pageContentLayoutListener)
     detachPrimaryScrollObserver()
+    pageRestoreRequests.clear()
+    pendingPageRestores.clear()
+    ownedScrollerRestoreRequests.clear()
     transitionHeaderOffsets?.let { headers ->
       resumeTransitionSource = transitionSourcePage
       syntheticPageRestore = true

package/docs/SPEC.md

@@ -39,6 +39,18 @@ body offset. Existing pre-draw observation also reconciles a same-position comma
 that emits no scroll notification. Zero-sized geometry retains the pending intent;
 no timeout infers that delayed content is permanently short.
 
+In smooth-header mode, Android queued RecyclerView and native ScrollView
+restoration requests belong to one page, native view and attachment generation.
+Touch cancellation or replacement MUST invalidate the old request. A stale posted
+callback MUST NOT restore its offset or clear a newer request's pending state.
+
+On iOS, a valid scrollTo or scrollToEnd command for the currently observed page
+MUST cancel that page's pre-layout restoration intent before executing, including
+commands whose target is already the current offset. The command takes ownership
+of the live reading position; other pages' pending intent is unchanged. This
+coordination does not apply during horizontal transitions or synthetic alignment,
+and does not change legacy mode or invalid-command behavior.
+
 ## Independent NativeScroller migration
 
 Status: implemented in source. Both native builds pass. Android focused emulator

package/ios/RNCCollapsiblePagerViewComponentView.mm

@@ -3398,6 +3398,25 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
   }
 }
 
+- (void)nativeScrollerWillReceiveScrollCommand:(RNCNativeScrollerComponentView *)scroller
+{
+  UIScrollView *scrollView = scroller.scrollView;
+  NSString *ownerKey = _observedPageKey;
+  if (!_nativeSmoothHeaderScrollEnabled || scrollView != _observedScrollView ||
+      ownerKey == nil || ![ownerKey isEqualToString:self.currentPageKey] ||
+      _observedPageIndex != _currentIndex || _currentIndex < 0 || _currentIndex >= _pageControllers.count ||
+      _observedPageGeneration != _generation || _transitioning || _isPagerDragging ||
+      _transitionPageOffsets != nil || _syntheticPageRestore ||
+      ![_pendingPageRestoreKeys containsObject:ownerKey]) return;
+  [self offsetDiag:@"command-pending-cancel-before" page:_observedPageIndex scroll:scrollView];
+  [_pendingPageRestoreKeys removeObject:ownerKey];
+  _currentLogicalOffset = scrollView.contentOffset.y + scrollView.contentInset.top;
+  _pageOffsets[ownerKey] = @(_currentLogicalOffset);
+  [self updateHeaderForScrollView:scrollView];
+  [self offsetDiag:@"command-pending-cancel-after" page:_observedPageIndex scroll:scrollView];
+}
+
+
 - (void)nativeScroller:(RNCNativeScrollerComponentView *)scroller
     callerInsetChangedFrom:(UIEdgeInsets)previous to:(UIEdgeInsets)next
 {

package/ios/RNCNativeScrollerComponentView.h

@@ -10,6 +10,7 @@ NS_ASSUME_NONNULL_BEGIN
 
 // Native inset ownership stays separate from Fabric/Yoga content layout.
 @protocol RNCNativeScrollerInsetCoordinator <NSObject>
+- (void)nativeScrollerWillReceiveScrollCommand:(RNCNativeScrollerComponentView *)scroller;
 - (void)nativeScroller:(RNCNativeScrollerComponentView *)scroller
     callerInsetChangedFrom:(UIEdgeInsets)previous to:(UIEdgeInsets)next;
 @end

package/ios/RNCNativeScrollerComponentView.mm

@@ -428,6 +428,14 @@ static Event RNCScrollerMetrics(UIScrollView *scroll, CGPoint velocity, CGPoint
 - (void)scrollTo:(double)x y:(double)y animated:(BOOL)animated
 {
   if (_recycled || !isfinite(x) || !isfinite(y)) return;
+  for (UIView *owner = self.superview; owner != nil; owner = owner.superview) {
+    if ([owner conformsToProtocol:@protocol(RNCNativeScrollerInsetCoordinator)]) {
+      [(id<RNCNativeScrollerInsetCoordinator>)owner nativeScrollerWillReceiveScrollCommand:self];
+    }
+  }
+#if DEBUG
+  [self offsetDiag:[NSString stringWithFormat:@"command-scrollTo-enter-x=%.4f-y=%.4f-animated=%d", x, y, animated]];
+#endif
   [self stopScrolling];
   UIEdgeInsets inset = _scrollView.adjustedContentInset;
   CGPoint target = CGPointMake(MAX(-inset.left, MIN(x,

package/ios/tests/RNCCollapsiblePagerFirstFrameTests.mm

@@ -22,11 +22,95 @@ using namespace facebook::react;
 - (void)applyInsetsToScrollView:(UIScrollView *)scrollView pageIndex:(NSInteger)index restore:(BOOL)restore;
 @end
 
+@interface RNCNativeScrollerComponentView (ScrollCommandTesting)
+- (void)scrollTo:(double)x y:(double)y animated:(BOOL)animated;
+- (void)scrollToEnd:(BOOL)animated;
+@end
+
 @interface RNCCollapsiblePagerFirstFrameTests : XCTestCase
 @end
 
 @implementation RNCCollapsiblePagerFirstFrameTests
 
+- (void)testReachableTopCommandBeforeLayoutMustNotReplayPendingPagePosition
+{
+  for (NSNumber *command in @[@0, @1, @2]) {
+    RNCCollapsiblePagerViewComponentView *pager = [self pagerWithPageCount:1];
+    RNCNativeScrollerComponentView *scroller = [self addScrollerToPager:pager atIndex:0];
+    NSMutableDictionary *offsets = [pager valueForKey:@"pageOffsets"];
+    offsets[@"page-0"] = @660;
+    scroller.scrollView.contentSize = CGSizeMake(0, 0);
+    [pager attachScrollObserverForCurrentPage];
+    XCTAssertTrue([[pager valueForKey:@"pendingPageRestoreKeys"] containsObject:@"page-0"]);
+    XCTAssertEqualObjects(offsets[@"page-0"], @660);
+    XCTAssertEqual([pager valueForKey:@"observedScrollView"], scroller.scrollView);
+    XCTAssertEqualObjects([pager valueForKey:@"observedPageKey"], @"page-0");
+    XCTAssertEqualObjects([pager valueForKey:@"currentIndex"], @0);
+    if (command.boolValue) {
+      if (command.integerValue == 2) {
+        CGFloat reachableEndQ = MAX(-scroller.scrollView.adjustedContentInset.top,
+          scroller.scrollView.contentSize.height - scroller.scrollView.bounds.size.height +
+          scroller.scrollView.adjustedContentInset.bottom) + scroller.scrollView.contentInset.top;
+        XCTAssertEqualWithAccuracy(reachableEndQ, 120, 0.01);
+        XCTAssertEqualWithAccuracy(scroller.scrollView.contentOffset.y + scroller.scrollView.contentInset.top, reachableEndQ, 0.01);
+        [scroller scrollToEnd:NO];
+      }
+      else [scroller scrollTo:0 y:-scroller.scrollView.adjustedContentInset.top animated:NO];
+      XCTAssertEqualWithAccuracy(scroller.scrollView.contentOffset.y + scroller.scrollView.contentInset.top, command.integerValue == 2 ? 120 : 0, 0.01);
+      XCTAssertFalse([[pager valueForKey:@"pendingPageRestoreKeys"] containsObject:@"page-0"]);
+      XCTAssertEqualWithAccuracy([offsets[@"page-0"] doubleValue], command.integerValue == 2 ? 120 : 0, 0.01);
+      XCTAssertEqual([pager valueForKey:@"observedScrollView"], scroller.scrollView);
+      XCTAssertEqualObjects([pager valueForKey:@"observedPageKey"], @"page-0");
+    }
+    // The existing observed content-size path retries the pending restoration.
+    scroller.scrollView.contentSize = CGSizeMake(320, 1500);
+    XCTAssertFalse([[pager valueForKey:@"pendingPageRestoreKeys"] containsObject:@"page-0"]);
+    CGFloat expected = command.integerValue == 2 ? 120 : (command.boolValue ? 0 : 660);
+    XCTAssertEqualWithAccuracy(scroller.scrollView.contentOffset.y + scroller.scrollView.contentInset.top,
+                              expected, 0.01, @"command=%@ must not replay a cancelled reading position", command);
+    XCTAssertEqualWithAccuracy([[pager valueForKey:@"headerOffset"] doubleValue], command.integerValue == 1 ? 0 : 120, 0.01);
+  }
+}
+
+- (void)testScrollCommandCancellationRespectsOwnerAndValidity
+{
+  for (NSNumber *mode in @[@0, @1, @2]) {
+    RNCCollapsiblePagerViewComponentView *pager = [self pagerWithPageCount:2];
+    RNCNativeScrollerComponentView *current = [self addScrollerToPager:pager atIndex:0];
+    RNCNativeScrollerComponentView *other = [self addScrollerToPager:pager atIndex:1];
+    NSMutableDictionary *offsets = [pager valueForKey:@"pageOffsets"];
+    offsets[@"page-0"] = @660;
+    offsets[@"page-1"] = @360;
+    current.scrollView.contentSize = CGSizeMake(0, 0);
+    [pager attachScrollObserverForCurrentPage];
+    XCTAssertTrue([[pager valueForKey:@"pendingPageRestoreKeys"] containsObject:@"page-0"]);
+    if (mode.integerValue == 0) {
+      [current scrollTo:0 y:NAN animated:NO];
+    } else if (mode.integerValue == 1) {
+      [other scrollTo:0 y:-other.scrollView.adjustedContentInset.top animated:NO];
+    } else {
+      NSUInteger generation = [[pager valueForKey:@"generation"] unsignedIntegerValue];
+      [pager setValue:@(generation + 1) forKey:@"observedPageGeneration"];
+      [current scrollTo:0 y:-current.scrollView.adjustedContentInset.top animated:NO];
+    }
+    XCTAssertTrue([[pager valueForKey:@"pendingPageRestoreKeys"] containsObject:@"page-0"]);
+    XCTAssertEqualObjects(offsets[@"page-0"], @660);
+    XCTAssertEqualObjects(offsets[@"page-1"], @360);
+  }
+  RNCCollapsiblePagerViewComponentView *pager = [self pagerWithPageCount:2];
+  RNCNativeScrollerComponentView *current = [self addScrollerToPager:pager atIndex:0];
+  [self addScrollerToPager:pager atIndex:1];
+  NSMutableDictionary *offsets = [pager valueForKey:@"pageOffsets"];
+  offsets[@"page-0"] = @0;
+  offsets[@"page-1"] = @360;
+  [pager attachScrollObserverForCurrentPage];
+  XCTAssertFalse([[pager valueForKey:@"pendingPageRestoreKeys"] containsObject:@"page-0"]);
+  [current scrollTo:0 y:200 - current.scrollView.contentInset.top animated:NO];
+  XCTAssertEqualWithAccuracy(current.scrollView.contentOffset.y + current.scrollView.contentInset.top, 200, 0.01);
+  XCTAssertEqualWithAccuracy([offsets[@"page-0"] doubleValue], 200, 0.01);
+  XCTAssertEqualObjects(offsets[@"page-1"], @360);
+}
+
 - (void)testTransitionLayoutCannotSaveSourceOffsetIntoDestinationCache
 {
   RNCCollapsiblePagerViewComponentView *pager = [self pagerWithPageCount:2];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/react-native-pager-view",
-  "version": "3.0.171",
+  "version": "3.0.172",
   "description": "React Native wrapper for Android and iOS ViewPager",
   "source": "./src/index.tsx",
   "main": "./lib/module/index.js",
@@ -72,7 +72,7 @@
     "typescript": "^5.9.2"
   },
   "peerDependencies": {
-    "@onekeyfe/react-native-native-logger": "3.0.171",
+    "@onekeyfe/react-native-native-logger": "3.0.172",
     "react": "*",
     "react-native": "*"
   },