@onekeyfe/react-native-pager-view 3.0.157-alpha.258 → 3.0.157-alpha.262

package/README.md

@@ -73,6 +73,10 @@ non-adjacent presses jump directly to the target without passing intermediate
 pages. Set `nativeTabPressAnimationEnabled={true}` to always animate, or `false`
 to always jump. Swipe gestures and imperative page commands are unchanged.
 
+> **Behavior change:** earlier versions animated every native tab press when
+> `nativeTabPressAnimationEnabled` was omitted. Pass
+> `nativeTabPressAnimationEnabled={true}` to keep that behavior.
+
 Thank you again to Callstack and everyone who contributes to
 `react-native-pager-view` 💙
 

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

@@ -135,8 +135,11 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
   private var observedOwnedScroller: NativeScrollerViewport? = null
   private var observedOwnedScrollerKey: String? = null
   private var observedOwnedScrollerListener: ViewTreeObserver.OnScrollChangedListener? = null
+  private var observedOwnedScrollerTreeObserver: ViewTreeObserver? = null
   private var observedNativeScroller: ScrollView? = null
   private var observedNativeScrollerListener: ViewTreeObserver.OnScrollChangedListener? = null
+  private var observedNativeScrollerTreeObserver: ViewTreeObserver? = null
+  private var observedPageRemoved = false
   private var attachmentGeneration = 0
   private val touchSlopPx = ViewConfiguration.get(context).scaledTouchSlop
   private val hostIdentity = System.identityHashCode(this)
