@onekeyfe/react-native-pager-view 3.0.113 → 3.0.115

package/ios/RNCCollapsiblePagerViewComponentView.mm

@@ -15,8 +15,10 @@ static void *RNCCollapsiblePagerContentOffsetContext = &RNCCollapsiblePagerConte
   RCTRNCCollapsiblePagerViewViewProtocol,
   UIPageViewControllerDataSource,
   UIPageViewControllerDelegate,
-  UIScrollViewDelegate
+  UIScrollViewDelegate,
+  UIGestureRecognizerDelegate
 >
+- (void)finishPagerScrollEmittingSelection:(BOOL)emitSelection;
 @end
 
 @implementation RNCCollapsiblePagerViewComponentView {
@@ -34,13 +36,23 @@ static void *RNCCollapsiblePagerContentOffsetContext = &RNCCollapsiblePagerConte
   NSInteger _stickyHeaderHeight;
   CGFloat _headerOffset;
   BOOL _scrollEnabled;
+  // OneKey patch: Coordinate this inner pager with an outer horizontal pager.
+  BOOL _nestedScrollEnabled;
+  UIPanGestureRecognizer *_blockerGesture;
   BOOL _transitioning;
+  BOOL _isPagerDragging;
+  BOOL _hasReceivedPageCommand;
+  NSUInteger _transitionId;
+  // OneKey patch: Retain the latest tab tap while an animation is in flight.
+  NSInteger _pendingGoToIndex;
   BOOL _hasAppliedInitialPage;
+  BOOL _needsPropsReapply;
   NSString *_layoutDirection;
   NSArray<NSString *> *_pageKeys;
   NSString *_retainedPages;
   NSMutableDictionary<NSString *, NSNumber *> *_pageOffsets;
   NSMapTable<UIScrollView *, NSValue *> *_originalInsets;
+  NSMapTable<UIScrollView *, NSNumber *> *_appliedTopInsets;
   NSMapTable<UIScrollView *, NSValue *> *_originalIndicatorInsets;
   NSMapTable<UIScrollView *, NSNumber *> *_originalAlwaysBounceVertical;
   NSMapTable<UIScrollView *, NSNumber *> *_originalInsetAdjustmentBehavior;
@@ -64,6 +76,7 @@ static void *RNCCollapsiblePagerContentOffsetContext = &RNCCollapsiblePagerConte
     _pageControllers = [NSMutableArray new];
     _pageOffsets = [NSMutableDictionary new];
     _originalInsets = [NSMapTable weakToStrongObjectsMapTable];
+    _appliedTopInsets = [NSMapTable weakToStrongObjectsMapTable];
     _originalIndicatorInsets = [NSMapTable weakToStrongObjectsMapTable];
     _originalAlwaysBounceVertical = [NSMapTable weakToStrongObjectsMapTable];
     _originalInsetAdjustmentBehavior = [NSMapTable weakToStrongObjectsMapTable];
@@ -73,7 +86,10 @@ static void *RNCCollapsiblePagerContentOffsetContext = &RNCCollapsiblePagerConte
     _destinationIndex = 0;
     _pendingInitialPage = 0;
     _scrollEnabled = YES;
+    _nestedScrollEnabled = NO;
+    _pendingGoToIndex = -1;
     _hasAppliedInitialPage = NO;
+    _needsPropsReapply = YES;
     _layoutDirection = @"ltr";
 
     _containerView = [UIView new];
@@ -94,6 +110,17 @@ static void *RNCCollapsiblePagerContentOffsetContext = &RNCCollapsiblePagerConte
   }
 }
 
+- (void)didMoveToWindow
+{
+  [super didMoveToWindow];
+  // OneKey patch: removing a decelerating page from its window can suppress
+  // UIKit's final scroll callback. Restore the last acknowledged page on reattach.
+  if (self.window != nil && _isPagerDragging &&
+      !_pagerScrollView.dragging && !_pagerScrollView.decelerating) {
+    [self finishPagerScrollEmittingSelection:NO];
+  }
+}
+
 - (void)initializePageViewController
 {
   _pageViewController = [[UIPageViewController alloc]
@@ -102,7 +129,9 @@ static void *RNCCollapsiblePagerContentOffsetContext = &RNCCollapsiblePagerConte
     options:nil];
   _pageViewController.dataSource = self;
   _pageViewController.delegate = self;
-  [_containerView addSubview:_pageViewController.view];
+  // Fabric may mount header slots before a recycled pager reattaches.
+  // Keep the recreated page container below those existing headers.
+  [_containerView insertSubview:_pageViewController.view atIndex:0];
 
   for (UIView *subview in _pageViewController.view.subviews) {
     if ([subview isKindOfClass:UIScrollView.class]) {
@@ -113,6 +142,7 @@ static void *RNCCollapsiblePagerContentOffsetContext = &RNCCollapsiblePagerConte
       break;
     }
   }
+  [self applyNestedScrollBlocker];
 }
 
 #pragma mark - React mounting
