@onekeyfe/react-native-pager-view 6.7.0-2 → 6.7.0-20

package/ios/RNCNativeScrollerComponentView.h

@@ -13,6 +13,8 @@ NS_ASSUME_NONNULL_BEGIN
 - (void)nativeScrollerWillReceiveScrollCommand:(RNCNativeScrollerComponentView *)scroller;
 - (void)nativeScroller:(RNCNativeScrollerComponentView *)scroller
     callerInsetChangedFrom:(UIEdgeInsets)previous to:(UIEdgeInsets)next;
+@optional
+- (void)nativeScrollViewDidBecomeReady:(UIScrollView *)scrollView;
 @end
 
 NS_ASSUME_NONNULL_END

package/ios/RNCNativeScrollerComponentView.mm

@@ -8,6 +8,25 @@
 
 using namespace facebook::react;
 
+static void RNCNativeScrollerHomeVisualLog(NSString *phase, UIScrollView *scrollView)
+{
+#if DEBUG
+  Class logClass = NSClassFromString(@"ReactNativeNativeLogger.OneKeyLog");
+  if (logClass == nil) logClass = NSClassFromString(@"OneKeyLog");
+  SEL selector = NSSelectorFromString(@"debug::");
+  if (logClass == nil || ![logClass respondsToSelector:selector]) return;
+  UIRefreshControl *control = scrollView.refreshControl;
+  NSString *message = [NSString stringWithFormat:
+    @"[IOS-HOME-VISUAL] epochMs=%.0f monoMs=%.0f phase=scroller-%@ scrollTag=%ld refresh=%d refreshing=%d scrollY=%.1f insetTop=%.1f",
+    [NSDate.date timeIntervalSince1970] * 1000, CACurrentMediaTime() * 1000,
+    phase, (long)scrollView.tag, control != nil, control.isRefreshing,
+    scrollView.contentOffset.y, scrollView.contentInset.top];
+  typedef void (*LogFunction)(id, SEL, NSString *, NSString *);
+  LogFunction logFunction = (LogFunction)[logClass methodForSelector:selector];
+  logFunction(logClass, selector, @"NativeScroller", message);
+#endif
+}
+
 @interface RNCNativeVerticalScrollView : UIScrollView
 @end
 @implementation RNCNativeVerticalScrollView
@@ -156,6 +175,7 @@ static Event RNCScrollerMetrics(UIScrollView *scroll, CGPoint velocity, CGPoint
     [_refreshControl addTarget:self action:@selector(refreshTriggered:)
              forControlEvents:UIControlEventValueChanged];
     _scrollView.refreshControl = _refreshControl;
+    RNCNativeScrollerHomeVisualLog(@"refresh-created", _scrollView);
   } else if (!next.refreshEnabled && _refreshControl != nil) {
     [_refreshControl endRefreshing];
     _scrollView.refreshControl = nil;
@@ -174,8 +194,10 @@ static Event RNCScrollerMetrics(UIScrollView *scroll, CGPoint velocity, CGPoint
     }
     if (next.refreshing && !_refreshControl.refreshing) {
       [_refreshControl beginRefreshing];
+      RNCNativeScrollerHomeVisualLog(@"refresh-begin-prop", _scrollView);
     } else if (!next.refreshing && (previous.refreshing || createdRefreshControl)) {
       [_refreshControl endRefreshing];
+      if (previous.refreshing) RNCNativeScrollerHomeVisualLog(@"refresh-end-prop", _scrollView);
     }
   }
 
@@ -276,10 +298,23 @@ static Event RNCScrollerMetrics(UIScrollView *scroll, CGPoint velocity, CGPoint
   }
 }
 
+- (void)notifyCoordinatorScrollViewReadyIfNeeded
+{
+  if (_recycled || self.window == nil ||
+      CGRectGetWidth(_scrollView.bounds) <= 0 || CGRectGetHeight(_scrollView.bounds) <= 0) return;
+  for (UIView *owner = self.superview; owner != nil; owner = owner.superview) {
+    if ([owner conformsToProtocol:@protocol(RNCNativeScrollerInsetCoordinator)] &&
+        [owner respondsToSelector:@selector(nativeScrollViewDidBecomeReady:)]) {
+      [(id<RNCNativeScrollerInsetCoordinator>)owner nativeScrollViewDidBecomeReady:_scrollView];
+    }
+  }
+}
+
 - (void)didMoveToSuperview
 {
   [super didMoveToSuperview];
   [self updateTopScrollEdge];
+  [self notifyCoordinatorScrollViewReadyIfNeeded];
 }
 
 - (void)updateLayoutMetrics:(const LayoutMetrics &)layoutMetrics
