@onekeyfe/react-native-pager-view 3.0.157-alpha.255 → 3.0.157-alpha.257

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

@@ -9,6 +9,7 @@ import android.view.ViewConfiguration
 import android.view.ViewGroup
 import android.view.ViewTreeObserver
 import android.widget.HorizontalScrollView
+import android.widget.ImageView
 import android.widget.ScrollView
 // OneKey patch: FrameLayout is inherited through NestedScrollableHost.
 // import android.widget.FrameLayout
@@ -17,11 +18,14 @@ import androidx.core.view.NestedScrollingParentHelper
 import androidx.core.view.ViewCompat
 import androidx.recyclerview.widget.LinearLayoutManager
 import androidx.recyclerview.widget.RecyclerView
+import androidx.swiperefreshlayout.widget.CircularProgressDrawable
 import androidx.viewpager2.widget.ViewPager2
 import com.facebook.react.R as ReactR
 import com.facebook.react.uimanager.events.NativeGestureUtil
 import com.facebook.react.views.scroll.ReactScrollView
+import com.facebook.react.views.swiperefresh.ReactSwipeRefreshLayout
 import com.margelo.nitro.nativelogger.OneKeyLog
+import java.lang.ref.WeakReference
 import java.util.WeakHashMap
 import kotlin.math.max
 import kotlin.math.min
@@ -116,6 +120,7 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
   private val restoredRecyclerKeys = WeakHashMap<RecyclerView, String>()
   private val originalScrollerPadding = WeakHashMap<ScrollView, ScrollerPadding>()
   private val restoredScrollerKeys = WeakHashMap<ScrollView, String>()
+  private val scrollerRefreshIndicators = WeakHashMap<ScrollView, WeakReference<View>>()
   private val pageOffsets = HashMap<String, Int>()
   private var observedRecyclerView: RecyclerView? = null
   private var observedScrollListener: RecyclerView.OnScrollListener? = null
