@onekeyfe/react-native-pager-view 3.0.168 → 3.0.169

package/docs/SPEC.md

@@ -260,6 +260,18 @@ remain able to recognize before finger-up while Pager intent is pending. A
 second touch in the pending Pager guard fails recognition; an already active
 Pager guard cancels and restores each held pan's original minimum touch count.
 
+In iOS smooth-header mode, a confirmed horizontal guard displacement of at
+least 32 points, exceeding vertical displacement, MUST cancel the active React
+press on its one eligible content Surface before finger-up even when the pager
+pan has not begun. The content observer stays non-recognizing and resets only
+that Surface's already Began/Changed touch handler. Shared-header native controls,
+stationary taps, pending small-horizontal-to-vertical gestures, and multi-touch
+sequences retain their existing ownership. Cancellation is emitted at most once
+for the tracked touch; end, cancellation, and reuse clear that touch's state.
+The attached UIKit regression intentionally constrains the real pager pan to two
+required touches to prove the no-pan path; it is distinct from natural Home OS
+input, coalesced-event delivery, and physical-device acceptance.
+
 ## Native tab-press animation default
 
 Behavior change: previously an omitted `nativeTabPressAnimationEnabled` animated

package/ios/RNCCollapsiblePagerViewComponentView.mm

@@ -1070,11 +1070,12 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
 
 @end
 
-// This observer never competes for scrolling. The owning pager explicitly
-// recognizes it only after its real pan begins, so UIKit terminates RN presses.
+// This observer never competes for scrolling. RN presses are terminated when
+// the pager pan begins or the existing guard resolves horizontal intent.
 @interface RNCCollapsiblePagerContentPressCancellationGestureRecognizer : UIGestureRecognizer
 @property (nonatomic, weak) UIGestureRecognizer *reactTouchHandler;
 - (void)cancelPressForPan:(UIPanGestureRecognizer *)pan;
+- (void)cancelPressForHorizontalTouch:(UITouch *)touch event:(UIEvent *)event;
 - (void)observeIncomingTouch:(UITouch *)touch;
 @end
 
@@ -1084,6 +1085,7 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
   BOOL _multipleSurfaceTouchesObserved;
   CGPoint _trackedTouchStartPoint;
   BOOL _didCancelReactPressForVerticalMovement;
+  BOOL _didCancelReactPressForHorizontalMovement;
 }
 
 - (BOOL)canPreventGestureRecognizer:(UIGestureRecognizer *)other
@@ -1122,6 +1124,7 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
   _trackedTouch = touches.anyObject;
   _trackedTouchStartPoint = [_trackedTouch locationInView:self.view];
   _didCancelReactPressForVerticalMovement = NO;
+  _didCancelReactPressForHorizontalMovement = NO;
   [self recordEvent:event];
 }
 
@@ -1153,6 +1156,31 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
   handler.enabled = YES;
 }
 
+- (void)cancelPressForHorizontalTouch:(UITouch *)touch event:(UIEvent *)event
+{
+  [self recordEvent:event];
+  UIGestureRecognizer *handler = self.reactTouchHandler;
+  BOOL eligible = touch != nil && touch == _trackedTouch &&
+    touch.phase != UITouchPhaseEnded && touch.phase != UITouchPhaseCancelled &&
+    self.state == UIGestureRecognizerStatePossible &&
+    !_multipleSurfaceTouchesObserved && !_didCancelReactPressForHorizontalMovement &&
+    handler.view != nil && self.view == handler.view.superview &&
+    (handler.state == UIGestureRecognizerStateBegan || handler.state == UIGestureRecognizerStateChanged);
+  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 (!eligible || activeTouches != 1) return;
+  // A coalesced move can resolve horizontal intent before the pager pan begins.
+  _didCancelReactPressForHorizontalMovement = YES;
+#if DEBUG
+  RNCCollapsiblePagerLog(@"content-press-cancel axis=horizontal");
+#endif
+  handler.enabled = NO;
+  handler.enabled = YES;
+}
+
 - (void)cancelPressForPan:(UIPanGestureRecognizer *)pan
 {
   UIGestureRecognizer *handler = self.reactTouchHandler;
@@ -1185,6 +1213,7 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
   _trackedTouch = nil;
   _touchEvent = nil;
   _didCancelReactPressForVerticalMovement = NO;
+  _didCancelReactPressForHorizontalMovement = NO;
 }
 
 - (void)touchesCancelled:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
