@onekeyfe/react-native-pager-view 3.0.157 → 3.0.159

package/ios/tests/RNCCollapsiblePagerPressCancellationWiringTests.mm

@@ -0,0 +1,109 @@
+#import <XCTest/XCTest.h>
+#import <React/RCTSurfaceTouchHandler.h>
+
+#import "RNCCollapsiblePagerViewComponentView.h"
+#import <react/renderer/components/pagerview/Props.h>
+
+using namespace facebook::react;
+
+@interface RNCPressWiringTestTouch : UITouch
+@property (nonatomic, strong) UIView *testView;
+@end
+@implementation RNCPressWiringTestTouch
+- (UIView *)view { return self.testView; }
+@end
+
+@interface RNCCollapsiblePagerPressCancellationWiringTests : XCTestCase
+@property (nonatomic, strong) UIWindow *window;
+@property (nonatomic, strong) UIView *host;
+@property (nonatomic, strong) UIView *surface;
+@property (nonatomic, strong) RCTSurfaceTouchHandler *handler;
+@property (nonatomic, strong) RNCCollapsiblePagerViewComponentView *pager;
+@end
+
+@implementation RNCCollapsiblePagerPressCancellationWiringTests
+
+- (void)setUp
+{
+  [super setUp];
+  // Window membership installs the bridge without presenting or taking focus.
+  self.window = [[UIWindow alloc] initWithFrame:CGRectMake(0, 0, 320, 600)];
+  self.host = [[UIView alloc] initWithFrame:self.window.bounds];
+  self.surface = [[UIView alloc] initWithFrame:self.host.bounds];
+  [self.window addSubview:self.host];
+  [self.host addSubview:self.surface];
+  self.handler = [RCTSurfaceTouchHandler new];
+  [self.handler attachToView:self.surface];
+  self.pager = [[RNCCollapsiblePagerViewComponentView alloc] init];
+  auto props = std::make_shared<RNCCollapsiblePagerViewProps>();
+  props->nativeSmoothHeaderScrollEnabled = true;
+  [self.pager updateProps:props oldProps:nullptr];
+  self.pager.frame = self.surface.bounds;
+  [self.surface addSubview:self.pager];
+}
+
+- (void)tearDown
+{
+  [self.pager removeFromSuperview];
+  [self.handler detachFromView:self.surface];
+  self.pager = nil;
+  self.handler = nil;
+  self.surface = nil;
+  self.host = nil;
+  self.window = nil;
+  [super tearDown];
+}
+
+- (void)testInstalledBridgeCancelsTouchesAndFiltersItsContentScope
+{
+  UIGestureRecognizer *bridge = [self.pager valueForKey:@"contentPressCancellationGesture"];
+  XCTAssertNotNil(bridge);
+  XCTAssertTrue([bridge isKindOfClass:NSClassFromString(@"RNCCollapsiblePagerContentPressCancellationGestureRecognizer")]);
+  XCTAssertEqual(bridge.view, self.host);
+  XCTAssertEqual([bridge valueForKey:@"reactTouchHandler"], self.handler);
+  XCTAssertTrue(bridge.cancelsTouchesInView);
+  XCTAssertFalse(bridge.delaysTouchesBegan);
+  XCTAssertFalse(bridge.delaysTouchesEnded);
+  XCTAssertTrue([self.handler canBePreventedByGestureRecognizer:bridge]);
+
+  UIScrollView *scrollView = [self.pager valueForKey:@"pagerScrollView"];
+  XCTAssertNotNil(scrollView);
+  UIView *content = [UIView new];
+  [scrollView addSubview:content];
+  UIView *header = [self.pager valueForKey:@"sharedHeaderHostView"];
+  // Smooth mode reparents the shared header into the same content subtree.
+  [scrollView addSubview:header];
+  UIView *headerButton = [UIView new];
+  [header addSubview:headerButton];
+  RNCPressWiringTestTouch *touch = [RNCPressWiringTestTouch new];
+  id<UIGestureRecognizerDelegate> delegate = bridge.delegate;
+  XCTAssertEqual((id)delegate, self.pager);
+  touch.testView = content;
+  XCTAssertTrue([delegate gestureRecognizer:bridge shouldReceiveTouch:touch]);
+  touch.testView = headerButton;
+  XCTAssertFalse([delegate gestureRecognizer:bridge shouldReceiveTouch:touch]);
+  touch.testView = self.surface;
+  XCTAssertFalse([delegate gestureRecognizer:bridge shouldReceiveTouch:touch]);
+}
+
+- (void)testWindowDetachUnbindsInstalledBridge
+{
+  UIGestureRecognizer *bridge = [self.pager valueForKey:@"contentPressCancellationGesture"];
+  XCTAssertNotNil(bridge);
+  [self.pager removeFromSuperview];
+  XCTAssertNil(bridge.view);
+  XCTAssertNil([bridge valueForKey:@"reactTouchHandler"]);
+  XCTAssertNil([self.pager valueForKey:@"contentPressCancellationGesture"]);
+}
+
+- (void)testRecycleUnbindsInstalledBridge
+{
+  UIGestureRecognizer *bridge = [self.pager valueForKey:@"contentPressCancellationGesture"];
+  XCTAssertNotNil(bridge);
+  [self.pager prepareForRecycle];
+  XCTAssertNil(bridge.view);
+  XCTAssertNil([bridge valueForKey:@"reactTouchHandler"]);
+  XCTAssertNil([self.pager valueForKey:@"contentPressCancellationGesture"]);
+}
+
+@end