@@ -140,6 +170,10 @@ static void *RNCCollapsiblePagerContentOffsetContext = &RNCCollapsiblePagerConte
 - (void)rebuildSlots
 {
   [self detachScrollObserver];
+  // OneKey patch: Fabric reuses these views without resetting transforms
+  // written by a native parent. Release our collapse translation with the slot.
+  _headerView.transform = CGAffineTransformIdentity;
+  _stickyHeaderView.transform = CGAffineTransformIdentity;
   [_headerView removeFromSuperview];
   [_stickyHeaderView removeFromSuperview];
   _headerView = nil;
@@ -166,7 +200,8 @@ static void *RNCCollapsiblePagerContentOffsetContext = &RNCCollapsiblePagerConte
         _pendingInitialPage >= 0 &&
         _pendingInitialPage < _pageControllers.count) {
       _currentIndex = _pendingInitialPage;
-      _hasAppliedInitialPage = YES;
+      // A recycled host may receive slots before its page controller exists.
+      _hasAppliedInitialPage = _pageViewController != nil;
     } else {
       _currentIndex = MIN(MAX(_currentIndex, 0), _pageControllers.count - 1);
     }
@@ -192,6 +227,19 @@ static void *RNCCollapsiblePagerContentOffsetContext = &RNCCollapsiblePagerConte
   [super layoutSubviews];
   _containerView.frame = self.bounds;
   _pageViewController.view.frame = _containerView.bounds;
+  // OneKey patch: Fabric may mount page slots before applying the host props.
+  // Commit the pending initial page once both props and page controllers exist.
+  if (!_hasAppliedInitialPage && _pageViewController != nil &&
+      _pendingInitialPage >= 0 && _pendingInitialPage < _pageControllers.count) {
+    [self detachScrollObserver];
+    _currentIndex = _pendingInitialPage;
+    _destinationIndex = _currentIndex;
+    _hasAppliedInitialPage = YES;
+    [_pageViewController setViewControllers:@[_pageControllers[_currentIndex]]
+                                  direction:UIPageViewControllerNavigationDirectionForward
+                                   animated:NO
+                                 completion:nil];
+  }
   // UIKit frame assignment is undefined while a view has a non-identity transform.
   // Lay out the original slots, then restore the shared collapse translation.
   _headerView.transform = CGAffineTransformIdentity;
@@ -203,6 +251,8 @@ static void *RNCCollapsiblePagerContentOffsetContext = &RNCCollapsiblePagerConte
     self.bounds.size.width,
     _stickyHeaderHeight
   );