@@ -1195,6 +1224,7 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
   _trackedTouch = nil;
   _touchEvent = nil;
   _didCancelReactPressForVerticalMovement = NO;
+  _didCancelReactPressForHorizontalMovement = NO;
 }
 
 - (void)reset
@@ -1204,6 +1234,7 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
   _touchEvent = nil;
   _multipleSurfaceTouchesObserved = NO;
   _didCancelReactPressForVerticalMovement = NO;
+  _didCancelReactPressForHorizontalMovement = NO;
 }
 
 @end
@@ -1238,6 +1269,7 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
 
 @interface RNCCollapsiblePagerVerticalPagerGuardGestureRecognizer : UIGestureRecognizer
 @property (nonatomic, weak) UIPanGestureRecognizer *pagerPan;
+@property (nonatomic, weak) RNCCollapsiblePagerContentPressCancellationGestureRecognizer *contentPressCancellation;
 - (CGPoint)translationInView:(UIView *)view;
 - (CGPoint)velocityInView:(UIView *)view;
 @end
@@ -1333,6 +1365,9 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
       RNCCollapsiblePagerLog([NSString stringWithFormat:
         @"gesture-intent axis=%@ dx=%.2f dy=%.2f held-pans=%lu",
         dy > dx ? @"vertical" : @"horizontal", dx, dy, (unsigned long)_heldPans.count]);
+      if (dx >= 32 && dx > dy) {
+        [self.contentPressCancellation cancelPressForHorizontalTouch:_trackedTouch event:event];
+      }
       self.state = UIGestureRecognizerStateBegan;
       if (self.state == UIGestureRecognizerStateFailed) [self restoreHeldPans];
     }
@@ -2716,6 +2751,7 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
     [_contentPressCancellationGesture.view removeGestureRecognizer:_contentPressCancellationGesture];
   }
   _contentPressCancellationGesture.reactTouchHandler = nil;
