@onekeyfe/react-native-pager-view 6.7.0-15 → 6.7.0-17

package/ios/RNCCollapsiblePagerViewComponentView.mm

@@ -18,6 +18,7 @@
 
 // OneKey patch: deduplicate structural mutation parents before scanning the page.
 #include <unordered_set>
+#include <cmath>
 
 using namespace facebook::react;
 
@@ -157,6 +158,20 @@ static NSString *const RNCCollapsiblePagerNativeScrollerIDPrefix =
 
 static const CFTimeInterval RNCCollapsiblePagerFallbackDebounceInterval = 0.5;
 
+typedef NS_ENUM(NSInteger, RNCScrollCandidateTier) {
+  RNCScrollCandidateTierNone = 0,
+  RNCScrollCandidateTierGenericFallback = 1,
+  RNCScrollCandidateTierVerifiedNativeList = 2,
+  RNCScrollCandidateTierFabricScrollView = 3,
+  RNCScrollCandidateTierExplicitScroller = 4,
+};
+
+struct RNCScrollCandidateResolution {
+  UIScrollView *scrollView = nil;
+  RNCScrollCandidateTier tier = RNCScrollCandidateTierNone;
+  BOOL hasUnreadyScrollHost = NO;
+};
+
 // OneKey patch: native scroll views can survive a move or be reused for a new
 // Fabric component. Keep weak identity until their page is attached again.
 @interface RNCCollapsiblePagerReleasedScrollState : NSObject
@@ -368,7 +383,9 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
 @property (nonatomic, copy) RNCCollapsiblePagerNativeTabPressHandler onTabPress;
 - (void)updateItemsJSON:(NSString *)itemsJSON;
 - (void)updateStyleWithHeight:(CGFloat)height
+                      variant:(NSString *)variant
      contentPaddingHorizontal:(CGFloat)contentPaddingHorizontal
+       contentPaddingVertical:(CGFloat)contentPaddingVertical
                   itemSpacing:(CGFloat)itemSpacing
                      fontSize:(CGFloat)fontSize
                    fontFamily:(NSString *)fontFamily
@@ -385,12 +402,15 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
 
 @implementation RNCCollapsiblePagerNativeTabBarView {
   RNCCollapsiblePagerHorizontalScrollView *_scrollView;
+  UIView *_trackView;
   UIView *_indicatorView;
   NSArray<NSDictionary *> *_items;
   NSMutableArray<UIButton *> *_buttons;
   NSMutableArray<NSValue *> *_indicatorFrames;
   CGFloat _barHeight;
   CGFloat _contentPaddingHorizontal;
+  CGFloat _contentPaddingVertical;
+  BOOL _segmented;
   CGFloat _itemSpacing;
   CGFloat _fontSize;
   NSString *_fontFamily;
@@ -413,6 +433,8 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
     _indicatorFrames = [NSMutableArray new];
     _barHeight = 44;
     _contentPaddingHorizontal = 20;
+    _contentPaddingVertical = 0;
+    _segmented = NO;
     _itemSpacing = 8;
     _fontSize = 16;
     _activeTextColor = UIColor.labelColor;
@@ -434,6 +456,10 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
     _scrollView.delegate = self;
     [self addSubview:_scrollView];
 
+    _trackView = [UIView new];
+    _trackView.userInteractionEnabled = NO;
+    [_scrollView addSubview:_trackView];
+
     _indicatorView = [UIView new];
     _indicatorView.userInteractionEnabled = NO;
     [_scrollView addSubview:_indicatorView];
@@ -488,7 +514,9 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
 }
 
 - (void)updateStyleWithHeight:(CGFloat)height
+                      variant:(NSString *)variant
      contentPaddingHorizontal:(CGFloat)contentPaddingHorizontal
+       contentPaddingVertical:(CGFloat)contentPaddingVertical
                   itemSpacing:(CGFloat)itemSpacing
                      fontSize:(CGFloat)fontSize
                    fontFamily:(NSString *)fontFamily
@@ -500,19 +528,26 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
               indicatorBottom:(CGFloat)indicatorBottom
 {
   _barHeight = MAX(1, height);
+  BOOL wasSegmented = _segmented;
+  _segmented = [variant isEqualToString:@"segmented"];
   _contentPaddingHorizontal = MAX(0, contentPaddingHorizontal);
+  _contentPaddingVertical = MAX(0, contentPaddingVertical);
   _itemSpacing = MAX(0, itemSpacing);
   _fontSize = MAX(1, fontSize);
   _fontFamily = [fontFamily copy];
-  self.backgroundColor = backgroundColor ?: UIColor.clearColor;
+  self.backgroundColor = _segmented ? UIColor.clearColor : (backgroundColor ?: UIColor.clearColor);
   _scrollView.backgroundColor = self.backgroundColor;
+  _scrollView.scrollEnabled = !_segmented;
+  if (_segmented && !wasSegmented) [_scrollView setContentOffset:CGPointZero animated:NO];
+  _trackView.hidden = !_segmented;
+  _trackView.backgroundColor = backgroundColor ?: UIColor.clearColor;
   _activeTextColor = activeTextColor ?: UIColor.labelColor;
   _inactiveTextColor = inactiveTextColor ?: UIColor.secondaryLabelColor;
   _indicatorColor = indicatorColor ?: _activeTextColor;
   _indicatorHeight = MAX(0, indicatorHeight);
   _indicatorBottom = MAX(0, indicatorBottom);
   _indicatorView.backgroundColor = _indicatorColor;
-  _indicatorView.layer.cornerRadius = _indicatorHeight / 2;
+  _indicatorView.layer.cornerRadius = _segmented ? 0 : _indicatorHeight / 2;
   for (UIButton *button in _buttons) button.titleLabel.font = self.tabFont;
   [self setNeedsLayout];
 }