@@ -340,6 +343,12 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
         stickyHeaderView = null
       }
       else -> {
+        val observed = observedRecyclerView ?: observedOwnedScroller ?: observedNativeScroller
+        if (observed != null && isDescendant(observed, child)) {
+          // The page detaches only later; its scroller must not keep writing this key.
+          detachPrimaryScrollObserver(recordOffset = false)
+          observedPageRemoved = true
+        }
         when (val scrollable =
           findExplicitNativeScrollerInView(child) ?: findVerticalScrollableView(child)) {
           is RecyclerView -> restoreRecyclerInsets(scrollable)
@@ -554,7 +563,8 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
     nativeTabBarView.translationY = -offset
     nativeSubHeaderView.translationY = -offset
     observedRecyclerView?.let { publishConsumedOffset(it) }
-    observedOwnedScroller?.let { publishConsumedOffset(it) }
+    // Adjacent owned pages are translated too; unchanged values are not republished.
+    for (scroller in ownedScrollerKeys.keys) publishConsumedOffset(scroller)
   }
 
   private fun pageKey(index: Int): String = pageKeys.getOrNull(index) ?: "page-$index"
@@ -647,7 +657,8 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
   private fun attachPrimaryScrollObserver() {
     if (selectedPage !in 0 until adapter.itemCount) return
     val previous = observedRecyclerView ?: observedOwnedScroller ?: observedNativeScroller
-    if (previous != null && !isDescendant(previous, adapter.pageAt(selectedPage))) {
+    if (observedPageRemoved || previous != null && !isDescendant(previous, adapter.pageAt(selectedPage))) {
+      observedPageRemoved = false
       detachPrimaryScrollObserver()
       // A replacement scroller starts at the beginning while retaining header collapse.
       pageOffsets[currentPageKey()] = 0
@@ -689,11 +700,11 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
     )
   }
 
-  private fun detachRecyclerObserver() {
+  private fun detachRecyclerObserver(recordOffset: Boolean) {
     val recycler = observedRecyclerView
     val listener = observedScrollListener
     if (recycler != null) {
-      pageOffsets[currentPageKey()] = recycler.computeVerticalScrollOffset()
+      if (recordOffset) pageOffsets[currentPageKey()] = recycler.computeVerticalScrollOffset()
       publishConsumedOffset(recycler, remove = true)
     }
     if (recycler != null && listener != null) recycler.removeOnScrollListener(listener)
@@ -716,27 +727,35 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
     detachPrimaryScrollObserver()
     observedNativeScroller = scroller
     applyNativeScrollerInsets(scroller, selectedPage)
-    val listener = ViewTreeObserver.OnScrollChangedListener {
-      val contentOffset = scroller.scrollY
-      pageOffsets[currentPageKey()] = contentOffset
-      if (contentOffset > 0 && headerOffsetPx < headerHeightPx) {
-        setHeaderOffset(headerHeightPx)
+    val listener = object : ViewTreeObserver.OnScrollChangedListener {
+      override fun onScrollChanged() {
+        if (observedNativeScrollerListener !== this) {
+          removeScrollChangedListener(null, scroller, this)
+          return
+        }
+        val contentOffset = scroller.scrollY
+        pageOffsets[currentPageKey()] = contentOffset
+        if (contentOffset > 0 && headerOffsetPx < headerHeightPx) {
+          setHeaderOffset(headerHeightPx)
+        }
       }
     }
     observedNativeScrollerListener = listener
-    scroller.viewTreeObserver.addOnScrollChangedListener(listener)
+    observedNativeScrollerTreeObserver = scroller.viewTreeObserver.also {
+      it.addOnScrollChangedListener(listener)
+    }
     log(
       "scroller-observer-attach inner=$selectedPage key=${currentPageKey()} " +
         "scroller=${System.identityHashCode(scroller)}",
     )
   }
 
-  private fun detachNativeScrollerObserver() {
+  private fun detachNativeScrollerObserver(recordOffset: Boolean) {
     val scroller = observedNativeScroller
     val listener = observedNativeScrollerListener
-    if (scroller != null) pageOffsets[currentPageKey()] = scroller.scrollY
-    if (scroller != null && listener != null && scroller.viewTreeObserver.isAlive) {
-      scroller.viewTreeObserver.removeOnScrollChangedListener(listener)
+    if (scroller != null && recordOffset) pageOffsets[currentPageKey()] = scroller.scrollY
+    if (scroller != null && listener != null) {
+      removeScrollChangedListener(observedNativeScrollerTreeObserver, scroller, listener)
     }
     if (scroller != null) {
       log(
@@ -746,12 +765,25 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
     }
     observedNativeScroller = null
     observedNativeScrollerListener = null
+    observedNativeScrollerTreeObserver = null
   }
 
-  private fun detachPrimaryScrollObserver() {
-    detachOwnedScrollerObserver()
-    detachRecyclerObserver()
-    detachNativeScrollerObserver()
+  private fun detachPrimaryScrollObserver(recordOffset: Boolean = true) {
+    detachOwnedScrollerObserver(recordOffset)
+    detachRecyclerObserver(recordOffset)
+    detachNativeScrollerObserver(recordOffset)
+  }
+
+  private fun removeScrollChangedListener(
+    registered: ViewTreeObserver?,
+    scroller: View,
+    listener: ViewTreeObserver.OnScrollChangedListener,
+  ) {
+    // A detached scroller returns a new floating observer, while the listener is
+    // still registered on the window observer. Try every instance that can own it.
+    for (observer in arrayOf(registered, scroller.viewTreeObserver, viewTreeObserver)) {
+      if (observer != null && observer.isAlive) observer.removeOnScrollChangedListener(listener)
+    }
   }
 
   private fun applyOwnedScrollerInsets(scroller: NativeScrollerViewport, pageIndex: Int) {
@@ -762,13 +794,14 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
     ownedScrollerKeys[scroller] = key
     postForCurrentAttachment {
       if (ownedScrollerKeys[scroller] == key && scroller.isAttachedToWindow) {
-        scroller.scrollTo(0, pageOffsets[key] ?: 0)
+        scroller.host.restoreScrollOffset(pageOffsets[key] ?: 0)
       }
     }
   }
 
   private fun restoreOwnedScrollerInsets(scroller: NativeScrollerViewport) {
     scroller.stopMotion()
+    scroller.host.cancelPendingScrollRestore()
     ownedScrollerKeys.remove(scroller)
     publishConsumedOffset(scroller, remove = true)
     scroller.host.setPagerInset(this, null)
@@ -784,26 +817,35 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
     observedOwnedScrollerKey = currentPageKey()
     val key = currentPageKey()
     applyOwnedScrollerInsets(scroller, selectedPage)
-    val listener = ViewTreeObserver.OnScrollChangedListener {
-      val contentOffset = scroller.scrollY
-      pageOffsets[key] = contentOffset
-      if (contentOffset > 0 && headerOffsetPx < headerHeightPx) setHeaderOffset(headerHeightPx)
+    val listener = object : ViewTreeObserver.OnScrollChangedListener {
+      override fun onScrollChanged() {
+        if (observedOwnedScrollerListener !== this) {
+          removeScrollChangedListener(null, scroller, this)
+          return
+        }
+        val contentOffset = scroller.scrollY
+        pageOffsets[key] = contentOffset
+        if (contentOffset > 0 && headerOffsetPx < headerHeightPx) setHeaderOffset(headerHeightPx)
+      }
     }
     observedOwnedScrollerListener = listener
-    scroller.viewTreeObserver.addOnScrollChangedListener(listener)
+    observedOwnedScrollerTreeObserver = scroller.viewTreeObserver.also {
+      it.addOnScrollChangedListener(listener)
+    }
   }
 
-  private fun detachOwnedScrollerObserver() {
+  private fun detachOwnedScrollerObserver(recordOffset: Boolean) {
     val scroller = observedOwnedScroller ?: return
     scroller.stopMotion()
     publishConsumedOffset(scroller, remove = true)
-    observedOwnedScrollerKey?.let { pageOffsets[it] = scroller.scrollY }
+    if (recordOffset) observedOwnedScrollerKey?.let { pageOffsets[it] = scroller.scrollY }
     observedOwnedScrollerListener?.let {
-      if (scroller.viewTreeObserver.isAlive) scroller.viewTreeObserver.removeOnScrollChangedListener(it)
+      removeScrollChangedListener(observedOwnedScrollerTreeObserver, scroller, it)
     }
     observedOwnedScroller = null
     observedOwnedScrollerKey = null
     observedOwnedScrollerListener = null
+    observedOwnedScrollerTreeObserver = null
   }
 
   private fun applyRecyclerInsets(recycler: RecyclerView, pageIndex: Int) {

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

@@ -0,0 +1,26 @@
+package com.reactnativepagerview
+
+/**
+ * A pager-owned offset restoration that NestedScrollView clamped because the
+ * React content height had not reached native yet. It is reapplied on content
+ * layout until reached or cancelled by user/command/content replacement.
+ */
+internal class NativeScrollerPendingRestore {
+  var target: Int? = null
+    private set
+
+  fun request(target: Int, reached: Int) {
+    this.target = if (reached == target) null else target
+  }
+
+  /** The offset to reapply after a content layout pass. */
+  fun anchor(current: Int): Int = target ?: current
+
+  fun settle(reached: Int) {
+    if (target == reached) target = null
+  }
+
+  fun cancel() {
+    target = null
+  }
+}

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

@@ -64,6 +64,8 @@ class NativeScrollerView(context: Context) : FrameLayout(context) {
   private var lastScrollEvent = 0L
   private var laidOut = false
   private var requestedRefresh = false
+  private var refreshStatePending = false
+  private val pendingRestore = NativeScrollerPendingRestore()
   private var refreshOffset = 0
   private var appliedRefreshOffset: Int? = null
   private var appliedRefreshSize = SwipeRefreshLayout.DEFAULT
@@ -175,6 +177,7 @@ class NativeScrollerView(context: Context) : FrameLayout(context) {
 
   internal fun removeReactChild() {
     viewport.stopMotion()
+    pendingRestore.cancel()
     reactChild?.let(contentOriginFrame::removeView)
     reactChild = null
     contentWidthPx = 0
@@ -221,19 +224,35 @@ class NativeScrollerView(context: Context) : FrameLayout(context) {
     )
     refresh.layout(0, 0, width, height)
     // Reapply the current anchor after content shrink; NestedScrollView clamps it.
-    viewport.scrollTo(x, y)
+    // A pager restoration clamped before content reached native resumes as it grows.
+    viewport.scrollTo(x, pendingRestore.anchor(y))
+    pendingRestore.settle(viewport.scrollY)
     laidOut = true
     publishContentViewport()
     publishContentOrigin()
     applyRefreshOffset()
-    if (refresh.isRefreshing != requestedRefresh) refresh.isRefreshing = requestedRefresh
+    // Apply only a prop received before the first layout. Reapplying it on later
+    // layouts would hide a gesture-started spinner before JS commits refreshing.
+    if (refreshStatePending) {
+      refreshStatePending = false
+      if (refresh.isRefreshing != requestedRefresh) refresh.isRefreshing = requestedRefresh
+    }
   }
 
   internal fun setRefreshing(value: Boolean) {
     requestedRefresh = value
-    if (laidOut) refresh.isRefreshing = value
+    if (laidOut) refresh.isRefreshing = value else refreshStatePending = true
+  }
+
+  /** Scrolls to a pager-owned saved offset, retrying while content is too short to reach it. */
+  internal fun restoreScrollOffset(y: Int) {
+    val target = y.coerceAtLeast(0)
+    viewport.scrollTo(0, target)
+    pendingRestore.request(target, viewport.scrollY)
   }
 
+  internal fun cancelPendingScrollRestore() = pendingRestore.cancel()
+
   internal fun setRefreshOffset(value: Int) {
     refreshOffset = value
     applyRefreshOffset()
@@ -273,6 +292,7 @@ class NativeScrollerView(context: Context) : FrameLayout(context) {
 
   internal fun scrollToPosition(x: Int, y: Int, animated: Boolean) {
     viewport.stopMotion()
+    pendingRestore.cancel()
     if (animated) viewport.scrollToAnimated(y)
     else viewport.scrollTo(0, y.coerceAtLeast(0))
     emitScroll(force = true)
@@ -395,6 +415,7 @@ internal class NativeScrollerViewport(context: Context, internal val host: Nativ
   // Record at the refresh boundary so interception does not truncate the pointer history.
   internal fun recordTouchEvent(event: MotionEvent) {
     if (event.actionMasked == MotionEvent.ACTION_DOWN) {
+      host.cancelPendingScrollRestore()
       stopMotion()
       velocityTracker = VelocityTracker.obtain()
       activePointerId = event.getPointerId(0)
@@ -422,6 +443,8 @@ internal class NativeScrollerViewport(context: Context, internal val host: Nativ
   internal fun beginDrag(event: MotionEvent) {
     if (dragging) return
     dragging = true
+    // Header-forwarded touches bypass the refresh boundary's touch stream.
+    host.cancelPendingScrollRestore()
     if (host.keyboardDismissMode != "none") host.dismissKeyboard()
     NativeGestureUtil.notifyNativeGestureStarted(host, event)
     host.emitLifecycle("topScrollBeginDrag")
@@ -481,13 +504,17 @@ internal class NativeScrollerViewport(context: Context, internal val host: Nativ
       try { endDrag(cancel) } finally { cancel.recycle() }
     }
     releaseTouchTracking()
-    stopping = true
-    try {
-      // Replace the same AndroidX trajectory with zero velocity without touching its smooth-scroll clock.
-      super.fling(0)
-      super.stopNestedScroll(ViewCompat.TYPE_NON_TOUCH)
-    } finally {
-      stopping = false
+    // An idle view has nothing to stop. A zero fling would still start and stop a
+    // non-touch nested scroll, which ancestors observe as a finished gesture.
+    if (momentum || hasNestedScrollingParent(ViewCompat.TYPE_NON_TOUCH)) {
+      stopping = true
+      try {
+        // Replace the same AndroidX trajectory with zero velocity without touching its smooth-scroll clock.
+        super.fling(0)
+        super.stopNestedScroll(ViewCompat.TYPE_NON_TOUCH)
+      } finally {
+        stopping = false
+      }
     }
     finishMomentum()
   }

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

@@ -2,7 +2,9 @@ package com.reactnativepagerview
 
 import android.graphics.Color
 import android.view.View
+import com.facebook.react.bridge.ColorPropConverter
 import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableType
 import com.facebook.react.module.annotations.ReactModule
 import com.facebook.react.uimanager.ReactStylesDiffMap
 import com.facebook.react.uimanager.StateWrapper
@@ -100,7 +102,20 @@ class NativeScrollerViewManager : ViewGroupManager<NativeScrollerView>(),
   }
   @ReactProp(name = "refreshColors", customType = "ColorArray")
   override fun setRefreshColors(view: NativeScrollerView, value: ReadableArray?) {
-    view.setRefreshColors(if (value == null) intArrayOf(Color.GRAY) else IntArray(value.size()) { value.getInt(it) })
+    if (value == null) {
+      view.setRefreshColors(intArrayOf(Color.GRAY))
+      return
+    }
+    val colors = ArrayList<Int>(value.size())
+    for (index in 0 until value.size()) {
+      // PlatformColor/DynamicColorIOS values arrive as maps, as in RN's SwipeRefreshLayoutManager.
+      when (value.getType(index)) {
+        ReadableType.Map -> ColorPropConverter.getColor(value.getMap(index), view.context)?.let(colors::add)
+        ReadableType.Number -> colors.add(value.getInt(index))
+        else -> Unit
+      }
+    }
+    view.setRefreshColors(colors.toIntArray())
   }
   @ReactProp(name = "refreshProgressBackgroundColor", customType = "Color")
   override fun setRefreshProgressBackgroundColor(view: NativeScrollerView, value: Int?) =

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

@@ -0,0 +1,31 @@
+package com.reactnativepagerview
+
+/** Standalone JVM regression: compile together with the production helper. */
+fun main() {
+  val restore = NativeScrollerPendingRestore()
+
+  // Reachable immediately: nothing remains pending and layout keeps the current anchor.
+  restore.request(target = 640, reached = 640)
+  check(restore.target == null)
+  check(restore.anchor(320) == 320)
+
+  // Content height has not reached native: NestedScrollView clamped the request to 0.
+  restore.request(target = 640, reached = 0)
+  check(restore.target == 640)
+  check(restore.anchor(0) == 640)
+  // Partial growth keeps retrying the original target, not the partially clamped offset.
+  restore.settle(reached = 300)
+  check(restore.target == 640)
+  check(restore.anchor(300) == 640)
+  // Once reached, later layouts keep the live position again.
+  restore.settle(reached = 640)
+  check(restore.target == null)
+  check(restore.anchor(900) == 900)
+
+  // User touch, commands and content replacement cancel a pending target.
+  restore.request(target = 480, reached = 120)
+  restore.cancel()
+  check(restore.target == null)
+  check(restore.anchor(120) == 120)
+  println("Native scroller pending restore: clamp retry, partial growth, settle and cancel passed")
+}

package/docs/SPEC.md

@@ -96,7 +96,13 @@ position emits no new pair. A new command ends any previous active sequence
 before starting its own, and non-animated movement does not start momentum;
 recycled views MUST NOT emit into an old owner. Content shrink clamps unreachable
 offsets without a blank tail; resize/inset changes MUST NOT accumulate offsets.
+On Android, a pager offset restoration that is clamped because React content has
+not reached native yet is reapplied on content layout until reached; a new touch,
+drag, scroll command, content-root replacement or pager release cancels it.
+Stopping an idle scroller MUST NOT start or end a non-touch nested scroll.
 Refresh is controlled by the caller and emits once per qualifying gesture.
+Android applies a refreshing value when it changes (or at first layout); later
+layout passes do not reassert it over a gesture-started indicator.
 
 Acceptance requires both native builds, focused contract checks and iOS/Android
 recordings: expanded/collapsed Home Spot/Perps/DeFi, short/empty and dynamically
@@ -161,17 +167,22 @@ builds; the currently installed npm version does not yet contain this migration.
 
 ## Native tab-press animation default
 
+Behavior change: previously an omitted `nativeTabPressAnimationEnabled` animated
+every native tab press. Callers that relied on that default MUST pass `true`.
+
 On iOS and Android, an omitted `nativeTabPressAnimationEnabled` MUST animate a
 press to an adjacent page and jump directly to a non-adjacent page. Adjacency is
-the absolute difference between the target index and the currently selected
-index, not the last requested target. Explicit `true` continues to animate all
+the absolute difference between the target index and the current page. While a
+tab command that native has already received is in flight, its target is the
+current page; otherwise it is the selected index. A request superseded before it
+reached native is ignored. Explicit `true` continues to animate all
 tab presses, and explicit `false` continues to jump for all tab presses.
 Page retention, selection callbacks, swipe gestures, imperative `setPage` /
 `setPageWithoutAnimation` commands and Web behavior retain their contracts.
 Callers rendering their own JS tab bar choose the matching imperative command.
 
-Status: implemented; focused native-wrapper tests cover both directions and
-explicit overrides. Home applies this policy to its JS tab bar, with iOS and
+Status: implemented; focused native-wrapper tests cover both directions,
+explicit overrides and in-flight/superseded command targets. Home applies this policy to its JS tab bar, with iOS and
 Android simulator recordings verifying distant jumps and adjacent transitions.
 
 ## Android refresh foreground coordination
@@ -355,6 +366,10 @@ A new child receives current header travel before threshold evaluation. Native
 list offsets remain local to the leaf, while consumers of this protocol add all
 ancestor contributions exactly once. Programmatic scrolling/header restoration
 must publish the resulting header offset through the same path.
+Every NativeScroller viewport the coordinator owns, including adjacent pages it
+translates, receives each header offset change, not only the observed page.
+Content-offset observers are removed from the observer instance they were
+registered on, and a removed page's scroller stops writing offsets immediately.
 
 ## Acceptance
 

package/ios/tests/RNCCollapsiblePagerPressCancellationTests.mm

@@ -1,6 +1,202 @@
 #import <XCTest/XCTest.h>
 #import <UIKit/UIGestureRecognizerSubclass.h>
 #import <React/RCTSurfaceTouchHandler.h>
+#import <React/RCTViewComponentView.h>
+#import <dlfcn.h>
+#import <mach/mach_time.h>
+#import <objc/message.h>
+
+#import "RNCCollapsiblePagerViewComponentView.h"
+#import <react/renderer/components/pagerview/Props.h>
+
+using namespace facebook::react;
+
+#pragma mark - UIKit gesture environment and touch delivery
+
+// Pod unit tests run in xctest without an application. UIKit then has no
+// gesture environment: every programmatic recognizer state change, including
+// Began on a plain UIGestureRecognizer, is dropped. Create the application
+// singleton (what UIApplicationMain does first) so recognizers run under the
+// real UIGestureEnvironment. Touches below are delivered through
+// -[UIWindow sendEvent:], the path UIApplication uses for touch events, using
+// the same private UITouch/UIEvent/IOHIDEvent calls as KIF. These are
+// test-only; a missing symbol fails the test instead of skipping it.
+@interface RNCPressCancellationTestApplication : UIApplication
+@end
+
+@implementation RNCPressCancellationTestApplication
+// UIApplicationMain never ran, so there is no event run loop. UIScrollView
+// pushes a tracking run-loop mode when its real pan begins; scheduling is
+// outside the recognizer semantics under test.
+- (void)_pushRunLoopMode:(id)mode requester:(id)requester reason:(id)reason {}
+- (void)_popRunLoopMode:(id)mode requester:(id)requester reason:(id)reason {}
+@end
+
+static BOOL RNCEnsureUIKitGestureEnvironment(void)
+{
+  if (UIApplication.sharedApplication != nil) return YES;
+  void (*instantiate)(Class) =
+    (void (*)(Class))dlsym(RTLD_DEFAULT, "UIApplicationInstantiateSingleton");
+  if (instantiate == NULL) return NO;
+  instantiate(RNCPressCancellationTestApplication.class);
+  return UIApplication.sharedApplication != nil;
+}
+
+typedef struct __IOHIDEvent *RNCTestHIDEventRef;
+
+@interface UITouch (RNCPressCancellationSynthesis)
+- (void)setWindow:(UIWindow *)window;
+- (void)setView:(UIView *)view;
+- (void)setGestureView:(UIView *)view;
+- (void)setPhase:(UITouchPhase)phase;
+- (void)setTimestamp:(NSTimeInterval)timestamp;
+- (void)setTapCount:(NSUInteger)tapCount;
+- (void)_setLocationInWindow:(CGPoint)location resetPrevious:(BOOL)resetPrevious;
+- (void)_setIsTapToClick:(BOOL)isTapToClick;
+- (void)_setHidEvent:(RNCTestHIDEventRef)event;
+@end
+
+@interface UIEvent (RNCPressCancellationSynthesis)
+- (instancetype)_init;
+- (void)_clearTouches;
+- (void)_addTouch:(UITouch *)touch forDelayedDelivery:(BOOL)delayed;
+- (void)_setHIDEvent:(RNCTestHIDEventRef)event;
+@end
+
+// Delivers one finger or several simultaneous fingers through a window.
+@interface RNCSynthesizedTouchDriver : NSObject
+- (instancetype)initWithWindow:(UIWindow *)window;
+@property (nonatomic, readonly) NSString *unavailableReason;
+- (UITouch *)beginAt:(CGPoint)windowPoint;
+- (void)move:(UITouch *)touch to:(CGPoint)windowPoint;
+- (void)end:(UITouch *)touch;
+@end
+
+@implementation RNCSynthesizedTouchDriver {
+  UIWindow *_window;
+  UIEvent *_event;
+  NSMutableArray<UITouch *> *_activeTouches;
+  NSTimeInterval _timestamp;
+  RNCTestHIDEventRef (*_createHand)(CFAllocatorRef, uint64_t, uint32_t, uint32_t, uint32_t,
+                                    uint32_t, uint32_t, double, double, double, double, double,
+                                    Boolean, Boolean, uint32_t);
+  RNCTestHIDEventRef (*_createFinger)(CFAllocatorRef, uint64_t, uint32_t, uint32_t, uint32_t,
+                                      double, double, double, double, double, double, double,
+                                      double, double, double, Boolean, Boolean, uint32_t);
+  void (*_setIntegerValue)(RNCTestHIDEventRef, uint32_t, long, uint32_t);
+  void (*_appendEvent)(RNCTestHIDEventRef, RNCTestHIDEventRef, uint32_t);
+  void (*_setSenderID)(RNCTestHIDEventRef, uint64_t);
+}
+
+- (instancetype)initWithWindow:(UIWindow *)window
+{
+  if (self = [super init]) {
+    _window = window;
+    _activeTouches = [NSMutableArray new];
+    _timestamp = NSProcessInfo.processInfo.systemUptime;
+    void *iokit = dlopen("/System/Library/Frameworks/IOKit.framework/IOKit", RTLD_NOW);
+    _createHand = (decltype(_createHand))dlsym(iokit, "IOHIDEventCreateDigitizerEvent");
+    _createFinger =
+      (decltype(_createFinger))dlsym(iokit, "IOHIDEventCreateDigitizerFingerEventWithQuality");
+    _setIntegerValue =
+      (decltype(_setIntegerValue))dlsym(iokit, "IOHIDEventSetIntegerValueWithOptions");
+    _appendEvent = (decltype(_appendEvent))dlsym(iokit, "IOHIDEventAppendEvent");
+    _setSenderID = (decltype(_setSenderID))dlsym(iokit, "IOHIDEventSetSenderID");
+    Class eventClass = NSClassFromString(@"UITouchesEvent");
+    if (!RNCEnsureUIKitGestureEnvironment()) {
+      _unavailableReason = @"UIApplication singleton unavailable";
+    } else if (_createHand == NULL || _createFinger == NULL || _setIntegerValue == NULL ||
+               _appendEvent == NULL || _setSenderID == NULL) {
+      _unavailableReason = @"IOHIDEvent symbols unavailable";
+    } else if (eventClass == Nil || ![eventClass instancesRespondToSelector:@selector(_init)] ||
+               ![eventClass instancesRespondToSelector:@selector(_addTouch:forDelayedDelivery:)] ||
+               ![UITouch instancesRespondToSelector:@selector(_setLocationInWindow:resetPrevious:)] ||
+               ![UITouch instancesRespondToSelector:@selector(_setHidEvent:)]) {
+      _unavailableReason = @"UITouch/UITouchesEvent synthesis selectors unavailable";
+    } else {
+      _event = [[eventClass alloc] _init];
+    }
+  }
+  return self;
+}
+
+- (RNCTestHIDEventRef)newHIDEvent
+{
+  static const uint32_t kDigitizerDisplayIntegrated = (11 << 16) | 25;
+  static const uint32_t kIsBuiltIn = 4;
+  static const uint32_t kOptions = (uint32_t)-268435456;
+  uint64_t machTime = mach_absolute_time();
+  // Hand transducer, touch mask.
+  RNCTestHIDEventRef hand =
+    _createHand(kCFAllocatorDefault, machTime, 3, 0, 0, 1 << 1, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+  _setIntegerValue(hand, kDigitizerDisplayIntegrated, 1, kOptions);
+  _setIntegerValue(hand, kIsBuiltIn, 1, kOptions);
+  _setSenderID(hand, 0x000000010000027F);
+  uint32_t index = 0;
+  for (UITouch *touch in _activeTouches) {
+    UITouchPhase phase = touch.phase;
+    // Position for moves; range and touch for contact changes.
+    uint32_t mask = phase == UITouchPhaseMoved ? (1 << 2) : ((1 << 0) | (1 << 1));
+    Boolean down = phase != UITouchPhaseEnded && phase != UITouchPhaseCancelled;
+    CGPoint point = [touch locationInView:_window];
+    RNCTestHIDEventRef finger = _createFinger(kCFAllocatorDefault, machTime, ++index, 2, mask,
+                                              point.x, point.y, 0, 0, 0, 5, 5, 1, 1, 1,
+                                              down, down, 0);
+    _setIntegerValue(finger, kDigitizerDisplayIntegrated, 1, kOptions);
+    _appendEvent(hand, finger, 0);
+    CFRelease(finger);
+  }
+  return hand;
+}
+
+- (void)sendChangingTouch:(UITouch *)changed phase:(UITouchPhase)phase
+{
+  NSAssert(_event != nil, @"%@", _unavailableReason);
+  _timestamp += 1.0 / 60.0;
+  for (UITouch *touch in _activeTouches) {
+    [touch setPhase:touch == changed ? phase : UITouchPhaseStationary];
+    [touch setTimestamp:_timestamp];
+  }
+  RNCTestHIDEventRef hid = [self newHIDEvent];
+  for (UITouch *touch in _activeTouches) [touch _setHidEvent:hid];
+  [_event _setHIDEvent:hid];
+  if (phase == UITouchPhaseBegan) [_event _addTouch:changed forDelayedDelivery:NO];
+  CFRelease(hid);
+  [_window sendEvent:_event];
+  if (phase == UITouchPhaseEnded || phase == UITouchPhaseCancelled) {
+    [_activeTouches removeObjectIdenticalTo:changed];
+    if (_activeTouches.count == 0) [_event _clearTouches];
+  }
+}
+
+- (UITouch *)beginAt:(CGPoint)windowPoint
+{
+  if (_activeTouches.count == 0) [_event _clearTouches];
+  UITouch *touch = [UITouch new];
+  UIView *view = [_window hitTest:windowPoint withEvent:nil];
+  [touch setWindow:_window];
+  [touch _setLocationInWindow:windowPoint resetPrevious:YES];
+  [touch setView:view];
+  if ([touch respondsToSelector:@selector(setGestureView:)]) [touch setGestureView:view];
+  [touch _setIsTapToClick:NO];
+  [touch setTapCount:1];
+  [_activeTouches addObject:touch];
+  [self sendChangingTouch:touch phase:UITouchPhaseBegan];
+  return touch;
+}
+
+- (void)move:(UITouch *)touch to:(CGPoint)windowPoint
+{
+  [touch _setLocationInWindow:windowPoint resetPrevious:NO];
+  [self sendChangingTouch:touch phase:UITouchPhaseMoved];
+}
+
+- (void)end:(UITouch *)touch
+{
+  [self sendChangingTouch:touch phase:UITouchPhaseEnded];
+}
+
+@end
 
 // Private declarations access the production class compiled into the pod.
 @interface RNCCollapsiblePagerContentPressCancellationGestureRecognizer : UIGestureRecognizer
@@ -9,8 +205,8 @@
 - (void)observeIncomingTouch:(UITouch *)touch;
 @end
 
-// UIKit can reset terminal states immediately outside real touch delivery.
-// Observe requests while retaining the production implementation and UIKit setter.
+// Terminal states are reset by UIKit once it processes them. Observe requests
+// while retaining the production implementation and UIKit setter.
 @interface RNCPressCancellationObservedBridge : RNCCollapsiblePagerContentPressCancellationGestureRecognizer
 @property (nonatomic, strong) NSMutableArray<NSNumber *> *requestedStates;
 @end
@@ -23,8 +219,9 @@
 }
 @end
 
-// These doubles supply input facts only. The production bridge owns its state
-// transitions; this suite does not claim to synthesize UIKit touch delivery.
+// These doubles supply input facts to the bridge's decision logic directly.
+// The production bridge owns its state transitions. End-to-end UIKit delivery
+// through the real pager is covered by the delivery suite below.
 @interface RNCPressCancellationTestTouch : UITouch
 @property (nonatomic, strong) UIView *testView;
 @property (nonatomic, assign) UITouchPhase testPhase;
@@ -49,6 +246,7 @@
 @end
 
 @interface RNCCollapsiblePagerPressCancellationTests : XCTestCase
+@property (nonatomic, strong) UIWindow *window;
 @property (nonatomic, strong) UIView *host;
 @property (nonatomic, strong) UIView *surface;
 @property (nonatomic, strong) UIView *content;
@@ -63,9 +261,16 @@
 - (void)setUp
 {
   [super setUp];
+  XCTAssertTrue(NSThread.isMainThread);
+  // Without an application UIKit drops every programmatic recognizer state.
+  XCTAssertTrue(RNCEnsureUIKitGestureEnvironment());
+  // Register the recognizers with a UIKit gesture environment without taking focus.
+  self.window = [[UIWindow alloc] initWithFrame:CGRectMake(0, 0, 320, 600)];
+  self.window.hidden = NO;
   self.host = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 320, 600)];
   self.surface = [[UIView alloc] initWithFrame:self.host.bounds];
   self.content = [[UIView alloc] initWithFrame:self.surface.bounds];
+  [self.window addSubview:self.host];
   [self.host addSubview:self.surface];
   [self.surface addSubview:self.content];
   self.handler = [RCTSurfaceTouchHandler new];
@@ -75,6 +280,8 @@
   self.bridge = [RNCPressCancellationObservedBridge new];
   self.bridge.reactTouchHandler = self.handler;
   [self.host addGestureRecognizer:self.bridge];
+  XCTAssertEqual(self.bridge.view.window, self.window);
+  XCTAssertEqual(self.handler.view.window, self.window);
   self.pan = [RNCPressCancellationTestPan new];
   self.pan.testState = UIGestureRecognizerStateBegan;
   self.touch = [self touchInView:self.content phase:UITouchPhaseBegan];
@@ -90,7 +297,10 @@
   self.pan = nil;
   self.content = nil;
   self.surface = nil;
+  [self.host removeFromSuperview];
   self.host = nil;
+  self.window.hidden = YES;
+  self.window = nil;
   [super tearDown];
 }
 
@@ -143,6 +353,8 @@
   }
   self.pan.testState = UIGestureRecognizerStateBegan;
   [self.bridge cancelPressForPan:self.pan];
+  XCTAssertTrue([self.bridge.requestedStates containsObject:@(UIGestureRecognizerStateBegan)],
+                @"The production bridge must request recognition before UIKit retains Began");
   XCTAssertEqual(self.bridge.state, UIGestureRecognizerStateBegan);
 }
 
@@ -178,6 +390,8 @@
   [self.bridge touchesBegan:[NSSet setWithObject:self.touch]
                  withEvent:[self eventWithTouches:[NSSet setWithObjects:self.touch, other, ended, cancelled, nil]]];
   [self.bridge cancelPressForPan:self.pan];
+  XCTAssertTrue([self.bridge.requestedStates containsObject:@(UIGestureRecognizerStateBegan)],
+                @"The production bridge must request recognition before UIKit retains Began");
   XCTAssertEqual(self.bridge.state, UIGestureRecognizerStateBegan);
 }
 
@@ -196,6 +410,8 @@
 {
   [self beginSingleTouch];
   [self.bridge cancelPressForPan:self.pan];
+  XCTAssertTrue([self.bridge.requestedStates containsObject:@(UIGestureRecognizerStateBegan)],
+                @"The production bridge must request recognition before UIKit retains Began");
   XCTAssertEqual(self.bridge.state, UIGestureRecognizerStateBegan);
   RNCPressCancellationTestTouch *second = [self touchInView:self.content phase:UITouchPhaseBegan];
   RNCPressCancellationTestEvent *event =
@@ -247,6 +463,8 @@
   [self.bridge reset];
   [self beginSingleTouch];
   [self.bridge cancelPressForPan:self.pan];
+  XCTAssertTrue([self.bridge.requestedStates containsObject:@(UIGestureRecognizerStateBegan)],
+                @"The production bridge must request recognition before UIKit retains Began");
   XCTAssertEqual(self.bridge.state, UIGestureRecognizerStateBegan);
 }
 
@@ -258,6 +476,8 @@
   [self beginSingleTouch];
   [self.bridge observeIncomingTouch:second];
   [self.bridge cancelPressForPan:self.pan];
+  XCTAssertTrue([self.bridge.requestedStates containsObject:@(UIGestureRecognizerStateBegan)],
+                @"The production bridge must request recognition before UIKit retains Began");
   XCTAssertEqual(self.bridge.state, UIGestureRecognizerStateBegan);
 }
 
@@ -279,6 +499,8 @@
   XCTAssertEqual(self.bridge.state, UIGestureRecognizerStatePossible);
   [self beginSingleTouch];
   [self.bridge cancelPressForPan:self.pan];
+  XCTAssertTrue([self.bridge.requestedStates containsObject:@(UIGestureRecognizerStateBegan)],
+                @"The production bridge must request recognition before UIKit retains Began");
   XCTAssertEqual(self.bridge.state, UIGestureRecognizerStateBegan);
 }
 
@@ -290,6 +512,8 @@
     weakEvent = event;
     [self.bridge touchesBegan:[NSSet setWithObject:self.touch] withEvent:event];
     [self.bridge cancelPressForPan:self.pan];
+    XCTAssertTrue([self.bridge.requestedStates containsObject:@(UIGestureRecognizerStateBegan)],
+                  @"The production bridge must request recognition before UIKit retains Began");
     XCTAssertEqual(self.bridge.state, UIGestureRecognizerStateBegan);
     self.touch.testPhase = UITouchPhaseEnded;
     [self.bridge touchesEnded:[NSSet setWithObject:self.touch] withEvent:event];
@@ -318,6 +542,8 @@
 {
   [self beginSingleTouch];
   [self.bridge cancelPressForPan:self.pan];
+  XCTAssertTrue([self.bridge.requestedStates containsObject:@(UIGestureRecognizerStateBegan)],
+                @"The production bridge must request recognition before UIKit retains Began");
   XCTAssertEqual(self.bridge.state, UIGestureRecognizerStateBegan);
   self.touch.testPhase = UITouchPhaseCancelled;
   [self.bridge touchesCancelled:[NSSet setWithObject:self.touch]
@@ -344,3 +570,190 @@
 }
 
 @end
+
+#pragma mark - Real UIKit delivery through the production pager
+
+// Records what RN's Fabric touch handler observes. Its reset dispatches
+// touchCancel for every still-registered touch, which is how a Pressable loses
+// its press when an external recognizer prevents the handler.
+@interface RNCRecordingSurfaceTouchHandler : RCTSurfaceTouchHandler
+@property (nonatomic, strong) NSMutableArray<NSString *> *events;
+@property (nonatomic, assign) NSInteger registeredTouches;
+@end
+
+@implementation RNCRecordingSurfaceTouchHandler
+- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+{
+  [super touchesBegan:touches withEvent:event];
+  self.registeredTouches += touches.count;
+  [self.events addObject:@"began"];
+}
+- (void)touchesMoved:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+{
+  [super touchesMoved:touches withEvent:event];
+  if (![self.events.lastObject isEqualToString:@"moved"]) [self.events addObject:@"moved"];
+}
+- (void)touchesEnded:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+{
+  [super touchesEnded:touches withEvent:event];
+  self.registeredTouches -= touches.count;
+  [self.events addObject:@"ended"];
+}
+- (void)touchesCancelled:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+{
+  [super touchesCancelled:touches withEvent:event];
+  self.registeredTouches -= touches.count;
+  [self.events addObject:@"cancelled"];
+}
+- (void)reset
+{
+  NSInteger pending = self.registeredTouches;
+  [super reset];
+  self.registeredTouches = 0;
+  if (pending > 0) [self.events addObject:@"reset-cancelled"];
+}
+@end
+
+@interface RNCCollapsiblePagerPressCancellationDeliveryTests : XCTestCase
+@property (nonatomic, strong) UIWindow *window;
+@property (nonatomic, strong) UIView *surface;
+@property (nonatomic, strong) RNCRecordingSurfaceTouchHandler *handler;
+@property (nonatomic, strong) RNCCollapsiblePagerViewComponentView *pager;
+@property (nonatomic, strong) RNCSynthesizedTouchDriver *driver;
+@property (nonatomic, strong) UIView *firstPage;
+@end
+
+@implementation RNCCollapsiblePagerPressCancellationDeliveryTests
+
+- (void)setUp
+{
+  [super setUp];
+  self.window = [[UIWindow alloc] initWithFrame:CGRectMake(0, 0, 390, 800)];
+  self.window.hidden = NO;
+  UIView *host = [[UIView alloc] initWithFrame:self.window.bounds];
+  self.surface = [[UIView alloc] initWithFrame:host.bounds];
+  [self.window addSubview:host];
+  [host addSubview:self.surface];
+  self.handler = [RNCRecordingSurfaceTouchHandler new];
+  self.handler.events = [NSMutableArray new];
+  [self.handler attachToView:self.surface];
+
+  self.pager = [RNCCollapsiblePagerViewComponentView new];
+  auto props = std::make_shared<RNCCollapsiblePagerViewProps>();
+  props->nativeSmoothHeaderScrollEnabled = true;
+  props->headerHeight = 120;
+  props->stickyHeaderHeight = 44;
+  [self.pager updateProps:props oldProps:nullptr];
+  self.pager.frame = self.surface.bounds;
+  [self.surface addSubview:self.pager];
+  NSArray<UIView<RCTComponentViewProtocol> *> *children = @[
+    [RCTViewComponentView new],  // header
+    [RCTViewComponentView new],  // sticky header
+    [RCTViewComponentView new],  // page 0
+    [RCTViewComponentView new],  // page 1
+  ];
+  children[0].frame = CGRectMake(0, 0, 390, 120);
+  children[1].frame = CGRectMake(0, 0, 390, 44);
+  [children enumerateObjectsUsingBlock:^(UIView<RCTComponentViewProtocol> *child,
+                                         NSUInteger index,
+                                         BOOL *stop) {
+    [self.pager mountChildComponentView:child index:(NSInteger)index];
+  }];
+  self.firstPage = children[2];
+  [self.window layoutIfNeeded];
+  [self drainMainQueue];
+  self.firstPage.frame = self.firstPage.superview.bounds;
+  self.driver = [[RNCSynthesizedTouchDriver alloc] initWithWindow:self.window];
+}
+
+- (void)tearDown
+{
+  [self.pager removeFromSuperview];
+  [self.handler detachFromView:self.surface];
+  self.window.hidden = YES;
+  self.driver = nil;
+  self.firstPage = nil;
+  self.pager = nil;
+  self.handler = nil;
+  self.surface = nil;
+  self.window = nil;
+  [super tearDown];
+}
+
+- (void)drainMainQueue
+{
+  XCTestExpectation *drained = [self expectationWithDescription:@"main queue drained"];
+  dispatch_async(dispatch_get_main_queue(), ^{ [drained fulfill]; });
+  [self waitForExpectations:@[drained] timeout:2];
+}
+
+- (void)assertFixtureIsReadyForDelivery
+{
+  XCTAssertNil(self.driver.unavailableReason);
+  UIGestureRecognizer *bridge = [self.pager valueForKey:@"contentPressCancellationGesture"];
+  UIScrollView *pagerScrollView = [self.pager valueForKey:@"pagerScrollView"];
+  XCTAssertNotNil(bridge);
+  XCTAssertEqual([bridge valueForKey:@"reactTouchHandler"], self.handler);
+  XCTAssertEqual((id)pagerScrollView.delegate, self.pager);
+  XCTAssertGreaterThan(pagerScrollView.contentSize.width, CGRectGetWidth(pagerScrollView.bounds));
+  // The touch must start on React page content, outside the shared header.
+  CGPoint point = [self pressPoint];
+  UIView *hit = [self.window hitTest:point withEvent:nil];
+  XCTAssertTrue(hit == self.firstPage || [hit isDescendantOfView:self.firstPage],
+                @"hit view %@", hit);
+}
+
+- (CGPoint)pressPoint
+{
+  return CGPointMake(200, 600);
+}
+
+- (void)testHorizontalPagerDragCancelsReactPressBeforeFingerLifts
+{
+  [self assertFixtureIsReadyForDelivery];
+  UIScrollView *pagerScrollView = [self.pager valueForKey:@"pagerScrollView"];
+  CGPoint point = [self pressPoint];
+  UITouch *touch = [self.driver beginAt:point];
+  XCTAssertEqualObjects(self.handler.events, @[@"began"]);
+  XCTAssertEqual(self.handler.registeredTouches, 1);
+
+  for (NSInteger step = 1; step <= 8 && !pagerScrollView.isDragging; ++step) {
+    [self.driver move:touch to:CGPointMake(point.x - 12 * step, point.y)];
+  }
+  XCTAssertTrue(pagerScrollView.isDragging, @"the real pager pan must begin");
+  // Finger is still down: RN must already have cancelled its responder.
+  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"]);
+  NSUInteger eventsBeforeLift = self.handler.events.count;
+
+  [self.driver end:touch];
+  // UIKit must not deliver the lift to the prevented handler as a press end.
+  XCTAssertFalse([self.handler.events containsObject:@"ended"], @"events %@", self.handler.events);
+  XCTAssertEqual(self.handler.events.count, eventsBeforeLift);
+}
+
+- (void)testStationaryTapKeepsReactPress
+{
+  [self assertFixtureIsReadyForDelivery];
+  UITouch *touch = [self.driver beginAt:[self pressPoint]];
+  [self.driver end:touch];
+  XCTAssertEqualObjects(self.handler.events, (@[@"began", @"ended"]));
+  XCTAssertEqual(self.handler.registeredTouches, 0);
+}
+
+- (void)testSmallMovementBelowPanThresholdKeepsReactPress
+{
+  [self assertFixtureIsReadyForDelivery];
+  UIScrollView *pagerScrollView = [self.pager valueForKey:@"pagerScrollView"];
+  CGPoint point = [self pressPoint];
+  UITouch *touch = [self.driver beginAt:point];
+  [self.driver move:touch to:CGPointMake(point.x - 2, point.y)];
+  XCTAssertFalse(pagerScrollView.isDragging);
+  [self.driver end:touch];
+  XCTAssertEqualObjects(self.handler.events, (@[@"began", @"moved", @"ended"]));
+}
+
+@end

package/lib/module/CollapsiblePagerView.js

@@ -30,6 +30,10 @@ export class CollapsiblePagerView extends React.PureComponent {
   lastMountSignature = null;
   nativeTabCommandId = 0;
   latestNativeTabTarget = null;
+
+  // Target of the last tab command native has received and not yet reported
+  // as selected. Commands superseded before their frame never reach native.
+  dispatchedNativeTabTarget = null;
   latestNativeSelectedPage = this.state.selectedPage;
   nativePagerScrollState = "idle";
   nativeTabCommandQueuedDuringScroll = false;
@@ -89,6 +93,7 @@ export class CollapsiblePagerView extends React.PureComponent {
         if (commandId !== this.nativeTabCommandId || !this.nativeRef) {
           return;
         }
+        this.dispatchedNativeTabTarget = position;
         if (animated) {
           CollapsiblePagerViewNativeCommands.setPage(this.nativeRef, position);
         } else {
@@ -136,6 +141,7 @@ export class CollapsiblePagerView extends React.PureComponent {
       const transitionComplete = pendingTarget === position;
       if (transitionComplete) {
         this.latestNativeTabTarget = null;
+        this.dispatchedNativeTabTarget = null;
         this.nativeTabCommandQueuedDuringScroll = false;
       }
       this.setState({
@@ -154,6 +160,7 @@ export class CollapsiblePagerView extends React.PureComponent {
     if (scrollState === "idle" && this.latestNativeTabTarget !== null && this.latestNativeTabTarget !== this.latestNativeSelectedPage && !queuedDuringPreviousScroll) {
       ++this.nativeTabCommandId;
       this.latestNativeTabTarget = null;
+      this.dispatchedNativeTabTarget = null;
       this.setState({
         transientRetainedPages: []
       }, this.notifyMountedPagesChanged);
@@ -166,7 +173,9 @@ export class CollapsiblePagerView extends React.PureComponent {
   onNativeTabPress = event => {
     const position = pageIndex(event.nativeEvent.position);
     if (position !== null && position >= 0 && position < this.pages().length && (position !== this.state.selectedPage || this.latestNativeTabTarget !== null)) {
-      this.dispatchNativeTabPageCommand(position, this.props.nativeTabPressAnimationEnabled ?? Math.abs(position - this.state.selectedPage) <= 1);
+      // Selection state lags an in-flight transition until native reports it.
+      const currentPage = this.dispatchedNativeTabTarget ?? this.state.selectedPage;
+      this.dispatchNativeTabPageCommand(position, this.props.nativeTabPressAnimationEnabled ?? Math.abs(position - currentPage) <= 1);
     }
     this.props.onNativeTabPress?.(event);
   };

package/lib/typescript/src/CollapsiblePagerView.d.ts

@@ -105,6 +105,7 @@ export declare class CollapsiblePagerView extends React.PureComponent<Collapsibl
     private lastMountSignature;
     private nativeTabCommandId;
     private latestNativeTabTarget;
+    private dispatchedNativeTabTarget;
     private latestNativeSelectedPage;
     private nativePagerScrollState;
     private nativeTabCommandQueuedDuringScroll;

package/package.json

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

package/src/CollapsiblePagerView.tsx

@@ -190,6 +190,10 @@ export class CollapsiblePagerView extends React.PureComponent<
 
   private latestNativeTabTarget: number | null = null;
 
+  // Target of the last tab command native has received and not yet reported
+  // as selected. Commands superseded before their frame never reach native.
+  private dispatchedNativeTabTarget: number | null = null;
+
   private latestNativeSelectedPage = this.state.selectedPage;
 
   private nativePagerScrollState: OnPageScrollStateChangedEventData["pageScrollState"] =
@@ -282,6 +286,7 @@ export class CollapsiblePagerView extends React.PureComponent<
           if (commandId !== this.nativeTabCommandId || !this.nativeRef) {
             return;
           }
+          this.dispatchedNativeTabTarget = position;
           if (animated) {
             CollapsiblePagerViewNativeCommands.setPage(
               this.nativeRef,
@@ -354,6 +359,7 @@ export class CollapsiblePagerView extends React.PureComponent<
       const transitionComplete = pendingTarget === position;
       if (transitionComplete) {
         this.latestNativeTabTarget = null;
+        this.dispatchedNativeTabTarget = null;
         this.nativeTabCommandQueuedDuringScroll = false;
       }
       this.setState(
@@ -386,6 +392,7 @@ export class CollapsiblePagerView extends React.PureComponent<
     ) {
       ++this.nativeTabCommandId;
       this.latestNativeTabTarget = null;
+      this.dispatchedNativeTabTarget = null;
       this.setState(
         { transientRetainedPages: [] },
         this.notifyMountedPagesChanged
@@ -408,10 +415,13 @@ export class CollapsiblePagerView extends React.PureComponent<
       (position !== this.state.selectedPage ||
         this.latestNativeTabTarget !== null)
     ) {
+      // Selection state lags an in-flight transition until native reports it.
+      const currentPage =
+        this.dispatchedNativeTabTarget ?? this.state.selectedPage;
       this.dispatchNativeTabPageCommand(
         position,
         this.props.nativeTabPressAnimationEnabled ??
-          Math.abs(position - this.state.selectedPage) <= 1
+          Math.abs(position - currentPage) <= 1
       );
     }
     this.props.onNativeTabPress?.(event);