+  _verticalPagerGesture.contentPressCancellation = nil;
   _contentPressCancellationGesture = nil;
   if (_sharedHeaderPressCancellationGesture.view != nil) {
     [_sharedHeaderPressCancellationGesture.view
@@ -2814,6 +2850,7 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
     _contentPressCancellationGesture.delaysTouchesEnded = NO;
   }
   _contentPressCancellationGesture.reactTouchHandler = reactTouchHandler;
+  _verticalPagerGesture.contentPressCancellation = _contentPressCancellationGesture;
   [gestureHost addGestureRecognizer:_contentPressCancellationGesture];
   _reactTouchHandler = reactTouchHandler;
   _sharedHeaderPressCancellationGestureHost = gestureHost;

package/ios/tests/RNCCollapsiblePagerPressCancellationTests.mm

@@ -70,6 +70,9 @@ typedef struct __IOHIDEvent *RNCTestHIDEventRef;
 - (UITouch *)beginAt:(CGPoint)windowPoint;
 - (void)move:(UITouch *)touch to:(CGPoint)windowPoint;
 - (void)end:(UITouch *)touch;
+- (void)cancel:(UITouch *)touch;
+- (void)singleMoveKeepingDownTimestamp:(UITouch *)touch to:(CGPoint)point;
+- (void)endAfterTwoFrames:(UITouch *)touch;
 @end
 
 @implementation RNCSynthesizedTouchDriver {
@@ -198,6 +201,25 @@ typedef struct __IOHIDEvent *RNCTestHIDEventRef;
   [self sendChangingTouch:touch phase:UITouchPhaseEnded];
 }
 
+- (void)cancel:(UITouch *)touch
+{
+  [self sendChangingTouch:touch phase:UITouchPhaseCancelled];
+}
+
+- (void)singleMoveKeepingDownTimestamp:(UITouch *)touch to:(CGPoint)point
+{
+  // One controlled delivered MOVE shares DOWN's touch timestamp.
+  // This is controlled UIWindow delivery, not OS input or coalescing coverage.
+  _timestamp -= 1.0 / 60.0;
+  [self move:touch to:point];
+}
+
+- (void)endAfterTwoFrames:(UITouch *)touch
+{
+  _timestamp += 1.0 / 60.0;
+  [self end:touch];
+}
+
 @end
 
 // Private declarations access the production class compiled into the pod.
@@ -581,14 +603,32 @@ typedef struct __IOHIDEvent *RNCTestHIDEventRef;
 @interface RNCRecordingSurfaceTouchHandler : RCTSurfaceTouchHandler
 @property (nonatomic, strong) NSMutableArray<NSString *> *events;
 @property (nonatomic, assign) NSInteger registeredTouches;
+@property (nonatomic) NSUInteger enabledNoWithRegisteredTouch;
+@property (nonatomic, strong) NSMutableArray<NSDictionary *> *timeline;
 @end
 
 @implementation RNCRecordingSurfaceTouchHandler
+- (void)recordTimeline:(NSString *)event
+{
+  if (self.timeline == nil) self.timeline = [NSMutableArray new];
+  [self.timeline addObject:@{@"event": event, @"state": @(self.state),
+                            @"registered": @(self.registeredTouches),
+                            @"enabled": @(self.enabled)}];
+}
+- (void)setEnabled:(BOOL)enabled
+{
+  if (!enabled && self.registeredTouches > 0) {
+    self.enabledNoWithRegisteredTouch += 1;
+    [self recordTimeline:@"enabled-NO-before-super"];
+  }
+  [super setEnabled:enabled];
+}
 - (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
 {
   [super touchesBegan:touches withEvent:event];
   self.registeredTouches += touches.count;
   [self.events addObject:@"began"];
+  [self recordTimeline:@"began"];
 }
 - (void)touchesMoved:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
 {
@@ -606,13 +646,17 @@ typedef struct __IOHIDEvent *RNCTestHIDEventRef;
   [super touchesCancelled:touches withEvent:event];
   self.registeredTouches -= touches.count;
   [self.events addObject:@"cancelled"];
+  [self recordTimeline:@"cancelled"];
 }
 - (void)reset
 {
   NSInteger pending = self.registeredTouches;
   [super reset];
   self.registeredTouches = 0;
-  if (pending > 0) [self.events addObject:@"reset-cancelled"];
+  if (pending > 0) {
+    [self.events addObject:@"reset-cancelled"];
+    [self recordTimeline:@"reset-cancelled"];
+  }
 }
 @end
 
@@ -624,6 +668,7 @@ typedef struct __IOHIDEvent *RNCTestHIDEventRef;
 @property (nonatomic, strong) RNCSynthesizedTouchDriver *driver;
 @property (nonatomic, strong) UIView *firstPage;
 @property (nonatomic) NSUInteger longPressBegins;
+@property (nonatomic) NSUInteger pagerPanBegins;
 @end
 
 @implementation RNCCollapsiblePagerPressCancellationDeliveryTests
@@ -711,6 +756,127 @@ typedef struct __IOHIDEvent *RNCTestHIDEventRef;
   return CGPointMake(200, 600);
 }
 
+- (void)assertDirectPagerForRegression
+{
+  XCTAssertTrue([[self.pager valueForKey:@"directNativePagerEnabled"] boolValue]);
+  UIScrollView *pager = [self.pager valueForKey:@"pagerScrollView"];
+  XCTAssertTrue([pager isKindOfClass:NSClassFromString(@"RNCCollapsiblePagerDirectScrollView")]);
+}
+
+- (void)recordPagerPan:(UIPanGestureRecognizer *)pan
+{
+  if (pan.state == UIGestureRecognizerStateBegan) self.pagerPanBegins += 1;
+}
+
+- (UITouch *)beginSingleMoveHorizontalSequence
+{
+  [self assertFixtureIsReadyForDelivery];
+  [self assertDirectPagerForRegression];
+  UIScrollView *pager = [self.pager valueForKey:@"pagerScrollView"];
+  // A controlled absence of pager-pan recognition, independent of UIKit event timing.
+  // This does not model the natural Home OS recognizer configuration.
+  pager.panGestureRecognizer.minimumNumberOfTouches = 2;
+  XCTAssertTrue(pager.panGestureRecognizer.enabled);
+  XCTAssertEqual(pager.panGestureRecognizer.minimumNumberOfTouches, 2);
+  [pager.panGestureRecognizer addTarget:self action:@selector(recordPagerPan:)];
+  CGPoint point = CGPointMake(350, 600);
+  UIView *hit = [self.window hitTest:point withEvent:nil];
+  XCTAssertTrue(hit == self.firstPage || [hit isDescendantOfView:self.firstPage]);
+  UITouch *touch = [self.driver beginAt:point];
+  XCTAssertEqual(self.handler.registeredTouches, 1);
+  XCTAssertTrue(self.handler.state == UIGestureRecognizerStateBegan ||
+                self.handler.state == UIGestureRecognizerStateChanged);
+  UIGestureRecognizer *observer = [self.pager valueForKey:@"contentPressCancellationGesture"];
+  XCTAssertEqual(observer.state, UIGestureRecognizerStatePossible);
+  XCTAssertEqual([observer valueForKey:@"reactTouchHandler"], self.handler);
+  XCTAssertEqual(observer.view, self.handler.view.superview);
+  XCTAssertTrue([touch.view isDescendantOfView:self.handler.view]);
+  NSTimeInterval down = touch.timestamp;
+  [self.driver singleMoveKeepingDownTimestamp:touch to:CGPointMake(25, 600)];
+  XCTAssertEqualWithAccuracy(touch.timestamp, down, 0.000001);
+  XCTAssertEqual(self.pagerPanBegins, 0, @"A pager-pan callback cannot explain this cancellation");
+  XCTAssertFalse(pager.isDragging);
+  XCTAssertTrue([[observer valueForKey:@"didCancelReactPressForHorizontalMovement"] boolValue]);
+  XCTAssertEqual(self.handler.registeredTouches, 0);
+  NSUInteger cancellations = 0;
+  for (NSString *event in self.handler.events) {
+    if ([event isEqualToString:@"reset-cancelled"] || [event isEqualToString:@"cancelled"]) ++cancellations;
+  }
+  XCTAssertEqual(cancellations, 1, @"Exactly one real RN cancellation must occur before UP: %@", self.handler.events);
+  XCTAssertEqual(self.handler.enabledNoWithRegisteredTouch, 1);
+  NSPredicate *disabled = [NSPredicate predicateWithFormat:@"event == %@", @"enabled-NO-before-super"];
+  NSArray *disableCalls = [self.handler.timeline filteredArrayUsingPredicate:disabled];
+  XCTAssertEqual(disableCalls.count, 1);
+  XCTAssertEqualObjects(disableCalls.firstObject[@"registered"], @1);
+  XCTAssertFalse([self.handler.events containsObject:@"ended"]);
+  NSLog(@"[PagerPressDelivery] case=%@ oneMoveH=325 constrainedMinTouches=2 panBegins=%lu registered=%ld cancellationCount=%lu enabledNO=%lu events=%@ timeline=%@",
+        self.name, (unsigned long)self.pagerPanBegins, (long)self.handler.registeredTouches,
+        (unsigned long)cancellations, (unsigned long)self.handler.enabledNoWithRegisteredTouch,
+        self.handler.events, self.handler.timeline);
+  return touch;
+}
+
+- (void)testSingleDeliveredHorizontalMoveCancelsBeforeUpWithoutPagerPanBegan
+{
+  UITouch *touch = [self beginSingleMoveHorizontalSequence];
+  [self.driver endAfterTwoFrames:touch];
+  XCTAssertEqual(((UIScrollView *)[self.pager valueForKey:@"pagerScrollView"]).panGestureRecognizer.minimumNumberOfTouches, 2);
+  XCTAssertEqual(self.pagerPanBegins, 0);
+  XCTAssertFalse([self.handler.events containsObject:@"ended"]);
+}
+
+- (void)testSingleMoveHorizontalUpAllowsNextStationaryTap
+{
+  UITouch *touch = [self beginSingleMoveHorizontalSequence];
+  [self.driver endAfterTwoFrames:touch];
+  XCTAssertEqual(self.pagerPanBegins, 0);
+  XCTAssertEqual(((UIScrollView *)[self.pager valueForKey:@"pagerScrollView"]).panGestureRecognizer.minimumNumberOfTouches, 2);
+  [self drainMainQueue];
+  [self.handler.events removeAllObjects];
+  UITouch *next = [self.driver beginAt:[self pressPoint]];
+  [self.driver end:next];
+  XCTAssertEqualObjects(self.handler.events, (@[@"began", @"ended"]));
+  XCTAssertEqual(self.handler.registeredTouches, 0);
+}
+
+- (void)testSingleMoveHorizontalCancelAllowsNextStationaryTap
+{
+  UITouch *touch = [self beginSingleMoveHorizontalSequence];
+  [self.driver cancel:touch];
+  XCTAssertEqual(self.pagerPanBegins, 0);
+  XCTAssertEqual(((UIScrollView *)[self.pager valueForKey:@"pagerScrollView"]).panGestureRecognizer.minimumNumberOfTouches, 2);
+  [self drainMainQueue];
+  [self.handler.events removeAllObjects];
+  UITouch *next = [self.driver beginAt:[self pressPoint]];
+  [self.driver end:next];
+  XCTAssertEqualObjects(self.handler.events, (@[@"began", @"ended"]));
+  XCTAssertEqual(self.handler.registeredTouches, 0);
+}
+
+- (void)testSecondActiveTouchOnSameSurfaceBlocksSingleMoveHorizontalReset
+{
+  [self assertFixtureIsReadyForDelivery];
+  [self assertDirectPagerForRegression];
+  UIScrollView *pager = [self.pager valueForKey:@"pagerScrollView"];
+  pager.panGestureRecognizer.minimumNumberOfTouches = 2;
+  XCTAssertTrue(pager.panGestureRecognizer.enabled);
+  UIView *sibling = [RCTViewComponentView new];
+  sibling.frame = CGRectMake(0, 40, 100, 80);
+  [self.surface addSubview:sibling];
+  UITouch *first = [self.driver beginAt:CGPointMake(350, 600)];
+  UITouch *second = [self.driver beginAt:CGPointMake(50, 80)];
+  XCTAssertEqual(self.handler.registeredTouches, 2);
+  [self.driver singleMoveKeepingDownTimestamp:first to:CGPointMake(25, 600)];
+  XCTAssertEqual(self.handler.registeredTouches, 2);
+  XCTAssertFalse([self.handler.events containsObject:@"reset-cancelled"]);
+  XCTAssertFalse([self.handler.events containsObject:@"cancelled"]);
+  XCTAssertEqual(self.handler.enabledNoWithRegisteredTouch, 0);
+  [self.driver end:second];
+  [self.driver end:first];
+  XCTAssertEqual(pager.panGestureRecognizer.minimumNumberOfTouches, 2);
+  XCTAssertEqual(self.handler.registeredTouches, 0);
+}
+
 - (void)testHorizontalPagerDragCancelsReactPressBeforeFingerLifts
 {
   [self assertFixtureIsReadyForDelivery];

package/package.json

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