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

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"];
   }
 }
 
@@ -319,6 +351,7 @@ static Event RNCScrollerMetrics(UIScrollView *scroll, CGPoint velocity, CGPoint
 - (void)stopScrolling
 {
   if (_stopping) return;
+  [self offsetDiag:@"stop-before"];
   _stopping = YES;
   [_scrollView setContentOffset:_scrollView.contentOffset animated:NO];
   if (_dragActive) {
@@ -330,6 +363,7 @@ static Event RNCScrollerMetrics(UIScrollView *scroll, CGPoint velocity, CGPoint
   }
   [self finishMomentum];
   _stopping = NO;
+  [self offsetDiag:@"stop-after"];
 }
 
 - (void)scrollViewWillBeginDragging:(UIScrollView *)scrollView
@@ -394,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

@@ -6,11 +6,25 @@
 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)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 +32,249 @@ 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;
+    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];
+  RNCNativeScrollerComponentView *source = [self addScrollerToPager:pager atIndex:0];
+  RNCNativeScrollerComponentView *target = [self addScrollerToPager:pager atIndex:1];
+  NSMutableDictionary *offsets = [pager valueForKey:@"pageOffsets"];
+  offsets[@"page-0"] = @120;
+  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, 660, 0.01);
+  XCTAssertNotEqual([pager valueForKey:@"observedScrollView"], source.scrollView);
+}
+
+- (void)testSmoothTransitionRestoresWholePagePositionsAndCancellation
+{
+  for (NSNumber *targetQ 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"] = targetQ;
+    [pager attachScrollObserverForCurrentPage];
+    [pager beginPageStateTransition];
+    [pager setValue:@YES forKey:@"isPagerDragging"];
+    [pager setValue:@YES forKey:@"transitioning"];
+    [pager updatePageStateTransitionProgress:0.5];
+    CGFloat displayH = MIN(targetQ.doubleValue, 120) / 2;
+    XCTAssertEqualWithAccuracy([[pager valueForKey:@"headerOffset"] doubleValue], displayH, 0.01);
+    XCTAssertEqualWithAccuracy(source.scrollView.contentOffset.y + source.scrollView.contentInset.top, displayH, 0.01);
+    XCTAssertEqualWithAccuracy(target.scrollView.contentOffset.y + target.scrollView.contentInset.top,
+                              MAX(targetQ.doubleValue - 120, 0) + displayH, 0.01);
+    XCTAssertEqualObjects(offsets[@"page-0"], @0);
+    XCTAssertEqualObjects(offsets[@"page-1"], targetQ);
+    // Cancelling the swipe restores both pages, not just the selected source.
+    [pager finishPageStateTransition];
+    XCTAssertEqualWithAccuracy(source.scrollView.contentOffset.y + source.scrollView.contentInset.top, 0, 0.01);
+    XCTAssertEqualWithAccuracy(target.scrollView.contentOffset.y + target.scrollView.contentInset.top, targetQ.doubleValue, 0.01);
+    XCTAssertEqualObjects(offsets[@"page-1"], targetQ);
+    [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,
+                              MIN(targetQ.doubleValue, 120), 0.01);
+    [pager setValue:@1 forKey:@"currentIndex"];
+    [pager attachScrollObserverForCurrentPageAfterTransition:YES];
+    XCTAssertEqualWithAccuracy(target.scrollView.contentOffset.y + target.scrollView.contentInset.top, targetQ.doubleValue, 0.01);
+    XCTAssertEqualWithAccuracy([[pager valueForKey:@"headerOffset"] doubleValue], MIN(targetQ.doubleValue, 120), 0.01);
+  }
+}
+
+- (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 attachScrollObserverForCurrentPage];
+  [pager beginPageStateTransition];
+  [pager setValue:@3 forKey:@"destinationIndex"];
+  [pager preparePageForHorizontalTransitionAtIndex:3];
+  [pager updatePageStateTransitionProgress:1];
+  XCTAssertEqualWithAccuracy([[pager valueForKey:@"headerOffset"] doubleValue], 40, 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;
+    NSString *key = [NSString stringWithFormat:@"page-%ld", (long)index];
+    XCTAssertEqualWithAccuracy(scroller.scrollView.contentOffset.y + scroller.scrollView.contentInset.top,
+                              [offsets[key] doubleValue], 0.01);
+  }
+}
+
+- (void)testZeroLayoutPreservesPendingWholePageRestore
+{
+  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];
+  XCTAssertEqualObjects(offsets[@"page-0"], @660);
+  XCTAssertTrue([[pager valueForKey:@"pendingPageRestoreKeys"] containsObject:@"page-0"]);
+  // Releasing an observed but unmeasured identity must retain its pending Q.
+  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, 660, 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 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/react-native-pager-view",
-  "version": "3.0.170",
+  "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.170",
+    "@onekeyfe/react-native-native-logger": "3.0.172",
     "react": "*",
     "react-native": "*"
   },