@@ -292,6 +327,10 @@ static Event RNCScrollerMetrics(UIScrollView *scroll, CGPoint velocity, CGPoint
   if (!CGSizeEqualToSize(previous, _scrollView.bounds.size)) {
     _needsContentClamp = YES;
     [self scheduleContentClamp];
+    if ((previous.width <= 0 || previous.height <= 0) &&
+        _scrollView.bounds.size.width > 0 && _scrollView.bounds.size.height > 0) {
+      [self notifyCoordinatorScrollViewReadyIfNeeded];
+    }
   }
 }
 
@@ -379,6 +418,7 @@ static Event RNCScrollerMetrics(UIScrollView *scroll, CGPoint velocity, CGPoint
   const auto &props = *std::static_pointer_cast<const RNCNativeScrollerProps>(_props);
   if (!props.refreshEnabled || props.refreshing) return;
   _refreshEventSentForDrag = YES;
+  RNCNativeScrollerHomeVisualLog(@"refresh-native-trigger", _scrollView);
   if (_eventEmitter) {
     std::static_pointer_cast<const RNCNativeScrollerEventEmitter>(_eventEmitter)->onRefresh({});
   }
@@ -523,6 +563,7 @@ static Event RNCScrollerMetrics(UIScrollView *scroll, CGPoint velocity, CGPoint
 - (void)setRefreshing:(BOOL)refreshing
 {
   if (_recycled || _refreshControl == nil) return;
+  RNCNativeScrollerHomeVisualLog(refreshing ? @"refresh-command-start" : @"refresh-command-stop", _scrollView);
   if (refreshing) {
     if (!_refreshControl.refreshing) [_refreshControl beginRefreshing];
   } else {
@@ -550,6 +591,7 @@ static Event RNCScrollerMetrics(UIScrollView *scroll, CGPoint velocity, CGPoint
     const auto &props = *std::static_pointer_cast<const RNCNativeScrollerProps>(_props);
     if (props.refreshing) [_refreshControl beginRefreshing];
     [self scheduleContentClamp];
+    [self notifyCoordinatorScrollViewReadyIfNeeded];
   }
 }
 

package/ios/tests/RNCCollapsiblePagerFirstFrameTests.mm

@@ -1,6 +1,8 @@
 #import <XCTest/XCTest.h>
 #import "RNCCollapsiblePagerViewComponentView.h"
 #import "RNCNativeScrollerComponentView.h"
+#import <React/RCTScrollViewComponentView.h>
+#import <react/renderer/components/pagerview/Props.h>
 #import <react/renderer/mounting/MountingTransaction.h>
 
 using namespace facebook::react;
@@ -12,6 +14,7 @@ using namespace facebook::react;
                withSurfaceTelemetry:(const SurfaceTelemetry &)telemetry;
 - (UIScrollView *)findExplicitNativeScrollerInView:(UIView *)view;
 - (UIScrollView *)findVerticalScrollViewInView:(UIView *)view;
+- (UIScrollView *)verticalScrollViewForPageAtIndex:(NSInteger)pageIndex;
 - (void)attachScrollObserverForCurrentPage;
 - (void)attachScrollObserverForCurrentPageAfterTransition:(BOOL)selectionSettled;
 - (void)detachScrollObserver;
@@ -22,6 +25,10 @@ using namespace facebook::react;
 - (void)updateHeaderSettledStateForceBusy:(BOOL)forceBusy;
 - (void)preparePageForHorizontalTransitionAtIndex:(NSInteger)index;
 - (void)applyInsetsToScrollView:(UIScrollView *)scrollView pageIndex:(NSInteger)index restore:(BOOL)restore;
+- (void)updateProps:(const Props::Shared &)props oldProps:(const Props::Shared &)oldProps;
+- (void)mountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView index:(NSInteger)index;
+- (CGFloat)effectiveTopOverlayHeight;
+- (void)updateRefreshControlForScrollView:(UIScrollView *)scrollView;
 @end
 
 @interface RNCNativeScrollerComponentView (ScrollCommandTesting)
@@ -34,6 +41,125 @@ using namespace facebook::react;
 
 @implementation RNCCollapsiblePagerFirstFrameTests
 
+- (void)testPendingLocalOverlayReservesManagedScrollerInsetBeforeSlotRebuild
+{
+  RNCCollapsiblePagerViewComponentView *pager =
+    [[RNCCollapsiblePagerViewComponentView alloc] initWithFrame:CGRectMake(0, 0, 320, 844)];
+  UIWindow *window = [[UIWindow alloc] initWithFrame:pager.frame];
+  UIViewController *root = [UIViewController new];
+  window.rootViewController = root;
+  [root.view addSubview:pager];
+  window.hidden = NO;
+  [self addTeardownBlock:^{
+    [pager prepareForRecycle];
+    window.hidden = YES;
+  }];
+
+  auto baseline = std::make_shared<RNCCollapsiblePagerViewProps>();
+  baseline->nativeSmoothHeaderScrollEnabled = true;
+  baseline->headerHeight = 120;
+  baseline->stickyHeaderHeight = 44;
+  baseline->pageKeys = "[\"page-0\"]";
+  [pager updateProps:baseline oldProps:nullptr];
+
+  UIView *header = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 320, 120)];
+  UIView *sticky = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 320, 44)];
+  UIView *page = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 320, 844)];
+  RNCNativeScrollerComponentView *scroller = [RNCNativeScrollerComponentView new];
+  scroller.frame = page.bounds;
+  scroller.scrollView.frame = scroller.bounds;
+  scroller.scrollView.contentSize = CGSizeMake(320, 1500);
+  [page addSubview:scroller];
+  [pager mountChildComponentView:(id)header index:0];
+  [pager mountChildComponentView:(id)sticky index:1];
+  [pager mountChildComponentView:(id)page index:2];
+  [root.view layoutIfNeeded];
+  [pager layoutIfNeeded];
+  XCTestExpectation *settled = [self expectationWithDescription:@"Baseline slots and observer settled"];
+  dispatch_async(dispatch_get_main_queue(), ^{ [settled fulfill]; });
+  [self waitForExpectations:@[settled] timeout:1];
+  [pager attachScrollObserverForCurrentPage];
+  UIScrollView *ownedScroll = scroller.scrollView;
+  XCTAssertEqual([pager valueForKey:@"observedScrollView"], ownedScroll);
+  XCTAssertEqualWithAccuracy(ownedScroll.contentInset.top, 164, 0.01);
+  [scroller scrollTo:0 y:40 - ownedScroll.contentInset.top animated:NO];
+  [pager setValue:@40 forKey:@"headerOffset"];
+  CGFloat initialLogicalOffset = ownedScroll.contentOffset.y + ownedScroll.contentInset.top;
+  XCTAssertEqualWithAccuracy(initialLogicalOffset, 40, 0.01);
+
+  auto hard = std::make_shared<RNCCollapsiblePagerViewProps>();
+  hard->nativeSmoothHeaderScrollEnabled = true;
+  hard->headerHeight = 120;
+  hard->stickyHeaderHeight = 44;
+  hard->pageKeys = "[\"page-0\"]";
+  hard->topScrollEdgeEffect = RNCCollapsiblePagerViewTopScrollEdgeEffect::Hard;
+  hard->topOverlayHeight = 162;
+  [pager updateProps:hard oldProps:baseline];
+  XCTAssertNil([pager valueForKey:@"topOverlayView"]);
+  XCTAssertEqual([pager valueForKey:@"observedScrollView"], ownedScroll);
+  XCTAssertEqualWithAccuracy([pager effectiveTopOverlayHeight], 162, 0.01);
+  XCTAssertEqualWithAccuracy(ownedScroll.contentInset.top, 326, 0.01);
+  XCTAssertEqualWithAccuracy(ownedScroll.contentOffset.y + ownedScroll.contentInset.top,
+                             initialLogicalOffset, 0.01);
+  [self finishMount:pager];
+  XCTAssertNil([pager valueForKey:@"topOverlayView"]);
+  XCTAssertTrue([[pager valueForKey:@"deferTopEdgeSlotRebuild"] boolValue]);
+
+  UIView *overlay = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 320, 162)];
+  [pager mountChildComponentView:(id)overlay index:2];
+  XCTAssertNil([pager valueForKey:@"topOverlayView"]);
+  [self finishMount:pager];
+  UIView *overlayHost = [pager valueForKey:@"topOverlayHostView"];
+  XCTAssertEqual([pager valueForKey:@"topOverlayView"], overlay);
+  XCTAssertEqual(overlay.superview, overlayHost);
+  XCTAssertEqual(overlay.window, window);
+  XCTAssertEqualWithAccuracy(ownedScroll.contentInset.top, 326, 0.01);
+  XCTAssertEqualWithAccuracy(ownedScroll.contentOffset.y + ownedScroll.contentInset.top,
+                             initialLogicalOffset, 0.01);
+  XCTestExpectation *rebuilt = [self expectationWithDescription:@"Post-mount observer restored"];
+  dispatch_async(dispatch_get_main_queue(), ^{ [rebuilt fulfill]; });
+  [self waitForExpectations:@[rebuilt] timeout:1];
+  [pager attachScrollObserverForCurrentPage];
+  XCTAssertEqual([pager valueForKey:@"topOverlayView"], overlay);
+  XCTAssertEqual([pager valueForKey:@"observedScrollView"], ownedScroll);
+  XCTAssertEqualWithAccuracy(ownedScroll.contentInset.top, 326, 0.01);
+  XCTAssertEqualWithAccuracy(ownedScroll.contentOffset.y + ownedScroll.contentInset.top,
+                             initialLogicalOffset, 0.01);
+
+  UIRefreshControl *control = [UIRefreshControl new];
+  ownedScroll.refreshControl = control;
+  [pager updateRefreshControlForScrollView:ownedScroll];
+  UIEdgeInsets refreshingInset = ownedScroll.contentInset;
+  refreshingInset.top += 60;
+  ownedScroll.contentInset = refreshingInset;
+  auto disabled = std::make_shared<RNCCollapsiblePagerViewProps>();
+  disabled->nativeSmoothHeaderScrollEnabled = true;
+  disabled->headerHeight = 120;
+  disabled->stickyHeaderHeight = 44;
+  disabled->pageKeys = "[\"page-0\"]";
+  disabled->topScrollEdgeEffect = RNCCollapsiblePagerViewTopScrollEdgeEffect::None;
+  disabled->topOverlayHeight = 0;
+  [pager updateProps:disabled oldProps:hard];
+  XCTAssertEqual(ownedScroll.refreshControl, control);
+  XCTAssertEqualWithAccuracy([pager effectiveTopOverlayHeight], 0, 0.01);
+  XCTAssertEqualWithAccuracy(ownedScroll.contentInset.top, 224, 0.01);
+}
+
+- (void)testPendingLocalOverlayHeightDoesNotOverrideExternalGeometry
+{
+  RNCCollapsiblePagerViewComponentView *pager = [RNCCollapsiblePagerViewComponentView new];
+  auto props = std::make_shared<RNCCollapsiblePagerViewProps>();
+  props->topScrollEdgeEffect = RNCCollapsiblePagerViewTopScrollEdgeEffect::Hard;
+  props->topOverlayHeight = 162;
+  props->externalTopOverlayTag = 999;
+  [pager updateProps:props oldProps:nullptr];
+  XCTAssertNil([pager valueForKey:@"topOverlayView"]);
+  XCTAssertEqualWithAccuracy([pager effectiveTopOverlayHeight], 0, 0.01);
+  [pager setValue:@64 forKey:@"externalTopOverlayHeight"];
+  XCTAssertEqualWithAccuracy([pager effectiveTopOverlayHeight], 64, 0.01);
+  [pager prepareForRecycle];
+}
+
 - (void)testHeaderSettledAtTopRequiresCurrentQuietOwnerAndCancelsDetachedTimer
 {
   RNCCollapsiblePagerViewComponentView *pager = [self pagerWithPageCount:1];
@@ -335,6 +461,138 @@ using namespace facebook::react;
   XCTAssertTrue([[pager valueForKey:@"pendingPageRestoreKeys"] containsObject:@"page-1"]);
 }
 
