@onekeyfe/react-native-pager-view 3.0.162-alpha.270 → 3.0.162

package/docs/SPEC.md

@@ -165,6 +165,28 @@ warnings were observed. Keyboard, multi-touch, physical-device performance and
 the full lifecycle/interaction matrix remain unverified. These are local source
 builds; the currently installed npm version does not yet contain this migration.
 
+## iOS vertical-scroll press cancellation
+
+Status: implemented in source. A source-identical `node_modules` build was
+runtime verified on a dedicated iOS 26.5 HomePager simulator on 2026-09-30:
+a slow drag from the Show more button did not activate it, a fling from the
+same button scrolled the list, and a stationary tap activated it. The Pager
+XCTest suite passed 47/47 tests on a separate iOS 26.5 simulator with its data
+on the external drive on 2026-09-30.
+
+In `CollapsiblePagerView` smooth-header mode, a single-finger
+vertical drag beginning on React page content MUST cancel that Surface's active
+React press before finger-up once vertical displacement reaches 10 points and
+exceeds horizontal displacement. Cancellation MUST leave the native vertical
+scroller's pan and momentum intact. Stationary taps, movement below the threshold,
+horizontal drags, and multi-touch sequences MUST retain their existing behavior.
+The iOS content press bridge owns cancellation on the UI thread; the pager's
+existing horizontal-drag cancellation remains independent. The bridge MUST clear
+per-touch state on end, cancellation, and reuse. Android and Web behavior is
+unchanged. Acceptance requires a real iOS button-origin drag that does not fire
+the button, a button-origin fling that scrolls, an ordinary tap that fires, and
+focused native touch-delivery coverage.
+
 ## Native tab-press animation default
 
 Behavior change: previously an omitted `nativeTabPressAnimationEnabled` animated
@@ -306,6 +328,24 @@ and refresh completion, caller offset changes, late installation/replacement,
 retained-page switching, clipping and nested-owner cleanup. Programmatic UIKit
 unit tests do not substitute for real pull-gesture visibility acceptance.
 
+When a smooth shared header is attached to the active iOS scroll view, UIKit's
+temporary refresh top inset MUST keep the header and content aligned. Both are
+children of that scroll view and move together with its content offset; the
+pager MUST NOT apply a separate refresh translation to the header. The scroll
+view's inset and offset, the refresh indicator, and refresh callback ownership
+remain unchanged. Removing the refresh inset or control preserves this alignment
+even without a scroll-offset event. Caller inset changes update the pager
+baseline. The sticky tab row MUST pin against the baseline top inset; the
+refresh control's temporary inset MUST NOT move it below the content, including
+rapid direction reversals while the spinner is active. Detaching the header
+restores its normal transform. This applies to RN NativeScroller and NativeList
+pages; non-smooth and detached headers keep
+their existing positioning. The 2026-09-30 Home Spot simulator checkpoint covers
+shared header/content alignment and inset removal. A separate source-identical
+local package build verified the sticky row during active-refresh vertical
+reversals; published-package, other Home pages and physical-device acceptance
+remain open.
+
 ## iOS shared-header hit testing
 
 Smooth-header hit forwarding is restricted to the pager's own interactive

package/ios/RNCCollapsiblePagerViewComponentView.mm

@@ -1033,6 +1033,8 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
   __weak UITouch *_trackedTouch;
   UIEvent *_touchEvent;
   BOOL _multipleSurfaceTouchesObserved;
+  CGPoint _trackedTouchStartPoint;
+  BOOL _didCancelReactPressForVerticalMovement;
 }
 
 - (BOOL)canPreventGestureRecognizer:(UIGestureRecognizer *)other
@@ -1069,12 +1071,37 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
     return;
   }
   _trackedTouch = touches.anyObject;