@@ -604,6 +609,12 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
   }
 
   private fun prepareAdjacentPages() {
+    // Retained pages and replaced controls may leave the attached view tree.
+    for ((scroller, indicator) in scrollerRefreshIndicators.toMap()) {
+      if (nativeScrollerRefreshIndicator(scroller) !== indicator.get()) {
+        restoreNativeScrollerRefreshIndicator(scroller)
+      }
+    }
     val first = max(0, selectedPage - 1)
     val last = min(adapter.itemCount - 1, selectedPage + 1)
     for (index in first..last) {
@@ -794,6 +805,7 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
     updateScrollerPaddingOwnership(scroller, original)
     val topInset = headerHeightPx + stickyHeaderHeightPx
     scroller.clipToPadding = false
+    applyNativeScrollerRefreshIndicator(scroller, topInset)
     if (scroller is ReactScrollView) {
       // Fabric owns the content child's layout, so ScrollView padding alone
       // cannot move it. RN's native ScrollAway API also updates Fabric culling.
@@ -896,6 +908,7 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
   }
 
   private fun restoreNativeScrollerInsets(scroller: ScrollView) {
+    restoreNativeScrollerRefreshIndicator(scroller)
     val original = originalScrollerPadding.remove(scroller) ?: return
     updateScrollerPaddingOwnership(scroller, original)
     restoredScrollerKeys.remove(scroller)
@@ -910,6 +923,44 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
     scroller.setPadding(original.left, original.top, original.right, original.bottom)
   }
 
+  private fun nativeScrollerRefreshIndicator(scroller: ScrollView): View? {
+    if (!nativeSmoothHeaderScrollEnabled) return null
+    var ancestor = scroller.parent
+    while (ancestor != null && ancestor !== this) ancestor = ancestor.parent
+    if (ancestor !== this) return null
+    val refresh = scroller.parent as? ReactSwipeRefreshLayout ?: return null
+    for (index in 0 until refresh.childCount) {
+      val child = refresh.getChildAt(index)
+      if (child is ImageView && child.drawable is CircularProgressDrawable) return child
+    }
+    return null
+  }
+
+  private fun applyNativeScrollerRefreshIndicator(scroller: ScrollView, inset: Int) {
+    val indicator = nativeScrollerRefreshIndicator(scroller)
+    if (scrollerRefreshIndicators[scroller]?.get() !== indicator) {
+      restoreNativeScrollerRefreshIndicator(scroller)
+    }
+    if (indicator == null) return
+    if (scrollerRefreshIndicators[scroller]?.get() !== indicator) {
+      scrollerRefreshIndicators[scroller] = WeakReference(indicator)
+    }
+    val translation = refreshIndicatorTranslations.getOrPut(indicator) {
+      NativeScrollerRefreshTranslation(indicator.translationY)
+    }
+    // Moving only the drawing preserves RN's offsets and AndroidX's active pull/refresh animation.
+    // setProgressViewOffset would reset that animation and clear isRefreshing.
+    val next = translation.update(indicator.translationY, this, inset.toFloat())
+    if (indicator.translationY != next) indicator.translationY = next
+  }
+
+  private fun restoreNativeScrollerRefreshIndicator(scroller: ScrollView) {
+    val indicator = scrollerRefreshIndicators.remove(scroller)?.get() ?: return
+    val translation = refreshIndicatorTranslations[indicator] ?: return
+    indicator.translationY = translation.update(indicator.translationY, this, null)
+    if (translation.isEmpty) refreshIndicatorTranslations.remove(indicator)
+  }
+
   private fun headerRegionAt(y: Float): String? {
     val headerBottom = headerHeightPx - headerOffsetPx
     val stickyBottom = headerHeightPx + stickyHeaderHeightPx - headerOffsetPx
@@ -1232,6 +1283,7 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
   }
 
   companion object {
+    private val refreshIndicatorTranslations = WeakHashMap<View, NativeScrollerRefreshTranslation>()
     const val NATIVE_SCROLLER_ID_PREFIX = "rnc-collapsible-pager-native-scroller:"
     const val PAGE_SLOT_OFFSET = 2
   }

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

@@ -1,5 +1,7 @@
 package com.reactnativepagerview
 
+import java.util.WeakHashMap
+
 // Replace only this pager's contribution; another native owner may share the scroller.
 internal fun nativeScrollerScrollAwayTop(currentTop: Int, previousInset: Int, nextInset: Int): Int =
   (currentTop - previousInset).coerceAtLeast(0) + nextInset
@@ -15,3 +17,21 @@ internal fun nativeScrollerPaddingWasResetByScrollAway(
   scrollAwayBottom: Int,
 ): Boolean = appliedInset > 0 && left == 0 && top == 0 && right == 0 &&
   bottom == scrollAwayTop + scrollAwayBottom
+
+internal class NativeScrollerRefreshTranslation(initialTranslation: Float) {
+  private val contributions = WeakHashMap<Any, Float>()
+  private var baseline = initialTranslation
+  private var lastApplied = initialTranslation
+
+  val isEmpty: Boolean
+    get() = contributions.isEmpty()
+
+  fun update(currentTranslation: Float, owner: Any, inset: Float?): Float {
+    // Native refresh layout owns top/scale, while an external translation is
+    // an absolute baseline rather than another copy of our previous inset.
+    if (currentTranslation != lastApplied) baseline = currentTranslation
+    if (inset == null) contributions.remove(owner) else contributions[owner] = inset
+    lastApplied = baseline + contributions.values.sum()
+    return lastApplied
+  }
+}

package/android/src/test/java/com/reactnativepagerview/NativeScrollerScrollAwayInsetsTest.kt

@@ -34,4 +34,62 @@ fun main() {
   // Initial discovery must capture caller values before this pager owns an inset.
   check(!nativeScrollerPaddingWasResetByScrollAway(0, 0, 0, 0, 230, 230, 0))
   println("NativeScroller ScrollAway ownership: initial, repeat, measured resize, nested detach, Fabric reset, RN padding replay, and caller updates passed")
+
+  val firstOwner = Any()
+  val secondOwner = Any()
+  val translation = NativeScrollerRefreshTranslation(7.5f)
+  check(translation.isEmpty)
+  var current = translation.update(7.5f, firstOwner, 230f)
+  check(current == 237.5f)
+  check(!translation.isEmpty)
+  current = translation.update(current, firstOwner, 230f)
+  check(current == 237.5f)
+  current = translation.update(current, firstOwner, 358f)
+  check(current == 365.5f)
+  current = translation.update(current, secondOwner, 64f)
+  check(current == 429.5f)
+  current = translation.update(current, firstOwner, null)
+  check(current == 71.5f)
+  check(!translation.isEmpty)
+  current = translation.update(current, secondOwner, null)
+  check(current == 7.5f)
+  check(translation.isEmpty)
+
+  // Reversing release order must restore the same original translation.
+  current = translation.update(current, firstOwner, 230f)
+  current = translation.update(current, secondOwner, 64f)
+  current = translation.update(current, secondOwner, null)
+  check(current == 237.5f)
+  current = translation.update(current, firstOwner, null)
+  check(current == 7.5f)
+  check(translation.isEmpty)
+
+  // A caller's absolute translation update replaces the baseline, not its inset.
+  current = translation.update(current, firstOwner, 230f)
+  check(current == 237.5f)
+  current = translation.update(-12.5f, firstOwner, 230f)
+  check(current == 217.5f)
+  current = translation.update(current, secondOwner, 64f)
+  check(current == 281.5f)
+  current = translation.update(current, firstOwner, null)
+  check(current == 51.5f)
+  current = translation.update(current, secondOwner, null)
+  check(current == -12.5f)
+  check(translation.isEmpty)
+
+  // Zero is a real owned contribution; only null releases ownership.
+  current = translation.update(current, firstOwner, 0f)
+  check(current == -12.5f)
+  check(!translation.isEmpty)
+  current = translation.update(current, secondOwner, 0f)
+  current = translation.update(current, firstOwner, null)
+  check(current == -12.5f)
+  check(!translation.isEmpty)
+  current = translation.update(current, secondOwner, null)
+  check(current == -12.5f)
+  check(translation.isEmpty)
+  current = translation.update(9f, firstOwner, null)
+  check(current == 9f)
+  check(translation.isEmpty)
+  println("NativeScroller refresh translation: repeat, resize, nested release orders, external baseline, zero contribution, and final restoration passed")
 }

package/docs/SPEC.md

@@ -3,6 +3,65 @@
 Existing PagerView and CollapsiblePagerView APIs are documented in README.md.
 The sections below define native coordination boundaries without new React props.
 
+## Android NativeScroller refresh indicator placement
+
+Status: implemented; Android API 36 Home pull-gesture visibility verified on
+2026-09-28. Spot, Perps and DeFi (RN NativeScroller), plus the unchanged NFT and
+History (NativeList), each pass header-origin and content-origin pulls. Ten
+recordings show a visible indicator below the shared tabs, one refresh event and
+normal disappearance. This verifies UI feedback and event dispatch, not
+downstream request completion. Dynamic caller offset, refresh-time header resize
+and nested-pager replacement remain separate device acceptance work.
+In smooth-header mode, each pager contributes its header-plus-sticky height in
+physical pixels to the RN NativeScroller refresh indicator's `translationY`.
+The coordinator identifies only the refresh layout's direct indicator child;
+it MUST NOT translate the content ScrollView or change refresh offsets, bounds,
+scale, animation, visibility, trigger distance, refreshing state or callbacks.
+RN retains ownership of `progressViewOffset`, including dynamic caller updates.
+NativeList keeps its existing independent refresh-indicator positioning.
+
+One state per indicator combines weak owner contributions on the UI thread.
+Repeated application and header resizing replace only the calling owner's
+contribution. An external translation different from the last applied value
+becomes the new baseline. Removing an owner preserves the remaining contributions;
+removing the final owner restores the latest baseline. A zero contribution still
+has an owner until explicitly released. State MUST NOT strongly retain an owner
+or the indicator. Late mounting, indicator replacement and scroller/pager detach
+use the existing native layout lifecycle; there is no JavaScript frame callback.
+
+The standalone JVM policy test covers nonzero baselines, repeated application,
+resize, nested owners removed in either order, external translation updates,
+zero contributions and final restoration. It does not prove Android view
+discovery, actual refresh state or rendered placement. Runtime acceptance requires
+header-origin and content-origin pulls on NativeScroller pages, caller offset
+changes, refresh-time layout changes, replacement/detach, and visible disappearance
+after completion; existing NativeList pages must remain unchanged.
+
+## iOS refresh indicator placement
+
+Status: source implementation; real refresh-cycle acceptance pending.
+In smooth-header mode, the pager shifts the refresh control's sublayers upward
+by its header-plus-sticky height. It does not change the refresh control frame,
+bounds, scroll offset, refresh state or JavaScript callback. RN's caller-owned
+`progressViewOffset` remains untouched, including dynamic updates whose bounds
+origin could otherwise collide with a coordinator-applied value.
+
+One internal state per UIRefreshControl combines weak pager-owner contributions.
+It preserves the original sublayer transform and clipping setting. Repeated
+attachment and header resizing replace an owner's contribution. Layer clipping
+is disabled while coordinating so it cannot hide the translated indicator.
+A control replacement, scroll-view release, pager recycling or destruction
+removes only that owner's contribution and restores the baseline when none remain.
+Controls installed after the scroller is attached are also coordinated. Native
+UICollectionView controls and RN ScrollView controls use this same UIKit boundary.
+
+Native layer observations reapply the contribution after an external sublayer
+transform change, without observing or interpreting UIKit/RN bounds writes.
+There is no per-frame JavaScript work. Acceptance must cover real UIKit pulling
+and refresh completion, caller offset changes, late installation/replacement,
+retained-page switching, clipping and nested-owner cleanup. Programmatic UIKit
+unit tests do not substitute for real pull-gesture visibility acceptance.
+
 ## iOS shared-header hit testing
 
 Smooth-header hit forwarding is restricted to the pager's own interactive

package/ios/RNCCollapsiblePagerViewComponentView.mm

@@ -11,6 +11,7 @@
 #import "React/RCTScrollViewComponentView.h"
 #import "React/RCTSurfaceTouchHandler.h"
 #import "React/RCTTouchHandler.h"
+#import <objc/runtime.h>
 
 // OneKey patch: deduplicate structural mutation parents before scanning the page.
 #include <unordered_set>
@@ -18,6 +19,116 @@
 using namespace facebook::react;
 
 static void *RNCCollapsiblePagerContentOffsetContext = &RNCCollapsiblePagerContentOffsetContext;
+static void *RNCRefreshControlLayerContext = &RNCRefreshControlLayerContext;
+static void *RNCScrollRefreshControlContext = &RNCScrollRefreshControlContext;
+static char RNCRefreshControlOffsetKey;
+
+@interface RNCRefreshControlOffsetState : NSObject
++ (void)setOffset:(CGFloat)offset forControl:(UIRefreshControl *)control owner:(id)owner;
++ (void)removeControl:(UIRefreshControl *)control owner:(id)owner;
+@end
+
+@implementation RNCRefreshControlOffsetState {
+  __weak UIRefreshControl *_control;
+  NSMapTable<id, NSNumber *> *_offsets;
+  CATransform3D _baselineTransform;
+  CATransform3D _appliedTransform;
+  BOOL _originalMasksToBounds;
+  BOOL _applying;
+  BOOL _observing;
+}
+
+- (instancetype)initWithControl:(UIRefreshControl *)control
+{
+  if ((self = [super init])) {
+    _control = control;
+    _baselineTransform = control.layer.sublayerTransform;
+    _originalMasksToBounds = control.layer.masksToBounds;
+    _offsets = [NSMapTable weakToStrongObjectsMapTable];
+    [control.layer addObserver:self forKeyPath:@"sublayerTransform"
+                       options:NSKeyValueObservingOptionNew
+                       context:RNCRefreshControlLayerContext];
+    [control.layer addObserver:self forKeyPath:@"masksToBounds"
+                       options:NSKeyValueObservingOptionNew
+                       context:RNCRefreshControlLayerContext];
+    _observing = YES;
+  }
+  return self;
+}
+
+- (void)apply
+{
+  UIRefreshControl *control = _control;
+  if (control == nil) return;
+  CGFloat offset = 0;
+  for (NSNumber *value in _offsets.objectEnumerator) offset += value.doubleValue;
+  CATransform3D transform = CATransform3DConcat(
+    _baselineTransform, CATransform3DMakeTranslation(0, -offset, 0));
+  _appliedTransform = transform;
+  _applying = YES;
+  // Visual placement must not change UIKit's refresh geometry or RN's bounds
+  // origin (progressViewOffset). Allow the shifted indicator outside its host.
+  [CATransaction begin];
+  [CATransaction setDisableActions:YES];
+  control.layer.masksToBounds = _offsets.count == 0 ? _originalMasksToBounds : NO;
+  if (!CATransform3DEqualToTransform(control.layer.sublayerTransform, transform)) {
+    control.layer.sublayerTransform = transform;
+  }
+  [CATransaction commit];
+  _applying = NO;
+}
+
++ (void)setOffset:(CGFloat)offset forControl:(UIRefreshControl *)control owner:(id)owner
+{
+  if (control == nil) return;
+  RNCRefreshControlOffsetState *state = objc_getAssociatedObject(control, &RNCRefreshControlOffsetKey);
+  if (state == nil) {
+    state = [[self alloc] initWithControl:control];
+    objc_setAssociatedObject(control, &RNCRefreshControlOffsetKey, state, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+  }
+  [state->_offsets setObject:@(offset) forKey:owner];
+  [state apply];
+}
+
++ (void)removeControl:(UIRefreshControl *)control owner:(id)owner
+{
+  if (control == nil) return;
+  RNCRefreshControlOffsetState *state = objc_getAssociatedObject(control, &RNCRefreshControlOffsetKey);
+  if (state == nil) return;
+  [state->_offsets removeObjectForKey:owner];
+  [state apply];
+  if (state->_offsets.count == 0) {
+    [control.layer removeObserver:state forKeyPath:@"sublayerTransform" context:RNCRefreshControlLayerContext];
+    [control.layer removeObserver:state forKeyPath:@"masksToBounds" context:RNCRefreshControlLayerContext];
+    state->_observing = NO;
+    objc_setAssociatedObject(control, &RNCRefreshControlOffsetKey, nil, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+  }
+}
+
+- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object
+                      change:(NSDictionary<NSKeyValueChangeKey, id> *)change context:(void *)context
+{
+  if (context == RNCRefreshControlLayerContext) {
+    if (_applying) return;
+    if ([keyPath isEqualToString:@"sublayerTransform"]) {
+      CATransform3D next = [change[NSKeyValueChangeNewKey] CATransform3DValue];
+      if (CATransform3DEqualToTransform(next, _appliedTransform)) return;
+      _baselineTransform = next;
+    }
+    [self apply];
+    return;
+  }
+  [super observeValueForKeyPath:keyPath ofObject:object change:change context:context];
+}
+
+- (void)dealloc
+{
+  if (_observing && _control != nil) {
+    [_control.layer removeObserver:self forKeyPath:@"sublayerTransform" context:RNCRefreshControlLayerContext];
+    [_control.layer removeObserver:self forKeyPath:@"masksToBounds" context:RNCRefreshControlLayerContext];
+  }
+}
+@end
 static NSString *const RNCCollapsiblePagerNativeScrollerIDPrefix =
   @"rnc-collapsible-pager-native-scroller:";
 
@@ -973,6 +1084,8 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
 - (void)preparePageForHorizontalTransitionAtIndex:(NSInteger)pageIndex;
 - (void)updateSharedHeaderPressCancellationGesture;
 - (void)detachSharedHeaderPressCancellationGesture;
+- (void)updateRefreshControlForScrollView:(UIScrollView *)scrollView;
+- (void)releaseRefreshControlForScrollView:(UIScrollView *)scrollView;
 - (void)sharedHeaderPressCancellationGestureChanged:(UIPanGestureRecognizer *)recognizer;
 - (void)outerPagerGestureChanged:(UIPanGestureRecognizer *)recognizer;
 - (void)verticalPagerGuardGestureChanged:(UIPanGestureRecognizer *)recognizer;
@@ -1023,6 +1136,8 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
   NSString *_retainedPages;
   NSMutableDictionary<NSString *, NSNumber *> *_pageOffsets;
   NSMapTable<UIScrollView *, NSValue *> *_originalInsets;
+  NSMapTable<UIScrollView *, UIRefreshControl *> *_managedRefreshControls;
+  NSHashTable<UIScrollView *> *_refreshControlObservedScrollViews;
   NSMapTable<UIScrollView *, NSNumber *> *_appliedTopInsets;
   NSMapTable<UIScrollView *, NSValue *> *_originalIndicatorInsets;
   NSMapTable<UIScrollView *, NSNumber *> *_originalAlwaysBounceVertical;
@@ -1066,6 +1181,8 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
     _pageOffsets = [NSMutableDictionary new];
     _releasedPageScrollStates = [NSMutableDictionary new];
     _originalInsets = [NSMapTable weakToStrongObjectsMapTable];
+    _managedRefreshControls = [NSMapTable weakToWeakObjectsMapTable];
+    _refreshControlObservedScrollViews = [NSHashTable weakObjectsHashTable];
     _appliedTopInsets = [NSMapTable weakToStrongObjectsMapTable];
     _originalIndicatorInsets = [NSMapTable weakToStrongObjectsMapTable];
     _originalAlwaysBounceVertical = [NSMapTable weakToStrongObjectsMapTable];
@@ -1201,6 +1318,9 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
 
 - (void)dealloc
 {
+  for (UIScrollView *scrollView in _refreshControlObservedScrollViews.allObjects) {
+    [self releaseRefreshControlForScrollView:scrollView];
+  }
   [self detachSharedHeaderPressCancellationGesture];
 }
 
@@ -1739,6 +1859,9 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
   [self detachSharedHeaderPressCancellationGesture];
   [self detachScrollObserver];
   [self restoreSharedHeadersToContainer];
+  for (UIScrollView *scrollView in _refreshControlObservedScrollViews.allObjects) {
+    [self releaseRefreshControlForScrollView:scrollView];
+  }
   for (UIScrollView *scrollView in _originalInsets.keyEnumerator) {
     NSValue *value = [_originalInsets objectForKey:scrollView];
     if (value != nil) {
@@ -2428,10 +2551,44 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
   }
 }
 
+- (void)updateRefreshControlForScrollView:(UIScrollView *)scrollView
+{
+  if (!_nativeSmoothHeaderScrollEnabled || _isBeingRecycled) {
+    [self releaseRefreshControlForScrollView:scrollView];
+    return;
+  }
+  if (![_refreshControlObservedScrollViews containsObject:scrollView]) {
+    [_refreshControlObservedScrollViews addObject:scrollView];
+    [scrollView addObserver:self forKeyPath:@"refreshControl"
+                   options:NSKeyValueObservingOptionNew
+                   context:RNCScrollRefreshControlContext];
+  }
+  UIRefreshControl *previous = [_managedRefreshControls objectForKey:scrollView];
+  UIRefreshControl *current = scrollView.refreshControl;
+  if (previous != current) {
+    [RNCRefreshControlOffsetState removeControl:previous owner:self];
+    [_managedRefreshControls removeObjectForKey:scrollView];
+    if (current != nil) [_managedRefreshControls setObject:current forKey:scrollView];
+  }
+  [RNCRefreshControlOffsetState setOffset:_headerHeight + _stickyHeaderHeight
+                             forControl:current owner:self];
+}
+
+- (void)releaseRefreshControlForScrollView:(UIScrollView *)scrollView
+{
+  if ([_refreshControlObservedScrollViews containsObject:scrollView]) {
+    [scrollView removeObserver:self forKeyPath:@"refreshControl" context:RNCScrollRefreshControlContext];
+    [_refreshControlObservedScrollViews removeObject:scrollView];
+  }
+  [RNCRefreshControlOffsetState removeControl:[_managedRefreshControls objectForKey:scrollView] owner:self];
+  [_managedRefreshControls removeObjectForKey:scrollView];
+}
+
 // 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
 {
+  [self releaseRefreshControlForScrollView:scrollView];
   if (scrollView == _observedScrollView) {
     [self detachScrollObserver];
     if (resetSavedOffset) _pageOffsets[self.currentPageKey] = @(_headerOffset);
@@ -2548,6 +2705,7 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
   // 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;
+  [self updateRefreshControlForScrollView:scrollView];
   CGFloat previousTopInset = scrollView.contentInset.top;
   CGFloat previousLogicalOffset = scrollView.contentOffset.y + previousTopInset;
   NSNumber *appliedTop = [_appliedTopInsets objectForKey:scrollView];
@@ -2636,6 +2794,10 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
                         change:(NSDictionary<NSKeyValueChangeKey,id> *)change
                        context:(void *)context
 {
+  if (context == RNCScrollRefreshControlContext) {
+    [self updateRefreshControlForScrollView:(UIScrollView *)object];
+    return;
+  }
   if (context == RNCCollapsiblePagerContentOffsetContext && object == _observedScrollView) {
     if ([keyPath isEqualToString:@"contentSize"]) {
       NSValue *oldSize = change[NSKeyValueChangeOldKey];

package/ios/tests/RNCCollapsiblePagerRefreshControlTests.mm

@@ -0,0 +1,180 @@
+#import <XCTest/XCTest.h>
+#import "RNCCollapsiblePagerViewComponentView.h"
+
+@interface RNCCollapsiblePagerViewComponentView (RefreshControlTesting)
+- (void)updateRefreshControlForScrollView:(UIScrollView *)scrollView;
+- (void)releaseRefreshControlForScrollView:(UIScrollView *)scrollView;
+@end
+
+@interface RNCCollapsiblePagerRefreshControlTests : XCTestCase
+@end
+
+@implementation RNCCollapsiblePagerRefreshControlTests
+
+- (RNCCollapsiblePagerViewComponentView *)pagerWithHeader:(CGFloat)height
+{
+  RNCCollapsiblePagerViewComponentView *pager = [RNCCollapsiblePagerViewComponentView new];
+  [pager setValue:@YES forKey:@"nativeSmoothHeaderScrollEnabled"];
+  [pager setValue:@(height) forKey:@"headerHeight"];
+  [pager setValue:@44 forKey:@"stickyHeaderHeight"];
+  return pager;
+}
+
+- (void)testLateControlAndCallerOffsetUpdatesPreserveBaseline
+{
+  RNCCollapsiblePagerViewComponentView *pager = [self pagerWithHeader:64];
+  UIScrollView *scroll = [[UIScrollView alloc] initWithFrame:CGRectMake(0, 0, 320, 600)];
+  [pager updateRefreshControlForScrollView:scroll];
+  UIRefreshControl *control = [UIRefreshControl new];
+  control.bounds = CGRectMake(3, -12, 320, 60);
+  scroll.refreshControl = control;
+  XCTAssertEqualWithAccuracy(control.layer.sublayerTransform.m42, -108, 0.001);
+  XCTAssertEqualWithAccuracy(control.bounds.origin.y, -12, 0.001);
+  [pager updateRefreshControlForScrollView:scroll];
+  XCTAssertEqualWithAccuracy(control.layer.sublayerTransform.m42, -108, 0.001);
+  XCTAssertEqualWithAccuracy(control.bounds.origin.y, -12, 0.001);
+  control.layer.sublayerTransform = control.layer.sublayerTransform;
+  // Also cover an explicit no-op KVO notification, even if CALayer's setter
+  // suppresses notifications for equal transforms on the current OS.
+  [control.layer willChangeValueForKey:@"sublayerTransform"];
+  [control.layer didChangeValueForKey:@"sublayerTransform"];
+  XCTAssertEqualWithAccuracy(control.layer.sublayerTransform.m42, -108, 0.001);
+
+  // Fabric's progressViewOffset setter replaces bounds.origin.y directly.
+  control.bounds = CGRectMake(3, -20, 320, 60);
+  XCTAssertEqualWithAccuracy(control.layer.sublayerTransform.m42, -108, 0.001);
+  XCTAssertEqualWithAccuracy(control.bounds.origin.y, -20, 0.001);
+  [pager setValue:@100 forKey:@"headerHeight"];
+  [pager updateRefreshControlForScrollView:scroll];
+  XCTAssertEqualWithAccuracy(control.layer.sublayerTransform.m42, -144, 0.001);
+  XCTAssertEqualWithAccuracy(control.bounds.origin.y, -20, 0.001);
+  [pager releaseRefreshControlForScrollView:scroll];
+  XCTAssertEqualWithAccuracy(control.bounds.origin.y, -20, 0.001);
+  XCTAssertEqualWithAccuracy(control.bounds.origin.x, 3, 0.001);
+}
+
+- (void)testUIKitSizeChangesAndRefreshCycleDoNotAccumulateOffset
+{
+  RNCCollapsiblePagerViewComponentView *pager = [self pagerWithHeader:64];
+  UIScrollView *scroll = [[UIScrollView alloc] initWithFrame:CGRectMake(0, 0, 320, 600)];
+  // UIKit ignores offscreen beginRefreshing calls. Exercise the actual refresh
+  // lifecycle in a visible window rather than weakening the state assertion.
+  UIWindow *window = [[UIWindow alloc] initWithFrame:scroll.frame];
+  UIViewController *controller = [UIViewController new];
+  window.rootViewController = controller;
+  scroll.contentInsetAdjustmentBehavior = UIScrollViewContentInsetAdjustmentNever;
+  [controller.view addSubview:scroll];
+  window.hidden = NO;
+  [self addTeardownBlock:^{ window.hidden = YES; }];
+  UIRefreshControl *control = [UIRefreshControl new];
+  scroll.refreshControl = control;
+  [window layoutIfNeeded];
+  [scroll layoutIfNeeded];
+  XCTAssertEqual(control.window, window);
+  [pager updateRefreshControlForScrollView:scroll];
+  CGRect bounds = control.bounds;
+  bounds.size = CGSizeMake(320, 60);
+  control.bounds = bounds;
+  XCTAssertEqualWithAccuracy(control.layer.sublayerTransform.m42, -108, 0.001);
+  XCTAssertEqualWithAccuracy(control.bounds.origin.y, 0, 0.001);
+  [control beginRefreshing];
+  [control layoutIfNeeded];
+  [pager updateRefreshControlForScrollView:scroll];
+  XCTAssertTrue(control.isRefreshing);
+  XCTAssertEqualWithAccuracy(control.layer.sublayerTransform.m42, -108, 0.001);
+  XCTAssertEqualWithAccuracy(control.bounds.origin.y, 0, 0.001);
+  [control endRefreshing];
+  [control layoutIfNeeded];
+  XCTAssertFalse(control.isRefreshing);
+  XCTAssertEqualWithAccuracy(control.layer.sublayerTransform.m42, -108, 0.001);
+  XCTAssertEqualWithAccuracy(control.bounds.origin.y, 0, 0.001);
+  [pager releaseRefreshControlForScrollView:scroll];
+  XCTAssertEqualWithAccuracy(control.bounds.origin.y, 0, 0.001);
+  XCTAssertTrue(CATransform3DIsIdentity(control.layer.sublayerTransform));
+}
+
+- (void)testReplacementAndNestedOwnerReleaseRestoreOnlyTheirContributions
+{
+  RNCCollapsiblePagerViewComponentView *first = [self pagerWithHeader:64];
+  RNCCollapsiblePagerViewComponentView *second = [self pagerWithHeader:20];
+  UICollectionView *scroll = [[UICollectionView alloc] initWithFrame:CGRectMake(0, 0, 320, 600)
+                                                        collectionViewLayout:[UICollectionViewFlowLayout new]];
+  UIRefreshControl *original = [UIRefreshControl new];
+  scroll.refreshControl = original;
+  [first updateRefreshControlForScrollView:scroll];
+  [second updateRefreshControlForScrollView:scroll];
+  XCTAssertEqualWithAccuracy(original.layer.sublayerTransform.m42, -172, 0.001);
+  [first releaseRefreshControlForScrollView:scroll];
+  XCTAssertEqualWithAccuracy(original.layer.sublayerTransform.m42, -64, 0.001);
+
+  UIRefreshControl *replacement = [UIRefreshControl new];
+  replacement.bounds = CGRectMake(0, -8, 320, 60);
+  scroll.refreshControl = replacement;
+  XCTAssertTrue(CATransform3DIsIdentity(original.layer.sublayerTransform));
+  XCTAssertEqualWithAccuracy(replacement.layer.sublayerTransform.m42, -64, 0.001);
+  XCTAssertEqualWithAccuracy(replacement.bounds.origin.y, -8, 0.001);
+  [second prepareForRecycle];
+  XCTAssertEqualWithAccuracy(replacement.bounds.origin.y, -8, 0.001);
+  XCTAssertTrue(CATransform3DIsIdentity(replacement.layer.sublayerTransform));
+  scroll.refreshControl = nil;
+}
+
+- (void)testPagerDestructionRestoresControl
+{
+  UIScrollView *scroll = [UIScrollView new];
+  UIRefreshControl *control = [UIRefreshControl new];
+  scroll.refreshControl = control;
+  @autoreleasepool {
+    RNCCollapsiblePagerViewComponentView *pager = [self pagerWithHeader:64];
+    [pager updateRefreshControlForScrollView:scroll];
+    XCTAssertEqualWithAccuracy(control.layer.sublayerTransform.m42, -108, 0.001);
+    XCTAssertEqualWithAccuracy(control.bounds.origin.y, 0, 0.001);
+  }
+  XCTAssertEqualWithAccuracy(control.bounds.origin.y, 0, 0.001);
+  XCTAssertTrue(CATransform3DIsIdentity(control.layer.sublayerTransform));
+}
+
+- (void)testCallerOffsetCollisionDoesNotAffectVisualContribution
+{
+  RNCCollapsiblePagerViewComponentView *pager = [self pagerWithHeader:56];
+  UIScrollView *scroll = [UIScrollView new];
+  UIRefreshControl *control = [UIRefreshControl new];
+  scroll.refreshControl = control;
+  control.bounds = CGRectMake(0, -200, 320, 60);
+  [pager updateRefreshControlForScrollView:scroll];
+  control.bounds = CGRectMake(0, -100, 320, 60);
+  XCTAssertEqualWithAccuracy(control.bounds.origin.y, -100, 0.001);
+  XCTAssertEqualWithAccuracy(control.layer.sublayerTransform.m42, -100, 0.001);
+  [pager releaseRefreshControlForScrollView:scroll];
+  XCTAssertEqualWithAccuracy(control.bounds.origin.y, -100, 0.001);
+  XCTAssertTrue(CATransform3DIsIdentity(control.layer.sublayerTransform));
+}
+
+- (void)testNestedOwnerDestructionPreservesBaselineAndRestoresClipping
+{
+  RNCCollapsiblePagerViewComponentView *second = [self pagerWithHeader:20];
+  UIScrollView *scroll = [UIScrollView new];
+  UIRefreshControl *control = [UIRefreshControl new];
+  scroll.refreshControl = control;
+  CATransform3D baseline = CATransform3DMakeTranslation(7, 13, 0);
+  control.layer.sublayerTransform = baseline;
+  control.layer.masksToBounds = YES;
+  @autoreleasepool {
+    RNCCollapsiblePagerViewComponentView *first = [self pagerWithHeader:64];
+    [first updateRefreshControlForScrollView:scroll];
+    [second updateRefreshControlForScrollView:scroll];
+    XCTAssertEqualWithAccuracy(control.layer.sublayerTransform.m42, 13 - 172, 0.001);
+    XCTAssertFalse(control.layer.masksToBounds);
+  }
+  XCTAssertEqualWithAccuracy(control.layer.sublayerTransform.m42, 13 - 64, 0.001);
+  // A UIKit layer reset must not discard the remaining visual contribution.
+  control.layer.sublayerTransform = baseline;
+  control.layer.masksToBounds = YES;
+  XCTAssertEqualWithAccuracy(control.layer.sublayerTransform.m42, 13 - 64, 0.001);
+  XCTAssertFalse(control.layer.masksToBounds);
+  [second releaseRefreshControlForScrollView:scroll];
+  XCTAssertTrue(CATransform3DEqualToTransform(control.layer.sublayerTransform, baseline));
+  XCTAssertTrue(control.layer.masksToBounds);
+}
+
+@end

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/react-native-pager-view",
-  "version": "3.0.157-alpha.255",
+  "version": "3.0.157-alpha.257",
   "description": "React Native wrapper for Android and iOS ViewPager",
   "source": "./src/index.tsx",
   "main": "./lib/module/index.js",