@@ -571,6 +606,33 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
 {
   [super layoutSubviews];
   _scrollView.frame = self.bounds;
+  if (_segmented) {
+    CGFloat width = CGRectGetWidth(self.bounds);
+    CGFloat height = CGRectGetHeight(self.bounds);
+    CGFloat insetX = MIN(_contentPaddingHorizontal, width / 2);
+    CGFloat insetY = MIN(_contentPaddingVertical, height / 2);
+    CGRect trackFrame = CGRectMake(insetX, insetY,
+      MAX(0, width - 2 * insetX), MAX(0, height - 2 * insetY));
+    _trackView.frame = trackFrame;
+    _trackView.layer.cornerRadius = CGRectGetHeight(trackFrame) / 2;
+    _scrollView.contentSize = self.bounds.size;
+    [_indicatorFrames removeAllObjects];
+    NSUInteger count = _buttons.count;
+    [_buttons enumerateObjectsUsingBlock:^(UIButton *button, NSUInteger index, BOOL *stop) {
+      CGFloat first = CGRectGetMinX(trackFrame) + CGRectGetWidth(trackFrame) * index / count;
+      CGFloat last = CGRectGetMinX(trackFrame) + CGRectGetWidth(trackFrame) * (index + 1) / count;
+      CGFloat x = self->_leftToRight ? first : CGRectGetMaxX(trackFrame) - (last - CGRectGetMinX(trackFrame));
+      CGFloat end = self->_leftToRight ? last : CGRectGetMaxX(trackFrame) - (first - CGRectGetMinX(trackFrame));
+      button.frame = CGRectMake(x, CGRectGetMinY(trackFrame), MAX(0, end - x), CGRectGetHeight(trackFrame));
+      CGRect thumbFrame = CGRectMake(x + 2, CGRectGetMinY(trackFrame) + 2,
+        MAX(0, CGRectGetWidth(button.frame) - 4), MAX(0, CGRectGetHeight(trackFrame) - 4));
+      [self->_indicatorFrames addObject:[NSValue valueWithCGRect:thumbFrame]];
+    }];
+    _indicatorView.layer.cornerRadius = MAX(0, CGRectGetHeight(trackFrame) - 4) / 2;
+    [self updatePresentation];
+    return;
+  }
+  _trackView.frame = CGRectZero;
   UIFont *font = self.tabFont;
   NSMutableArray<NSNumber *> *widths = [NSMutableArray arrayWithCapacity:_buttons.count];
   CGFloat itemsWidth = 0;
@@ -634,10 +696,10 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
     CGRectGetMinX(fromFrame) + (CGRectGetMinX(toFrame) - CGRectGetMinX(fromFrame)) * fraction,
     CGRectGetMinY(fromFrame),
     CGRectGetWidth(fromFrame) + (CGRectGetWidth(toFrame) - CGRectGetWidth(fromFrame)) * fraction,
-    _indicatorHeight
+    _segmented ? CGRectGetHeight(fromFrame) : _indicatorHeight
   );
   _indicatorView.frame = indicatorFrame;
-  _indicatorView.hidden = _indicatorHeight <= 0;
+  _indicatorView.hidden = CGRectGetHeight(indicatorFrame) <= 0;
 
   NSInteger selectedIndex = (NSInteger)round(progress);
   [_buttons enumerateObjectsUsingBlock:^(UIButton *button, NSUInteger index, BOOL *stop) {
@@ -654,7 +716,7 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
       : UIAccessibilityTraitButton;
   }];
 