+- (void)testReleasedOwnerRecoversReplacementWithoutAnotherFabricInsertion
+{
+  RNCCollapsiblePagerViewComponentView *pager = [self pagerWithPageCount:1];
+  // The fixture mounts page 0 directly; UIKit must not select it again.
+  [pager setValue:@YES forKey:@"hasAppliedInitialPage"];
+  RNCNativeScrollerComponentView *source = [self addScrollerToPager:pager atIndex:0];
+  source.tag = 91001;
+  [pager.window layoutIfNeeded];
+  [pager layoutIfNeeded];
+  [[NSRunLoop mainRunLoop] runUntilDate:[NSDate dateWithTimeIntervalSinceNow:0.15]];
+  [pager setValue:@120 forKey:@"headerOffset"];
+  [pager attachScrollObserverForCurrentPage];
+  XCTAssertEqual([pager valueForKey:@"observedScrollView"], source.scrollView);
+
+  // Finish the old owner's removal before the replacement becomes available.
+  ShadowView removedView;
+  removedView.tag = (Tag)source.tag;
+  MountingTransaction removal(1, 1, {ShadowViewMutation::RemoveMutation(1, removedView, 0)}, {});
+  SurfaceTelemetry telemetry;
+  [pager mountingTransactionWillMount:removal withSurfaceTelemetry:telemetry];
+  [source removeFromSuperview];
+  [self finishMount:pager];
+  XCTAssertNil([pager valueForKey:@"observedScrollView"]);
+
+  RNCNativeScrollerComponentView *replacement = [self addScrollerToPager:pager atIndex:0];
+  [[NSRunLoop mainRunLoop] runUntilDate:[NSDate dateWithTimeIntervalSinceNow:0.3]];
+  XCTAssertEqual([pager valueForKey:@"observedScrollView"], replacement.scrollView);
+  XCTAssertEqual([pager valueForKey:@"sharedHeaderScrollView"], replacement.scrollView);
+  XCTAssertEqualWithAccuracy(replacement.scrollView.contentOffset.y + replacement.scrollView.contentInset.top,
+                            120, 0.01);
+  XCTAssertEqualWithAccuracy([[pager valueForKey:@"headerOffset"] doubleValue], 120, 0.01);
+}
+
+- (void)testCurrentPageInsertionRestartsExhaustedReplacementRecovery
+{
+  [self assertReplacementRecoveryWithCancelledDrag:NO finalRetryPending:NO];
+}
+
+- (void)testCancelledDragRetainsReplacementRecoveryFromInsertion
+{
+  [self assertReplacementRecoveryWithCancelledDrag:YES finalRetryPending:NO];
+}
+
+- (void)testInsertionInvalidatesPendingFinalReplacementRetry
+{
+  [self assertReplacementRecoveryWithCancelledDrag:NO finalRetryPending:YES];
+}
+
+- (void)assertReplacementRecoveryWithCancelledDrag:(BOOL)cancelDrag
+                                finalRetryPending:(BOOL)finalRetryPending
+{
+  RNCCollapsiblePagerViewComponentView *pager = [self pagerWithPageCount:2];
+  [pager setValue:@YES forKey:@"hasAppliedInitialPage"];
+  RNCNativeScrollerComponentView *source = [self addScrollerToPager:pager atIndex:0];
+  source.tag = 91001;
+  UIView *page = source.superview;
+  page.tag = 92001;
+  UIViewController *otherPage = [pager valueForKey:@"pageControllers"][1];
+  otherPage.view.tag = 92002;
+  [pager.window layoutIfNeeded];
+  [pager layoutIfNeeded];
+  [[NSRunLoop mainRunLoop] runUntilDate:[NSDate dateWithTimeIntervalSinceNow:0.15]];
+  [pager setValue:@120 forKey:@"headerOffset"];
+  [pager attachScrollObserverForCurrentPage];
+  XCTAssertEqual([pager valueForKey:@"observedScrollView"], source.scrollView);
+
+  ShadowView removedView;
+  removedView.tag = (Tag)source.tag;
+  MountingTransaction removal(1, 1, {ShadowViewMutation::RemoveMutation((Tag)page.tag, removedView, 0)}, {});
+  SurfaceTelemetry telemetry;
+  [pager mountingTransactionWillMount:removal withSurfaceTelemetry:telemetry];
+  [source removeFromSuperview];
+  [self finishMount:pager];
+  NSDate *deadline = [NSDate dateWithTimeIntervalSinceNow:3];
+  while (([[pager valueForKey:@"scrollResolveRetryAttempt"] integerValue] < 12 ||
+          (!finalRetryPending && [[pager valueForKey:@"scrollResolveRetryScheduled"] boolValue])) &&
+         deadline.timeIntervalSinceNow > 0) {
+    [[NSRunLoop mainRunLoop] runUntilDate:[NSDate dateWithTimeIntervalSinceNow:0.01]];
+  }
+  XCTAssertEqualObjects([pager valueForKey:@"scrollResolveRetryAttempt"], @12);
+  XCTAssertEqualObjects([pager valueForKey:@"scrollResolveRetryScheduled"], @(finalRetryPending));
+  XCTAssertNotNil([pager valueForKey:@"releasedPageScrollStates"][@"page-0"]);
+
+  // Only a new insertion in the current page can reopen the exhausted budget.
+  [self finishMount:pager];
+  [pager mountingTransactionDidMount:removal withSurfaceTelemetry:telemetry];
+  UIView *replacementHost = [UIView new];
+  replacementHost.tag = 93001;
+  [otherPage.view addSubview:replacementHost];
+  ShadowView insertedView;
+  insertedView.tag = (Tag)replacementHost.tag;
+  MountingTransaction unrelated(1, 2, {ShadowViewMutation::InsertMutation((Tag)otherPage.view.tag, insertedView, 0)}, {});
+  [pager mountingTransactionDidMount:unrelated withSurfaceTelemetry:telemetry];
+  XCTAssertEqualObjects([pager valueForKey:@"scrollResolveRetryAttempt"], @12);
+  XCTAssertEqualObjects([pager valueForKey:@"scrollResolveRetryScheduled"], @(finalRetryPending));
+
+  if (cancelDrag) {
+    [pager beginPageStateTransition];
+    [pager setValue:@YES forKey:@"transitioning"];
+    [pager setValue:@YES forKey:@"isPagerDragging"];
+  }
+  [page addSubview:replacementHost];
+  MountingTransaction insertion(1, 3, {ShadowViewMutation::InsertMutation((Tag)page.tag, insertedView, 0)}, {});
+  [pager mountingTransactionDidMount:insertion withSurfaceTelemetry:telemetry];
+  XCTAssertNil([pager valueForKey:@"observedScrollView"]);
+  NSNumber *retryToken = [pager valueForKey:@"scrollResolveRetryToken"];
+  [pager mountingTransactionDidMount:insertion withSurfaceTelemetry:telemetry];
+  XCTAssertEqualObjects([pager valueForKey:@"scrollResolveRetryToken"], retryToken);
+  if (cancelDrag) {
+    XCTAssertNil([pager valueForKey:@"sharedHeaderScrollView"]);
+    XCTAssertFalse([[pager valueForKey:@"scrollResolveRetryScheduled"] boolValue]);
+    // Settle on the source page while the replacement is still unavailable.
+    [pager attachScrollObserverForCurrentPageAfterTransition:YES];
+    [pager setValue:@NO forKey:@"isPagerDragging"];
+    [pager setValue:@NO forKey:@"transitioning"];
+    [pager attachScrollObserverForCurrentPage];
+    XCTAssertEqualObjects([pager valueForKey:@"currentIndex"], @0);
+  }
+  __block RNCNativeScrollerComponentView *replacement;
+  int64_t replacementDelay = finalRetryPending ? 150 : 50;
+  dispatch_after(dispatch_time(DISPATCH_TIME_NOW, replacementDelay * NSEC_PER_MSEC), dispatch_get_main_queue(), ^{
+    replacement = [self addScrollerToPager:pager atIndex:0];
+    [replacementHost addSubview:replacement];
+  });
+  [[NSRunLoop mainRunLoop] runUntilDate:[NSDate dateWithTimeIntervalSinceNow:0.3]];
+  XCTAssertEqual([pager valueForKey:@"observedScrollView"], replacement.scrollView);
+  XCTAssertEqual([pager valueForKey:@"sharedHeaderScrollView"], replacement.scrollView);
+  XCTAssertEqualWithAccuracy(replacement.scrollView.contentOffset.y + replacement.scrollView.contentInset.top,
+                            120, 0.01);
+  XCTAssertEqualWithAccuracy([[pager valueForKey:@"headerOffset"] doubleValue], 120, 0.01);
+}
+
 - (void)testRenamedPageDoesNotResurrectPrunedObserverCache
 {
   RNCCollapsiblePagerViewComponentView *pager = [self pagerWithPageCount:1];
@@ -479,4 +737,139 @@ using namespace facebook::react;
   XCTAssertEqual(removed.count, 0u);
 }
 