+  _trackedTouchStartPoint = [_trackedTouch locationInView:self.view];
+  _didCancelReactPressForVerticalMovement = NO;
   [self recordEvent:event];
 }
 
 - (void)touchesMoved:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
 {
   [self recordEvent:event];
+  UITouch *touch = _trackedTouch;
+  UIGestureRecognizer *handler = self.reactTouchHandler;
+  if (touch == nil || ![touches containsObject:touch] ||
+      self.state != UIGestureRecognizerStatePossible ||
+      _didCancelReactPressForVerticalMovement || _multipleSurfaceTouchesObserved ||
+      handler.view == nil || self.view != handler.view.superview ||
+      handler.state == UIGestureRecognizerStateFailed ||
+      handler.state == UIGestureRecognizerStateCancelled ||
+      handler.state == UIGestureRecognizerStateEnded) return;
+  CGPoint point = [touch locationInView:self.view];
+  CGFloat dx = point.x - _trackedTouchStartPoint.x;
+  CGFloat dy = point.y - _trackedTouchStartPoint.y;
+  if (fabs(dy) < 10.0 || fabs(dy) <= fabs(dx)) return;
+  NSUInteger activeTouches = 0;
+  for (UITouch *activeTouch in event.allTouches) {
+    if (activeTouch.phase == UITouchPhaseEnded ||
+        activeTouch.phase == UITouchPhaseCancelled) continue;
+    if ([activeTouch.view isDescendantOfView:handler.view]) ++activeTouches;
+  }
+  if (activeTouches != 1) return;
+  _didCancelReactPressForVerticalMovement = YES;
+  handler.enabled = NO;
+  handler.enabled = YES;
 }
 
 - (void)cancelPressForPan:(UIPanGestureRecognizer *)pan
@@ -1108,6 +1135,7 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
     ? UIGestureRecognizerStateEnded : UIGestureRecognizerStateFailed;
   _trackedTouch = nil;
   _touchEvent = nil;
+  _didCancelReactPressForVerticalMovement = NO;
 }
 
 - (void)touchesCancelled:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
@@ -1117,6 +1145,7 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
     ? UIGestureRecognizerStateCancelled : UIGestureRecognizerStateFailed;
   _trackedTouch = nil;
   _touchEvent = nil;
+  _didCancelReactPressForVerticalMovement = NO;
 }
 
 - (void)reset
@@ -1125,6 +1154,7 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
   _trackedTouch = nil;
   _touchEvent = nil;
   _multipleSurfaceTouchesObserved = NO;
+  _didCancelReactPressForVerticalMovement = NO;
 }
 
 @end
@@ -2437,6 +2467,10 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
               forKeyPath:@"contentOffset"
                  options:NSKeyValueObservingOptionNew
                  context:RNCCollapsiblePagerContentOffsetContext];
+  [candidate addObserver:self
+              forKeyPath:@"contentInset"
+                 options:NSKeyValueObservingOptionNew
+                 context:RNCCollapsiblePagerContentOffsetContext];
   [candidate addObserver:self
               forKeyPath:@"contentSize"
                  options:NSKeyValueObservingOptionOld | NSKeyValueObservingOptionNew
@@ -2459,6 +2493,9 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
       [scrollView removeObserver:self
                       forKeyPath:@"contentOffset"
                          context:RNCCollapsiblePagerContentOffsetContext];
+      [scrollView removeObserver:self
+                      forKeyPath:@"contentInset"
+                         context:RNCCollapsiblePagerContentOffsetContext];
       [scrollView removeObserver:self
                       forKeyPath:@"contentSize"
                          context:RNCCollapsiblePagerContentOffsetContext];
@@ -2932,6 +2969,7 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
   if (appliedTop != nil) {
     [_appliedTopInsets setObject:@(appliedTop.doubleValue + next.top - previous.top) forKey:scrollView];
   }
+  if (scrollView == _observedScrollView) [self updateHeaderForScrollView:scrollView];
 }
 
 - (void)reapplyInsetsToObservedScrollView
