@onekeyfe/react-native-pager-view 3.0.133 → 3.0.134

package/android/src/main/java/com/reactnativepagerview/CollapsiblePagerNativeHeaders.kt

@@ -184,10 +184,12 @@ private class CollapsiblePagerHorizontalItemsView(
     }
   }
 
-  private fun selectedBackground(selected: Boolean) = GradientDrawable().apply {
+  private fun selectedBackground(selected: Boolean, height: Int) = GradientDrawable().apply {
     shape = GradientDrawable.RECTANGLE
     setColor(if (selected) selectedBackgroundColor else Color.TRANSPARENT)
-    cornerRadius = dp(10.0).toFloat()
+    // OneKey patch: match the pill shape of the React category filters.
+    // cornerRadius = dp(10.0).toFloat()
+    cornerRadius = height / 2f
   }
 
   override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
@@ -278,7 +280,7 @@ private class CollapsiblePagerHorizontalItemsView(
       buttons.forEachIndexed { index, button ->
         val selected = index == selectedIndex
         button.setTextColor(if (selected) activeTextColor else inactiveTextColor)
-        button.background = selectedBackground(selected)
+        button.background = selectedBackground(selected, button.height)
         button.isSelected = selected
       }
     }

package/ios/RNCCollapsiblePagerViewComponentView.mm

@@ -11,12 +11,39 @@
 #import "React/RCTSurfaceTouchHandler.h"
 #import "React/RCTTouchHandler.h"
 
+// OneKey patch: deduplicate structural mutation parents before scanning the page.
+#include <unordered_set>
+
 using namespace facebook::react;
 
 static void *RNCCollapsiblePagerContentOffsetContext = &RNCCollapsiblePagerContentOffsetContext;
 static NSString *const RNCCollapsiblePagerNativeScrollerIDPrefix =
   @"rnc-collapsible-pager-native-scroller:";
 
+static const CFTimeInterval RNCCollapsiblePagerFallbackDebounceInterval = 0.5;
+
+// 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
+@property (nonatomic, weak) UIScrollView *scrollView;
+@property (nonatomic, weak) UIView *componentView;
+@property (nonatomic, assign) NSInteger componentTag;
+@property (nonatomic, weak) UIScrollView *pendingFallbackScrollView;
+@property (nonatomic, assign) CFTimeInterval pendingFallbackDetectedAt;
+@end
+
+@implementation RNCCollapsiblePagerReleasedScrollState
+@end
+
+static UIView *RNCScrollComponentView(UIScrollView *scrollView)
+{
+  for (UIView *view = scrollView; view != nil; view = view.superview) {
+    // UIView's Fabric category adopts the protocol even for unregistered views.
+    if ([view isKindOfClass:RCTViewComponentView.class] && view.tag > 0) return view;
+  }
+  return nil;
+}
+
 typedef void (^RNCCollapsiblePagerNativeTabPressHandler)(NSInteger index, NSString *key);
 
 static CGFloat RNCClamp(CGFloat value, CGFloat minimum, CGFloat maximum)
@@ -716,7 +743,9 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
     NSString *key = [item[@"key"] isKindOfClass:NSString.class] ? item[@"key"] : @"";
     BOOL selected = [key isEqualToString:self->_selectedKey];
     button.backgroundColor = selected ? self->_selectedBackgroundColor : UIColor.clearColor;
-    button.layer.cornerRadius = 10;
+    // OneKey patch: match the pill shape of the React category filters.
+    // button.layer.cornerRadius = 10;
+    button.layer.cornerRadius = CGRectGetHeight(button.bounds) / 2;
     [button setTitleColor:selected ? self->_activeTextColor : self->_inactiveTextColor
                  forState:UIControlStateNormal];
     button.accessibilityTraits = selected
@@ -989,6 +1018,9 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
   NSMapTable<UIScrollView *, NSValue *> *_originalIndicatorInsets;
   NSMapTable<UIScrollView *, NSNumber *> *_originalAlwaysBounceVertical;
   NSMapTable<UIScrollView *, NSNumber *> *_originalInsetAdjustmentBehavior;
+  // OneKey patch: pair pre-mount release with recovery, including deferred mounts.
+  NSMutableDictionary<NSString *, RNCCollapsiblePagerReleasedScrollState *> *_releasedPageScrollStates;
+  BOOL _needsScrollObserverReattachAfterMount;
   __weak UIScrollView *_observedScrollView;
   __weak UIScrollView *_sharedHeaderScrollView;
   __weak UIScrollView *_pendingFallbackScrollView;
@@ -1023,6 +1055,7 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
     _logicalChildren = [NSMutableArray new];
     _pageControllers = [NSMutableArray new];
     _pageOffsets = [NSMutableDictionary new];
+    _releasedPageScrollStates = [NSMutableDictionary new];
     _originalInsets = [NSMapTable weakToStrongObjectsMapTable];
     _appliedTopInsets = [NSMapTable weakToStrongObjectsMapTable];
     _originalIndicatorInsets = [NSMapTable weakToStrongObjectsMapTable];
@@ -1132,6 +1165,19 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
       !_pagerScrollView.dragging && !_pagerScrollView.decelerating) {
     [self finishPagerScrollEmittingSelection:NO];
   }
