@onekeyfe/react-native-pager-view 3.0.162-alpha.272 → 3.0.163

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

@@ -364,13 +364,14 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
   fun removeAllReactChildren() {
     releaseRefreshForeground()
     detachPrimaryScrollObserver()
-    for (recycler in originalRecyclerPadding.keys.toList()) {
+    // Weak keys may disappear after size is read; Collection.toArray tolerates this.
+    for (recycler in originalRecyclerPadding.keys.toTypedArray()) {
       restoreRecyclerInsets(recycler)
     }
-    for (scroller in originalScrollerPadding.keys.toList()) {
+    for (scroller in originalScrollerPadding.keys.toTypedArray()) {
       restoreNativeScrollerInsets(scroller)
     }
-    for (scroller in ownedScrollerKeys.keys.toList()) restoreOwnedScrollerInsets(scroller)
+    for (scroller in ownedScrollerKeys.keys.toTypedArray()) restoreOwnedScrollerInsets(scroller)
     headerView?.let { view -> super.removeView(view) }
     stickyHeaderView?.let { view -> super.removeView(view) }
     headerView = null
@@ -1504,13 +1505,14 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
     nestedNativeGestureStarted = false
     viewTreeObserver.removeOnPreDrawListener(pageContentLayoutListener)
     detachPrimaryScrollObserver()
-    for (recycler in originalRecyclerPadding.keys.toList()) {
+    // Snapshot live keys before restoration removes their padding records.
+    for (recycler in originalRecyclerPadding.keys.toTypedArray()) {
       restoreRecyclerInsets(recycler)
     }
-    for (scroller in originalScrollerPadding.keys.toList()) {
+    for (scroller in originalScrollerPadding.keys.toTypedArray()) {
       restoreNativeScrollerInsets(scroller)
     }
-    for (scroller in ownedScrollerKeys.keys.toList()) restoreOwnedScrollerInsets(scroller)
+    for (scroller in ownedScrollerKeys.keys.toTypedArray()) restoreOwnedScrollerInsets(scroller)
     log(
       "host-detach generation=$attachmentGeneration inner=$selectedPage " +
         "outer=${outerPagerIndex()} nativePages=${adapter.itemCount}",

package/docs/SPEC.md

@@ -165,6 +165,28 @@ warnings were observed. Keyboard, multi-touch, physical-device performance and
 the full lifecycle/interaction matrix remain unverified. These are local source
 builds; the currently installed npm version does not yet contain this migration.
 
+## iOS vertical-scroll press cancellation
+
+Status: implemented in source. A source-identical `node_modules` build was
+runtime verified on a dedicated iOS 26.5 HomePager simulator on 2026-09-30:
+a slow drag from the Show more button did not activate it, a fling from the
+same button scrolled the list, and a stationary tap activated it. The Pager
+XCTest suite passed 47/47 tests on a separate iOS 26.5 simulator with its data
+on the external drive on 2026-09-30.
+
+In `CollapsiblePagerView` smooth-header mode, a single-finger
+vertical drag beginning on React page content MUST cancel that Surface's active
+React press before finger-up once vertical displacement reaches 10 points and
+exceeds horizontal displacement. Cancellation MUST leave the native vertical
+scroller's pan and momentum intact. Stationary taps, movement below the threshold,
+horizontal drags, and multi-touch sequences MUST retain their existing behavior.
+The iOS content press bridge owns cancellation on the UI thread; the pager's
+existing horizontal-drag cancellation remains independent. The bridge MUST clear
+per-touch state on end, cancellation, and reuse. Android and Web behavior is
+unchanged. Acceptance requires a real iOS button-origin drag that does not fire
+the button, a button-origin fling that scrolls, an ordinary tap that fires, and
+focused native touch-delivery coverage.
+
 ## Native tab-press animation default
 
 Behavior change: previously an omitted `nativeTabPressAnimationEnabled` animated
@@ -306,6 +328,24 @@ 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.
 
+When a smooth shared header is attached to the active iOS scroll view, UIKit's
+temporary refresh top inset MUST keep the header and content aligned. Both are
+children of that scroll view and move together with its content offset; the
+pager MUST NOT apply a separate refresh translation to the header. The scroll
+view's inset and offset, the refresh indicator, and refresh callback ownership
+remain unchanged. Removing the refresh inset or control preserves this alignment
+even without a scroll-offset event. Caller inset changes update the pager
+baseline. The sticky tab row MUST pin against the baseline top inset; the
+refresh control's temporary inset MUST NOT move it below the content, including
+rapid direction reversals while the spinner is active. Detaching the header
+restores its normal transform. This applies to RN NativeScroller and NativeList
+pages; non-smooth and detached headers keep
+their existing positioning. The 2026-09-30 Home Spot simulator checkpoint covers
+shared header/content alignment and inset removal. A separate source-identical
+local package build verified the sticky row during active-refresh vertical
+reversals; published-package, other Home pages and physical-device acceptance
+remain open.
+
 ## iOS shared-header hit testing
 
 Smooth-header hit forwarding is restricted to the pager's own interactive
@@ -413,3 +453,73 @@ The focused policy regression includes nonzero caller left/right/bottom padding,
 nonzero prior native insets, explicit caller padding changes/clear, and initial
 discovery before ownership. Current Home zero-padding behavior is unchanged by
 this ownership guard.
+
+## Weak padding-record cleanup
+
+Status: Implemented. Android detach/reattach acceptance passed on the
+pre-migration host described below. Remove-all and owned NativeScroller cleanup
+have source and focused regression coverage; current-host device acceptance is
+pending.
+
+### Scope and ownership
+
+This specification covers restoring child scroll insets when a collapsible pager
+detaches or removes all React children. Other pager behavior remains documented
+in the package README. Navigation animations belong to the consuming app.
+
+The native host owns its temporary inset changes and original-padding records.
+Android lifecycle callbacks and restoration run on the UI thread. Garbage
+collection can clear weak child references independently of that thread.
+
+### API, lifecycle, and identity
+
+No public props, events, defaults, or serialization formats change. Detaching
+and removing all children must restore the original insets of every still-live
+tracked RecyclerView, native ScrollView, and owned NativeScroller viewport.
+Restoration may remove entries from the tracking maps. Reattaching must remain supported.
+
+Padding records are keyed by native child identity using weak references. The
+host must not retain removed scroll children solely for later cleanup. A cleanup
+snapshot temporarily holds surviving children strongly until restoration ends.
+
+### Platforms and failure handling
+
+Android uses WeakHashMap padding records. Its snapshot must tolerate keys being
+collected between reading the collection size and enumerating it, including
+single-entry and multiple-entry maps. Collected children require no restoration;
+they must not cause NoSuchElementException. Live children must not be skipped
+because restoration changes the map.
+
+iOS uses weak-key NSMapTable records and keyEnumerator.allObjects snapshots in
+restoreDetachedScrollInsets. Its implementation is unchanged. Web has no Android
+native-padding records and is unaffected.
+
+### Resource budget
+
+Cleanup performs one snapshot and one restoration per surviving tracked child
+on the UI thread. Temporary storage is proportional to the existing padding
+records; no new persistent cache, retry, background task, or bridge traffic is
+introduced. This change makes no frame-rate claim.
+
+### Conformance and acceptance
+
+- Source: android/src/main/java/com/reactnativepagerview/CollapsiblePagerHost.kt,
+  removeAllReactChildren and onDetachedFromWindow.
+- Focused JVM regression: tests/kotlin/WeakPaddingSnapshotTest.kt checks a
+  shrinking weak-key collection and restoration that removes snapshot entries.
+- The same regression passed seven assertions on Android 36 ART using Kotlin
+  2.1.20. Compile it without additional dependencies, then run its main function.
+- Android acceptance: build the native host, repeatedly navigate from a populated
+  Market pager into stock/token details and back, and exercise modal dismissal.
+  Check native fatal logs and pager scroll/header state after returning.
+- Runtime evidence on 2026-10-08 against the pre-migration host (1e1809509):
+  four NVDA detail visits and gesture returns,
+  BTC detail, quick settings Sheet and chart settings modal dismissal, Market
+  Perps tab entry/return, and header collapse/expand passed. The app retained its
+  PID and produced no app-native fatal crash during this run.
+- Source and JVM checks do not establish native device acceptance or iOS visual
+  parity. Update runtime status only after the actual app has been exercised.
+
+The newly merged NativeScroller viewport tracking uses the same weak-key
+snapshot rule. Its cleanup has source and focused regression coverage; the
+pre-migration runtime checks above do not establish its device acceptance.

package/ios/RNCCollapsiblePagerViewComponentView.mm

@@ -1033,6 +1033,8 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
   __weak UITouch *_trackedTouch;
   UIEvent *_touchEvent;
   BOOL _multipleSurfaceTouchesObserved;
+  CGPoint _trackedTouchStartPoint;
+  BOOL _didCancelReactPressForVerticalMovement;
 }
 
 - (BOOL)canPreventGestureRecognizer:(UIGestureRecognizer *)other
@@ -1069,12 +1071,37 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
     return;
   }
   _trackedTouch = touches.anyObject;
+  _trackedTouchStartPoint = [_trackedTouch locationInView:self.view];
+  _didCancelReactPressForVerticalMovement = NO;
   [self recordEvent:event];
 }
 
 - (void)touchesMoved:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
 {
   [self recordEvent:event];
+  UITouch *touch = _trackedTouch;
+  UIGestureRecognizer *handler = self.reactTouchHandler;
+  if (touch == nil || ![touches containsObject:touch] ||
+      self.state != UIGestureRecognizerStatePossible ||
+      _didCancelReactPressForVerticalMovement || _multipleSurfaceTouchesObserved ||
+      handler.view == nil || self.view != handler.view.superview ||
+      handler.state == UIGestureRecognizerStateFailed ||
+      handler.state == UIGestureRecognizerStateCancelled ||
+      handler.state == UIGestureRecognizerStateEnded) return;
+  CGPoint point = [touch locationInView:self.view];
+  CGFloat dx = point.x - _trackedTouchStartPoint.x;
+  CGFloat dy = point.y - _trackedTouchStartPoint.y;
+  if (fabs(dy) < 10.0 || fabs(dy) <= fabs(dx)) return;
+  NSUInteger activeTouches = 0;
+  for (UITouch *activeTouch in event.allTouches) {
+    if (activeTouch.phase == UITouchPhaseEnded ||
+        activeTouch.phase == UITouchPhaseCancelled) continue;
+    if ([activeTouch.view isDescendantOfView:handler.view]) ++activeTouches;
+  }
+  if (activeTouches != 1) return;
+  _didCancelReactPressForVerticalMovement = YES;
+  handler.enabled = NO;
+  handler.enabled = YES;
 }
 
 - (void)cancelPressForPan:(UIPanGestureRecognizer *)pan
@@ -1108,6 +1135,7 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
     ? UIGestureRecognizerStateEnded : UIGestureRecognizerStateFailed;
   _trackedTouch = nil;
   _touchEvent = nil;
+  _didCancelReactPressForVerticalMovement = NO;
 }
 
 - (void)touchesCancelled:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
@@ -1117,6 +1145,7 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
     ? UIGestureRecognizerStateCancelled : UIGestureRecognizerStateFailed;
   _trackedTouch = nil;
   _touchEvent = nil;
+  _didCancelReactPressForVerticalMovement = NO;
 }
 
 - (void)reset
@@ -1125,6 +1154,7 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
   _trackedTouch = nil;
   _touchEvent = nil;
   _multipleSurfaceTouchesObserved = NO;
+  _didCancelReactPressForVerticalMovement = NO;
 }
 
 @end