package/ios/tests/RNCCollapsiblePagerRefreshControlTests.mm

@@ -0,0 +1,214 @@
+#import <XCTest/XCTest.h>
+#import "RNCCollapsiblePagerViewComponentView.h"
+
+@interface RNCCollapsiblePagerViewComponentView (RefreshControlTesting)
+- (void)updateRefreshControlForScrollView:(UIScrollView *)scrollView;
+- (void)releaseRefreshControlForScrollView:(UIScrollView *)scrollView;
+- (void)attachScrollObserverForCurrentPage;
+@end
+
+@interface RNCCollapsiblePagerRefreshControlTests : XCTestCase
+@end
+
+@implementation RNCCollapsiblePagerRefreshControlTests
+
+- (RNCCollapsiblePagerViewComponentView *)pagerWithHeader:(CGFloat)height
+{
+  RNCCollapsiblePagerViewComponentView *pager = [RNCCollapsiblePagerViewComponentView new];
+  [pager setValue:@YES forKey:@"nativeSmoothHeaderScrollEnabled"];
+  [pager setValue:@(height) forKey:@"headerHeight"];
+  [pager setValue:@44 forKey:@"stickyHeaderHeight"];
+  return pager;
+}
+
+- (void)testLateControlAndCallerOffsetUpdatesPreserveBaseline
+{
+  RNCCollapsiblePagerViewComponentView *pager = [self pagerWithHeader:64];
+  UIScrollView *scroll = [[UIScrollView alloc] initWithFrame:CGRectMake(0, 0, 320, 600)];
+  [pager updateRefreshControlForScrollView:scroll];
+  UIRefreshControl *control = [UIRefreshControl new];
+  control.bounds = CGRectMake(3, -12, 320, 60);
+  scroll.refreshControl = control;
+  XCTAssertEqualWithAccuracy(control.layer.sublayerTransform.m42, -108, 0.001);
+  XCTAssertEqualWithAccuracy(control.bounds.origin.y, -12, 0.001);
+  [pager updateRefreshControlForScrollView:scroll];
+  XCTAssertEqualWithAccuracy(control.layer.sublayerTransform.m42, -108, 0.001);
+  XCTAssertEqualWithAccuracy(control.bounds.origin.y, -12, 0.001);
+  control.layer.sublayerTransform = control.layer.sublayerTransform;
+  // Also cover an explicit no-op KVO notification, even if CALayer's setter
+  // suppresses notifications for equal transforms on the current OS.
+  [control.layer willChangeValueForKey:@"sublayerTransform"];
+  [control.layer didChangeValueForKey:@"sublayerTransform"];
+  XCTAssertEqualWithAccuracy(control.layer.sublayerTransform.m42, -108, 0.001);
+
+  // Fabric's progressViewOffset setter replaces bounds.origin.y directly.
+  control.bounds = CGRectMake(3, -20, 320, 60);
+  XCTAssertEqualWithAccuracy(control.layer.sublayerTransform.m42, -108, 0.001);
+  XCTAssertEqualWithAccuracy(control.bounds.origin.y, -20, 0.001);
+  [pager setValue:@100 forKey:@"headerHeight"];
+  [pager updateRefreshControlForScrollView:scroll];
+  XCTAssertEqualWithAccuracy(control.layer.sublayerTransform.m42, -144, 0.001);
+  XCTAssertEqualWithAccuracy(control.bounds.origin.y, -20, 0.001);
+  [pager releaseRefreshControlForScrollView:scroll];
+  XCTAssertEqualWithAccuracy(control.bounds.origin.y, -20, 0.001);
+  XCTAssertEqualWithAccuracy(control.bounds.origin.x, 3, 0.001);
+}
+
+- (void)testUIKitSizeChangesAndRefreshCycleDoNotAccumulateOffset
+{
+  RNCCollapsiblePagerViewComponentView *pager = [self pagerWithHeader:64];
+  UIScrollView *scroll = [[UIScrollView alloc] initWithFrame:CGRectMake(0, 0, 320, 600)];
+  // UIKit ignores offscreen beginRefreshing calls. Exercise the actual refresh
+  // lifecycle in a visible window rather than weakening the state assertion.
+  UIWindow *window = [[UIWindow alloc] initWithFrame:scroll.frame];
+  UIViewController *controller = [UIViewController new];
+  window.rootViewController = controller;
+  scroll.contentInsetAdjustmentBehavior = UIScrollViewContentInsetAdjustmentNever;
+  [controller.view addSubview:scroll];
+  window.hidden = NO;
+  [self addTeardownBlock:^{ window.hidden = YES; }];
+  UIRefreshControl *control = [UIRefreshControl new];
+  scroll.refreshControl = control;
+  [window layoutIfNeeded];
+  [scroll layoutIfNeeded];
+  XCTAssertEqual(control.window, window);
+  [pager updateRefreshControlForScrollView:scroll];
+  CGRect bounds = control.bounds;
+  bounds.size = CGSizeMake(320, 60);
+  control.bounds = bounds;
+  XCTAssertEqualWithAccuracy(control.layer.sublayerTransform.m42, -108, 0.001);
+  XCTAssertEqualWithAccuracy(control.bounds.origin.y, 0, 0.001);
+  [control beginRefreshing];
+  [control layoutIfNeeded];
+  [pager updateRefreshControlForScrollView:scroll];
+  XCTAssertTrue(control.isRefreshing);
+  XCTAssertEqualWithAccuracy(control.layer.sublayerTransform.m42, -108, 0.001);
+  XCTAssertEqualWithAccuracy(control.bounds.origin.y, 0, 0.001);
+  [control endRefreshing];
+  [control layoutIfNeeded];
+  XCTAssertFalse(control.isRefreshing);
+  XCTAssertEqualWithAccuracy(control.layer.sublayerTransform.m42, -108, 0.001);
+  XCTAssertEqualWithAccuracy(control.bounds.origin.y, 0, 0.001);
+  [pager releaseRefreshControlForScrollView:scroll];
+  XCTAssertEqualWithAccuracy(control.bounds.origin.y, 0, 0.001);
+  XCTAssertTrue(CATransform3DIsIdentity(control.layer.sublayerTransform));
+}
+
+- (void)testReplacementAndNestedOwnerReleaseRestoreOnlyTheirContributions
+{
+  RNCCollapsiblePagerViewComponentView *first = [self pagerWithHeader:64];
+  RNCCollapsiblePagerViewComponentView *second = [self pagerWithHeader:20];
+  UICollectionView *scroll = [[UICollectionView alloc] initWithFrame:CGRectMake(0, 0, 320, 600)
+                                                        collectionViewLayout:[UICollectionViewFlowLayout new]];
+  UIRefreshControl *original = [UIRefreshControl new];
+  scroll.refreshControl = original;
+  [first updateRefreshControlForScrollView:scroll];
+  [second updateRefreshControlForScrollView:scroll];
+  XCTAssertEqualWithAccuracy(original.layer.sublayerTransform.m42, -172, 0.001);
+  [first releaseRefreshControlForScrollView:scroll];
+  XCTAssertEqualWithAccuracy(original.layer.sublayerTransform.m42, -64, 0.001);
+
+  UIRefreshControl *replacement = [UIRefreshControl new];
+  replacement.bounds = CGRectMake(0, -8, 320, 60);
+  scroll.refreshControl = replacement;
+  XCTAssertTrue(CATransform3DIsIdentity(original.layer.sublayerTransform));
+  XCTAssertEqualWithAccuracy(replacement.layer.sublayerTransform.m42, -64, 0.001);
+  XCTAssertEqualWithAccuracy(replacement.bounds.origin.y, -8, 0.001);
+  [second prepareForRecycle];
+  XCTAssertEqualWithAccuracy(replacement.bounds.origin.y, -8, 0.001);
+  XCTAssertTrue(CATransform3DIsIdentity(replacement.layer.sublayerTransform));
+  scroll.refreshControl = nil;
+}
+
+- (void)testPagerDestructionRestoresControl
+{
+  UIScrollView *scroll = [UIScrollView new];
+  UIRefreshControl *control = [UIRefreshControl new];
+  scroll.refreshControl = control;
+  @autoreleasepool {
+    RNCCollapsiblePagerViewComponentView *pager = [self pagerWithHeader:64];
+    [pager updateRefreshControlForScrollView:scroll];
+    XCTAssertEqualWithAccuracy(control.layer.sublayerTransform.m42, -108, 0.001);
+    XCTAssertEqualWithAccuracy(control.bounds.origin.y, 0, 0.001);
+  }
+  XCTAssertEqualWithAccuracy(control.bounds.origin.y, 0, 0.001);
+  XCTAssertTrue(CATransform3DIsIdentity(control.layer.sublayerTransform));
+}
+
+- (void)testCallerOffsetCollisionDoesNotAffectVisualContribution
+{
+  RNCCollapsiblePagerViewComponentView *pager = [self pagerWithHeader:56];
+  UIScrollView *scroll = [UIScrollView new];
+  UIRefreshControl *control = [UIRefreshControl new];
+  scroll.refreshControl = control;
+  control.bounds = CGRectMake(0, -200, 320, 60);
+  [pager updateRefreshControlForScrollView:scroll];
+  control.bounds = CGRectMake(0, -100, 320, 60);
+  XCTAssertEqualWithAccuracy(control.bounds.origin.y, -100, 0.001);
+  XCTAssertEqualWithAccuracy(control.layer.sublayerTransform.m42, -100, 0.001);
+  [pager releaseRefreshControlForScrollView:scroll];
+  XCTAssertEqualWithAccuracy(control.bounds.origin.y, -100, 0.001);
+  XCTAssertTrue(CATransform3DIsIdentity(control.layer.sublayerTransform));
+}
+
+- (void)testNestedOwnerDestructionPreservesBaselineAndRestoresClipping
+{
+  RNCCollapsiblePagerViewComponentView *second = [self pagerWithHeader:20];
+  UIScrollView *scroll = [UIScrollView new];
+  UIRefreshControl *control = [UIRefreshControl new];
+  scroll.refreshControl = control;
+  CATransform3D baseline = CATransform3DMakeTranslation(7, 13, 0);
+  control.layer.sublayerTransform = baseline;
+  control.layer.masksToBounds = YES;
+  @autoreleasepool {
+    RNCCollapsiblePagerViewComponentView *first = [self pagerWithHeader:64];
+    [first updateRefreshControlForScrollView:scroll];
+    [second updateRefreshControlForScrollView:scroll];
+    XCTAssertEqualWithAccuracy(control.layer.sublayerTransform.m42, 13 - 172, 0.001);
+    XCTAssertFalse(control.layer.masksToBounds);
+  }
+  XCTAssertEqualWithAccuracy(control.layer.sublayerTransform.m42, 13 - 64, 0.001);
+  // A UIKit layer reset must not discard the remaining visual contribution.
+  control.layer.sublayerTransform = baseline;
+  control.layer.masksToBounds = YES;
+  XCTAssertEqualWithAccuracy(control.layer.sublayerTransform.m42, 13 - 64, 0.001);
+  XCTAssertFalse(control.layer.masksToBounds);
+  [second releaseRefreshControlForScrollView:scroll];
+  XCTAssertTrue(CATransform3DEqualToTransform(control.layer.sublayerTransform, baseline));
+  XCTAssertTrue(control.layer.masksToBounds);
+}
+
+- (void)testRefreshTopInsetDoesNotDisplaceAttachedSharedHeader
+{
+  RNCCollapsiblePagerViewComponentView *pager = [self pagerWithHeader:64];
+  UIScrollView *scroll = [[UIScrollView alloc] initWithFrame:CGRectMake(0, 0, 320, 600)];
+  scroll.refreshControl = [UIRefreshControl new];
+  scroll.contentSize = CGSizeMake(320, 2000);
+  scroll.contentInset = UIEdgeInsetsMake(232, 0, 0, 0);
+  UIViewController *page = [UIViewController new];
+  [page.view addSubview:scroll];
+  NSMutableArray<UIViewController *> *pages = [pager valueForKey:@"pageControllers"];
+  [pages addObject:page];
+  [pager attachScrollObserverForCurrentPage];
+  UIView *headerHost = [pager valueForKey:@"sharedHeaderHostView"];
+  XCTAssertEqual(headerHost.superview, scroll);
+  XCTAssertEqualWithAccuracy(scroll.contentInset.top, 340, 0.001);
+  XCTAssertEqualWithAccuracy(headerHost.transform.ty, 0, 0.001);
+
+  scroll.contentOffset = CGPointMake(0, 500);
+  CGPoint offset = scroll.contentOffset;
+  scroll.contentInset = UIEdgeInsetsMake(400, 0, 0, 0);
+  XCTAssertTrue(CGPointEqualToPoint(scroll.contentOffset, offset));
+  XCTAssertEqualWithAccuracy(headerHost.transform.ty, -60, 0.001);
+
+  scroll.contentInset = UIEdgeInsetsMake(340, 0, 0, 0);
+  XCTAssertEqualWithAccuracy(headerHost.transform.ty, 0, 0.001);
+
+  scroll.contentInset = UIEdgeInsetsMake(400, 0, 0, 0);
+  XCTAssertEqualWithAccuracy(headerHost.transform.ty, -60, 0.001);
+  scroll.refreshControl = nil;
+  XCTAssertEqualWithAccuracy(headerHost.transform.ty, 0, 0.001);
+  [pager prepareForRecycle];
+}
+
+@end