-  if (_shouldCenterSelectedItem && !_scrollView.tracking && !_scrollView.dragging &&
+  if (_shouldCenterSelectedItem && !_segmented && !_scrollView.tracking && !_scrollView.dragging &&
       !_scrollView.decelerating && CGRectGetWidth(_scrollView.bounds) > 0) {
     CGFloat maximumOffset = MAX(0, _scrollView.contentSize.width - CGRectGetWidth(_scrollView.bounds));
     CGFloat desiredOffset = RNCClamp(
@@ -1471,13 +1533,17 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
 - (void)liftSharedHeadersForPagerTransition:(NSString *)reason;
 - (void)restoreSharedHeadersToContainer;
 - (void)layoutSharedHeaders;
+- (void)bringReservedStickyControlToFront;
 - (void)restorePinnedStickyHeader;
 - (void)updatePinnedStickyHeader;
 - (UIScrollView *)currentVerticalScrollViewForParentPager;
 - (UIScrollView *)verticalScrollViewForPageAtIndex:(NSInteger)pageIndex;
+- (RNCScrollCandidateResolution)resolveScrollCandidateForPageAtIndex:(NSInteger)pageIndex;
+- (RNCScrollCandidateResolution)resolveScrollCandidateInView:(UIView *)view;
 - (UIScrollView *)findExplicitNativeScrollerInView:(UIView *)view;
 - (UIScrollView *)findFabricScrollViewInView:(UIView *)view;
 - (UIScrollView *)findVerticalScrollViewInView:(UIView *)view;
+- (void)scheduleCoalescedScrollReconcile;
 - (void)scheduleScrollObserverRetryForCurrentPage;
 - (void)preparePageForHorizontalTransitionAtIndex:(NSInteger)pageIndex;
 - (void)updateSharedHeaderPressCancellationGesture;
@@ -1558,6 +1624,7 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
   NSUInteger _pendingTopInsetReboundGeneration;
   NSTimer *_topInsetReboundTimer;
   CGFloat _nativeTabBarHeight;
+  CGFloat _nativeTabBarTrailingReservedWidth;
   CGFloat _nativeSubHeaderHeight;
   CGFloat _headerOffset;
   BOOL _scrollEnabled;
@@ -1644,6 +1711,8 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
   RNCCollapsiblePagerOuterPagerPanGestureRecognizer *_sharedHeaderOuterPagerGesture;
   RNCCollapsiblePagerVerticalPagerGuardGestureRecognizer *_verticalPagerGesture;
   BOOL _observingContentOffset;
+  BOOL _awaitingScrollOwnerForCurrentPage;
+  BOOL _scrollReconcileScheduled;
   BOOL _scrollResolveRetryScheduled;
   CFTimeInterval _pendingFallbackScrollViewDetectedAt;
   NSInteger _scrollResolveRetryPageIndex;
@@ -1675,6 +1744,8 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
     _displayBodyOverrides = [NSMutableDictionary new];
     [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(nativeListScrollCommandAccepted:)
       name:@"OneKeyNativeListScrollCommandAccepted" object:nil];
+    [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(nativeScrollViewDidBecomeReadyNotification:)
+      name:@"OneKeyNativeScrollViewDidBecomeReady" object:nil];
     _pendingPageRestoreKeys = [NSMutableSet new];
     _releasedPageScrollStates = [NSMutableDictionary new];
     _mountingRemovedScrollViews = [NSHashTable weakObjectsHashTable];
@@ -2332,6 +2403,7 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
   [self updateTopScrollEdgeForScrollView:nil];
   [self cancelHeaderSettledCheck];
   [[NSNotificationCenter defaultCenter] removeObserver:self name:@"OneKeyNativeListScrollCommandAccepted" object:nil];
+  [[NSNotificationCenter defaultCenter] removeObserver:self name:@"OneKeyNativeScrollViewDidBecomeReady" object:nil];
   for (UIScrollView *scrollView in _originalInsets.keyEnumerator) {
     [self updateNativeScrollerViewport:scrollView stickyHeight:0];
   }
@@ -2479,6 +2551,7 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
   }
   [_nativeTabBarView updateAncestorGesturePrecedence];
   [_nativeSubHeaderView updateAncestorGesturePrecedence];
+  [self bringReservedStickyControlToFront];
 }
 
 - (void)restoreSharedHeadersToContainer
@@ -2584,10 +2657,11 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
   CGFloat nativeTabBarVisibleHeight = _nativeTabBarView.hidden
     ? 0
     : MIN(_stickyHeaderHeight, _nativeTabBarHeight);
+  CGFloat tabReservedWidth = MIN(width, MAX(0, _nativeTabBarTrailingReservedWidth));
   _nativeTabBarView.frame = CGRectMake(
-    0,
+    self.isLtrLayout ? 0 : tabReservedWidth,
     stickyChildY,
-    width,
+    width - tabReservedWidth,
     nativeTabBarVisibleHeight
   );
   _nativeSubHeaderView.frame = CGRectMake(
@@ -2601,9 +2675,26 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
   );
   _topOverlayHostView.frame = CGRectMake(0, 0, width, self.effectiveTopOverlayHeight);
   _topOverlayView.frame = _topOverlayHostView.bounds;
+  [self bringReservedStickyControlToFront];
   [self applyHeaderOffset];
 }
 