@@ -2437,6 +2467,10 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
               forKeyPath:@"contentOffset"
                  options:NSKeyValueObservingOptionNew
                  context:RNCCollapsiblePagerContentOffsetContext];
+  [candidate addObserver:self
+              forKeyPath:@"contentInset"
+                 options:NSKeyValueObservingOptionNew
+                 context:RNCCollapsiblePagerContentOffsetContext];
   [candidate addObserver:self
               forKeyPath:@"contentSize"
                  options:NSKeyValueObservingOptionOld | NSKeyValueObservingOptionNew
@@ -2459,6 +2493,9 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
       [scrollView removeObserver:self
                       forKeyPath:@"contentOffset"
                          context:RNCCollapsiblePagerContentOffsetContext];
+      [scrollView removeObserver:self
+                      forKeyPath:@"contentInset"
+                         context:RNCCollapsiblePagerContentOffsetContext];
       [scrollView removeObserver:self
                       forKeyPath:@"contentSize"
                          context:RNCCollapsiblePagerContentOffsetContext];
@@ -2932,6 +2969,7 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
   if (appliedTop != nil) {
     [_appliedTopInsets setObject:@(appliedTop.doubleValue + next.top - previous.top) forKey:scrollView];
   }
+  if (scrollView == _observedScrollView) [self updateHeaderForScrollView:scrollView];
 }
 
 - (void)reapplyInsetsToObservedScrollView