+  // OneKey patch: a detached pager can return without a new Fabric transaction.
+  // Wait until the current mount has finished before inspecting its new lists.
+  if (self.window != nil &&
+      (_needsScrollObserverReattachAfterMount || _releasedPageScrollStates.count > 0)) {
+    NSUInteger generation = _generation;
+    dispatch_async(dispatch_get_main_queue(), ^{
+      if (self->_generation == generation &&
+          (self->_needsScrollObserverReattachAfterMount || self->_releasedPageScrollStates.count > 0)) {
+        self->_needsScrollObserverReattachAfterMount = YES;
+        [self attachScrollObserverForCurrentPage];
+      }
+    });
+  }
 }
 
 - (void)dealloc
@@ -1375,6 +1421,63 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
 
 #pragma mark - React mounting
 
+// OneKey patch: Fabric can recycle a removed list as a descendant of our header
+// within the same transaction. Release native ownership before that reuse can
+// form a cycle; did-mount recovery runs too late to prevent it.
+- (void)mountingTransactionWillMount:(const MountingTransaction &)transaction
+                withSurfaceTelemetry:(const SurfaceTelemetry &)surfaceTelemetry
+{
+  if (_isBeingRecycled || (_originalInsets.count == 0 && _releasedPageScrollStates.count == 0)) return;
+  std::unordered_set<NSInteger> removedTags;
+  std::unordered_set<NSInteger> deletedTags;
+  for (const auto &mutation : transaction.getMutations()) {
+    if ((mutation.type == ShadowViewMutation::Remove ||
+         mutation.type == ShadowViewMutation::Delete) && mutation.oldChildShadowView.tag > 0) {
+      removedTags.insert(mutation.oldChildShadowView.tag);
+      if (mutation.type == ShadowViewMutation::Delete) {
+        deletedTags.insert(mutation.oldChildShadowView.tag);
+      }
+    }
+  }
+  // A transition can defer reattachment across several mounting transactions.
+  for (RNCCollapsiblePagerReleasedScrollState *state in _releasedPageScrollStates.allValues) {
+    if (deletedTags.find(state.componentTag) != deletedTags.end()) state.componentView = nil;
+  }
+  if (removedTags.empty()) return;
+
+  // Inspect only the managed scroll views' ancestor chains, including wrappers
+  // above the pager. Row removals and unrelated commits keep ownership intact.
+  for (UIScrollView *scrollView in _originalInsets.keyEnumerator.allObjects) {
+    for (UIView *ancestor = scrollView; ancestor != nil; ancestor = ancestor.superview) {
+      if (removedTags.find(ancestor.tag) == removedTags.end()) continue;
+      BOOL belongsToPage = NO;
+      for (NSInteger index = 0; index < _pageControllers.count; index++) {
+        if (![scrollView isDescendantOfView:_pageControllers[index].view]) continue;
+        belongsToPage = YES;
+        NSString *pageKey = [self pageKeyForIndex:index];
+        UIView *componentView = RNCScrollComponentView(scrollView);
+        RNCCollapsiblePagerReleasedScrollState *state = [RNCCollapsiblePagerReleasedScrollState new];
+        state.scrollView = scrollView;
+        state.componentTag = componentView.tag;
+        // A deleted component can reuse both the native object and its tag.
+        if (deletedTags.find(componentView.tag) == deletedTags.end()) {
+          state.componentView = componentView;
+        }
+        _releasedPageScrollStates[pageKey] = state;
+        // Retained pages may be visually aligned to the expanded header while
+        // their saved offsets still hold the user's independent list position.
+        if (scrollView == _observedScrollView || _pageOffsets[pageKey] == nil) {
+          _pageOffsets[pageKey] = @(scrollView.contentOffset.y + scrollView.contentInset.top);
+        }
+        break;
+      }
+      _needsScrollObserverReattachAfterMount = YES;
+      [self restoreScrollViewState:scrollView resetSavedOffset:!belongsToPage];
+      break;
+    }
+  }
+}
+
 - (void)mountingTransactionDidMount:(const MountingTransaction &)transaction
                withSurfaceTelemetry:(const SurfaceTelemetry &)surfaceTelemetry
 {
@@ -1382,16 +1485,55 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
       _isPagerDragging || _isBeingRecycled || self.window == nil ||
       _currentIndex < 0 || _currentIndex >= _pageControllers.count) return;
 
