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

package/docs/SPEC.md

@@ -3,6 +3,31 @@
 Existing PagerView and CollapsiblePagerView APIs are documented in README.md.
 The sections below define native coordination boundaries without new React props.
 
+## 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.256",
   "description": "React Native wrapper for Android and iOS ViewPager",
   "source": "./src/index.tsx",
   "main": "./lib/module/index.js",