@@ -2964,10 +3002,16 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
                        context:(void *)context
 {
   if (context == RNCScrollRefreshControlContext) {
-    [self updateRefreshControlForScrollView:(UIScrollView *)object];
+    UIScrollView *scrollView = (UIScrollView *)object;
+    [self updateRefreshControlForScrollView:scrollView];
+    if (scrollView == _observedScrollView) [self updateHeaderForScrollView:scrollView];
     return;
   }
   if (context == RNCCollapsiblePagerContentOffsetContext && object == _observedScrollView) {
+    if ([keyPath isEqualToString:@"contentInset"]) {
+      [self updateHeaderForScrollView:(UIScrollView *)object];
+      return;
+    }
     if ([keyPath isEqualToString:@"contentSize"]) {
       NSValue *oldSize = change[NSKeyValueChangeOldKey];
       NSValue *newSize = change[NSKeyValueChangeNewKey];
@@ -2998,9 +3042,15 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
   BOOL attachedToList = _nativeSmoothHeaderScrollEnabled &&
     _sharedHeaderScrollView != nil && !_sharedHeadersLiftedForPagerTransition;
   if (attachedToList) {
+    // The header and content share this scroll view. UIKit's refresh inset
+    // moves both together, so translating the header would separate them.
     _sharedHeaderHostView.transform = CGAffineTransformIdentity;
     _headerView.transform = CGAffineTransformIdentity;
-    CGFloat pinnedTranslation = MAX(0, _currentLogicalOffset - _headerHeight);
+    UIScrollView *scrollView = _sharedHeaderScrollView;
+    NSNumber *appliedTop = [_appliedTopInsets objectForKey:scrollView];
+    CGFloat refreshInset = scrollView.refreshControl != nil && appliedTop != nil
+      ? MAX(0, scrollView.contentInset.top - appliedTop.doubleValue) : 0;
+    CGFloat pinnedTranslation = MAX(0, _currentLogicalOffset - _headerHeight - refreshInset);
     CGAffineTransform stickyTransform = CGAffineTransformMakeTranslation(0, pinnedTranslation);
     _stickyHeaderView.transform = stickyTransform;
     _nativeTabBarView.transform = stickyTransform;

package/ios/tests/RNCCollapsiblePagerPressCancellationTests.mm

@@ -744,6 +744,59 @@ typedef struct __IOHIDEvent *RNCTestHIDEventRef;
   XCTAssertEqual(self.handler.registeredTouches, 0);
 }
 
+- (void)testVerticalPageDragCancelsReactPressBeforeFingerLifts
+{
+  [self assertFixtureIsReadyForDelivery];
+  CGPoint point = [self pressPoint];
+  UITouch *touch = [self.driver beginAt:point];
+  XCTAssertEqual(self.handler.registeredTouches, 1);
+
+  [self.driver move:touch to:CGPointMake(point.x, point.y - 12)];
+  XCTAssertEqual(self.handler.registeredTouches, 0);
+  XCTAssertTrue([self.handler.events containsObject:@"reset-cancelled"] ||
+                  [self.handler.events containsObject:@"cancelled"],
+                @"handler events %@", self.handler.events);
+  XCTAssertFalse([self.handler.events containsObject:@"ended"]);
+
+  [self.driver end:touch];
+  XCTAssertFalse([self.handler.events containsObject:@"ended"], @"events %@", self.handler.events);
+}
+
+- (void)testVerticalSiblingControlDragKeepsReactPress
+{
+  [self assertFixtureIsReadyForDelivery];
+  UIView *sibling = [RCTViewComponentView new];
+  sibling.frame = CGRectMake(160, 540, 80, 100);
+  [self.surface addSubview:sibling];
+  CGPoint point = [self pressPoint];
+  UIScrollView *pagerScrollView = [self.pager valueForKey:@"pagerScrollView"];
+  XCTAssertEqual(sibling.superview, self.pager.superview);
+  XCTAssertFalse([sibling isDescendantOfView:pagerScrollView]);
+  XCTAssertEqual([self.window hitTest:point withEvent:nil], sibling);
+
+  UITouch *touch = [self.driver beginAt:point];
+  XCTAssertEqual(self.handler.registeredTouches, 1);
+  [self.driver move:touch to:CGPointMake(point.x, point.y - 12)];
+  XCTAssertEqual(self.handler.registeredTouches, 1);
+  XCTAssertFalse([self.handler.events containsObject:@"reset-cancelled"]);
+  XCTAssertFalse([self.handler.events containsObject:@"cancelled"]);
+
+  [self.driver end:touch];
+  XCTAssertEqualObjects(self.handler.events, (@[@"began", @"moved", @"ended"]));
+  XCTAssertEqual(self.handler.registeredTouches, 0);
+}
+
+- (void)testSmallVerticalMovementKeepsReactPress
+{
+  [self assertFixtureIsReadyForDelivery];
+  CGPoint point = [self pressPoint];
+  UITouch *touch = [self.driver beginAt:point];
+  [self.driver move:touch to:CGPointMake(point.x, point.y - 8)];
+  XCTAssertEqual(self.handler.registeredTouches, 1);
+  [self.driver end:touch];
+  XCTAssertEqualObjects(self.handler.events, (@[@"began", @"moved", @"ended"]));
+}
+
 - (void)testSmallMovementBelowPanThresholdKeepsReactPress
 {
   [self assertFixtureIsReadyForDelivery];

package/ios/tests/RNCCollapsiblePagerRefreshControlTests.mm

@@ -1,9 +1,11 @@
 #import <XCTest/XCTest.h>
+#import <React/RCTViewComponentView.h>
 #import "RNCCollapsiblePagerViewComponentView.h"
 
 @interface RNCCollapsiblePagerViewComponentView (RefreshControlTesting)
 - (void)updateRefreshControlForScrollView:(UIScrollView *)scrollView;
 - (void)releaseRefreshControlForScrollView:(UIScrollView *)scrollView;
+- (void)attachScrollObserverForCurrentPage;
 @end
 
 @interface RNCCollapsiblePagerRefreshControlTests : XCTestCase
@@ -177,4 +179,71 @@
   XCTAssertTrue(control.layer.masksToBounds);
 }
 
+- (void)testRefreshTopInsetDoesNotDisplaceAttachedSharedHeader
+{
+  RNCCollapsiblePagerViewComponentView *pager = [self pagerWithHeader:64];
+  [pager mountChildComponentView:[RCTViewComponentView new] index:0];
+  [pager mountChildComponentView:[RCTViewComponentView new] index:1];
+  UIScrollView *scroll = [[UIScrollView alloc] initWithFrame:CGRectMake(0, 0, 320, 600)];
+  scroll.refreshControl = [UIRefreshControl new];
+  scroll.contentSize = CGSizeMake(320, 2000);
+  scroll.contentInset = UIEdgeInsetsMake(232, 0, 0, 0);
+  UIView *content = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 320, 2000)];
+  [scroll addSubview:content];
+  UIViewController *page = [UIViewController new];
+  [page.view addSubview:scroll];
+  NSMutableArray<UIViewController *> *pages = [pager valueForKey:@"pageControllers"];
+  [pages addObject:page];
+  [pager attachScrollObserverForCurrentPage];
+  UIView *headerHost = [pager valueForKey:@"sharedHeaderHostView"];
+  UIView *stickyHeader = [pager valueForKey:@"stickyHeaderView"];
+  UIView *tabBar = [pager valueForKey:@"nativeTabBarView"];
+  XCTAssertNotNil(stickyHeader);
+  XCTAssertEqual(stickyHeader.superview, headerHost);
+  XCTAssertEqual(headerHost.superview, scroll);
+  XCTAssertEqualWithAccuracy(scroll.contentInset.top, 340, 0.001);
+  XCTAssertEqualWithAccuracy(headerHost.transform.ty, 0, 0.001);
+
+  scroll.contentOffset = CGPointMake(0, 500);
+  CGFloat baselineStickyTranslation = stickyHeader.transform.ty;
+  CGFloat baselineTabBarTranslation = tabBar.transform.ty;
+  XCTAssertEqualWithAccuracy(baselineStickyTranslation, 776, 0.001);
+  XCTAssertEqualWithAccuracy(baselineTabBarTranslation, 776, 0.001);
+  CGPoint offset = scroll.contentOffset;
+  scroll.contentInset = UIEdgeInsetsMake(400, 0, 0, 0);
+  XCTAssertTrue(CGPointEqualToPoint(scroll.contentOffset, offset));
+  XCTAssertEqualWithAccuracy(headerHost.transform.ty, 0, 0.001);
+  XCTAssertEqualWithAccuracy(stickyHeader.transform.ty, baselineStickyTranslation, 0.001);
+  XCTAssertEqualWithAccuracy(tabBar.transform.ty, baselineTabBarTranslation, 0.001);
+  XCTAssertEqualWithAccuracy(CGRectGetMaxY(headerHost.frame), CGRectGetMinY(content.frame), 0.001);
+
+  // Exercise actual scroll notifications while the temporary refresh inset is
+  // present, including direction reversals and the sticky/unpinned boundary.
+  // The pre-fix formula adds the extra 60 points on these scroll updates.
+  for (NSNumber *nextOffset in @[@620, @450, @-300, @-340, @500]) {
+    scroll.contentOffset = CGPointMake(0, nextOffset.doubleValue);
+    CGFloat expectedTranslation = MAX(0, nextOffset.doubleValue + 340 - 64);
+    XCTAssertEqualWithAccuracy(headerHost.transform.ty, 0, 0.001);
+    XCTAssertEqualWithAccuracy(stickyHeader.transform.ty, expectedTranslation, 0.001);
+    XCTAssertEqualWithAccuracy(tabBar.transform.ty, expectedTranslation, 0.001);
+    XCTAssertEqualWithAccuracy(CGRectGetMaxY(headerHost.frame), CGRectGetMinY(content.frame), 0.001);
+  }
+
+  offset = scroll.contentOffset;
+  scroll.contentInset = UIEdgeInsetsMake(340, 0, 0, 0);
+  XCTAssertTrue(CGPointEqualToPoint(scroll.contentOffset, offset));
+  XCTAssertEqualWithAccuracy(headerHost.transform.ty, 0, 0.001);
+  XCTAssertEqualWithAccuracy(stickyHeader.transform.ty, baselineStickyTranslation, 0.001);
+  XCTAssertEqualWithAccuracy(tabBar.transform.ty, baselineTabBarTranslation, 0.001);
+
+  scroll.contentInset = UIEdgeInsetsMake(400, 0, 0, 0);
+  XCTAssertEqualWithAccuracy(headerHost.transform.ty, 0, 0.001);
+  XCTAssertEqualWithAccuracy(stickyHeader.transform.ty, baselineStickyTranslation, 0.001);
+  XCTAssertEqualWithAccuracy(tabBar.transform.ty, baselineTabBarTranslation, 0.001);
+  XCTAssertEqualWithAccuracy(CGRectGetMaxY(headerHost.frame), CGRectGetMinY(content.frame), 0.001);
+  scroll.refreshControl = nil;
+  XCTAssertEqualWithAccuracy(headerHost.transform.ty, 0, 0.001);
+  [pager prepareForRecycle];
+}
+
 @end

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/react-native-pager-view",
-  "version": "3.0.162-alpha.272",
+  "version": "3.0.163",
   "description": "React Native wrapper for Android and iOS ViewPager",
   "source": "./src/index.tsx",
   "main": "./lib/module/index.js",
@@ -51,11 +51,14 @@
   ],
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/nicholasxuu/app-modules.git",
+    "url": "git+https://github.com/OneKeyHQ/app-modules.git",
     "directory": "native-views/react-native-pager-view"
   },
   "author": "OneKey",
-  "homepage": "https://github.com/nicholasxuu/app-modules#readme",
+  "bugs": {
+    "url": "https://github.com/OneKeyHQ/app-modules/issues"
+  },
+  "homepage": "https://github.com/OneKeyHQ/app-modules/tree/main/native-views/react-native-pager-view#readme",
   "license": "MIT",
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",
@@ -69,7 +72,7 @@
     "typescript": "^5.9.2"
   },
   "peerDependencies": {
-    "@onekeyfe/react-native-native-logger": "3.0.162-alpha.272",
+    "@onekeyfe/react-native-native-logger": "3.0.163",
     "react": "*",
     "react-native": "*"
   },