-  UIView *pageView = _pageControllers[_currentIndex].view;
-  BOOL shouldResolve = _observedScrollView == nil ||
-    ![_observedScrollView isDescendantOfView:pageView];
-  if (!shouldResolve &&
-      [_observedScrollView isKindOfClass:UICollectionView.class]) {
-    UIScrollView *preferred = [self findExplicitNativeScrollerInView:pageView];
-    if (preferred == nil) preferred = [self findFabricScrollViewInView:pageView];
-    shouldResolve = preferred != nil && preferred != _observedScrollView;
+  // OneKey patch: a release must recover even when the changed parent is above
+  // the page subtree. Missing lists keep their identity for a later insertion.
+  if (_needsScrollObserverReattachAfterMount) {
+    [self attachScrollObserverForCurrentPage];
+    return;
+  }
+  UIView *page = _pageControllers[_currentIndex].view;
+  BOOL headerIsAttached = [_sharedHeaderHostView isDescendantOfView:self];
+  BOOL currentListIsAttached = _observedScrollView != nil &&
+    [_observedScrollView isDescendantOfView:page] && headerIsAttached;
+  BOOL currentListIsFallback = currentListIsAttached &&
+    [_observedScrollView isKindOfClass:UICollectionView.class];
+  if (currentListIsAttached && !currentListIsFallback &&
+      _releasedPageScrollStates.count == 0) return;
+  if (!headerIsAttached) {
+    [self attachScrollObserverForCurrentPage];
+    return;
+  }
+  // Property-only updates cannot replace a list. Collect changed parents first
+  // so a burst of unrelated mutations scans the current page at most once.
+  std::unordered_set<NSInteger> changedParentTags;
+  for (const auto &mutation : transaction.getMutations()) {
+    if ((mutation.type == ShadowViewMutation::Insert ||
+         mutation.type == ShadowViewMutation::Remove) && mutation.parentTag > 0) {
+      changedParentTags.insert(mutation.parentTag);
+    }
+  }
+  if (changedParentTags.empty()) return;
+
+  // A missing list can return in a later transaction. Inspect only the current
+  // page needing an observer and pages whose released identities are retained.
+  for (NSInteger index = 0; index < _pageControllers.count; index++) {
+    BOOL hasReleasedList = _releasedPageScrollStates[[self pageKeyForIndex:index]] != nil;
+    BOOL currentPageNeedsResolve = index == _currentIndex &&
+      (!currentListIsAttached || currentListIsFallback);
+    if (!hasReleasedList && !currentPageNeedsResolve) continue;
+    NSMutableArray<UIView *> *pendingViews =
+      [NSMutableArray arrayWithObject:_pageControllers[index].view];
+    while (pendingViews.count > 0) {
+      UIView *view = pendingViews.lastObject;
+      [pendingViews removeLastObject];
+      if (changedParentTags.find(view.tag) != changedParentTags.end()) {
+        if (hasReleasedList) _needsScrollObserverReattachAfterMount = YES;
+        [self attachScrollObserverForCurrentPage];
+        return;
+      }
+      [pendingViews addObjectsFromArray:view.subviews];
+    }
   }
-  if (shouldResolve) [self attachScrollObserverForCurrentPage];
 }
 
 - (void)mountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView
@@ -1573,6 +1715,8 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
 {
   _isBeingRecycled = YES;
   _generation++;
+  _needsScrollObserverReattachAfterMount = NO;
+  [_releasedPageScrollStates removeAllObjects];
   [self detachSharedHeaderPressCancellationGesture];
   [self detachScrollObserver];
   [self restoreSharedHeadersToContainer];
@@ -1943,6 +2087,18 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
 
 - (void)attachScrollObserverForCurrentPage
 {
+  [self attachScrollObserverForCurrentPageAfterTransition:NO];
+}
+
+// OneKey patch: selection completion restores list state synchronously, before
+// the transition flags are cleared on the next run loop. Other callers wait.
+- (void)attachScrollObserverForCurrentPageAfterTransition:(BOOL)selectionSettled
+{
+  if (_isBeingRecycled) return;
+  if (_needsScrollObserverReattachAfterMount) {
+    if (self.window == nil || ((_transitioning || _isPagerDragging) && !selectionSettled)) return;
+    [self prepareAdjacentPageInsets];
+  }
   [self restoreDetachedScrollInsets];
   if (_scrollResolveRetryPageIndex != _currentIndex) {
     _scrollResolveRetryToken += 1;
@@ -1956,7 +2112,18 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
   if (candidate == nil) {
     [self detachScrollObserver];
     [self restoreSharedHeadersToContainer];
-    [self scheduleScrollObserverRetryForCurrentPage];
+    // Stop retrying released lists on unrelated commits without discarding a
+    // surviving identity or offset. A relevant insertion resumes recovery.
+    if (_needsScrollObserverReattachAfterMount) {
+      _needsScrollObserverReattachAfterMount = NO;
+      _scrollResolveRetryToken += 1;
+      _scrollResolveRetryScheduled = NO;
+      _scrollResolveRetryAttempt = 0;
+      _pendingFallbackScrollView = nil;
+      _pendingFallbackScrollViewDetectedAt = 0;
+    } else {
+      [self scheduleScrollObserverRetryForCurrentPage];
+    }
     return;
   }
   if ([candidate isKindOfClass:UICollectionView.class] &&
@@ -1966,7 +2133,8 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
       _pendingFallbackScrollViewDetectedAt = CACurrentMediaTime();
       _scrollResolveRetryAttempt = 0;
     }
-    if (CACurrentMediaTime() - _pendingFallbackScrollViewDetectedAt < 0.5) {
+    if (CACurrentMediaTime() - _pendingFallbackScrollViewDetectedAt <
+        RNCCollapsiblePagerFallbackDebounceInterval) {
       [self scheduleScrollObserverRetryForCurrentPage];
       return;
     }
@@ -1983,6 +2151,7 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
     [candidate.panGestureRecognizer requireGestureRecognizerToFail:_pagerScrollView.panGestureRecognizer];
   }
   if (candidate == _observedScrollView) {
+    _needsScrollObserverReattachAfterMount = NO;
     [self attachSharedHeadersToScrollView:candidate];
     [self updateSharedHeaderPressCancellationGesture];
     return;
@@ -2006,6 +2175,7 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
                  context:RNCCollapsiblePagerContentOffsetContext];
   [candidate.panGestureRecognizer addTarget:self action:@selector(observedListPanChanged:)];
   _observingContentOffset = YES;
+  _needsScrollObserverReattachAfterMount = NO;
   _currentLogicalOffset = candidate.contentOffset.y + candidate.contentInset.top;
   [self attachSharedHeadersToScrollView:candidate];
   [self updateSharedHeaderPressCancellationGesture];
@@ -2235,6 +2405,39 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
   }
 }
 
+// OneKey patch: release observers, headers and saved state while the scroll view
+// still represents the old list, before Fabric applies its next owner's props.
+- (void)restoreScrollViewState:(UIScrollView *)scrollView resetSavedOffset:(BOOL)resetSavedOffset
+{
+  if (scrollView == _observedScrollView) {
+    [self detachScrollObserver];
+    if (resetSavedOffset) _pageOffsets[self.currentPageKey] = @(_headerOffset);
+  }
+  if (scrollView == _sharedHeaderScrollView) {
+    [self restoreSharedHeadersToContainer];
+  }
+  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;
+  scrollView.alwaysBounceVertical =
+    [_originalAlwaysBounceVertical objectForKey:scrollView].boolValue;
+  scrollView.contentInsetAdjustmentBehavior = (UIScrollViewContentInsetAdjustmentBehavior)
+    [_originalInsetAdjustmentBehavior objectForKey:scrollView].integerValue;
+  [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];
+}
+
 - (void)restoreDetachedScrollInsets
 {
   for (UIScrollView *scrollView in _originalInsets.keyEnumerator.allObjects) {
@@ -2246,32 +2449,8 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
       }
     }
     if (belongsToPage) continue;
-    if (scrollView == _observedScrollView) {
-      [self detachScrollObserver];
-      _pageOffsets[self.currentPageKey] = @(_headerOffset);
-    }
-    // Fabric can reuse an empty RN ScrollView in another screen. Release all
-    // 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;
-    scrollView.alwaysBounceVertical =
-      [_originalAlwaysBounceVertical objectForKey:scrollView].boolValue;
-    scrollView.contentInsetAdjustmentBehavior = (UIScrollViewContentInsetAdjustmentBehavior)
-      [_originalInsetAdjustmentBehavior objectForKey:scrollView].integerValue;
-    [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];
+    // OneKey patch: share the full release path with pre-mount recycling.
+    [self restoreScrollViewState:scrollView resetSavedOffset:YES];
   }
 }
 