+  // Settle UIKit page containers before sizing their autoresizing child views.
+  [_pageViewController.view layoutIfNeeded];
   for (UIViewController *controller in _pageControllers) {
     controller.view.frame = _pageViewController.view.bounds;
     controller.view.subviews.firstObject.frame = controller.view.bounds;
@@ -223,7 +273,14 @@ static void *RNCCollapsiblePagerContentOffsetContext = &RNCCollapsiblePagerConte
   [self detachScrollObserver];
   for (UIScrollView *scrollView in _originalInsets.keyEnumerator) {
     NSValue *value = [_originalInsets objectForKey:scrollView];
-    if (value != nil) scrollView.contentInset = value.UIEdgeInsetsValue;
+    if (value != nil) {
+      UIEdgeInsets original = value.UIEdgeInsetsValue;
+      NSNumber *appliedTop = [_appliedTopInsets objectForKey:scrollView];
+      if (appliedTop != nil && scrollView.refreshControl != nil) {
+        original.top += MAX(0, scrollView.contentInset.top - appliedTop.doubleValue);
+      }
+      scrollView.contentInset = original;
+    }
     NSValue *indicatorValue = [_originalIndicatorInsets objectForKey:scrollView];
     if (indicatorValue != nil) {
       scrollView.verticalScrollIndicatorInsets = indicatorValue.UIEdgeInsetsValue;
@@ -236,9 +293,14 @@ static void *RNCCollapsiblePagerContentOffsetContext = &RNCCollapsiblePagerConte
     }
   }
   [_originalInsets removeAllObjects];
+  [_appliedTopInsets removeAllObjects];
   [_originalIndicatorInsets removeAllObjects];
   [_originalAlwaysBounceVertical removeAllObjects];
   [_originalInsetAdjustmentBehavior removeAllObjects];
+  // OneKey patch: Fabric reuses these views without resetting transforms
+  // written by a native parent. Release our collapse translation with the slot.
+  _headerView.transform = CGAffineTransformIdentity;
+  _stickyHeaderView.transform = CGAffineTransformIdentity;
   [_headerView removeFromSuperview];
   [_stickyHeaderView removeFromSuperview];
   [_logicalChildren removeAllObjects];
@@ -248,6 +310,10 @@ static void *RNCCollapsiblePagerContentOffsetContext = &RNCCollapsiblePagerConte
   _pageViewController.dataSource = nil;
   _pageViewController.delegate = nil;
   _pagerScrollView.delegate = nil;
+  if (_blockerGesture != nil) {
+    [self removeGestureRecognizer:_blockerGesture];
+    _blockerGesture = nil;
+  }
   [_pageViewController.view removeFromSuperview];
   _pageViewController = nil;
   _pagerScrollView = nil;
@@ -262,8 +328,14 @@ static void *RNCCollapsiblePagerContentOffsetContext = &RNCCollapsiblePagerConte
   _stickyHeaderHeight = 0;
   _headerOffset = 0;
   _scrollEnabled = YES;
+  _nestedScrollEnabled = NO;
   _transitioning = NO;
+  _isPagerDragging = NO;
+  _hasReceivedPageCommand = NO;
+  _pendingGoToIndex = -1;
   _hasAppliedInitialPage = NO;
+  // OneKey patch: Fabric retains old props when recycling this view.
+  _needsPropsReapply = YES;
   _layoutDirection = @"ltr";
   _isBeingRecycled = NO;
 }
@@ -275,38 +347,46 @@ static void *RNCCollapsiblePagerContentOffsetContext = &RNCCollapsiblePagerConte
   const auto &oldViewProps = *std::static_pointer_cast<const RNCCollapsiblePagerViewProps>(_props);
   const auto &newViewProps = *std::static_pointer_cast<const RNCCollapsiblePagerViewProps>(props);
 