+- (void)testEmptyPageWithoutReleasedOwnerOrScrollHostDoesNotScheduleRetry
+{
+  RNCCollapsiblePagerViewComponentView *pager = [self pagerWithPageCount:1];
+  [pager attachScrollObserverForCurrentPage];
+  XCTAssertNil([pager valueForKey:@"observedScrollView"]);
+  XCTAssertFalse([[pager valueForKey:@"scrollResolveRetryScheduled"] boolValue]);
+  XCTAssertEqual([[pager valueForKey:@"scrollResolveRetryAttempt"] integerValue], 0);
+}
+
+- (void)testLateReplacementRecoversImmediatelyOnReadinessEvenAfterRetryBudgetExpires
+{
+  RNCCollapsiblePagerViewComponentView *pager = [self pagerWithPageCount:1];
+  RNCNativeScrollerComponentView *previous = [self addScrollerToPager:pager atIndex:0];
+  previous.tag = 91003;
+  [pager attachScrollObserverForCurrentPage];
+  UIView *sharedHeader = [pager valueForKey:@"sharedHeaderHostView"];
+  XCTAssertEqual([pager valueForKey:@"observedScrollView"], previous.scrollView);
+
+  ShadowView removedView;
+  removedView.tag = (Tag)previous.tag;
+  MountingTransaction removal(1, 1, {ShadowViewMutation::RemoveMutation(1, removedView, 0)}, {});
+  SurfaceTelemetry telemetry;
+  [pager mountingTransactionWillMount:removal withSurfaceTelemetry:telemetry];
+  [previous removeFromSuperview];
+  [self finishMount:pager];
+  XCTAssertNil([pager valueForKey:@"observedScrollView"]);
+
+  // Simulate retry budget exhaustion before the replacement becomes ready.
+  [pager setValue:@12 forKey:@"scrollResolveRetryAttempt"];
+  [pager setValue:@NO forKey:@"scrollResolveRetryScheduled"];
+  NSUInteger oldToken = [[pager valueForKey:@"scrollResolveRetryToken"] unsignedIntegerValue];
+  [pager setValue:@(oldToken + 1) forKey:@"scrollResolveRetryToken"];
+
+  UIViewController *page = [pager valueForKey:@"pageControllers"][0];
+  UICollectionView *lateList = [[UICollectionView alloc]
+    initWithFrame:CGRectMake(0, 0, 320, 600)
+    collectionViewLayout:[UICollectionViewFlowLayout new]];
+  [page.view addSubview:lateList];
+
+  // Readiness notification triggers immediate reconcile even after retry budget expired.
+  [[NSNotificationCenter defaultCenter]
+    postNotificationName:@"OneKeyNativeScrollViewDidBecomeReady"
+                  object:lateList];
+  XCTAssertEqualObjects([pager valueForKey:@"pendingFallbackScrollView"], lateList);
+
+  // Explicit scroller readiness attaches synchronously with zero debounce delay.
+  [lateList removeFromSuperview];
+  RNCNativeScrollerComponentView *lateScroller = [self addScrollerToPager:pager atIndex:0];
+  XCTAssertEqual([pager valueForKey:@"observedScrollView"], lateScroller.scrollView);
+  XCTAssertEqual(sharedHeader.superview, lateScroller.scrollView);
+  XCTAssertEqualWithAccuracy(lateScroller.scrollView.contentInset.top, 164, 0.01);
+  XCTAssertNil([pager valueForKey:@"releasedPageScrollStates"][@"page-0"]);
+}
+
+- (RCTViewComponentView *)addNativeListToPager:(RNCCollapsiblePagerViewComponentView *)pager
+{
+  Class nativeListClass = NSClassFromString(@"HybridNativeListComponent");
+  XCTAssertNotNil(nativeListClass, @"The real NativeList test dependency must be linked");
+  RCTViewComponentView *component = [[nativeListClass alloc] init];
+  component.tag = 92001;
+  component.frame = CGRectMake(0, 0, 320, 600);
+  component.contentView.frame = component.bounds;
+  UIViewController *page = [pager valueForKey:@"pageControllers"][0];
+  [page.view addSubview:component];
+  [component.contentView layoutIfNeeded];
+  return component;
+}
+
+- (void)testNativeListFooterScrollViewCannotReplacePageOwner
+{
+  RNCCollapsiblePagerViewComponentView *pager = [self pagerWithPageCount:1];
+  RCTViewComponentView *component = [self addNativeListToPager:pager];
+  UICollectionView *list = nil;
+  for (UIView *child in component.contentView.subviews) {
+    if ([child isKindOfClass:UICollectionView.class]) {
+      list = (UICollectionView *)child;
+      break;
+    }
+  }
+  XCTAssertTrue([list isKindOfClass:UICollectionView.class]);
+  XCTAssertGreaterThan(CGRectGetWidth(list.bounds), 0);
+  XCTAssertGreaterThan(CGRectGetHeight(list.bounds), 0);
+  XCTAssertEqual(list.delegate, (id)component.contentView);
+  XCTAssertTrue([list isDescendantOfView:component.contentView]);
+  [pager attachScrollObserverForCurrentPage];
+  UIView *header = [pager valueForKey:@"sharedHeaderHostView"];
+  XCTAssertNotNil(header);
+  XCTAssertEqual([pager valueForKey:@"observedScrollView"], list);
+  XCTAssertEqual(header.superview, list);
+  CGFloat inset = list.contentInset.top;
+  CGFloat offset = list.contentOffset.y;
+
+  RCTScrollViewComponentView *footerList = [RCTScrollViewComponentView new];
+  footerList.tag = 92002;
+  footerList.frame = CGRectMake(0, 0, 320, 400);
+  footerList.scrollView.frame = footerList.bounds;
+  footerList.scrollView.contentSize = CGSizeMake(320, 1000);
+  footerList.scrollView.alwaysBounceHorizontal = NO;
+  for (NSInteger index = 0; index < 6; index++) {
+    UIView *slot = index == 2 ? footerList : [UIView new];
+    [component mountChildComponentView:(id)slot index:index];
+  }
+  XCTAssertTrue([footerList isDescendantOfView:list]);
+  XCTAssertEqual([pager verticalScrollViewForPageAtIndex:0], list);
+  ShadowView inserted;
+  inserted.tag = (Tag)footerList.tag;
+  MountingTransaction transaction(1, 2,
+    {ShadowViewMutation::InsertMutation((Tag)component.tag, inserted, 2)}, {});
+  SurfaceTelemetry telemetry;
+  [pager mountingTransactionDidMount:transaction withSurfaceTelemetry:telemetry];
+  XCTAssertEqual([pager valueForKey:@"observedScrollView"], list);
+  XCTAssertEqual(header.superview, list);
+  XCTAssertEqualWithAccuracy(list.contentInset.top, inset, 0.01);
+  XCTAssertEqualWithAccuracy(list.contentOffset.y, offset, 0.01);
+  XCTAssertEqualWithAccuracy(footerList.scrollView.contentInset.top, 0, 0.01);
+}
+
+- (void)testExplicitScrollerSiblingStillPrecedesNativeList
+{
+  RNCCollapsiblePagerViewComponentView *pager = [self pagerWithPageCount:1];
+  [self addNativeListToPager:pager];
+  RNCNativeScrollerComponentView *scroller = [self addScrollerToPager:pager atIndex:0];
+  XCTAssertEqual([pager verticalScrollViewForPageAtIndex:0], scroller.scrollView);
+}
+
+- (void)testPageWithoutNativeListStillDelegatesToNestedPager
+{
+  RNCCollapsiblePagerViewComponentView *outer = [self pagerWithPageCount:1];
+  RNCCollapsiblePagerViewComponentView *inner = [self pagerWithPageCount:1];
+  RNCNativeScrollerComponentView *scroller = [self addScrollerToPager:inner atIndex:0];
+  UIViewController *page = [outer valueForKey:@"pageControllers"][0];
+  [page.view addSubview:inner];
+  XCTAssertEqual([outer verticalScrollViewForPageAtIndex:0], scroller.scrollView);
+}
+
 @end