+- (void)bringReservedStickyControlToFront
+{
+  if (_stickyHeaderView != nil &&
+      _stickyHeaderView.superview == _nativeTabBarView.superview) {
+    if (_nativeTabBarTrailingReservedWidth > 0) {
+      [_stickyHeaderView.superview bringSubviewToFront:_stickyHeaderView];
+    } else {
+      [_nativeTabBarView.superview bringSubviewToFront:_nativeTabBarView];
+      if (!_nativeSubHeaderView.hidden &&
+          _nativeSubHeaderView.superview == _nativeTabBarView.superview) {
+        [_nativeSubHeaderView.superview bringSubviewToFront:_nativeSubHeaderView];
+      }
+    }
+  }
+}
+
 - (void)updatePinnedStickyHeader
 {
   BOOL attachedToList = _nativeSmoothHeaderScrollEnabled &&
@@ -2650,8 +2741,10 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
   CGFloat childY = shouldPin ? 0 : _headerHeight;
   CGFloat width = CGRectGetWidth(self.bounds);
   CGFloat tabHeight = _nativeTabBarView.hidden ? 0 : MIN(_stickyHeaderHeight, _nativeTabBarHeight);
+  CGFloat tabReservedWidth = MIN(width, MAX(0, _nativeTabBarTrailingReservedWidth));
   _stickyHeaderView.frame = CGRectMake(0, childY, width, _stickyHeaderHeight);
-  _nativeTabBarView.frame = CGRectMake(0, childY, width, tabHeight);
+  _nativeTabBarView.frame = CGRectMake(self.isLtrLayout ? 0 : tabReservedWidth,
+    childY, width - tabReservedWidth, tabHeight);
   _nativeSubHeaderView.frame = CGRectMake(0, childY + tabHeight, width,
     MIN(MAX(0, _stickyHeaderHeight - tabHeight), _nativeSubHeaderHeight));
   _pinnedStickyHostView.hidden = !shouldPin;
@@ -2671,6 +2764,7 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
   }
   [_nativeTabBarView updateAncestorGesturePrecedence];
   [_nativeSubHeaderView updateAncestorGesturePrecedence];
+  [self bringReservedStickyControlToFront];
   [self updateTopScrollEdgeForScrollView:_observedScrollView];
   [self logHomeVisualGeometry:shouldPin ? @"pin" : @"unpin"
                     scrollView:_observedScrollView];
@@ -2874,6 +2968,23 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
       [self applyInsetsToScrollView:scrollView pageIndex:index restore:YES];
     }
   }
+  UIView *page = _pageControllers[_currentIndex].view;
+  if (_scrollResolveRetryAttempt >= 12 &&
+      _releasedPageScrollStates[self.currentPageKey] != nil) {
+    for (const auto &mutation : transaction.getMutations()) {
+      if (mutation.type == ShadowViewMutation::Insert && mutation.parentTag > 0 &&
+          [page viewWithTag:mutation.parentTag] != nil) {
+        // A new current-page insertion starts a bounded recovery round after
+        // the previous replacement search has scheduled its final retry.
+        _scrollResolveRetryToken += 1;
+        _scrollResolveRetryScheduled = NO;
+        _scrollResolveRetryAttempt = 0;
+        break;
+      }
+    }
+  }
+
+  // Record recovery during transitions; ownership still waits for settlement.
   if (_transitioning || _isPagerDragging) return;
 
   // OneKey patch: a release must recover even when the changed parent is above
@@ -2882,7 +2993,6 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
     [self attachScrollObserverForCurrentPage];
     return;
   }
-  UIView *page = _pageControllers[_currentIndex].view;
   BOOL headerIsAttached = [_sharedHeaderHostView isDescendantOfView:self];
   BOOL currentListIsAttached = _observedScrollView != nil &&
     [_observedScrollView isDescendantOfView:page] && headerIsAttached;
@@ -3050,18 +3160,14 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
   if (_stickyHeaderView != nil) [_sharedHeaderHostView bringSubviewToFront:_stickyHeaderView];
   if (!_nativeTabBarView.hidden) [_sharedHeaderHostView bringSubviewToFront:_nativeTabBarView];
   if (!_nativeSubHeaderView.hidden) [_sharedHeaderHostView bringSubviewToFront:_nativeSubHeaderView];
+  [self bringReservedStickyControlToFront];
   [_containerView bringSubviewToFront:_sharedHeaderHostView];
   if (_stickyHeaderIsPinned) {
     [_pinnedStickyHostView.superview bringSubviewToFront:_pinnedStickyHostView];
   }
   if (self.hasFixedTopOverlay) [_containerView bringSubviewToFront:_topOverlayHostView];
   [self setNeedsLayout];
-  dispatch_async(dispatch_get_main_queue(), ^{
-    if (!self->_isBeingRecycled) {
-      [self prepareAdjacentPageInsets];
-      [self attachScrollObserverForCurrentPage];
-    }
-  });
+  [self scheduleCoalescedScrollReconcile];
 }
 
 - (void)layoutSubviews
@@ -3138,12 +3244,7 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
   [self updateScrollEdgeContentMasks];
   [self updateHeaderSettledStateForceBusy:NO];
   [self logHomeVisualGeometry:@"layout" scrollView:_observedScrollView];
-  dispatch_async(dispatch_get_main_queue(), ^{
-    if (!self->_isBeingRecycled) {
-      [self prepareAdjacentPageInsets];
-      [self attachScrollObserverForCurrentPage];
-    }
-  });
+  [self scheduleCoalescedScrollReconcile];
 }
 
 - (void)prepareForRecycle
@@ -3161,6 +3262,8 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
   _generation++;
   [_mountingRemovedScrollViews removeAllObjects];
   _needsScrollObserverReattachAfterMount = NO;