package/ios/tests/RNCCollapsiblePagerReleasedStatePolicyTests.mm

@@ -7,6 +7,29 @@
 
 @implementation RNCCollapsiblePagerReleasedStatePolicyTests
 
+- (void)testRestorationAfterInactiveContentShrinkCannotReapplyStaleCache
+{
+  // The list already corrected to -44 while inactive, but the pager still
+  // retains the old logical offset captured before rows were removed.
+  CGFloat savedLogicalOffset = 513.67;
+  CGFloat restored = RNCLimitRestoredScrollOffset(
+    savedLogicalOffset - 108, 132, 708, 108, 532);
+  XCTAssertEqualWithAccuracy(restored, -44, 0.001);
+  XCTAssertEqualWithAccuracy(restored + 108, 64, 0.001);
+  XCTAssertEqualWithAccuracy(
+    RNCLimitRestoredScrollOffset(restored, 132, 708, 108, 532), restored, 0.001);
+}
+
+- (void)testRestorationPreservesValidDeepAndNegativeOffsets
+{
+  XCTAssertEqualWithAccuracy(
+    RNCLimitRestoredScrollOffset(600, 2400, 708, 108, 0), 600, 0.001);
+  XCTAssertEqualWithAccuracy(
+    RNCLimitRestoredScrollOffset(-160, 132, 708, 108, 532), -160, 0.001);
+  XCTAssertEqualWithAccuracy(
+    RNCLimitRestoredScrollOffset(600, 0, 0, 108, 0), 600, 0.001);
+}
+
 - (void)testPrunesRemovedKeysAndKeepsStableKeysAcrossReorders
 {
   NSObject *alpha = [NSObject new];

package/ios/tests/RNCNativeScrollerTests.mm

@@ -0,0 +1,252 @@
+#import <XCTest/XCTest.h>
+#import "RNCNativeScrollerComponentView.h"
+#import "RNCCollapsiblePagerViewComponentView.h"
+#import <react/renderer/components/pagerview/Props.h>
+
+using namespace facebook::react;
+
+@interface RNCNativeScrollerComponentView (Tests)
+- (void)emitScrollEvent:(NSInteger)kind velocity:(CGPoint)velocity target:(CGPoint)target;
+- (void)clampContentOffsetIfNeeded;
+- (void)scrollTo:(double)x y:(double)y animated:(BOOL)animated;
+- (void)setRefreshing:(BOOL)refreshing;
+- (CGFloat)contentViewportHeight;
+@end
+
+@interface RNCCollapsiblePagerViewComponentView (ScrollerTests)
+- (void)applyInsetsToScrollView:(UIScrollView *)scrollView pageIndex:(NSInteger)index restore:(BOOL)restore;
+- (void)restoreScrollViewState:(UIScrollView *)scrollView resetSavedOffset:(BOOL)reset;
+@end
+
+@interface RNCObservedScroller : RNCNativeScrollerComponentView
+@property (nonatomic, strong) NSMutableArray<NSNumber *> *events;
+@end
+@implementation RNCObservedScroller
+- (void)emitScrollEvent:(NSInteger)kind velocity:(CGPoint)velocity target:(CGPoint)target
+{
+  if (self.events == nil) self.events = [NSMutableArray new];
+  [self.events addObject:@(kind)];
+  [super emitScrollEvent:kind velocity:velocity target:target];
+}
+@end
+
+@interface RNCNativeScrollerTests : XCTestCase
+@property (nonatomic, strong) RNCObservedScroller *scroller;
+@end
+@implementation RNCNativeScrollerTests
+
+- (void)setUp
+{
+  [super setUp];
+  self.scroller = [RNCObservedScroller new];
+  LayoutMetrics metrics;
+  metrics.frame.size = {320, 600};
+  [self.scroller updateLayoutMetrics:metrics oldLayoutMetrics:{}];
+}
+
+- (void)tearDown
+{
+  [self.scroller prepareForRecycle];
+  self.scroller = nil;
+  [super tearDown];
+}
+
+- (void)testContentSizeDoesNotRelayoutReactContentOrSharedHeader
+{
+  RCTViewComponentView *content = [RCTViewComponentView new];
+  content.frame = CGRectMake(0, 0, 320, 900);
+  [self.scroller mountChildComponentView:content index:0];
+  UIView *header = [[UIView alloc] initWithFrame:CGRectMake(0, -200, 320, 200)];
+  [self.scroller.scrollView addSubview:header];
+  auto props = std::make_shared<RNCNativeScrollerProps>();
+  props->contentWidth = 320;
+  props->contentHeight = 900;
+  [self.scroller updateProps:props oldProps:nullptr];
+  XCTAssertEqualWithAccuracy(self.scroller.scrollView.contentSize.height, 900, 0.01);
+  XCTAssertTrue(CGRectEqualToRect(content.frame, CGRectMake(0, 0, 320, 900)));
+  XCTAssertTrue(CGRectEqualToRect(header.frame, CGRectMake(0, -200, 320, 200)));
+  XCTAssertEqual(header.superview, self.scroller.scrollView);
+  XCTAssertFalse([self.scroller.scrollView isKindOfClass:NSClassFromString(@"RCTEnhancedScrollView")]);
+}
+
+- (void)testShrinkClampsOnlyUnreachableUpperOffset
+{
+  auto props = std::make_shared<RNCNativeScrollerProps>();
+  props->contentWidth = 320;
+  props->contentHeight = 1500;
+  [self.scroller updateProps:props oldProps:nullptr];
+  self.scroller.scrollView.contentInset = UIEdgeInsetsMake(200, 0, 468, 0);
+  self.scroller.scrollView.contentOffset = CGPointMake(0, 800);
+  auto shorter = std::make_shared<RNCNativeScrollerProps>();
+  shorter->contentWidth = 320;
+  shorter->contentHeight = 132;
+  [self.scroller updateProps:shorter oldProps:props];
+  [self.scroller clampContentOffsetIfNeeded];
+  XCTAssertEqualWithAccuracy(self.scroller.scrollView.contentOffset.y, 0, 0.01);
+  self.scroller.scrollView.contentOffset = CGPointMake(0, -240);
+  auto empty = std::make_shared<RNCNativeScrollerProps>();
+  empty->contentWidth = 320;
+  empty->contentHeight = 0;
+  [self.scroller updateProps:empty oldProps:shorter];
+  [self.scroller clampContentOffsetIfNeeded];
+  XCTAssertEqualWithAccuracy(self.scroller.scrollView.contentOffset.y, -240, 0.01);
+}
+
+- (void)testNativeInterruptionEndsEachDragAndMomentumOnlyOnce
+{
+  UIScrollView *scroll = self.scroller.scrollView;
+  id<UIScrollViewDelegate> delegate = scroll.delegate;
+  [delegate scrollViewWillBeginDragging:scroll];
+  [self.scroller stopScrolling];
+  [delegate scrollViewDidEndDragging:scroll willDecelerate:NO];
+  XCTAssertEqualObjects(self.scroller.events, (@[@1, @2]));
+  [self.scroller.events removeAllObjects];
+  [delegate scrollViewWillBeginDecelerating:scroll];
+  [self.scroller stopScrolling];
+  [delegate scrollViewDidEndDecelerating:scroll];
+  NSPredicate *terminal = [NSPredicate predicateWithFormat:@"SELF == 4"];
+  XCTAssertEqual([self.scroller.events filteredArrayUsingPredicate:terminal].count, 1u);
+  XCTAssertEqualObjects(self.scroller.events.firstObject, @3);
+}
+
+- (void)testRefreshReplacementAndRecycleDoNotKeepOldControl
+{
+  auto props = std::make_shared<RNCNativeScrollerProps>();
+  props->refreshEnabled = true;
+  props->refreshProgressViewOffset = 24;
+  [self.scroller updateProps:props oldProps:nullptr];
+  UIRefreshControl *original = self.scroller.scrollView.refreshControl;
+  XCTAssertNotNil(original);
+  XCTAssertEqualWithAccuracy(original.bounds.origin.y, -24, 0.01);
+  [self.scroller prepareForRecycle];
+  XCTAssertNil(self.scroller.scrollView.refreshControl);
+  [self.scroller updateProps:props oldProps:props];
+  XCTAssertNotNil(self.scroller.scrollView.refreshControl);
+  XCTAssertNotEqual(self.scroller.scrollView.refreshControl, original);
+  XCTAssertEqualWithAccuracy(self.scroller.scrollView.refreshControl.bounds.origin.y, -24, 0.01);
+  [self.scroller setRefreshing:NO];
+  XCTAssertFalse(self.scroller.scrollView.refreshControl.refreshing);
+}
+
+- (void)testCallerInsetUpdatesSurvivePagerReapplyAndRelease
+{
+  RNCCollapsiblePagerViewComponentView *pager = [RNCCollapsiblePagerViewComponentView new];
+  auto pagerProps = std::make_shared<RNCCollapsiblePagerViewProps>();
+  pagerProps->headerHeight = 120;
+  pagerProps->stickyHeaderHeight = 40;
+  [pager updateProps:pagerProps oldProps:nullptr];
+  [pager addSubview:self.scroller];
+  auto props = std::make_shared<RNCNativeScrollerProps>();
+  props->contentWidth = 320;
+  props->contentHeight = 1500;
+  props->contentInsetTop = 10;
+  [self.scroller updateProps:props oldProps:nullptr];
+  [pager applyInsetsToScrollView:self.scroller.scrollView pageIndex:0 restore:NO];
+  XCTAssertEqualWithAccuracy(self.scroller.scrollView.contentInset.top, 170, 0.01);
+  auto updated = std::make_shared<RNCNativeScrollerProps>();
+  updated->contentWidth = 320;
+  updated->contentHeight = 1500;
+  updated->contentInsetTop = 30;
+  updated->contentInsetBottom = 20;
+  [self.scroller updateProps:updated oldProps:props];
+  [pager applyInsetsToScrollView:self.scroller.scrollView pageIndex:0 restore:NO];
+  XCTAssertEqualWithAccuracy(self.scroller.scrollView.contentInset.top, 190, 0.01);
+  [pager restoreScrollViewState:self.scroller.scrollView resetSavedOffset:YES];
+  XCTAssertEqualWithAccuracy(self.scroller.scrollView.contentInset.top, 30, 0.01);
+  XCTAssertEqualWithAccuracy(self.scroller.scrollView.contentInset.bottom, 20, 0.01);
+  [self.scroller removeFromSuperview];
+}
+
+- (void)testRecycledDelegateCannotStartASequenceForTheNextOwner
+{
+  UIScrollView *scroll = self.scroller.scrollView;
+  id<UIScrollViewDelegate> oldDelegate = scroll.delegate;
+  [self.scroller prepareForRecycle];
+  XCTAssertNil(scroll.delegate);
+  [oldDelegate scrollViewWillBeginDragging:scroll];
+  [oldDelegate scrollViewWillBeginDecelerating:scroll];
+  auto props = std::make_shared<RNCNativeScrollerProps>();
+  [self.scroller updateProps:props oldProps:nullptr];
+  XCTAssertEqual(scroll.delegate, self.scroller);
+  [self.scroller stopScrolling];
+  NSPredicate *terminal = [NSPredicate predicateWithFormat:@"SELF == 2 OR SELF == 4"];
+  XCTAssertEqual([self.scroller.events filteredArrayUsingPredicate:terminal].count, 0u);
+}
+
+- (void)testPagerExplicitlyFindsIndependentScrollView
+{
+  RNCCollapsiblePagerViewComponentView *pager = [RNCCollapsiblePagerViewComponentView new];
+  UIView *page = [UIView new];
+  [page addSubview:self.scroller];
+  SEL finder = NSSelectorFromString(@"findExplicitNativeScrollerInView:");
+  UIScrollView *(*find)(id, SEL, UIView *) =
+    (UIScrollView *(*)(id, SEL, UIView *))[pager methodForSelector:finder];
+  XCTAssertEqual(find(pager, finder, page), self.scroller.scrollView);
+}
+
+- (void)testContentViewportUsesOnlyCallerInsetsAndStaticStickyHeight
+{
+  RNCCollapsiblePagerViewComponentView *pager = [RNCCollapsiblePagerViewComponentView new];
+  auto pagerProps = std::make_shared<RNCCollapsiblePagerViewProps>();
+  pagerProps->headerHeight = 120;
+  pagerProps->stickyHeaderHeight = 40;
+  [pager updateProps:pagerProps oldProps:nullptr];
+  [pager addSubview:self.scroller];
+  auto props = std::make_shared<RNCNativeScrollerProps>();
+  props->contentWidth = 320;
+  props->contentHeight = 20;
+  props->contentInsetTop = 10;
+  props->contentInsetBottom = 20;
+  [self.scroller updateProps:props oldProps:nullptr];
+  [pager applyInsetsToScrollView:self.scroller.scrollView pageIndex:0 restore:NO];
+  XCTAssertEqualWithAccuracy([self.scroller contentViewportHeight], 530, 0.01);
+  // Synthetic bottom fill and temporary refresh insets are not caller geometry.
+  self.scroller.scrollView.contentInset = UIEdgeInsetsMake(230, 0, 510, 0);
+  XCTAssertEqualWithAccuracy([self.scroller contentViewportHeight], 530, 0.01);
+  auto filled = std::make_shared<RNCNativeScrollerProps>();
+  filled->contentWidth = 320;
+  filled->contentHeight = 530;
+  filled->contentInsetTop = 10;
+  filled->contentInsetBottom = 20;
+  [self.scroller updateProps:filled oldProps:props];
+  XCTAssertEqualWithAccuracy([self.scroller contentViewportHeight], 530, 0.01);
+  LayoutMetrics metrics;
+  metrics.frame.size = {320, 700};
+  [self.scroller updateLayoutMetrics:metrics oldLayoutMetrics:{}];
+  XCTAssertEqualWithAccuracy([self.scroller contentViewportHeight], 630, 0.01);
+  auto updated = std::make_shared<RNCNativeScrollerProps>();
+  updated->contentWidth = 320;
+  updated->contentHeight = 530;
+  updated->contentInsetTop = 10;
+  updated->contentInsetBottom = 30;
+  [self.scroller updateProps:updated oldProps:filled];
+  XCTAssertEqualWithAccuracy([self.scroller contentViewportHeight], 620, 0.01);
+  auto tallerSticky = std::make_shared<RNCCollapsiblePagerViewProps>();
+  tallerSticky->headerHeight = 250;
+  tallerSticky->stickyHeaderHeight = 60;
+  [pager updateProps:tallerSticky oldProps:pagerProps];
+  [pager applyInsetsToScrollView:self.scroller.scrollView pageIndex:0 restore:NO];
+  XCTAssertEqualWithAccuracy([self.scroller contentViewportHeight], 600, 0.01);
+  [pager restoreScrollViewState:self.scroller.scrollView resetSavedOffset:YES];
+  XCTAssertEqualWithAccuracy([self.scroller contentViewportHeight], 660, 0.01);
+  [self.scroller removeFromSuperview];
+}
+
+- (void)testContentViewportReleasesIndependentPagerContributions
+{
+  NSObject *outer = [NSObject new];
+  NSObject *inner = [NSObject new];
+  [self.scroller setPagerStickyHeight:40 forOwner:outer];
+  [self.scroller setPagerStickyHeight:20 forOwner:inner];
+  XCTAssertEqualWithAccuracy([self.scroller contentViewportHeight], 540, 0.01);
+  [self.scroller setPagerStickyHeight:40 forOwner:outer];
+  XCTAssertEqualWithAccuracy([self.scroller contentViewportHeight], 540, 0.01);
+  [self.scroller setPagerStickyHeight:0 forOwner:outer];
+  XCTAssertEqualWithAccuracy([self.scroller contentViewportHeight], 580, 0.01);
+  [self.scroller prepareForRecycle];
+  auto props = std::make_shared<RNCNativeScrollerProps>();
+  [self.scroller updateProps:props oldProps:nullptr];
+  XCTAssertEqualWithAccuracy([self.scroller contentViewportHeight], 600, 0.01);
+}
+
+@end

package/lib/module/CollapsiblePagerView.js

@@ -30,6 +30,10 @@ export class CollapsiblePagerView extends React.PureComponent {
   lastMountSignature = null;
   nativeTabCommandId = 0;
   latestNativeTabTarget = null;
+
+  // Target of the last tab command native has received and not yet reported
+  // as selected. Commands superseded before their frame never reach native.
+  dispatchedNativeTabTarget = null;
   latestNativeSelectedPage = this.state.selectedPage;
   nativePagerScrollState = "idle";
   nativeTabCommandQueuedDuringScroll = false;
@@ -89,6 +93,7 @@ export class CollapsiblePagerView extends React.PureComponent {
         if (commandId !== this.nativeTabCommandId || !this.nativeRef) {
           return;
         }
+        this.dispatchedNativeTabTarget = position;
         if (animated) {
           CollapsiblePagerViewNativeCommands.setPage(this.nativeRef, position);
         } else {
@@ -136,6 +141,7 @@ export class CollapsiblePagerView extends React.PureComponent {
       const transitionComplete = pendingTarget === position;
       if (transitionComplete) {
         this.latestNativeTabTarget = null;
+        this.dispatchedNativeTabTarget = null;
         this.nativeTabCommandQueuedDuringScroll = false;
       }
       this.setState({
@@ -154,6 +160,7 @@ export class CollapsiblePagerView extends React.PureComponent {
     if (scrollState === "idle" && this.latestNativeTabTarget !== null && this.latestNativeTabTarget !== this.latestNativeSelectedPage && !queuedDuringPreviousScroll) {
       ++this.nativeTabCommandId;
       this.latestNativeTabTarget = null;
+      this.dispatchedNativeTabTarget = null;
       this.setState({
         transientRetainedPages: []
       }, this.notifyMountedPagesChanged);
@@ -166,7 +173,9 @@ export class CollapsiblePagerView extends React.PureComponent {
   onNativeTabPress = event => {
     const position = pageIndex(event.nativeEvent.position);
     if (position !== null && position >= 0 && position < this.pages().length && (position !== this.state.selectedPage || this.latestNativeTabTarget !== null)) {
-      this.dispatchNativeTabPageCommand(position, this.props.nativeTabPressAnimationEnabled ?? true);
+      // Selection state lags an in-flight transition until native reports it.
+      const currentPage = this.dispatchedNativeTabTarget ?? this.state.selectedPage;
+      this.dispatchNativeTabPageCommand(position, this.props.nativeTabPressAnimationEnabled ?? Math.abs(position - currentPage) <= 1);
     }
     this.props.onNativeTabPress?.(event);
   };