-  if (oldViewProps.initialPage != newViewProps.initialPage) {
+  if (_needsPropsReapply || oldViewProps.initialPage != newViewProps.initialPage) {
     _pendingInitialPage = MAX(0, newViewProps.initialPage);
-    _hasAppliedInitialPage = NO;
+    // Focus commands can arrive before the recycled host receives its props.
+    _hasAppliedInitialPage = _hasReceivedPageCommand;
+    // OneKey patch: Prop updates can arrive after the last slot was mounted.
+    [self setNeedsLayout];
   }
-  if (oldViewProps.scrollEnabled != newViewProps.scrollEnabled) {
+  if (_needsPropsReapply || oldViewProps.scrollEnabled != newViewProps.scrollEnabled) {
     _scrollEnabled = newViewProps.scrollEnabled;
     _pagerScrollView.scrollEnabled = _scrollEnabled;
   }
-  if (oldViewProps.layoutDirection != newViewProps.layoutDirection) {
+  if (_needsPropsReapply || oldViewProps.nestedScrollEnabled != newViewProps.nestedScrollEnabled) {
+    _nestedScrollEnabled = newViewProps.nestedScrollEnabled;
+    [self applyNestedScrollBlocker];
+  }
+  if (_needsPropsReapply || oldViewProps.layoutDirection != newViewProps.layoutDirection) {
     _layoutDirection = RCTNSStringFromString(toString(newViewProps.layoutDirection));
   }
   BOOL insetsChanged = NO;
-  if (oldViewProps.headerHeight != newViewProps.headerHeight) {
+  if (_needsPropsReapply || oldViewProps.headerHeight != newViewProps.headerHeight) {
     _headerHeight = MAX(0, newViewProps.headerHeight);
     _headerOffset = MIN(_headerOffset, _headerHeight);
     insetsChanged = YES;
   }
-  if (oldViewProps.stickyHeaderHeight != newViewProps.stickyHeaderHeight) {
+  if (_needsPropsReapply || oldViewProps.stickyHeaderHeight != newViewProps.stickyHeaderHeight) {
     _stickyHeaderHeight = MAX(0, newViewProps.stickyHeaderHeight);
     insetsChanged = YES;
   }
-  if (oldViewProps.pageKeys != newViewProps.pageKeys) {
+  if (_needsPropsReapply || oldViewProps.pageKeys != newViewProps.pageKeys) {
     NSString *json = RCTNSStringFromString(newViewProps.pageKeys);
     NSData *data = [json dataUsingEncoding:NSUTF8StringEncoding];
     id parsed = data == nil ? nil : [NSJSONSerialization JSONObjectWithData:data options:0 error:nil];
     _pageKeys = [parsed isKindOfClass:NSArray.class] ? parsed : @[];
   }
-  if (oldViewProps.retainedPages != newViewProps.retainedPages) {
+  if (_needsPropsReapply || oldViewProps.retainedPages != newViewProps.retainedPages) {
     _retainedPages = RCTNSStringFromString(newViewProps.retainedPages);
     [self setNeedsLayout];
   }
 
+  _needsPropsReapply = NO;
   [super updateProps:props oldProps:oldProps];
   if (insetsChanged) {
     [self reapplyInsetsToObservedScrollView];
@@ -358,7 +438,12 @@ static void *RNCCollapsiblePagerContentOffsetContext = &RNCCollapsiblePagerConte
   [self restoreDetachedScrollInsets];
   if (_currentIndex < 0 || _currentIndex >= _pageControllers.count) return;
   UIScrollView *candidate = [self findVerticalScrollViewInView:_pageControllers[_currentIndex].view];
-  if (candidate == nil || candidate == _observedScrollView) return;
+  if (candidate == nil) return;
+  // A decelerating list can otherwise claim a new horizontal touch immediately.
+  if (_pagerScrollView != nil) {
+    [candidate.panGestureRecognizer requireGestureRecognizerToFail:_pagerScrollView.panGestureRecognizer];
+  }
+  if (candidate == _observedScrollView) return;
 
   BOOL replacingCurrentScrollView = _observingContentOffset;
   [self detachScrollObserver];
@@ -416,6 +501,10 @@ static void *RNCCollapsiblePagerContentOffsetContext = &RNCCollapsiblePagerConte
     // pager-owned insets before that view is used as a search or dialog list.
     CGFloat logicalOffset = scrollView.contentOffset.y + scrollView.contentInset.top;
     UIEdgeInsets original = [_originalInsets objectForKey:scrollView].UIEdgeInsetsValue;
+    NSNumber *appliedTop = [_appliedTopInsets objectForKey:scrollView];
+    if (appliedTop != nil && scrollView.refreshControl != nil) {
+      original.top += MAX(0, scrollView.contentInset.top - appliedTop.doubleValue);
+    }
     scrollView.contentInset = original;
     scrollView.verticalScrollIndicatorInsets =
       [_originalIndicatorInsets objectForKey:scrollView].UIEdgeInsetsValue;
@@ -426,6 +515,7 @@ static void *RNCCollapsiblePagerContentOffsetContext = &RNCCollapsiblePagerConte
     [scrollView setContentOffset:CGPointMake(scrollView.contentOffset.x, logicalOffset - original.top)
                        animated:NO];
     [_originalInsets removeObjectForKey:scrollView];
+    [_appliedTopInsets removeObjectForKey:scrollView];
     [_originalIndicatorInsets removeObjectForKey:scrollView];
     [_originalAlwaysBounceVertical removeObjectForKey:scrollView];
     [_originalInsetAdjustmentBehavior removeObjectForKey:scrollView];
@@ -452,9 +542,17 @@ static void *RNCCollapsiblePagerContentOffsetContext = &RNCCollapsiblePagerConte
   // This host already includes the fixed header and safe area in its frame.
   // UIKit automatic adjustment would add them a second time to short pages.
   scrollView.contentInsetAdjustmentBehavior = UIScrollViewContentInsetAdjustmentNever;
-  CGFloat previousLogicalOffset = scrollView.contentOffset.y + scrollView.contentInset.top;
+  CGFloat previousTopInset = scrollView.contentInset.top;
+  CGFloat previousLogicalOffset = scrollView.contentOffset.y + previousTopInset;
+  NSNumber *appliedTop = [_appliedTopInsets objectForKey:scrollView];
+  // UIRefreshControl owns its temporary top inset, including while ending.
+  CGFloat refreshInset = appliedTop != nil && scrollView.refreshControl != nil
+    ? MAX(0, previousTopInset - appliedTop.doubleValue) : 0;
   UIEdgeInsets next = original;
   next.top += _headerHeight + _stickyHeaderHeight;
+  CGFloat pagerTopInset = next.top;
+  next.top += refreshInset;
+  [_appliedTopInsets setObject:@(pagerTopInset) forKey:scrollView];
   // Short pages still need enough range to collapse the header; long pages
   // must end at the last row rather than leave a header-sized blank footer.
   next.bottom += MAX(0, scrollView.bounds.size.height - _stickyHeaderHeight
@@ -467,7 +565,7 @@ static void *RNCCollapsiblePagerContentOffsetContext = &RNCCollapsiblePagerConte
   }
   scrollView.contentInset = next;
   UIEdgeInsets indicatorInsets = scrollView.verticalScrollIndicatorInsets;
-  indicatorInsets.top = next.top;
+  indicatorInsets.top = pagerTopInset;
   scrollView.verticalScrollIndicatorInsets = indicatorInsets;
   scrollView.alwaysBounceVertical = YES;
 
@@ -479,7 +577,10 @@ static void *RNCCollapsiblePagerContentOffsetContext = &RNCCollapsiblePagerConte
     targetOffset = (saved == nil ? _headerOffset : saved.doubleValue) - next.top;
     targetOffset = MAX(targetOffset, -next.top + _headerOffset);
   }
-  [scrollView setContentOffset:CGPointMake(scrollView.contentOffset.x, targetOffset) animated:NO];
+  // A bottom-inset change must not cancel UIKit's refresh or bounce settlement.
+  if (restore || previousTopInset != next.top) {
+    [scrollView setContentOffset:CGPointMake(scrollView.contentOffset.x, targetOffset) animated:NO];
+  }
   if (pageIndex == _currentIndex) [self updateHeaderForScrollView:scrollView];
 }
 
@@ -553,7 +654,24 @@ static void *RNCCollapsiblePagerContentOffsetContext = &RNCCollapsiblePagerConte
 - (void)goTo:(NSInteger)index animated:(BOOL)animated
 {
   if (_isBeingRecycled || index < 0 || index >= _pageControllers.count) return;
-  if (_transitioning && animated) return;
+  _hasReceivedPageCommand = YES;
+  _hasAppliedInitialPage = YES;
+  if (_transitioning && animated) {
+    _pendingGoToIndex = index;
+    return;
+  }
+
+  _pendingGoToIndex = -1;
+
+  // Re-selecting the displayed controller removes its view briefly and cancels
+  // an in-flight list touch. Focus synchronization must be idempotent.
+  if (!_transitioning && index == _currentIndex &&
+      _pageViewController.viewControllers.firstObject == _pageControllers[index]) {
+    [self attachScrollObserverForCurrentPage];
+    [self emitPageSelected:index];
+    [self emitDiagnostics:@"page-selected"];
+    return;
+  }
 
   [self detachScrollObserver];
   _destinationIndex = index;
@@ -563,6 +681,8 @@ static void *RNCCollapsiblePagerContentOffsetContext = &RNCCollapsiblePagerConte
     ? UIPageViewControllerNavigationDirectionForward
     : UIPageViewControllerNavigationDirectionReverse;
   _transitioning = YES;
+  _isPagerDragging = NO;
+  NSUInteger capturedTransition = ++_transitionId;
   NSUInteger capturedGeneration = _generation;
   __weak __typeof__(self) weakSelf = self;
   [_pageViewController setViewControllers:@[_pageControllers[index]]
@@ -570,12 +690,22 @@ static void *RNCCollapsiblePagerContentOffsetContext = &RNCCollapsiblePagerConte
                                  animated:animated && index != _currentIndex
                                completion:^(BOOL finished) {
     __strong __typeof__(weakSelf) self = weakSelf;
-    if (self == nil || self->_generation != capturedGeneration || self->_isBeingRecycled) return;
-    self->_transitioning = NO;
-    self->_currentIndex = index;
-    [self attachScrollObserverForCurrentPage];
-    [self emitPageSelected:index];
-    [self emitDiagnostics:@"page-selected"];
+    if (self == nil || self->_generation != capturedGeneration ||
+        self->_transitionId != capturedTransition || self->_isBeingRecycled) return;
+    if (finished) {
+      self->_currentIndex = index;
+      [self attachScrollObserverForCurrentPage];
+      [self emitPageSelected:index];
+      [self emitDiagnostics:@"page-selected"];
+    }
+    // UIKit is still unwinding its transition when this completion runs.
+    // Start a queued animation only after that callback has returned.
+    dispatch_async(dispatch_get_main_queue(), ^{
+      if (self->_generation != capturedGeneration ||
+          self->_transitionId != capturedTransition || self->_isBeingRecycled) return;
+      self->_transitioning = NO;
+      [self drainPendingGoTo];
+    });
   }];
 }
 
@@ -604,27 +734,23 @@ static void *RNCCollapsiblePagerContentOffsetContext = &RNCCollapsiblePagerConte
   return [self adjacentController:viewController delta:self.isLtrLayout ? -1 : 1];
 }
 
-- (void)pageViewController:(UIPageViewController *)pageViewController
-        didFinishAnimating:(BOOL)finished
-   previousViewControllers:(NSArray<UIViewController *> *)previousViewControllers
-       transitionCompleted:(BOOL)completed
+- (void)drainPendingGoTo
 {
-  _transitioning = NO;
-  if (!completed) return;
-  UIViewController *controller = _pageViewController.viewControllers.firstObject;
-  NSInteger index = [_pageControllers indexOfObjectIdenticalTo:controller];
-  if (index == NSNotFound) return;
-  [self detachScrollObserver];
-  _currentIndex = index;
-  [self attachScrollObserverForCurrentPage];
-  [self emitPageSelected:index];
-  [self emitDiagnostics:@"page-selected"];
+  NSInteger pending = _pendingGoToIndex;
+  _pendingGoToIndex = -1;
+  if (pending >= 0 && pending != _currentIndex) {
+    [self goTo:pending animated:YES];
+  }
 }
 
 #pragma mark - Pager UIScrollViewDelegate
 
 - (void)scrollViewWillBeginDragging:(UIScrollView *)scrollView
 {
+  // A user drag owns the result even if UIKit later completes the old animation.
+  ++_transitionId;
+  _isPagerDragging = YES;
+  _transitioning = YES;
   const auto emitter = [self eventEmitter];
   if (emitter) {
     emitter->onPageScrollStateChanged({
@@ -645,8 +771,57 @@ static void *RNCCollapsiblePagerContentOffsetContext = &RNCCollapsiblePagerConte
   }
 }
 
-- (void)scrollViewDidEndDecelerating:(UIScrollView *)scrollView
+- (void)scrollViewDidEndDragging:(UIScrollView *)scrollView
+                    willDecelerate:(BOOL)decelerate
 {
+  if (!decelerate) [self scrollViewDidEndDecelerating:scrollView];
+}
+
+- (void)finishPagerScrollEmittingSelection:(BOOL)emitSelection
+{
+  if (_isPagerDragging) {
+    UIViewController *controller = nil;
+    if (!emitSelection && _currentIndex >= 0 && _currentIndex < _pageControllers.count) {
+      // Detaching can make UIKit settle on a neighbouring controller without a
+      // completion callback. Keep the last page acknowledged by JavaScript.
+      controller = _pageControllers[_currentIndex];
+    } else {
+      controller = _pageViewController.viewControllers.firstObject;
+      // An interrupted programmatic animation can report its target while a
+      // different controller is centered. Read the settled UIKit viewport.
+      for (UIViewController *candidate in _pageControllers) {
+        if (candidate.view.window == nil) continue;
+        CGRect frame = [candidate.view convertRect:candidate.view.bounds toView:_containerView];
+        if (fabs(frame.origin.x) < 1 &&
+            fabs(frame.size.width - _containerView.bounds.size.width) < 1) {
+          controller = candidate;
+          break;
+        }
+      }
+    }
+    NSInteger index = [_pageControllers indexOfObjectIdenticalTo:controller];
+    if (index != NSNotFound) {
+      if (_pageViewController.viewControllers.firstObject != controller) {
+        // Correct UIKit only after its animation completion has returned.
+        [_pageViewController setViewControllers:@[controller]
+                                      direction:UIPageViewControllerNavigationDirectionForward
+                                       animated:NO
+                                     completion:nil];
+      }
+      [self detachScrollObserver];
+      _currentIndex = index;
+      _destinationIndex = index;
+      [self attachScrollObserverForCurrentPage];
+      // A newer tab tap remains authoritative while its queued command runs.
+      if (emitSelection &&
+          (_pendingGoToIndex < 0 || _pendingGoToIndex == index)) {
+        [self emitPageSelected:index];
+        [self emitDiagnostics:@"page-selected"];
+      }
+    }
+    _isPagerDragging = NO;
+    _transitioning = NO;
+  }
   const auto emitter = [self eventEmitter];
   if (emitter) {
     emitter->onPageScrollStateChanged({
@@ -654,6 +829,12 @@ static void *RNCCollapsiblePagerContentOffsetContext = &RNCCollapsiblePagerConte
     });
   }
   [self emitDiagnostics:@"pager-idle"];
+  [self drainPendingGoTo];
+}
+
+- (void)scrollViewDidEndDecelerating:(UIScrollView *)scrollView
+{
+  [self finishPagerScrollEmittingSelection:YES];
 }
 
 - (void)scrollViewDidScroll:(UIScrollView *)scrollView
@@ -725,6 +906,78 @@ static void *RNCCollapsiblePagerContentOffsetContext = &RNCCollapsiblePagerConte
   _pagerScrollView.scrollEnabled = scrollEnabled;
 }
 
+#pragma mark - Nested pager gesture coordination
+
+- (void)applyNestedScrollBlocker
+{
+  if (_pagerScrollView == nil) return;
+
+  if (_nestedScrollEnabled && _blockerGesture == nil) {
+    _blockerGesture = [[UIPanGestureRecognizer alloc]
+      initWithTarget:self
+      action:@selector(blockerGestureFired:)];
+    _blockerGesture.delegate = self;
+    _blockerGesture.cancelsTouchesInView = NO;
+    _blockerGesture.delaysTouchesBegan = NO;
+    [self addGestureRecognizer:_blockerGesture];
+    [_pagerScrollView.panGestureRecognizer requireGestureRecognizerToFail:_blockerGesture];
+  } else if (!_nestedScrollEnabled && _blockerGesture != nil) {
+    [self removeGestureRecognizer:_blockerGesture];
+    _blockerGesture = nil;
+  }
+}
+
+- (void)blockerGestureFired:(UIPanGestureRecognizer *)recognizer
+{
+  // Reset through the public enabled API. UIGestureRecognizer.state is
+  // read-only for clients; only recognizer subclasses may assign it.
+  if (recognizer.state == UIGestureRecognizerStateBegan) {
+    recognizer.enabled = NO;
+    recognizer.enabled = YES;
+  }
+}
+
+- (BOOL)gestureRecognizerShouldBegin:(UIGestureRecognizer *)gestureRecognizer
+{
+  if (gestureRecognizer != _blockerGesture) return YES;
+  if (!_nestedScrollEnabled) return NO;
+  if (![gestureRecognizer isKindOfClass:[UIPanGestureRecognizer class]]) return NO;
+
+  UIPanGestureRecognizer *pan = (UIPanGestureRecognizer *)gestureRecognizer;
+  CGPoint velocity = [pan velocityInView:self];
+  NSInteger pageCount = _pageControllers.count;
+  if (pageCount == 0 || _currentIndex < 0 || _currentIndex >= pageCount) return NO;
+
+  CGFloat absVelocityX = fabs(velocity.x);
+  CGFloat absVelocityY = fabs(velocity.y);
+  if (absVelocityX <= absVelocityY || absVelocityX < 1.0f) return NO;
+
+  BOOL isLtr = self.isLtrLayout;
+  NSInteger firstPageIndex = isLtr ? 0 : pageCount - 1;
+  NSInteger lastPageIndex = isLtr ? pageCount - 1 : 0;
+  if (_currentIndex == firstPageIndex && velocity.x > 0) return YES;
+  if (_currentIndex == lastPageIndex && velocity.x < 0) return YES;
+  return NO;
+}
+
+- (BOOL)gestureRecognizer:(UIGestureRecognizer *)gestureRecognizer shouldReceiveTouch:(UITouch *)touch
+{
+  // OneKey patch: a new touch can cancel UIKit's animation before its first
+  // frame without starting a drag or completing the animation. Finish the
+  // commanded page before handing that touch to the nested scroll views.
+  if (gestureRecognizer == _blockerGesture && _transitioning && !_isPagerDragging &&
+      [touch.view isDescendantOfView:_pagerScrollView]) {
+    [self goTo:_destinationIndex animated:NO];
+  }
+  return YES;
+}
+
+- (BOOL)gestureRecognizer:(UIGestureRecognizer *)gestureRecognizer
+    shouldRecognizeSimultaneouslyWithGestureRecognizer:(UIGestureRecognizer *)otherGestureRecognizer
+{
+  return gestureRecognizer == _blockerGesture;
+}
+
 + (ComponentDescriptorProvider)componentDescriptorProvider
 {
   return concreteComponentDescriptorProvider<RNCCollapsiblePagerViewComponentDescriptor>();

package/ios/RNCPagerViewComponentView.mm

@@ -593,9 +593,11 @@ using namespace facebook::react;
 
 // The blocker gesture never actually does anything — it only serves as a gate
 - (void)blockerGestureFired:(UIPanGestureRecognizer *)recognizer {
-    // Immediately cancel so it doesn't interfere with other gestures
+    // Reset through the public enabled API. UIGestureRecognizer.state is
+    // read-only for clients; only recognizer subclasses may assign it.
     if (recognizer.state == UIGestureRecognizerStateBegan) {
-        recognizer.state = UIGestureRecognizerStateCancelled;
+        recognizer.enabled = NO;
+        recognizer.enabled = YES;
     }
 }
 

package/lib/module/CollapsiblePagerView.js

@@ -4,6 +4,11 @@ import React from "react";
 import { I18nManager, Platform, StyleSheet, View } from "react-native";
 import CollapsiblePagerViewNativeComponent, { Commands as CollapsiblePagerViewNativeCommands } from "./CollapsiblePagerViewNativeComponent";
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+const pageIndex = value => {
+  const index = Math.trunc(value);
+  return Number.isFinite(index) ? index : null;
+};
+const clampedPageIndex = (value, pageCount) => Math.min(Math.max(0, pageIndex(value) ?? 0), Math.max(0, pageCount - 1));
 const pageKey = (child, index) => {
   if (/*#__PURE__*/React.isValidElement(child) && child.key != null) {
     return String(child.key);
@@ -18,7 +23,7 @@ const pageKey = (child, index) => {
  */
 export class CollapsiblePagerView extends React.PureComponent {
   state = {
-    selectedPage: Math.max(0, this.props.initialPage ?? 0)
+    selectedPage: clampedPageIndex(this.props.initialPage ?? 0, React.Children.toArray(this.props.children).length)
   };
   nativeRef = null;
   lastMountSignature = null;
@@ -26,16 +31,26 @@ export class CollapsiblePagerView extends React.PureComponent {
     this.notifyMountedPagesChanged();
   }
   componentDidUpdate() {
+    const pageCount = this.pages().length;
+    const selectedPage = clampedPageIndex(this.state.selectedPage, pageCount);
+    if (selectedPage !== this.state.selectedPage) {
+      this.setState({
+        selectedPage
+      });
+      return;
+    }
     this.notifyMountedPagesChanged();
   }
   setPage = selectedPage => {
-    if (this.nativeRef) {
-      CollapsiblePagerViewNativeCommands.setPage(this.nativeRef, selectedPage);
+    const position = pageIndex(selectedPage);
+    if (this.nativeRef && position !== null && position >= 0 && position < this.pages().length) {
+      CollapsiblePagerViewNativeCommands.setPage(this.nativeRef, position);
     }
   };
   setPageWithoutAnimation = selectedPage => {
-    if (this.nativeRef) {
-      CollapsiblePagerViewNativeCommands.setPageWithoutAnimation(this.nativeRef, selectedPage);
+    const position = pageIndex(selectedPage);
+    if (this.nativeRef && position !== null && position >= 0 && position < this.pages().length) {
+      CollapsiblePagerViewNativeCommands.setPageWithoutAnimation(this.nativeRef, position);
     }
   };
   setScrollEnabled = scrollEnabled => {
@@ -78,7 +93,7 @@ export class CollapsiblePagerView extends React.PureComponent {
     this.props.onMountedPagesChanged(state);
   };
   onPageSelected = event => {
-    const position = Math.max(0, Math.trunc(event.nativeEvent.position));
+    const position = clampedPageIndex(event.nativeEvent.position, this.pages().length);
     if (position !== this.state.selectedPage) {
       this.setState({
         selectedPage: position