@@ -2964,10 +3002,16 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
                        context:(void *)context
 {
   if (context == RNCScrollRefreshControlContext) {
-    [self updateRefreshControlForScrollView:(UIScrollView *)object];
+    UIScrollView *scrollView = (UIScrollView *)object;
+    [self updateRefreshControlForScrollView:scrollView];
+    if (scrollView == _observedScrollView) [self updateHeaderForScrollView:scrollView];
     return;
   }
   if (context == RNCCollapsiblePagerContentOffsetContext && object == _observedScrollView) {
+    if ([keyPath isEqualToString:@"contentInset"]) {
+      [self updateHeaderForScrollView:(UIScrollView *)object];
+      return;
+    }
     if ([keyPath isEqualToString:@"contentSize"]) {
       NSValue *oldSize = change[NSKeyValueChangeOldKey];
       NSValue *newSize = change[NSKeyValueChangeNewKey];
@@ -2998,9 +3042,15 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
   BOOL attachedToList = _nativeSmoothHeaderScrollEnabled &&
     _sharedHeaderScrollView != nil && !_sharedHeadersLiftedForPagerTransition;
   if (attachedToList) {
+    // The header and content share this scroll view. UIKit's refresh inset
+    // moves both together, so translating the header would separate them.
     _sharedHeaderHostView.transform = CGAffineTransformIdentity;
     _headerView.transform = CGAffineTransformIdentity;
-    CGFloat pinnedTranslation = MAX(0, _currentLogicalOffset - _headerHeight);
+    UIScrollView *scrollView = _sharedHeaderScrollView;
+    NSNumber *appliedTop = [_appliedTopInsets objectForKey:scrollView];
+    CGFloat refreshInset = scrollView.refreshControl != nil && appliedTop != nil
+      ? MAX(0, scrollView.contentInset.top - appliedTop.doubleValue) : 0;
+    CGFloat pinnedTranslation = MAX(0, _currentLogicalOffset - _headerHeight - refreshInset);
     CGAffineTransform stickyTransform = CGAffineTransformMakeTranslation(0, pinnedTranslation);
     _stickyHeaderView.transform = stickyTransform;
     _nativeTabBarView.transform = stickyTransform;

package/ios/tests/RNCCollapsiblePagerPressCancellationTests.mm

@@ -744,6 +744,59 @@ typedef struct __IOHIDEvent *RNCTestHIDEventRef;
   XCTAssertEqual(self.handler.registeredTouches, 0);
 }
 
+- (void)testVerticalPageDragCancelsReactPressBeforeFingerLifts
+{
+  [self assertFixtureIsReadyForDelivery];
+  CGPoint point = [self pressPoint];
+  UITouch *touch = [self.driver beginAt:point];
+  XCTAssertEqual(self.handler.registeredTouches, 1);
+
+  [self.driver move:touch to:CGPointMake(point.x, point.y - 12)];
+  XCTAssertEqual(self.handler.registeredTouches, 0);
+  XCTAssertTrue([self.handler.events containsObject:@"reset-cancelled"] ||
+                  [self.handler.events containsObject:@"cancelled"],
+                @"handler events %@", self.handler.events);
+  XCTAssertFalse([self.handler.events containsObject:@"ended"]);
+
+  [self.driver end:touch];
+  XCTAssertFalse([self.handler.events containsObject:@"ended"], @"events %@", self.handler.events);
+}
+
+- (void)testVerticalSiblingControlDragKeepsReactPress
+{
+  [self assertFixtureIsReadyForDelivery];
+  UIView *sibling = [RCTViewComponentView new];
+  sibling.frame = CGRectMake(160, 540, 80, 100);
+  [self.surface addSubview:sibling];
+  CGPoint point = [self pressPoint];
+  UIScrollView *pagerScrollView = [self.pager valueForKey:@"pagerScrollView"];
+  XCTAssertEqual(sibling.superview, self.pager.superview);
+  XCTAssertFalse([sibling isDescendantOfView:pagerScrollView]);
+  XCTAssertEqual([self.window hitTest:point withEvent:nil], sibling);
+
+  UITouch *touch = [self.driver beginAt:point];
+  XCTAssertEqual(self.handler.registeredTouches, 1);
+  [self.driver move:touch to:CGPointMake(point.x, point.y - 12)];
+  XCTAssertEqual(self.handler.registeredTouches, 1);
+  XCTAssertFalse([self.handler.events containsObject:@"reset-cancelled"]);
+  XCTAssertFalse([self.handler.events containsObject:@"cancelled"]);
+
+  [self.driver end:touch];
+  XCTAssertEqualObjects(self.handler.events, (@[@"began", @"moved", @"ended"]));
+  XCTAssertEqual(self.handler.registeredTouches, 0);
+}
+
+- (void)testSmallVerticalMovementKeepsReactPress
+{
+  [self assertFixtureIsReadyForDelivery];
+  CGPoint point = [self pressPoint];
+  UITouch *touch = [self.driver beginAt:point];
+  [self.driver move:touch to:CGPointMake(point.x, point.y - 8)];
+  XCTAssertEqual(self.handler.registeredTouches, 1);
+  [self.driver end:touch];
+  XCTAssertEqualObjects(self.handler.events, (@[@"began", @"moved", @"ended"]));
+}
+
 - (void)testSmallMovementBelowPanThresholdKeepsReactPress
 {
   [self assertFixtureIsReadyForDelivery];

package/ios/tests/RNCCollapsiblePagerRefreshControlTests.mm

@@ -1,9 +1,11 @@
 #import <XCTest/XCTest.h>
+#import <React/RCTViewComponentView.h>
 #import "RNCCollapsiblePagerViewComponentView.h"
 
 @interface RNCCollapsiblePagerViewComponentView (RefreshControlTesting)
 - (void)updateRefreshControlForScrollView:(UIScrollView *)scrollView;
 - (void)releaseRefreshControlForScrollView:(UIScrollView *)scrollView;
+- (void)attachScrollObserverForCurrentPage;
 @end
 
 @interface RNCCollapsiblePagerRefreshControlTests : XCTestCase
@@ -177,4 +179,71 @@
   XCTAssertTrue(control.layer.masksToBounds);
 }
 
+- (void)testRefreshTopInsetDoesNotDisplaceAttachedSharedHeader
+{
+  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)];
+  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];
+  NSMutableArray<UIViewController *> *pages = [pager valueForKey:@"pageControllers"];
+  [pages addObject:page];
+  [pager attachScrollObserverForCurrentPage];
+  UIView *headerHost = [pager valueForKey:@"sharedHeaderHostView"];
+  UIView *stickyHeader = [pager valueForKey:@"stickyHeaderView"];
+  UIView *tabBar = [pager valueForKey:@"nativeTabBarView"];
+  XCTAssertNotNil(stickyHeader);
+  XCTAssertEqual(stickyHeader.superview, headerHost);
+  XCTAssertEqual(headerHost.superview, scroll);
+  XCTAssertEqualWithAccuracy(scroll.contentInset.top, 340, 0.001);
+  XCTAssertEqualWithAccuracy(headerHost.transform.ty, 0, 0.001);
+
+  scroll.contentOffset = CGPointMake(0, 500);
+  CGFloat baselineStickyTranslation = stickyHeader.transform.ty;
+  CGFloat baselineTabBarTranslation = tabBar.transform.ty;
+  XCTAssertEqualWithAccuracy(baselineStickyTranslation, 776, 0.001);
+  XCTAssertEqualWithAccuracy(baselineTabBarTranslation, 776, 0.001);
+  CGPoint offset = scroll.contentOffset;
+  scroll.contentInset = UIEdgeInsetsMake(400, 0, 0, 0);
+  XCTAssertTrue(CGPointEqualToPoint(scroll.contentOffset, offset));
+  XCTAssertEqualWithAccuracy(headerHost.transform.ty, 0, 0.001);
+  XCTAssertEqualWithAccuracy(stickyHeader.transform.ty, baselineStickyTranslation, 0.001);
+  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
+  // 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);
+    CGFloat expectedTranslation = MAX(0, nextOffset.doubleValue + 340 - 64);
+    XCTAssertEqualWithAccuracy(headerHost.transform.ty, 0, 0.001);
+    XCTAssertEqualWithAccuracy(stickyHeader.transform.ty, expectedTranslation, 0.001);
+    XCTAssertEqualWithAccuracy(tabBar.transform.ty, expectedTranslation, 0.001);
+    XCTAssertEqualWithAccuracy(CGRectGetMaxY(headerHost.frame), CGRectGetMinY(content.frame), 0.001);
+  }
+
+  offset = scroll.contentOffset;
+  scroll.contentInset = UIEdgeInsetsMake(340, 0, 0, 0);
+  XCTAssertTrue(CGPointEqualToPoint(scroll.contentOffset, offset));
+  XCTAssertEqualWithAccuracy(headerHost.transform.ty, 0, 0.001);
+  XCTAssertEqualWithAccuracy(stickyHeader.transform.ty, baselineStickyTranslation, 0.001);
+  XCTAssertEqualWithAccuracy(tabBar.transform.ty, baselineTabBarTranslation, 0.001);
+
+  scroll.contentInset = UIEdgeInsetsMake(400, 0, 0, 0);
+  XCTAssertEqualWithAccuracy(headerHost.transform.ty, 0, 0.001);
+  XCTAssertEqualWithAccuracy(stickyHeader.transform.ty, baselineStickyTranslation, 0.001);
+  XCTAssertEqualWithAccuracy(tabBar.transform.ty, baselineTabBarTranslation, 0.001);
+  XCTAssertEqualWithAccuracy(CGRectGetMaxY(headerHost.frame), CGRectGetMinY(content.frame), 0.001);
+  scroll.refreshControl = nil;
+  XCTAssertEqualWithAccuracy(headerHost.transform.ty, 0, 0.001);
+  [pager prepareForRecycle];
+}
+
 @end

package/package.json

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