@@ -2279,6 +2458,57 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
                       pageIndex:(NSInteger)pageIndex
                         restore:(BOOL)restore
 {
+  // OneKey patch: a surviving list keeps its full offset. A replacement keeps
+  // only header collapse, even if Fabric reused the same native scroll object.
+  NSString *pageKey = [self pageKeyForIndex:pageIndex];
+  RNCCollapsiblePagerReleasedScrollState *released = _releasedPageScrollStates[pageKey];
+  BOOL deferredReleasedIdentity = NO;
+  if (released != nil) {
+    UIView *componentView = RNCScrollComponentView(scrollView);
+    BOOL sameList = released.scrollView == scrollView && componentView != nil &&
+      released.componentView == componentView && released.componentTag == componentView.tag;
+    // Adjacent Nitro lists are visible only as generic UICollectionViews, so
+    // debounce each replacement candidate independently before rejecting the
+    // released identity. A surviving native list is safe to accept immediately.
+    BOOL needsFallbackDebounce = !sameList &&
+      [scrollView isKindOfClass:UICollectionView.class] && scrollView != _observedScrollView;
+    if (needsFallbackDebounce) {
+      CFTimeInterval now = CACurrentMediaTime();
+      if (released.pendingFallbackScrollView != scrollView) {
+        released.pendingFallbackScrollView = scrollView;
+        released.pendingFallbackDetectedAt = now;
+        __weak __typeof__(self) weakSelf = self;
+        __weak RNCCollapsiblePagerReleasedScrollState *weakReleased = released;
+        __weak UIScrollView *weakScrollView = scrollView;
+        NSString *capturedPageKey = [pageKey copy];
+        NSUInteger capturedGeneration = _generation;
+        dispatch_after(
+          dispatch_time(
+            DISPATCH_TIME_NOW,
+            (int64_t)(RNCCollapsiblePagerFallbackDebounceInterval * NSEC_PER_SEC)
+          ),
+          dispatch_get_main_queue(),
+          ^{
+            RNCCollapsiblePagerViewComponentView *strongSelf = weakSelf;
+            RNCCollapsiblePagerReleasedScrollState *strongReleased = weakReleased;
+            UIScrollView *strongScrollView = weakScrollView;
+            if (strongSelf == nil || strongReleased == nil || strongScrollView == nil ||
+                strongSelf->_isBeingRecycled || strongSelf.window == nil ||
+                strongSelf->_generation != capturedGeneration ||
+                strongSelf->_releasedPageScrollStates[capturedPageKey] != strongReleased ||
+                strongReleased.pendingFallbackScrollView != strongScrollView) return;
+            [strongSelf prepareAdjacentPageInsets];
+          }
+        );
+      }
+      deferredReleasedIdentity = now - released.pendingFallbackDetectedAt <
+        RNCCollapsiblePagerFallbackDebounceInterval;
+    }
+    if (!deferredReleasedIdentity) {
+      if (!sameList) _pageOffsets[pageKey] = @(_headerOffset);
+      [_releasedPageScrollStates removeObjectForKey:pageKey];
+    }
+  }
   NSValue *storedOriginal = [_originalInsets objectForKey:scrollView];
   UIEdgeInsets original = storedOriginal == nil
     ? scrollView.contentInset
@@ -2327,7 +2557,9 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
     NSNumber *saved = _pageOffsets[[self pageKeyForIndex:pageIndex]];
     // The sticky slot can change height between pages. Cache offsets relative
     // to content start so a round trip does not add that height difference.
-    CGFloat restoredLogicalOffset = saved == nil ? _headerOffset : saved.doubleValue;
+    CGFloat restoredLogicalOffset = deferredReleasedIdentity || saved == nil
+      ? _headerOffset
+      : saved.doubleValue;
     // While the shared header is visible, retained pages must agree on its
     // collapse position. Deep offsets remain independent after full collapse.
     if (_nativeSmoothHeaderScrollEnabled && _headerOffset < _headerHeight) {
@@ -2483,7 +2715,7 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
         self->_currentIndex = index;
         self->_destinationIndex = index;
         [self->_nativeTabBarView setProgress:index];
-        [self attachScrollObserverForCurrentPage];
+        [self attachScrollObserverForCurrentPageAfterTransition:YES];
         [self emitPageSelected:index];
         [self emitDiagnostics:@"page-selected"];
       } else if (self->_pendingGoToIndex < 0) {
@@ -2520,7 +2752,7 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
       self->_currentIndex = index;
       self->_destinationIndex = index;
       [self->_nativeTabBarView setProgress:index];
-      [self attachScrollObserverForCurrentPage];
+      [self attachScrollObserverForCurrentPageAfterTransition:YES];
       [self emitPageSelected:index];
       [self emitDiagnostics:@"page-selected"];
     } else {
@@ -2660,7 +2892,7 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
       0
     ) animated:NO];
     [_nativeTabBarView setProgress:index];
-    [self attachScrollObserverForCurrentPage];
+    [self attachScrollObserverForCurrentPageAfterTransition:YES];
     if (emitSelection &&
         (_pendingGoToIndex < 0 || _pendingGoToIndex == index)) {
       [self emitPageSelected:index];
@@ -2711,7 +2943,7 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
       _currentIndex = index;
       _destinationIndex = index;
       [_nativeTabBarView setProgress:index];
-      [self attachScrollObserverForCurrentPage];
+      [self attachScrollObserverForCurrentPageAfterTransition:YES];
       // A newer tab tap remains authoritative while its queued command runs.
       if (emitSelection &&
           (_pendingGoToIndex < 0 || _pendingGoToIndex == index)) {

package/package.json

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