@onekeyfe/react-native-pager-view 3.0.173 → 3.0.174

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

@@ -33,6 +33,9 @@ static Event RNCScrollerMetrics(UIScrollView *scroll, CGPoint velocity, CGPoint
 @end
 
 @implementation RNCNativeScrollerComponentView {
+#if DEBUG
+  NSUInteger _offsetDiagSequence;
+#endif
   RNCNativeScrollerShadowNode::ConcreteState::Shared _state;
   RNCNativeVerticalScrollView *_scrollView;
   UIView<RCTComponentViewProtocol> *_reactContent;
@@ -51,6 +54,24 @@ static Event RNCScrollerMetrics(UIScrollView *scroll, CGPoint velocity, CGPoint
   NSNumber *_lastContentViewportHeight;
 }
 
+- (void)offsetDiag:(NSString *)reason
+{
+#if DEBUG
+  Class logClass = NSClassFromString(@"ReactNativeNativeLogger.OneKeyLog") ?: NSClassFromString(@"OneKeyLog");
+  SEL selector = NSSelectorFromString(@"debug::");
+  if (logClass == nil || ![logClass respondsToSelector:selector]) return;
+  NSString *message = [NSString stringWithFormat:
+    @"[HOME-OFFSET-DIAG] scroller phase=%@ seq=%lu wallMs=%.0f mono=%.6f host=%p tag=%ld scroll=%p generation=%lu physicalY=%.4f insetTop=%.4f logicalY=%.4f contentHeight=%.4f boundsHeight=%.4f adjustedBottom=%.4f needsClamp=%d drag=%d decel=%d refresh=%d",
+    reason, (unsigned long)++_offsetDiagSequence, NSDate.date.timeIntervalSince1970 * 1000, CACurrentMediaTime(),
+    (__bridge void *)self, (long)self.tag, (__bridge void *)_scrollView, (unsigned long)_generation,
+    _scrollView.contentOffset.y, _scrollView.contentInset.top, _scrollView.contentOffset.y + _scrollView.contentInset.top,
+    _scrollView.contentSize.height, _scrollView.bounds.size.height, _scrollView.adjustedContentInset.bottom,
+    _needsContentClamp, _scrollView.dragging, _scrollView.decelerating, _refreshControl.refreshing];
+  typedef void (*LogFunction)(id, SEL, NSString *, NSString *);
+  ((LogFunction)[logClass methodForSelector:selector])(logClass, selector, @"NativeScroller", message);
+#endif
+}
+
 + (ComponentDescriptorProvider)componentDescriptorProvider
 {
   return concreteComponentDescriptorProvider<RNCNativeScrollerComponentDescriptor>();
@@ -179,7 +200,9 @@ static Event RNCScrollerMetrics(UIScrollView *scroll, CGPoint velocity, CGPoint
     _needsContentClamp |= size.height < _scrollView.contentSize.height;
     CGPoint offset = _scrollView.contentOffset;
     BOOL wasPulling = offset.y < -_scrollView.adjustedContentInset.top;
+    [self offsetDiag:@"content-size-before"];
     _scrollView.contentSize = size;
+    [self offsetDiag:@"content-size-after"];
     // UIKit can synchronously discard a pull when content becomes empty.
     // Upper-range shrink correction remains owned by the deferred clamp.
     if (wasPulling && _scrollView.contentOffset.y != offset.y) {
@@ -197,10 +220,12 @@ static Event RNCScrollerMetrics(UIScrollView *scroll, CGPoint velocity, CGPoint
 - (void)updateLayoutMetrics:(const LayoutMetrics &)layoutMetrics
            oldLayoutMetrics:(const LayoutMetrics &)oldLayoutMetrics
 {
+  [self offsetDiag:@"layout-before"];
   CGSize previous = _scrollView.bounds.size;
   [super updateLayoutMetrics:layoutMetrics oldLayoutMetrics:oldLayoutMetrics];
   [self updateFabricContentOrigin];
   [self emitContentViewportChangeIfNeeded];
+  [self offsetDiag:@"layout-after"];
   if (!CGSizeEqualToSize(previous, _scrollView.bounds.size)) {
     _needsContentClamp = YES;
     [self scheduleContentClamp];
@@ -263,6 +288,7 @@ static Event RNCScrollerMetrics(UIScrollView *scroll, CGPoint velocity, CGPoint
 - (void)scheduleContentClamp
 {
   if (!_needsContentClamp) return;
+  [self offsetDiag:@"clamp-scheduled"];
   NSUInteger generation = _generation;
   __weak __typeof__(self) weakSelf = self;
   dispatch_async(dispatch_get_main_queue(), ^{
@@ -274,13 +300,19 @@ static Event RNCScrollerMetrics(UIScrollView *scroll, CGPoint velocity, CGPoint
 
 - (void)clampContentOffsetIfNeeded
 {
+  [self offsetDiag:@"clamp-enter-or-deferred"];
   if (!_needsContentClamp || _scrollView.dragging || _scrollView.decelerating ||
       _refreshControl.refreshing || _scrollView.bounds.size.height <= 0) return;
   _needsContentClamp = NO;
   CGFloat maximum = MAX(-_scrollView.adjustedContentInset.top,
     _scrollView.contentSize.height - _scrollView.bounds.size.height + _scrollView.adjustedContentInset.bottom);
+#if DEBUG
+  [self offsetDiag:[NSString stringWithFormat:@"clamp-candidate-max=%.4f", maximum]];
+#endif
   if (_scrollView.contentOffset.y > maximum) {
+    [self offsetDiag:@"clamp-applied-before"];
     [_scrollView setContentOffset:CGPointMake(_scrollView.contentOffset.x, maximum) animated:NO];
+    [self offsetDiag:@"clamp-applied-after"];
   }
 }
 
@@ -313,12 +345,15 @@ static Event RNCScrollerMetrics(UIScrollView *scroll, CGPoint velocity, CGPoint
 {
   if (!_momentumActive) return;
   _momentumActive = NO;
+  [[NSNotificationCenter defaultCenter] postNotificationName:@"OneKeyNativeListScrollCommandAccepted"
+    object:_scrollView userInfo:@{@"phase": @2}];
   [self emitScrollEvent:4 velocity:CGPointZero target:_scrollView.contentOffset];
 }
 
 - (void)stopScrolling
 {
   if (_stopping) return;
+  [self offsetDiag:@"stop-before"];
   _stopping = YES;
   [_scrollView setContentOffset:_scrollView.contentOffset animated:NO];
   if (_dragActive) {
@@ -330,6 +365,7 @@ static Event RNCScrollerMetrics(UIScrollView *scroll, CGPoint velocity, CGPoint
   }
   [self finishMomentum];
   _stopping = NO;
+  [self offsetDiag:@"stop-after"];
 }
 
 - (void)scrollViewWillBeginDragging:(UIScrollView *)scrollView
@@ -394,6 +430,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,
@@ -401,11 +445,15 @@ static Event RNCScrollerMetrics(UIScrollView *scroll, CGPoint velocity, CGPoint
     MAX(-inset.top, MIN(y,
     MAX(-inset.top, _scrollView.contentSize.height - _scrollView.bounds.size.height + inset.bottom))));
   if (CGPointEqualToPoint(target, _scrollView.contentOffset)) return;
+  [[NSNotificationCenter defaultCenter] postNotificationName:@"OneKeyNativeListScrollCommandAccepted"
+    object:_scrollView userInfo:@{@"phase": @1}];
   if (animated) {
     _momentumActive = YES;
     [self emitScrollEvent:3 velocity:CGPointZero target:target];
   }
   [_scrollView setContentOffset:target animated:animated];
+  if (!animated) [[NSNotificationCenter defaultCenter] postNotificationName:@"OneKeyNativeListScrollCommandAccepted"
+    object:_scrollView userInfo:@{@"phase": @2}];
 }
 
 - (void)scrollToEnd:(BOOL)animated

package/ios/tests/RNCCollapsiblePagerFirstFrameTests.mm

@@ -6,11 +6,26 @@
 using namespace facebook::react;
 
 @interface RNCCollapsiblePagerViewComponentView (FirstFrameTesting)
+- (void)mountingTransactionWillMount:(const MountingTransaction &)transaction
+                withSurfaceTelemetry:(const SurfaceTelemetry &)telemetry;
 - (void)mountingTransactionDidMount:(const MountingTransaction &)transaction
                withSurfaceTelemetry:(const SurfaceTelemetry &)telemetry;
 - (UIScrollView *)findExplicitNativeScrollerInView:(UIView *)view;
 - (UIScrollView *)findVerticalScrollViewInView:(UIView *)view;
 - (void)attachScrollObserverForCurrentPage;
+- (void)attachScrollObserverForCurrentPageAfterTransition:(BOOL)selectionSettled;
+- (void)detachScrollObserver;
+- (void)beginPageStateTransition;
+- (void)updatePageStateTransitionProgress:(CGFloat)progress;
+- (void)finishPageStateTransition;
+- (void)scrollToTop:(NSInteger)target animated:(BOOL)animated;
+- (void)preparePageForHorizontalTransitionAtIndex:(NSInteger)index;
+- (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
@@ -18,6 +33,284 @@ using namespace facebook::react;
 
 @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;
+    [pager setValue:@120 forKey:@"headerOffset"];
+    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], 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 : 780);
+    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;
+    [pager setValue:@120 forKey:@"headerOffset"];
+    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 setValue:@120 forKey:@"headerOffset"];
+  [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], 80, 0.01);
+  XCTAssertEqualObjects(offsets[@"page-1"], @360);
+}
+
+- (void)testPagerTopCommandsClearOnlyCurrentReadingMemoryInBothModes
+{
+  for (NSNumber *smooth in @[@NO, @YES]) {
+    for (NSNumber *target in @[@0, @1]) {
+      RNCCollapsiblePagerViewComponentView *pager = [self pagerWithPageCount:2];
+      [pager setValue:smooth forKey:@"nativeSmoothHeaderScrollEnabled"];
+      RNCNativeScrollerComponentView *current = [self addScrollerToPager:pager atIndex:0];
+      [self addScrollerToPager:pager atIndex:1];
+      NSMutableDictionary *offsets = [pager valueForKey:@"pageOffsets"];
+      offsets[@"page-0"] = smooth.boolValue ? @660 : @780;
+      offsets[@"page-1"] = @360;
+      [pager setValue:@120 forKey:@"headerOffset"];
+      [pager attachScrollObserverForCurrentPage];
+      [pager scrollToTop:target.integerValue animated:NO];
+      CGFloat expectedQ = target.boolValue ? 120 : 0;
+      XCTAssertEqualWithAccuracy(current.scrollView.contentOffset.y + current.scrollView.contentInset.top, expectedQ, 0.01);
+      XCTAssertEqualWithAccuracy([[pager valueForKey:@"headerOffset"] doubleValue], expectedQ, 0.01);
+      XCTAssertEqualWithAccuracy([offsets[@"page-0"] doubleValue], smooth.boolValue ? 0 : expectedQ, 0.01);
+      XCTAssertEqualObjects(offsets[@"page-1"], @360);
+      XCTAssertFalse([[pager valueForKey:@"pendingPageRestoreKeys"] containsObject:@"page-0"]);
+      XCTAssertNil([pager valueForKey:@"pagerTopScrollView"]);
+      // A same-target call cannot resurrect the old reading position.
+      [pager scrollToTop:target.integerValue animated:NO];
+      XCTAssertEqualWithAccuracy(current.scrollView.contentOffset.y + current.scrollView.contentInset.top, expectedQ, 0.01);
+      XCTAssertEqualObjects(offsets[@"page-1"], @360);
+    }
+  }
+}
+
+- (void)testTransitionLayoutCannotSaveSourceOffsetIntoDestinationCache
+{
+  RNCCollapsiblePagerViewComponentView *pager = [self pagerWithPageCount:2];
+  RNCNativeScrollerComponentView *source = [self addScrollerToPager:pager atIndex:0];
+  RNCNativeScrollerComponentView *target = [self addScrollerToPager:pager atIndex:1];
+  NSMutableDictionary *offsets = [pager valueForKey:@"pageOffsets"];
+  offsets[@"page-0"] = @0;
+  offsets[@"page-1"] = @660;
+  [pager setValue:@120 forKey:@"headerOffset"];
+  [pager attachScrollObserverForCurrentPage];
+  XCTAssertEqualWithAccuracy(source.scrollView.contentOffset.y + source.scrollView.contentInset.top, 120, 0.01);
+  XCTAssertEqualObjects([pager valueForKey:@"headerOffset"], @120);
+  XCTAssertEqualObjects(offsets[@"page-1"], @660);
+  [pager detachScrollObserver];
+  [pager setValue:@YES forKey:@"transitioning"];
+  // A layout pass runs between programmatic transition start and completion.
+  [pager attachScrollObserverForCurrentPage];
+  [pager setValue:@1 forKey:@"currentIndex"];
+  [pager attachScrollObserverForCurrentPageAfterTransition:YES];
+  XCTAssertEqualWithAccuracy([offsets[@"page-1"] doubleValue], 660, 0.01);
+  XCTAssertEqualWithAccuracy(target.scrollView.contentOffset.y + target.scrollView.contentInset.top, 780, 0.01);
+  XCTAssertNotEqual([pager valueForKey:@"observedScrollView"], source.scrollView);
+}
+
+- (void)testSmoothTransitionKeepsGlobalHeaderAndIndependentBodyMemory
+{
+  for (NSNumber *collapse in @[@0, @60, @120]) {
+    for (NSNumber *body in @[@0, @60, @660]) {
+      RNCCollapsiblePagerViewComponentView *pager = [self pagerWithPageCount:2];
+      RNCNativeScrollerComponentView *source = [self addScrollerToPager:pager atIndex:0];
+      RNCNativeScrollerComponentView *target = [self addScrollerToPager:pager atIndex:1];
+      NSMutableDictionary *offsets = [pager valueForKey:@"pageOffsets"];
+      offsets[@"page-0"] = @0;
+      offsets[@"page-1"] = body;
+      [pager setValue:collapse forKey:@"headerOffset"];
+      [pager attachScrollObserverForCurrentPage];
+      [pager beginPageStateTransition];
+      [pager setValue:@YES forKey:@"isPagerDragging"];
+      [pager setValue:@YES forKey:@"transitioning"];
+      [pager updatePageStateTransitionProgress:0.5];
+      CGFloat targetQ = collapse.doubleValue + (collapse.doubleValue == 120 ? body.doubleValue : 0);
+      XCTAssertEqualWithAccuracy([[pager valueForKey:@"headerOffset"] doubleValue], collapse.doubleValue, 0.01);
+      XCTAssertEqualWithAccuracy(source.scrollView.contentOffset.y + source.scrollView.contentInset.top, collapse.doubleValue, 0.01);
+      XCTAssertEqualWithAccuracy(target.scrollView.contentOffset.y + target.scrollView.contentInset.top, targetQ, 0.01);
+      XCTAssertEqualObjects(offsets[@"page-0"], @0);
+      XCTAssertEqualObjects(offsets[@"page-1"], body);
+      // Cancellation restores the source display without consuming either reading memory.
+      [pager finishPageStateTransition];
+      XCTAssertEqualWithAccuracy(source.scrollView.contentOffset.y + source.scrollView.contentInset.top, collapse.doubleValue, 0.01);
+      XCTAssertEqualObjects(offsets[@"page-1"], body);
+      [pager setValue:@NO forKey:@"isPagerDragging"];
+      [pager setValue:@NO forKey:@"transitioning"];
+      [pager attachScrollObserverForCurrentPage];
+      [pager beginPageStateTransition];
+      [pager setValue:@1 forKey:@"destinationIndex"];
+      [pager preparePageForHorizontalTransitionAtIndex:1];
+      [pager updatePageStateTransitionProgress:1];
+      XCTAssertEqualWithAccuracy(source.scrollView.contentOffset.y + source.scrollView.contentInset.top, collapse.doubleValue, 0.01);
+      [pager setValue:@1 forKey:@"currentIndex"];
+      [pager attachScrollObserverForCurrentPageAfterTransition:YES];
+      XCTAssertEqualWithAccuracy(target.scrollView.contentOffset.y + target.scrollView.contentInset.top, targetQ, 0.01);
+      XCTAssertEqualWithAccuracy([[pager valueForKey:@"headerOffset"] doubleValue], collapse.doubleValue, 0.01);
+      XCTAssertEqualObjects(offsets[@"page-1"], body);
+    }
+  }
+}
+
+- (void)testNonAdjacentTransitionUsesFixedEndpointsAndRestoresIntermediatePage
+{
+  RNCCollapsiblePagerViewComponentView *pager = [self pagerWithPageCount:4];
+  for (NSInteger index = 0; index < 4; index++) [self addScrollerToPager:pager atIndex:index];
+  NSMutableDictionary *offsets = [pager valueForKey:@"pageOffsets"];
+  offsets[@"page-0"] = @0;
+  offsets[@"page-1"] = @60;
+  offsets[@"page-2"] = @360;
+  offsets[@"page-3"] = @660;
+  [pager setValue:@60 forKey:@"headerOffset"];
+  [pager attachScrollObserverForCurrentPage];
+  [pager beginPageStateTransition];
+  [pager setValue:@3 forKey:@"destinationIndex"];
+  [pager preparePageForHorizontalTransitionAtIndex:3];
+  [pager updatePageStateTransitionProgress:1];
+  XCTAssertEqualWithAccuracy([[pager valueForKey:@"headerOffset"] doubleValue], 60, 0.01);
+  [pager setValue:@3 forKey:@"currentIndex"];
+  [pager attachScrollObserverForCurrentPageAfterTransition:YES];
+  XCTAssertEqualObjects(offsets[@"page-1"], @60);
+  XCTAssertEqualObjects(offsets[@"page-2"], @360);
+  XCTAssertEqualObjects(offsets[@"page-3"], @660);
+  for (NSInteger index = 1; index < 4; index++) {
+    UIViewController *page = [pager valueForKey:@"pageControllers"][index];
+    RNCNativeScrollerComponentView *scroller = page.view.subviews.firstObject;
+    XCTAssertEqualWithAccuracy(scroller.scrollView.contentOffset.y + scroller.scrollView.contentInset.top,
+                              60, 0.01);
+  }
+}
+
+- (void)testZeroLayoutPreservesPendingBodyRestore
+{
+  RNCCollapsiblePagerViewComponentView *pager = [self pagerWithPageCount:1];
+  RNCNativeScrollerComponentView *scroller = [self addScrollerToPager:pager atIndex:0];
+  NSMutableDictionary *offsets = [pager valueForKey:@"pageOffsets"];
+  offsets[@"page-0"] = @660;
+  [pager setValue:@120 forKey:@"headerOffset"];
+  scroller.scrollView.contentSize = CGSizeMake(0, 0);
+  [pager attachScrollObserverForCurrentPage];
+  XCTAssertEqualObjects(offsets[@"page-0"], @660);
+  XCTAssertTrue([[pager valueForKey:@"pendingPageRestoreKeys"] containsObject:@"page-0"]);
+  // Releasing an observed but unmeasured identity must retain its pending B.
+  scroller.tag = 91001;
+  ShadowView removedView;
+  removedView.tag = (Tag)scroller.tag;
+  MountingTransaction removal(1, 1, {ShadowViewMutation::RemoveMutation(1, removedView, 0)}, {});
+  SurfaceTelemetry telemetry;
+  [pager mountingTransactionWillMount:removal withSurfaceTelemetry:telemetry];
+  XCTAssertEqualObjects(offsets[@"page-0"], @660);
+  [self finishMount:pager];
+  XCTAssertEqualObjects(offsets[@"page-0"], @660);
+  scroller.scrollView.contentSize = CGSizeMake(320, 1500);
+  XCTAssertEqualObjects(offsets[@"page-0"], @660);
+  XCTAssertFalse([[pager valueForKey:@"pendingPageRestoreKeys"] containsObject:@"page-0"]);
+  XCTAssertEqualWithAccuracy(scroller.scrollView.contentOffset.y + scroller.scrollView.contentInset.top, 780, 0.01);
+}
+
+- (void)testUnresolvedReplacementDoesNotCommitTemporaryClamp
+{
+  RNCCollapsiblePagerViewComponentView *pager = [self pagerWithPageCount:2];
+  RNCNativeScrollerComponentView *source = [self addScrollerToPager:pager atIndex:0];
+  NSMutableDictionary *offsets = [pager valueForKey:@"pageOffsets"];
+  offsets[@"page-0"] = @0;
+  offsets[@"page-1"] = @660;
+  [pager setValue:@120 forKey:@"headerOffset"];
+  [pager attachScrollObserverForCurrentPage];
+  [pager beginPageStateTransition];
+  [pager setValue:@1 forKey:@"destinationIndex"];
+  UICollectionView *replacement = [[UICollectionView alloc]
+    initWithFrame:CGRectMake(0, 0, 320, 600)
+    collectionViewLayout:[UICollectionViewFlowLayout new]];
+  UIViewController *page = [pager valueForKey:@"pageControllers"][1];
+  [page.view addSubview:replacement];
+  id released = [NSClassFromString(@"RNCCollapsiblePagerReleasedScrollState") new];
+  XCTAssertNotNil(released);
+  [released setValue:source.scrollView forKey:@"scrollView"];
+  [released setValue:source forKey:@"componentView"];
+  [released setValue:@(source.tag) forKey:@"componentTag"];
+  [pager valueForKey:@"releasedPageScrollStates"][@"page-1"] = released;
+  [pager preparePageForHorizontalTransitionAtIndex:1];
+  [pager setValue:@1 forKey:@"currentIndex"];
+  [pager finishPageStateTransition];
+  XCTAssertEqualObjects(offsets[@"page-1"], @660);
+  XCTAssertTrue([[pager valueForKey:@"pendingPageRestoreKeys"] containsObject:@"page-1"]);
+}
+
+- (void)testRenamedPageDoesNotResurrectPrunedObserverCache
+{
+  RNCCollapsiblePagerViewComponentView *pager = [self pagerWithPageCount:1];
+  RNCNativeScrollerComponentView *scroller = [self addScrollerToPager:pager atIndex:0];
+  NSMutableDictionary *offsets = [pager valueForKey:@"pageOffsets"];
+  offsets[@"page-0"] = @60;
+  [pager attachScrollObserverForCurrentPage];
+  [pager setValue:@[@"replacement-key"] forKey:@"pageKeys"];
+  [offsets removeObjectForKey:@"page-0"];
+  scroller.scrollView.contentOffset = CGPointMake(0, 200);
+  [pager detachScrollObserver];
+  XCTAssertNil(offsets[@"page-0"]);
+  XCTAssertNil(offsets[@"replacement-key"]);
+}
+
 - (RNCCollapsiblePagerViewComponentView *)pagerWithPageCount:(NSInteger)count
 {
   RNCCollapsiblePagerViewComponentView *pager =

package/ios/tests/RNCCollapsiblePagerRefreshControlTests.mm

@@ -1,6 +1,7 @@
 #import <XCTest/XCTest.h>
 #import <React/RCTViewComponentView.h>
 #import "RNCCollapsiblePagerViewComponentView.h"
+#import "RNCNativeScrollerComponentView.h"
 
 @interface RNCCollapsiblePagerViewComponentView (RefreshControlTesting)
 - (void)updateRefreshControlForScrollView:(UIScrollView *)scrollView;
@@ -8,6 +9,10 @@
 - (void)attachScrollObserverForCurrentPage;
 @end
 
+@interface RNCNativeScrollerComponentView (RefreshControlScrollCommandTesting)
+- (void)scrollTo:(double)x y:(double)y animated:(BOOL)animated;
+@end
+
 @interface RNCCollapsiblePagerRefreshControlTests : XCTestCase
 @end
 
@@ -184,14 +189,18 @@
   RNCCollapsiblePagerViewComponentView *pager = [self pagerWithHeader:64];
   [pager mountChildComponentView:[RCTViewComponentView new] index:0];
   [pager mountChildComponentView:[RCTViewComponentView new] index:1];
-  UIScrollView *scroll = [[UIScrollView alloc] initWithFrame:CGRectMake(0, 0, 320, 600)];
+  RNCNativeScrollerComponentView *scroller = [RNCNativeScrollerComponentView new];
+  scroller.frame = CGRectMake(0, 0, 320, 600);
+  scroller.scrollView.frame = scroller.bounds;
+  UIScrollView *scroll = scroller.scrollView;
   scroll.refreshControl = [UIRefreshControl new];
   scroll.contentSize = CGSizeMake(320, 2000);
   scroll.contentInset = UIEdgeInsetsMake(232, 0, 0, 0);
   UIView *content = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 320, 2000)];
   [scroll addSubview:content];
   UIViewController *page = [UIViewController new];
-  [page.view addSubview:scroll];
+  [page.view addSubview:scroller];
+  [pager addSubview:page.view];
   NSMutableArray<UIViewController *> *pages = [pager valueForKey:@"pageControllers"];
   [pages addObject:page];
   [pager attachScrollObserverForCurrentPage];
@@ -204,7 +213,7 @@
   XCTAssertEqualWithAccuracy(scroll.contentInset.top, 340, 0.001);
   XCTAssertEqualWithAccuracy(headerHost.transform.ty, 0, 0.001);
 
-  scroll.contentOffset = CGPointMake(0, 500);
+  [scroller scrollTo:0 y:500 animated:NO];
   CGFloat baselineStickyTranslation = stickyHeader.transform.ty;
   CGFloat baselineTabBarTranslation = tabBar.transform.ty;
   XCTAssertEqualWithAccuracy(baselineStickyTranslation, 776, 0.001);
@@ -217,11 +226,11 @@
   XCTAssertEqualWithAccuracy(tabBar.transform.ty, baselineTabBarTranslation, 0.001);
   XCTAssertEqualWithAccuracy(CGRectGetMaxY(headerHost.frame), CGRectGetMinY(content.frame), 0.001);
 
-  // Exercise actual scroll notifications while the temporary refresh inset is
+  // Exercise accepted native commands while the temporary refresh inset is
   // present, including direction reversals and the sticky/unpinned boundary.
   // The pre-fix formula adds the extra 60 points on these scroll updates.
   for (NSNumber *nextOffset in @[@620, @450, @-300, @-340, @500]) {
-    scroll.contentOffset = CGPointMake(0, nextOffset.doubleValue);
+    [scroller scrollTo:0 y:nextOffset.doubleValue animated:NO];
     CGFloat expectedTranslation = MAX(0, nextOffset.doubleValue + 340 - 64);
     XCTAssertEqualWithAccuracy(headerHost.transform.ty, 0, 0.001);
     XCTAssertEqualWithAccuracy(stickyHeader.transform.ty, expectedTranslation, 0.001);

package/lib/module/CollapsiblePagerView.js

@@ -71,6 +71,12 @@ export class CollapsiblePagerView extends React.PureComponent {
       }
     }
   };
+  scrollToPageTop = options => {
+    if (this.nativeRef) CollapsiblePagerViewNativeCommands.scrollToTop(this.nativeRef, 0, options?.animated ?? true);
+  };
+  scrollToStickyTop = options => {
+    if (this.nativeRef) CollapsiblePagerViewNativeCommands.scrollToTop(this.nativeRef, 1, options?.animated ?? true);
+  };
   setScrollEnabled = scrollEnabled => {
     if (this.nativeRef) {
       CollapsiblePagerViewNativeCommands.setScrollEnabledImperatively(this.nativeRef, scrollEnabled);