+  _awaitingScrollOwnerForCurrentPage = NO;
+  _scrollReconcileScheduled = NO;
   [_releasedPageScrollStates removeAllObjects];
   [self detachSharedHeaderPressCancellationGesture];
   [self detachScrollObserver];
@@ -3262,6 +3365,7 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
   _homeVisualLastLayoutLog = 0;
   _homeVisualLastGeometrySignature = nil;
   _nativeTabBarHeight = 44;
+  _nativeTabBarTrailingReservedWidth = 0;
   _nativeSubHeaderHeight = 74;
   _headerOffset = 0;
   _currentLogicalOffset = 0;
@@ -3343,6 +3447,13 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
     _layoutDirection = RCTNSStringFromString(toString(newViewProps.layoutDirection));
     [_nativeTabBarView setLeftToRight:self.isLtrLayout];
     [_nativeSubHeaderView setLeftToRight:self.isLtrLayout];
+    [self setNeedsLayout];
+  }
+  if (_needsPropsReapply ||
+      oldViewProps.nativeTabBarTrailingReservedWidth != newViewProps.nativeTabBarTrailingReservedWidth) {
+    double reserved = newViewProps.nativeTabBarTrailingReservedWidth;
+    _nativeTabBarTrailingReservedWidth = std::isfinite(reserved) && reserved >= 0 ? reserved : 0;
+    [self setNeedsLayout];
   }
   BOOL insetsChanged = NO;
   if (_needsPropsReapply || oldViewProps.headerHeight != newViewProps.headerHeight) {
@@ -3423,7 +3534,9 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
   }
   if (_needsPropsReapply ||
       oldViewProps.nativeTabBarHeight != newViewProps.nativeTabBarHeight ||
+      oldViewProps.nativeTabBarVariant != newViewProps.nativeTabBarVariant ||
       oldViewProps.nativeTabBarContentPaddingHorizontal != newViewProps.nativeTabBarContentPaddingHorizontal ||
+      oldViewProps.nativeTabBarContentPaddingVertical != newViewProps.nativeTabBarContentPaddingVertical ||
       oldViewProps.nativeTabBarItemSpacing != newViewProps.nativeTabBarItemSpacing ||
       oldViewProps.nativeTabBarFontSize != newViewProps.nativeTabBarFontSize ||
       oldViewProps.nativeTabBarFontFamily != newViewProps.nativeTabBarFontFamily ||
@@ -3440,7 +3553,9 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
     NSString *fontFamily = RCTNSStringFromString(newViewProps.nativeTabBarFontFamily);
     [_nativeTabBarView
       updateStyleWithHeight:_nativeTabBarHeight
+      variant:RCTNSStringFromString(newViewProps.nativeTabBarVariant)
       contentPaddingHorizontal:MAX(0, newViewProps.nativeTabBarContentPaddingHorizontal)
+      contentPaddingVertical:MAX(0, newViewProps.nativeTabBarContentPaddingVertical)
       itemSpacing:MAX(0, newViewProps.nativeTabBarItemSpacing)
       fontSize:newViewProps.nativeTabBarFontSize > 0 ? newViewProps.nativeTabBarFontSize : 16
       fontFamily:fontFamily
@@ -3474,6 +3589,7 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
   if (!_nativeSubHeaderView.hidden) {
     [_nativeSubHeaderView.superview bringSubviewToFront:_nativeSubHeaderView];
   }
+  [self bringReservedStickyControlToFront];
   [_sharedHeaderHostView.superview bringSubviewToFront:_sharedHeaderHostView];
   if (_stickyHeaderIsPinned) {
     [_pinnedStickyHostView.superview bringSubviewToFront:_pinnedStickyHostView];
@@ -3501,12 +3617,105 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
 
 - (UIScrollView *)verticalScrollViewForPageAtIndex:(NSInteger)pageIndex
 {
-  if (pageIndex < 0 || pageIndex >= _pageControllers.count) return nil;
-  UIView *pageView = _pageControllers[pageIndex].view;
-  UIScrollView *explicitScroller = [self findExplicitNativeScrollerInView:pageView];
-  if (explicitScroller != nil) return explicitScroller;
-  UIScrollView *fabricScrollView = [self findFabricScrollViewInView:pageView];
-  return fabricScrollView ?: [self findVerticalScrollViewInView:pageView];
+  return [self resolveScrollCandidateForPageAtIndex:pageIndex].scrollView;
+}
+
+- (RNCScrollCandidateResolution)resolveScrollCandidateForPageAtIndex:(NSInteger)pageIndex
+{
+  if (pageIndex < 0 || pageIndex >= _pageControllers.count) return {};
+  return [self resolveScrollCandidateInView:_pageControllers[pageIndex].view];
+}
+
+// Single-pass tiered resolution replaces three separate subtree walks while
+// distinguishing genuinely static pages from pages with unready scroll hosts.
+- (RNCScrollCandidateResolution)resolveScrollCandidateInView:(UIView *)view
+{
+  RNCScrollCandidateResolution resolution;
+  if (view == nil || view == _sharedHeaderHostView) return resolution;
+  if (view != self &&
+      [view isKindOfClass:RNCCollapsiblePagerViewComponentView.class]) {
+    UIScrollView *nested = [(RNCCollapsiblePagerViewComponentView *)view
+      currentVerticalScrollViewForParentPager];
+    if (nested != nil) {
+      resolution.scrollView = nested;
+      resolution.tier = RNCScrollCandidateTierExplicitScroller;
+    } else {
+      resolution.hasUnreadyScrollHost = YES;
+    }
+    return resolution;
+  }
+
+  Class nativeListClass = NSClassFromString(@"HybridNativeListComponent");
+  if (nativeListClass != Nil && [view isKindOfClass:nativeListClass]) {
+    resolution.hasUnreadyScrollHost = YES;
+  }
+
+  if ([view isKindOfClass:RNCNativeScrollerComponentView.class]) {
+    UIScrollView *scrollView = ((RNCNativeScrollerComponentView *)view).scrollView;
+    if (![_mountingRemovedScrollViews containsObject:scrollView]) {
+      resolution.scrollView = scrollView;
+      resolution.tier = RNCScrollCandidateTierExplicitScroller;
+      return resolution;
+    }
+  } else if ([view isKindOfClass:RCTScrollViewComponentView.class]) {
+    RCTScrollViewComponentView *componentView = (RCTScrollViewComponentView *)view;
+    UIScrollView *scrollView = componentView.scrollView;
+    if (![_mountingRemovedScrollViews containsObject:scrollView]) {
+      if ([componentView.nativeId hasPrefix:RNCCollapsiblePagerNativeScrollerIDPrefix]) {
+        resolution.scrollView = scrollView;
+        resolution.tier = RNCScrollCandidateTierExplicitScroller;
+        return resolution;
+      }
+      if (!scrollView.alwaysBounceHorizontal) {
+        resolution.scrollView = scrollView;
+        resolution.tier = RNCScrollCandidateTierFabricScrollView;
+      }
+    }
+  } else if ([view isKindOfClass:UICollectionView.class]) {
+    UICollectionView *collectionView = (UICollectionView *)view;
+    if (![_mountingRemovedScrollViews containsObject:collectionView]) {
+      UICollectionViewLayout *layout = collectionView.collectionViewLayout;
+      BOOL isVerticalLayout = ![layout isKindOfClass:UICollectionViewFlowLayout.class] ||
+        ((UICollectionViewFlowLayout *)layout).scrollDirection == UICollectionViewScrollDirectionVertical;
+      if (isVerticalLayout) {
+        BOOL hasNativeListHost = RNCNativeListComponentForScrollView(collectionView) != nil;
+        BOOL isMountedNativeList = hasNativeListHost && RNCIsMountedNativeListScrollView(collectionView);
+        BOOL hasUsableBounds = CGRectGetWidth(collectionView.bounds) > 0 &&
+          CGRectGetHeight(collectionView.bounds) > 0;
+        if (hasNativeListHost && !isMountedNativeList) {
+          resolution.hasUnreadyScrollHost = YES;
+        } else if (!hasUsableBounds) {
+          resolution.hasUnreadyScrollHost = YES;
+        } else {
+          resolution.scrollView = collectionView;
+          resolution.tier = isMountedNativeList
+            ? RNCScrollCandidateTierVerifiedNativeList
+            : RNCScrollCandidateTierGenericFallback;
+        }
+      }
+    }
+  } else if ([view isKindOfClass:UIScrollView.class]) {
+    UIScrollView *scrollView = (UIScrollView *)view;
+    if (![_mountingRemovedScrollViews containsObject:scrollView] &&
+        !scrollView.alwaysBounceHorizontal &&
+        scrollView.contentSize.width <= scrollView.bounds.size.width + 1) {
+      resolution.scrollView = scrollView;
+      resolution.tier = RNCScrollCandidateTierGenericFallback;
+    }
+  }
+
+  for (UIView *subview in view.subviews) {
+    RNCScrollCandidateResolution child = [self resolveScrollCandidateInView:subview];
+    resolution.hasUnreadyScrollHost |= child.hasUnreadyScrollHost;
+    if (child.tier > resolution.tier) {
+      resolution.scrollView = child.scrollView;
+      resolution.tier = child.tier;
+      if (resolution.tier == RNCScrollCandidateTierExplicitScroller) {
+        return resolution;
+      }
+    }
+  }
+  return resolution;
 }
 
 - (UIScrollView *)findExplicitNativeScrollerInView:(UIView *)view
@@ -3602,6 +3811,19 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
   return nil;
 }
 
+- (void)scheduleCoalescedScrollReconcile
+{
+  if (_isBeingRecycled || _scrollReconcileScheduled) return;
+  _scrollReconcileScheduled = YES;
+  NSUInteger generation = _generation;
+  dispatch_async(dispatch_get_main_queue(), ^{
+    self->_scrollReconcileScheduled = NO;
+    if (self->_isBeingRecycled || self->_generation != generation) return;
+    [self prepareAdjacentPageInsets];
+    [self attachScrollObserverForCurrentPage];
+  });
+}
+
 - (void)scheduleScrollObserverRetryForCurrentPage
 {
   if (_scrollResolveRetryScheduled || _scrollResolveRetryAttempt >= 12 ||
@@ -3654,29 +3876,35 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
     _pendingFallbackScrollView = nil;
     _pendingFallbackScrollViewDetectedAt = 0;
   }
-  UIScrollView *candidate = [self verticalScrollViewForPageAtIndex:_currentIndex];
+  RNCScrollCandidateResolution resolution = [self resolveScrollCandidateForPageAtIndex:_currentIndex];
+  UIScrollView *candidate = resolution.scrollView;
   if (_nativeSmoothHeaderScrollEnabled && _currentIndex >= 0 && _currentIndex < _pageControllers.count) {
     RNCGuardNestedHorizontalPans(_pageControllers[_currentIndex].view, _verticalPagerGesture);
   }
   if (candidate == nil) {
     [self detachScrollObserver];
     [self restoreSharedHeadersToContainer];
-    // Stop retrying released lists on unrelated commits without discarding a
-    // surviving identity or offset. A relevant insertion resumes recovery.
-    if (_needsScrollObserverReattachAfterMount) {
-      _needsScrollObserverReattachAfterMount = NO;
+    _needsScrollObserverReattachAfterMount = NO;
+    _pendingFallbackScrollView = nil;
+    _pendingFallbackScrollViewDetectedAt = 0;
+    _awaitingScrollOwnerForCurrentPage = YES;
+    // Only schedule bounded retry when the page has an unready scroll host in
+    // its subtree or a released scroll owner awaiting replacement. Static pages
+    // without a scroll host do not spin retry timers, and late replacements on
+    // any page also attach deterministically via readiness notifications.
+    BOOL hasReleasedOwnerAwaitingReplacement = _releasedPageScrollStates[self.currentPageKey] != nil;
+    if (resolution.hasUnreadyScrollHost || hasReleasedOwnerAwaitingReplacement) {
+      [self scheduleScrollObserverRetryForCurrentPage];
+    } else {
       _scrollResolveRetryToken += 1;
       _scrollResolveRetryScheduled = NO;
       _scrollResolveRetryAttempt = 0;
-      _pendingFallbackScrollView = nil;
-      _pendingFallbackScrollViewDetectedAt = 0;
-    } else {
-      [self scheduleScrollObserverRetryForCurrentPage];
     }
     return;
   }
   if ([candidate isKindOfClass:UICollectionView.class] &&
       candidate != _observedScrollView && !RNCIsMountedNativeListScrollView(candidate)) {
+    _awaitingScrollOwnerForCurrentPage = YES;
     if (_pendingFallbackScrollView != candidate) {
       _pendingFallbackScrollView = candidate;
       _pendingFallbackScrollViewDetectedAt = CACurrentMediaTime();
@@ -3688,6 +3916,7 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
       return;
     }
   }
+  _awaitingScrollOwnerForCurrentPage = NO;
   _scrollResolveRetryAttempt = 0;
   _scrollResolveRetryPageIndex = _currentIndex;
   _scrollResolveRetryToken += 1;
@@ -4438,8 +4667,9 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
 
 - (void)updateNativeScrollerViewport:(UIScrollView *)scrollView stickyHeight:(CGFloat)height
 {
-  if ([scrollView.superview isKindOfClass:RNCNativeScrollerComponentView.class]) {
-    [(RNCNativeScrollerComponentView *)scrollView.superview setPagerStickyHeight:height forOwner:self];
+  id host = scrollView.superview;
+  if ([host respondsToSelector:@selector(setPagerStickyHeight:forOwner:)]) {
+    [host setPagerStickyHeight:height forOwner:self];
   }
 }
 
@@ -4511,6 +4741,66 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
 }
 
 
+- (void)nativeScrollViewDidBecomeReadyNotification:(NSNotification *)notification
+{
+  if ([notification.object isKindOfClass:UIScrollView.class]) {
+    [self nativeScrollViewDidBecomeReady:(UIScrollView *)notification.object];
+  }
+}
+
+- (void)nativeScrollViewDidBecomeReady:(UIScrollView *)scrollView
+{
+  if (_isBeingRecycled || self.window == nil || scrollView == nil ||
+      [_mountingRemovedScrollViews containsObject:scrollView]) return;
+  for (UIView *ancestor = scrollView.superview;
+       ancestor != nil && ancestor != self;
+       ancestor = ancestor.superview) {
+    if ([ancestor isKindOfClass:RNCCollapsiblePagerViewComponentView.class]) {
+      RNCCollapsiblePagerViewComponentView *nestedPager =
+        (RNCCollapsiblePagerViewComponentView *)ancestor;
+      if ([nestedPager currentVerticalScrollViewForParentPager] != scrollView) return;
+      break;
+    }
+  }
+  NSInteger pageIndex = NSNotFound;
+  for (NSInteger index = 0; index < _pageControllers.count; index++) {
+    if ([scrollView isDescendantOfView:_pageControllers[index].view]) {
+      pageIndex = index;
+      break;
+    }
+  }
+  if (pageIndex == NSNotFound) return;
+
+  NSString *pageKey = [self pageKeyForIndex:pageIndex];
+  BOOL hasReleasedStateForPage = _releasedPageScrollStates[pageKey] != nil;
+  BOOL currentPageNeedsOwner = pageIndex == _currentIndex &&
+    (_awaitingScrollOwnerForCurrentPage || _needsScrollObserverReattachAfterMount ||
+     hasReleasedStateForPage ||
+     (_observedScrollView != nil &&
+      [_observedScrollView isKindOfClass:UICollectionView.class] &&
+      !RNCIsMountedNativeListScrollView(_observedScrollView) &&
+      _observedScrollView != scrollView));
+
+  if (!hasReleasedStateForPage && !currentPageNeedsOwner &&
+      !_needsScrollObserverReattachAfterMount) return;
+
+  if (_nativeSmoothHeaderScrollEnabled) {
+    NSInteger first = MAX(0, _currentIndex - 1);
+    NSInteger last = MIN((NSInteger)_pageControllers.count - 1, _currentIndex + 1);
+    BOOL isOwnedScroller = [scrollView.superview isKindOfClass:RNCNativeScrollerComponentView.class] &&
+      ((RNCNativeScrollerComponentView *)scrollView.superview).scrollView == scrollView;
+    if ((pageIndex >= first && pageIndex <= last || pageIndex == _destinationIndex) &&
+        (RNCIsMountedNativeListScrollView(scrollView) || isOwnedScroller) &&
+        [_originalInsets objectForKey:scrollView] == nil) {
+      [self applyInsetsToScrollView:scrollView pageIndex:pageIndex restore:YES];
+    }
+  }
+
+  if (currentPageNeedsOwner && !_transitioning && !_isPagerDragging) {
+    [self attachScrollObserverForCurrentPage];
+  }
+}
+
 - (void)nativeScroller:(RNCNativeScrollerComponentView *)scroller
     callerInsetChangedFrom:(UIEdgeInsets)previous to:(UIEdgeInsets)next
 {
@@ -5233,6 +5523,13 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
 {
   UIScrollView *scrollView = _pagerTopScrollView;
   if (_dispatchingPagerTop || ![self matchesPagerTop:scrollView]) return;
+  CGFloat clampedTarget = MIN(MAX(_pagerTopLogicalTarget, 0), _headerHeight);
+  if (clampedTarget != _pagerTopLogicalTarget) {
+    _pagerTopLogicalTarget = clampedTarget;
+    CGFloat physicalTarget = RNCLimitRestoredScrollOffset(clampedTarget - scrollView.contentInset.top,
+      scrollView.contentSize.height, scrollView.bounds.size.height, scrollView.contentInset.top, scrollView.contentInset.bottom);
+    [scrollView setContentOffset:CGPointMake(scrollView.contentOffset.x, physicalTarget) animated:NO];
+  }
   CGFloat logical = scrollView.contentOffset.y + scrollView.contentInset.top;
   if (fabs(logical - _pagerTopLogicalTarget) > 0.5) return;
   _pageOffsets[_pagerTopPageKey] = @(_nativeSmoothHeaderScrollEnabled ? 0 : _pagerTopLogicalTarget);
@@ -5244,11 +5541,29 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
 }
 
 - (void)scrollToTop:(NSInteger)target animated:(BOOL)animated
+{
+  if (target != 0 && target != 1) return;
+  [self scrollHeaderToOffset:(target == 1 ? _headerHeight : 0) animated:animated];
+}
+
+- (void)scrollHeaderBy:(double)delta
+{
+  if (!std::isfinite(delta)) return;
+  [self scrollHeaderToOffset:MIN(MAX(_headerOffset + delta, 0), _headerHeight) animated:NO];
+}
+
+- (void)scrollHeaderToOffset:(double)offset
+{
+  if (!std::isfinite(offset)) return;
+  [self scrollHeaderToOffset:MIN(MAX(offset, 0), _headerHeight) animated:NO];
+}
+
+- (void)scrollHeaderToOffset:(CGFloat)logicalTarget animated:(BOOL)animated
 {
   [self cancelTopInsetReboundCheck];
   UIScrollView *scrollView = _observedScrollView;
   NSString *key = _observedPageKey;
-  if ((target != 0 && target != 1) || _isBeingRecycled || _transitioning || _isPagerDragging ||
+  if (_isBeingRecycled || _transitioning || _isPagerDragging ||
       _transitionPageOffsets != nil || _syntheticPageRestore || scrollView == nil || scrollView.window == nil ||
       key == nil || ![key isEqualToString:self.currentPageKey] || _observedPageIndex != _currentIndex ||
       _observedPageGeneration != _generation || self.window == nil) return;
@@ -5264,7 +5579,7 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
   [_alignedBodyKeys removeObject:key];
   [_suspendedBodyKeys removeObject:key];
   [_displayBodyOverrides removeObjectForKey:key];
-  CGFloat logicalTarget = target == 1 ? _headerHeight : 0;
+  logicalTarget = MIN(MAX(logicalTarget, 0), _headerHeight);
   _pageOffsets[key] = @(_nativeSmoothHeaderScrollEnabled ? 0 : logicalTarget);
   _pagerTopScrollView = scrollView;
   _pagerTopPageKey = [key copy];