@onekeyfe/react-native-pager-view 6.7.0-alpha.344 → 6.7.0-alpha.354

package/README.md

@@ -66,6 +66,11 @@ replacing its delegate. Android coordinates nested scroll with the active
 Web scroll child can opt in by exposing a DOM element with
 `data-collapsible-pager-scroll`. CSS scroll timelines drive header/sticky
 movement, so React is not updated on each vertical scroll frame.
+`pagerRef.current?.scrollHeaderBy(delta)` immediately moves the active page's
+collapsible header by a finite logical distance, clamped to its measured range.
+`scrollHeaderToOffset(offset)` targets an absolute collapse position, so a
+keyboard's own scroll adjustment cannot add a second relative movement.
+It is useful for revealing a focused field above a keyboard.
 
 On Web, `WebCollapsiblePagerView` is an explicit root export of the existing Web
 pager. It measures Header and sticky content when their heights are omitted.

package/android/src/androidTest/AndroidManifest.xml

@@ -0,0 +1,7 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+  <application android:supportsRtl="true">
+    <activity
+      android:name="com.reactnativepagerview.CollapsiblePagerHitTestActivity"
+      android:exported="false" />
+  </application>
+</manifest>

package/android/src/androidTest/java/com/reactnativepagerview/CollapsiblePagerTabReservationTest.kt

@@ -0,0 +1,136 @@
+package com.reactnativepagerview
+
+import android.app.Activity
+import android.content.Intent
+import android.content.pm.ApplicationInfo
+import android.graphics.Bitmap
+import android.graphics.Canvas
+import android.graphics.Color
+import android.test.InstrumentationTestCase
+import android.view.MotionEvent
+import android.view.View
+import android.view.ViewGroup
+import android.widget.HorizontalScrollView
+import android.widget.TextView
+import com.facebook.react.uimanager.PointerEvents
+import com.facebook.react.views.view.ReactViewGroup
+import java.util.concurrent.atomic.AtomicInteger
+import kotlin.math.roundToInt
+
+class CollapsiblePagerHitTestActivity : Activity()
+
+class CollapsiblePagerTabReservationTest : InstrumentationTestCase() {
+  fun testTabViewportToolbarHitAndResetInBothDirections() {
+    val context = instrumentation.targetContext
+    assertTrue(context.applicationInfo.flags and ApplicationInfo.FLAG_SUPPORTS_RTL != 0)
+    val activity = instrumentation.startActivitySync(
+      Intent(context, CollapsiblePagerHitTestActivity::class.java)
+        .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK),
+    ) as CollapsiblePagerHitTestActivity
+    val toolbarPresses = AtomicInteger()
+    val tabPresses = AtomicInteger()
+    try {
+      instrumentation.runOnMainSync {
+      val density = context.resources.displayMetrics.density
+      fun dp(value: Int) = (value * density).roundToInt()
+      val width = dp(320)
+      val height = dp(500)
+      val reserved = dp(64)
+      val tabHeight = dp(44)
+      val host = CollapsiblePagerHost(context)
+      activity.setContentView(host)
+      assertTrue(host.isAttachedToWindow)
+      val sticky = ReactViewGroup(context).apply { pointerEvents = PointerEvents.BOX_NONE }
+      val fade = View(context).apply { setBackgroundColor(Color.RED) }
+      val toolbar = View(context).apply {
+        setBackgroundColor(Color.BLUE)
+        isClickable = true
+      }
+      sticky.addView(fade)
+      sticky.addView(toolbar)
+      host.addReactChild(View(context), 0)
+      host.addReactChild(sticky, 1)
+      host.headerHeightPx = 0
+      host.stickyHeaderHeightPx = tabHeight
+      host.nativeTabBarBackgroundColor = Color.GREEN
+      host.applyNativeHeaderStyle()
+      host.updateNativeTabBarItems(
+        """[{"key":"a","title":"Overview"},{"key":"b","title":"Ethereum"},""" +
+          """{"key":"c","title":"BNB Chain"},{"key":"d","title":"Polygon"}]""",
+      )
+      val tab = (0 until host.childCount).map(host::getChildAt)
+        .first { it.javaClass.simpleName == "CollapsiblePagerNativeTabBarView" } as ViewGroup
+      val row = tab.getChildAt(0) as HorizontalScrollView
+      toolbar.setOnClickListener { toolbarPresses.incrementAndGet() }
+      host.onNativeTabPress = { _, _ -> tabPresses.incrementAndGet() }
+
+      fun layout() {
+        host.measure(View.MeasureSpec.makeMeasureSpec(width, View.MeasureSpec.EXACTLY),
+          View.MeasureSpec.makeMeasureSpec(height, View.MeasureSpec.EXACTLY))
+        host.layout(0, 0, width, height)
+      }
+      fun tap(x: Int) {
+        val time = android.os.SystemClock.uptimeMillis()
+        val down = MotionEvent.obtain(time, time, MotionEvent.ACTION_DOWN,
+          x.toFloat(), (tabHeight / 2).toFloat(), 0)
+        val up = MotionEvent.obtain(time, time + 20, MotionEvent.ACTION_UP,
+          x.toFloat(), (tabHeight / 2).toFloat(), 0)
+        host.dispatchTouchEvent(down)
+        host.dispatchTouchEvent(up)
+        down.recycle()
+        up.recycle()
+      }
+      fun colorAt(x: Int): Int {
+        val bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888)
+        host.draw(Canvas(bitmap))
+        val color = bitmap.getPixel(x, tabHeight / 2)
+        bitmap.recycle()
+        return color
+      }
+
+      host.nativeTabBarTrailingReservedWidth = 64.0
+      layout()
+      fade.layout(width - reserved - dp(20), 0, width - reserved, tabHeight)
+      toolbar.layout(width - reserved, 0, width, tabHeight)
+      assertEquals(width - reserved, tab.width)
+      assertEquals(0, tab.left)
+      assertEquals(width, sticky.width)
+      assertEquals(Color.RED, colorAt(width - reserved - dp(10)))
+      tap(width - dp(10))
+      tap(dp(28))
+      host.updateNativeTabProgress(3, 0f)
+      val content = row.getChildAt(0) as ViewGroup
+      val lastTab = (0 until content.childCount).map(content::getChildAt)
+        .filterIsInstance<TextView>().last()
+      assertTrue(lastTab.left >= row.scrollX - dp(1))
+      assertTrue(lastTab.right <= row.scrollX + row.width + dp(1))
+
+      host.setPagerLayoutDirection(View.LAYOUT_DIRECTION_RTL)
+      host.nativeTabBarTrailingReservedWidth = 64.0
+      layout()
+      assertEquals(View.LAYOUT_DIRECTION_RTL, tab.layoutDirection)
+      toolbar.layout(0, 0, reserved, tabHeight)
+      fade.layout(reserved, 0, reserved + dp(20), tabHeight)
+      assertEquals(reserved, tab.left)
+      assertEquals(width, tab.right)
+      assertEquals(Color.RED, colorAt(reserved + dp(10)))
+      tap(dp(10))
+
+      host.nativeTabBarTrailingReservedWidth = 500.0
+      layout()
+      assertEquals(0, tab.width)
+      host.nativeTabBarTrailingReservedWidth = 0.0
+      layout()
+      assertEquals(0, tab.left)
+      assertEquals(width, tab.width)
+      assertTrue(host.indexOfChild(sticky) < host.indexOfChild(tab))
+      }
+      instrumentation.waitForIdleSync()
+      assertEquals(2, toolbarPresses.get())
+      assertEquals(1, tabPresses.get())
+    } finally {
+      instrumentation.runOnMainSync { activity.finish() }
+      instrumentation.waitForIdleSync()
+    }
+  }
+}

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

@@ -142,7 +142,7 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
   private var transitionSourceRecyclerAnchor: RecyclerReadingAnchor? = null
   private val commandBodyKeys = HashSet<String>()
   private var explicitTopCommand: Pair<String, PageRestoreRequest>? = null
-  private class PagerTopRequest(view: View, val key: String, val pageIndex: Int, val generation: Int, val target: Int, val token: Int) {
+  private class PagerTopRequest(view: View, val key: String, val pageIndex: Int, val generation: Int, val logicalOffset: Int, val token: Int) {
     val view = WeakReference(view)
   }
   private var pagerTopRequest: PagerTopRequest? = null
@@ -293,6 +293,20 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
   var onNativeSubHeaderPress: ((Int, String) -> Unit)? = null
 
   var nativeTabBarHeight = 44.0
+  var nativeTabBarTrailingReservedWidth = 0.0
+    set(value) {
+      field = if (value.isFinite() && value >= 0.0) value else 0.0
+      bringNativeHeadersToFront()
+      requestLayout()
+    }
+
+  private fun nativeTabReservationPx(width: Int): Int {
+    val reserved = nativeTabBarTrailingReservedWidth
+    val density = resources.displayMetrics.density
+    return if (reserved.isFinite() && reserved > 0.0 && width > 0 && density > 0f) {
+      (reserved.coerceAtMost(width / density.toDouble()) * density).roundToInt()
+    } else 0
+  }
   var nativeTabBarContentPaddingHorizontal = 20.0
   var nativeTabBarItemSpacing = 8.0
   var nativeTabBarFontSize = 16.0
@@ -442,6 +456,7 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
   private fun bringNativeHeadersToFront() {
     nativeTabBarView.bringToFront()
     nativeSubHeaderView.bringToFront()
+    if (nativeTabBarTrailingReservedWidth > 0.0) stickyHeaderView?.bringToFront()
   }
 
   fun addReactChild(child: View, index: Int) {
@@ -689,7 +704,7 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
 
   private fun layoutPagerIfRequested() {
     val recycler = pager.getChildAt(0) as? RecyclerView ?: return
-    if (!recycler.isLayoutRequested || recycler.isComputingLayout || recycler.width <= 0 || recycler.height <= 0) return
+    if (!recycler.isLayoutRequested || recycler.isLayoutSuppressed || recycler.isComputingLayout || recycler.width <= 0 || recycler.height <= 0) return
     // OneKey patch: a non-animated page command queues RecyclerView layout, but RN
     // can stop that request after navigation. Drain it before showing the page.
     recycler.measure(
@@ -712,6 +727,9 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
     layout(left, top, right, bottom)
   }
 
+  private fun isPagerRecyclerLayoutSuppressed(): Boolean =
+    (pager.getChildAt(0) as? RecyclerView)?.isLayoutSuppressed == true
+
   override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
     val width = MeasureSpec.getSize(widthMeasureSpec)
     val height = MeasureSpec.getSize(heightMeasureSpec)
@@ -722,10 +740,12 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
       return
     }
     val pagerHeight = height + headerHeightPx
-    pager.measure(
-      MeasureSpec.makeMeasureSpec(width, MeasureSpec.EXACTLY),
-      MeasureSpec.makeMeasureSpec(pagerHeight, MeasureSpec.EXACTLY),
-    )
+    if (!isPagerRecyclerLayoutSuppressed()) {
+      pager.measure(
+        MeasureSpec.makeMeasureSpec(width, MeasureSpec.EXACTLY),
+        MeasureSpec.makeMeasureSpec(pagerHeight, MeasureSpec.EXACTLY),
+      )
+    }
     headerView?.measure(
       MeasureSpec.makeMeasureSpec(width, MeasureSpec.EXACTLY),
       MeasureSpec.makeMeasureSpec(headerHeightPx, MeasureSpec.EXACTLY),
@@ -737,8 +757,9 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
     val nativeTabHeight = if (nativeTabBarView.visibility == View.VISIBLE) {
       nativeTabBarView.preferredHeightPx()
     } else 0
+    val tabReservedWidth = nativeTabReservationPx(width)
     nativeTabBarView.measure(
-      MeasureSpec.makeMeasureSpec(width, MeasureSpec.EXACTLY),
+      MeasureSpec.makeMeasureSpec(width - tabReservedWidth, MeasureSpec.EXACTLY),
       MeasureSpec.makeMeasureSpec(nativeTabHeight, MeasureSpec.EXACTLY),
     )
     val nativeSubHeaderHeight = if (nativeSubHeaderView.visibility == View.VISIBLE) {
@@ -757,7 +778,9 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
     // RN ancestors allow overflow; keep translated header content inside this viewport.
     clipBounds = Rect(0, 0, width, height)
     if (width <= 0 || height <= 0) return
-    pager.layout(0, 0, width, height + headerHeightPx)
+    if (!isPagerRecyclerLayoutSuppressed()) {
+      pager.layout(0, 0, width, height + headerHeightPx)
+    }
     headerView?.layout(0, 0, width, headerHeightPx)
     stickyHeaderView?.layout(
       0,
@@ -766,7 +789,12 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
       headerHeightPx + stickyHeaderHeightPx,
     )
     val nativeTabHeight = nativeTabBarView.measuredHeight
-    nativeTabBarView.layout(0, headerHeightPx, width, headerHeightPx + nativeTabHeight)
+    val tabReservedWidth = nativeTabReservationPx(width)
+    val tabLeft = if (nativeTabBarView.layoutDirection == View.LAYOUT_DIRECTION_RTL) {
+      tabReservedWidth
+    } else 0
+    nativeTabBarView.layout(tabLeft, headerHeightPx, tabLeft + width - tabReservedWidth,
+      headerHeightPx + nativeTabHeight)
     nativeSubHeaderView.layout(
       0,
       headerHeightPx + nativeTabHeight,
@@ -828,7 +856,7 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
     }
     if (!reached()) {
       if (!isAttachedToWindow || !view.isAttachedToWindow || width <= 0 || height <= 0 ||
-          view.width <= 0 || view.height <= 0 || isInLayout || view.isInLayout || view.isComputingLayout ||
+          view.width <= 0 || view.height <= 0 || isInLayout || view.isInLayout || view.isLayoutSuppressed || view.isComputingLayout ||
           pageKey(index) != key || primaryScrollableForPage(index) !== view || !isCurrentPageRestore(key, request)) return false
       val previousSynthetic = syntheticPageRestore
       syntheticPageRestore = true
@@ -987,13 +1015,33 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
     if (!settled) return
     pageOffsets[request.key] = 0
     if (view is RecyclerView) saveRecyclerReadingAnchor(request.key, view)
-    setHeaderOffset(if (request.target == 1) headerHeightPx else 0)
-    offsetDiag("pager-top-complete-target=${request.target}-token=${request.token}", view, request.key)
+    setHeaderOffset(request.logicalOffset.coerceIn(0, headerHeightPx))
+    offsetDiag("pager-top-complete-offset=${request.logicalOffset}-token=${request.token}", view, request.key)
     cancelPagerTop()
   }
 
   internal fun scrollToTop(target: Int, animated: Boolean) {
-    if (target !in 0..1 || pager.scrollState != ViewPager2.SCROLL_STATE_IDLE || transitionHeaderOffsets != null ||
+    if (target !in 0..1) return
+    scrollHeaderToOffset(if (target == 1) headerHeightPx else 0, animated)
+  }
+
+  internal fun scrollHeaderBy(delta: Double) {
+    if (!delta.isFinite()) return
+    val density = resources.displayMetrics.density.toDouble()
+    val maxDip = headerHeightPx / density
+    val deltaPx = (delta.coerceIn(-maxDip, maxDip) * density).roundToInt()
+    scrollHeaderToOffset((headerOffsetPx.toLong() + deltaPx).coerceIn(0, headerHeightPx.toLong()).toInt(), false)
+  }
+
+  internal fun scrollHeaderToOffset(offset: Double) {
+    if (!offset.isFinite()) return
+    val density = resources.displayMetrics.density.toDouble()
+    val targetPx = (offset.coerceIn(0.0, headerHeightPx / density) * density).roundToInt()
+    scrollHeaderToOffset(targetPx, false)
+  }
+
+  private fun scrollHeaderToOffset(logicalOffset: Int, animated: Boolean) {
+    if (pager.scrollState != ViewPager2.SCROLL_STATE_IDLE || transitionHeaderOffsets != null ||
       syntheticPageRestore || selectedPage !in 0 until adapter.itemCount || !isAttachedToWindow) return
     val view = observedRecyclerView ?: observedOwnedScroller ?: observedNativeScroller ?: return
     val key = currentPageKey()
@@ -1020,11 +1068,12 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
     if (view is RecyclerView) deferredRecyclerGeometry.remove(view)
     if (view is ScrollView) deferredScrollerGeometry.remove(view)
     pageOffsets[key] = 0
-    val request = PagerTopRequest(view, key, selectedPage, attachmentGeneration, target, ++pagerTopToken)
+    val targetOffset = logicalOffset.coerceIn(0, headerHeightPx)
+    val request = PagerTopRequest(view, key, selectedPage, attachmentGeneration, targetOffset, ++pagerTopToken)
     pagerTopRequest = request
     commandBodyKeys.add(key)
-    setHeaderOffset(if (target == 1) headerHeightPx else 0)
-    offsetDiag("pager-top-begin-target=$target-animated=$animated-token=${request.token}", view, key)
+    setHeaderOffset(targetOffset)
+    offsetDiag("pager-top-begin-offset=$targetOffset-animated=$animated-token=${request.token}", view, key)
     dispatchingPagerTop = true
     try {
       when (view) {
@@ -1033,7 +1082,7 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
           if (animated && !recyclerIsAtBodyTop(view)) view.smoothScrollToPosition(0)
           else if (manager != null && manager.orientation == RecyclerView.VERTICAL) {
             manager.scrollToPositionWithOffset(0, 0)
-            if (view.width > 0 && view.height > 0 && !isInLayout && !view.isInLayout && !view.isComputingLayout) {
+            if (view.width > 0 && view.height > 0 && !isInLayout && !view.isInLayout && !view.isLayoutSuppressed && !view.isComputingLayout) {
               view.measure(MeasureSpec.makeMeasureSpec(view.width, MeasureSpec.EXACTLY), MeasureSpec.makeMeasureSpec(view.height, MeasureSpec.EXACTLY))
               view.layout(view.left, view.top, view.right, view.bottom)
             }
@@ -1638,7 +1687,7 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
       if (anchorOffset != null) manager?.scrollToPositionWithOffset(first, anchorOffset)
       // React Native can stop this nested requestLayout at its React-owned parent.
       // Commit the changed inset before drawing instead of waiting for a data update.
-      if (recycler.width > 0 && recycler.height > 0 && !recycler.isComputingLayout) {
+      if (recycler.width > 0 && recycler.height > 0 && !recycler.isLayoutSuppressed && !recycler.isComputingLayout) {
         recycler.forceLayout()
         recycler.measure(
           MeasureSpec.makeMeasureSpec(recycler.width, MeasureSpec.EXACTLY),
@@ -2012,14 +2061,16 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
     }
   }
 
-  private fun headerRegionAt(y: Float): String? {
+  private fun headerRegionAt(x: Float, y: Float): String? {
     val headerBottom = headerHeightPx - headerOffsetPx
     val stickyBottom = headerHeightPx + stickyHeaderHeightPx - headerOffsetPx
     return when {
       y < 0 || y >= stickyBottom -> null
       y < headerBottom -> "header"
       y < headerBottom + nativeTabBarView.measuredHeight &&
-        nativeTabBarView.visibility == View.VISIBLE -> "primary-tab"
+        nativeTabBarView.visibility == View.VISIBLE ->
+        if (x >= nativeTabBarView.left && x < nativeTabBarView.right) "primary-tab"
+        else "sticky-controls"
       y < headerBottom + nativeTabBarView.measuredHeight + nativeSubHeaderView.measuredHeight &&
         nativeSubHeaderView.visibility == View.VISIBLE -> "secondary-header"
       else -> "sticky-controls"
@@ -2128,7 +2179,7 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
         pressCancelled = false
         nativeGestureStarted = false
         nestedNativeGestureStarted = false
-        headerTouchRegion = headerRegionAt(event.y) ?: "none"
+        headerTouchRegion = headerRegionAt(event.x, event.y) ?: "none"
         headerTouchActive = headerTouchRegion != "none"
         if (!headerTouchActive) return super.dispatchTouchEvent(event)
         headerDownX = event.x

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

@@ -239,6 +239,11 @@ class CollapsiblePagerViewManager : ViewGroupManager<CollapsiblePagerHost>(),
     view.applyNativeHeaderStyle()
   }
 
+  @ReactProp(name = "nativeTabBarTrailingReservedWidth", defaultDouble = 0.0)
+  override fun setNativeTabBarTrailingReservedWidth(view: CollapsiblePagerHost?, value: Double) {
+    view?.nativeTabBarTrailingReservedWidth = value
+  }
+
   @ReactProp(name = "nativeTabBarContentPaddingHorizontal")
   override fun setNativeTabBarContentPaddingHorizontal(
     view: CollapsiblePagerHost?,
@@ -343,6 +348,14 @@ class CollapsiblePagerViewManager : ViewGroupManager<CollapsiblePagerHost>(),
     view?.scrollToTop(target, animated)
   }
 
+  override fun scrollHeaderBy(view: CollapsiblePagerHost?, delta: Double) {
+    view?.scrollHeaderBy(delta)
+  }
+
+  override fun scrollHeaderToOffset(view: CollapsiblePagerHost?, offset: Double) {
+    view?.scrollHeaderToOffset(offset)
+  }
+
   override fun setPage(view: CollapsiblePagerHost?, selectedPage: Int) {
     if (view != null && selectedPage in 0 until view.adapter.itemCount) {
       view.beginPageTransition(selectedPage)

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

@@ -37,26 +37,50 @@ class NativeScrollerView(context: Context) : FrameLayout(context) {
       setMeasuredDimension(MeasureSpec.getSize(widthSpec), MeasureSpec.getSize(heightSpec))
     }
     override fun onLayout(changed: Boolean, left: Int, top: Int, right: Int, bottom: Int) = Unit
+
+    override fun startViewTransition(view: View) {
+      super.startViewTransition(view)
+      if (view === reactChild) transitioningReactChild = view
+    }
+
+    override fun endViewTransition(view: View) {
+      super.endViewTransition(view)
+      if (transitioningReactChild === view) transitioningReactChild = null
+      if (retainedReactChild === view) {
+        clearRetainedGeometry()
+        if (isAttachedToWindow) scheduleLayout()
+      }
+    }
   }
   private val contentFrame = object : FrameLayout(context) {
     override fun onMeasure(widthSpec: Int, heightSpec: Int) {
       setMeasuredDimension(
-        max(MeasureSpec.getSize(widthSpec), contentWidthPx + insetLeft + insetRight),
-        contentHeightPx + contentTop + insetBottom,
+        max(MeasureSpec.getSize(widthSpec), effectiveContentWidthPx + insetLeft + insetRight),
+        effectiveContentHeightPx + contentTop + insetBottom,
       )
     }
 
     override fun onLayout(changed: Boolean, left: Int, top: Int, right: Int, bottom: Int) {
       // Only the native origin layer moves. Fabric owns its React child's layout/transform.
+      val contentWidth = effectiveContentWidthPx
+      val contentHeight = effectiveContentHeightPx
       contentOriginFrame.measure(
-        MeasureSpec.makeMeasureSpec(contentWidthPx, MeasureSpec.EXACTLY),
-        MeasureSpec.makeMeasureSpec(contentHeightPx, MeasureSpec.EXACTLY),
+        MeasureSpec.makeMeasureSpec(contentWidth, MeasureSpec.EXACTLY),
+        MeasureSpec.makeMeasureSpec(contentHeight, MeasureSpec.EXACTLY),
       )
-      contentOriginFrame.layout(insetLeft, contentTop, insetLeft + contentWidthPx, contentTop + contentHeightPx)
+      contentOriginFrame.layout(insetLeft, contentTop, insetLeft + contentWidth, contentTop + contentHeight)
     }
   }
   private val pagerInsets = WeakHashMap<View, Int>()
   private var reactChild: View? = null
+  private var transitioningReactChild: View? = null
+  private var retainedReactChild: View? = null
+  private var retainedContentWidthPx = 0
+  private var retainedContentHeightPx = 0
+  private val effectiveContentWidthPx: Int
+    get() = if (reactChild == null && retainedReactChild != null) retainedContentWidthPx else contentWidthPx
+  private val effectiveContentHeightPx: Int
+    get() = if (reactChild == null && retainedReactChild != null) retainedContentHeightPx else contentHeightPx
   private var fabricState: StateWrapper? = null
   private var lastOriginX: Int? = null
   private var lastOriginY: Int? = null
@@ -172,6 +196,8 @@ class NativeScrollerView(context: Context) : FrameLayout(context) {
   internal fun addReactChild(child: View, index: Int) {
     require(index == 0 && reactChild == null) { "NativeScroller requires one React content view" }
     viewport.stopMotion()
+    clearRetainedGeometry()
+    transitioningReactChild = null
     reactChild = child
     contentOriginFrame.addView(child)
     scheduleLayout()
@@ -180,13 +206,29 @@ class NativeScrollerView(context: Context) : FrameLayout(context) {
   internal fun removeReactChild() {
     viewport.stopMotion()
     pendingRestore.cancel()
-    reactChild?.let(contentOriginFrame::removeView)
+    reactChild?.let { child ->
+      clearRetainedGeometry()
+      // Fabric removes the child before its disappearing view finishes drawing.
+      if (transitioningReactChild === child &&
+        contentOriginFrame.width > 0 && contentOriginFrame.height > 0) {
+        retainedReactChild = child
+        retainedContentWidthPx = contentOriginFrame.width
+        retainedContentHeightPx = contentOriginFrame.height
+      }
+      contentOriginFrame.removeView(child)
+    }
     reactChild = null
     contentWidthPx = 0
     contentHeightPx = 0
     scheduleLayout()
   }
 
+  private fun clearRetainedGeometry() {
+    retainedReactChild = null
+    retainedContentWidthPx = 0
+    retainedContentHeightPx = 0
+  }
+
   internal fun reactChildCount() = if (reactChild == null) 0 else 1
   internal fun reactChildAt(index: Int): View {
     require(index == 0)
@@ -381,6 +423,8 @@ class NativeScrollerView(context: Context) : FrameLayout(context) {
     lastContentViewportHeight = null
     viewport.stopMotion()
     viewport.setTag(R.id.onekey_native_scroll_coordinator_offset_listener, null)
+    transitioningReactChild = null
+    clearRetainedGeometry()
     super.onDetachedFromWindow()
   }
 

package/docs/SPEC.md

@@ -74,7 +74,7 @@ the shared host before their old scroll-edge interaction is released.
 The measured overlay height is excluded from the collapsible header distance:
 `header` remains collapsible and `stickyHeader` pins immediately below the
 overlay. Selection, cancellation, reuse and disposal rebind or release the
-interaction and restore any prior scroll-edge style. Native scroll/refresh
+interaction and restore any prior scroll-edge style. The existing owner-scoped native sticky-height callback also reaches NativeList hosts, so their React container slots clip below the same fixed viewport region and release it when the owner detaches. Native scroll/refresh
 coordination continues on the main thread without per-frame JavaScript work.
 Refresh retains the pager-owned `overlay + header + sticky` top inset but offsets
 the indicator by `header + sticky`, so its spinner begins below the fixed overlay.
@@ -171,6 +171,24 @@ intent. Real vertical consumption, a newer valid command, or owner detachment
 releases the target. Existing NativeList and NativeScroller public coordinates
 are unchanged. The same page-top/sticky-top destinations are available without smooth-header mode.
 
+## Current-page partial header command
+
+`scrollHeaderBy(delta: number)` moves the current page's shared collapsible
+header from its displayed offset C to `clamp(C + delta, 0, D)`.
+`scrollHeaderToOffset(offset: number)` moves it to `clamp(offset, 0, D)`
+regardless of intervening native keyboard or user scrolling. D is the latest
+measured collapsible height. Inputs use logical points on iOS and Android and
+CSS pixels on Web. Non-finite values are ignored. The header and current body move immediately
+so a focused input becomes visible before the next keyboard frame. A valid command
+clears only the current page's body reading position B; it never changes
+another page's memory or adds permanent content/insets. It requires the same
+stable attached current owner as the page-top commands and is a safe no-op
+during horizontal transitions, before mount, or after disposal. A newer
+command or real user vertical consumption takes ownership from an older one.
+Dynamic header measurements clamp any in-flight target to the latest D.
+This command allows a focused input inside the shared header to move above a
+keyboard without replacing the pager's sole vertical scroll owner.
+
 ## Independent NativeScroller migration
 
 Status: implemented in source. Both native builds pass. Android focused emulator
@@ -333,6 +351,32 @@ 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.
 
+## Android removal-transition geometry retention
+
+Status: implemented locally; unreleased. On the Android UI thread, during a
+screen removal transition,
+NativeList and CollapsiblePager layout entry points respect the RecyclerView
+suppression state established by the screen-transition owner. The owner restores
+the original state when its last transition ownership ends. This adds no public
+API and does not change Web or iOS behavior.
+
+If Fabric removes the current NativeScroller React child while its origin-frame
+transition remains active, Android retains the already displayed native extent
+for drawing. The current child and raw content dimensions still clear normally;
+only native content measurement and layout use the retained effective extent.
+The matching transition end or detach clears the private child and extent state
+idempotently. Adding a new child cancels prior retention, and a late end for the
+old child cannot alter the new content. Ordinary removal, size events and scroll
+commands keep their existing semantics.
+
+Local arm64 DevShell acceptance covered Base, CXO and Overview exit content,
+normal scrolling, RecyclerView ownership and suppression cleanup for the
+observed CXO exit, and NativeScroller raw-zero content dimensions with a
+nonzero displayed origin followed by detach cleanup. Nested-owner and cancel
+paths, Overview rebound/cancel, natural resize and new-child runtime cases,
+and the full performance matrix remain unverified. SDK publication and
+consumer version alignment are separate steps.
+
 ## iOS vertical-scroll press cancellation
 
 Status: implemented in source. A source-identical `node_modules` build was
@@ -378,7 +422,7 @@ content, the shared header, and touches beginning on an inner horizontal banner.
 Normal taps MUST remain functional. Press-retention behavior in application
 controls belongs to the consuming responder implementation; the Pager package
 does not contain or publish Tamagui helpers. The native application tab bar has
-a separate contract in react-native-tab-view/docs/SPEC.md.
+a separate contract in react-native-bottom-tabs/docs/SPEC.md.
 
 The current native implementation confirms horizontal intent after at least
 32 points on iOS or 32 dp on Android, with horizontal displacement exceeding
@@ -472,6 +516,28 @@ 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.
 
+## Native tab trailing control reservation
+
+Status: implemented locally, unreleased. The focused Android host test passed
+(1/1); iOS hit tests had 8 passes and 1 existing skip. iOS companion-app UI
+acceptance remains unverified.
+`nativeTabBar.style.trailingReservedWidth` is an optional logical trailing
+reservation for a sibling React control in the full-width sticky header. It
+defaults to zero. JavaScript normalizes non-finite or negative input to zero;
+native also clamps the reservation to the actual tab viewport width. On Android
+and iOS, only the native tab viewport shrinks from `W` to `W - R`: its frame
+begins at zero in LTR and at `R` in RTL. The sticky React header, its height,
+and page content keep their original full-width geometry. Touches in the
+reserved region reach the sibling control, while native tab hit testing and
+last-tab visibility use the reduced viewport. Changing the reservation updates
+that viewport; removing it or recycling the pager restores the default zero.
+Web does not render the native tab and ignores this style field. For a positive
+reservation, the box-none sticky React control draws above the native tab so
+its inward fade and toolbar hit area remain visible; zero preserves the old
+native-tab foreground order. Acceptance requires focused native layout and hit
+testing for zero, nonzero, reset, and RTL reservations; type forwarding alone
+is insufficient.
+
 ## Android refresh foreground coordination
 
 Status: implemented; Android Home simulator placement verified on 2026-09-28.

package/ios/RNCCollapsiblePagerViewComponentView.mm

@@ -18,6 +18,7 @@
 
 // OneKey patch: deduplicate structural mutation parents before scanning the page.
 #include <unordered_set>
+#include <cmath>
 
 using namespace facebook::react;
 
@@ -1471,6 +1472,7 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
 - (void)liftSharedHeadersForPagerTransition:(NSString *)reason;
 - (void)restoreSharedHeadersToContainer;
 - (void)layoutSharedHeaders;
+- (void)bringReservedStickyControlToFront;
 - (void)restorePinnedStickyHeader;
 - (void)updatePinnedStickyHeader;
 - (UIScrollView *)currentVerticalScrollViewForParentPager;
@@ -1558,6 +1560,7 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
   NSUInteger _pendingTopInsetReboundGeneration;
   NSTimer *_topInsetReboundTimer;
   CGFloat _nativeTabBarHeight;
+  CGFloat _nativeTabBarTrailingReservedWidth;
   CGFloat _nativeSubHeaderHeight;
   CGFloat _headerOffset;
   BOOL _scrollEnabled;
@@ -2479,6 +2482,7 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
   }
   [_nativeTabBarView updateAncestorGesturePrecedence];
   [_nativeSubHeaderView updateAncestorGesturePrecedence];
+  [self bringReservedStickyControlToFront];
 }
 
 - (void)restoreSharedHeadersToContainer
@@ -2584,10 +2588,11 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
   CGFloat nativeTabBarVisibleHeight = _nativeTabBarView.hidden
     ? 0
     : MIN(_stickyHeaderHeight, _nativeTabBarHeight);
+  CGFloat tabReservedWidth = MIN(width, MAX(0, _nativeTabBarTrailingReservedWidth));
   _nativeTabBarView.frame = CGRectMake(
-    0,
+    self.isLtrLayout ? 0 : tabReservedWidth,
     stickyChildY,
-    width,
+    width - tabReservedWidth,
     nativeTabBarVisibleHeight
   );
   _nativeSubHeaderView.frame = CGRectMake(
@@ -2601,9 +2606,26 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
   );
   _topOverlayHostView.frame = CGRectMake(0, 0, width, self.effectiveTopOverlayHeight);
   _topOverlayView.frame = _topOverlayHostView.bounds;
+  [self bringReservedStickyControlToFront];
   [self applyHeaderOffset];
 }
 
+- (void)bringReservedStickyControlToFront
+{
+  if (_stickyHeaderView != nil &&
+      _stickyHeaderView.superview == _nativeTabBarView.superview) {
+    if (_nativeTabBarTrailingReservedWidth > 0) {
+      [_stickyHeaderView.superview bringSubviewToFront:_stickyHeaderView];
+    } else {
+      [_nativeTabBarView.superview bringSubviewToFront:_nativeTabBarView];
+      if (!_nativeSubHeaderView.hidden &&
+          _nativeSubHeaderView.superview == _nativeTabBarView.superview) {
+        [_nativeSubHeaderView.superview bringSubviewToFront:_nativeSubHeaderView];
+      }
+    }
+  }
+}
+
 - (void)updatePinnedStickyHeader
 {
   BOOL attachedToList = _nativeSmoothHeaderScrollEnabled &&
@@ -2650,8 +2672,10 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
   CGFloat childY = shouldPin ? 0 : _headerHeight;
   CGFloat width = CGRectGetWidth(self.bounds);
   CGFloat tabHeight = _nativeTabBarView.hidden ? 0 : MIN(_stickyHeaderHeight, _nativeTabBarHeight);
+  CGFloat tabReservedWidth = MIN(width, MAX(0, _nativeTabBarTrailingReservedWidth));
   _stickyHeaderView.frame = CGRectMake(0, childY, width, _stickyHeaderHeight);
-  _nativeTabBarView.frame = CGRectMake(0, childY, width, tabHeight);
+  _nativeTabBarView.frame = CGRectMake(self.isLtrLayout ? 0 : tabReservedWidth,
+    childY, width - tabReservedWidth, tabHeight);
   _nativeSubHeaderView.frame = CGRectMake(0, childY + tabHeight, width,
     MIN(MAX(0, _stickyHeaderHeight - tabHeight), _nativeSubHeaderHeight));
   _pinnedStickyHostView.hidden = !shouldPin;
@@ -2671,6 +2695,7 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
   }
   [_nativeTabBarView updateAncestorGesturePrecedence];
   [_nativeSubHeaderView updateAncestorGesturePrecedence];
+  [self bringReservedStickyControlToFront];
   [self updateTopScrollEdgeForScrollView:_observedScrollView];
   [self logHomeVisualGeometry:shouldPin ? @"pin" : @"unpin"
                     scrollView:_observedScrollView];
@@ -3050,6 +3075,7 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
   if (_stickyHeaderView != nil) [_sharedHeaderHostView bringSubviewToFront:_stickyHeaderView];
   if (!_nativeTabBarView.hidden) [_sharedHeaderHostView bringSubviewToFront:_nativeTabBarView];
   if (!_nativeSubHeaderView.hidden) [_sharedHeaderHostView bringSubviewToFront:_nativeSubHeaderView];
+  [self bringReservedStickyControlToFront];
   [_containerView bringSubviewToFront:_sharedHeaderHostView];
   if (_stickyHeaderIsPinned) {
     [_pinnedStickyHostView.superview bringSubviewToFront:_pinnedStickyHostView];
@@ -3262,6 +3288,7 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
   _homeVisualLastLayoutLog = 0;
   _homeVisualLastGeometrySignature = nil;
   _nativeTabBarHeight = 44;
+  _nativeTabBarTrailingReservedWidth = 0;
   _nativeSubHeaderHeight = 74;
   _headerOffset = 0;
   _currentLogicalOffset = 0;
@@ -3343,6 +3370,13 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
     _layoutDirection = RCTNSStringFromString(toString(newViewProps.layoutDirection));
     [_nativeTabBarView setLeftToRight:self.isLtrLayout];
     [_nativeSubHeaderView setLeftToRight:self.isLtrLayout];
+    [self setNeedsLayout];
+  }
+  if (_needsPropsReapply ||
+      oldViewProps.nativeTabBarTrailingReservedWidth != newViewProps.nativeTabBarTrailingReservedWidth) {
+    double reserved = newViewProps.nativeTabBarTrailingReservedWidth;
+    _nativeTabBarTrailingReservedWidth = std::isfinite(reserved) && reserved >= 0 ? reserved : 0;
+    [self setNeedsLayout];
   }
   BOOL insetsChanged = NO;
   if (_needsPropsReapply || oldViewProps.headerHeight != newViewProps.headerHeight) {
@@ -3474,6 +3508,7 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
   if (!_nativeSubHeaderView.hidden) {
     [_nativeSubHeaderView.superview bringSubviewToFront:_nativeSubHeaderView];
   }
+  [self bringReservedStickyControlToFront];
   [_sharedHeaderHostView.superview bringSubviewToFront:_sharedHeaderHostView];
   if (_stickyHeaderIsPinned) {
     [_pinnedStickyHostView.superview bringSubviewToFront:_pinnedStickyHostView];
@@ -4438,8 +4473,9 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
 
 - (void)updateNativeScrollerViewport:(UIScrollView *)scrollView stickyHeight:(CGFloat)height
 {
-  if ([scrollView.superview isKindOfClass:RNCNativeScrollerComponentView.class]) {
-    [(RNCNativeScrollerComponentView *)scrollView.superview setPagerStickyHeight:height forOwner:self];
+  id host = scrollView.superview;
+  if ([host respondsToSelector:@selector(setPagerStickyHeight:forOwner:)]) {
+    [host setPagerStickyHeight:height forOwner:self];
   }
 }
 
@@ -5233,6 +5269,13 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
 {
   UIScrollView *scrollView = _pagerTopScrollView;
   if (_dispatchingPagerTop || ![self matchesPagerTop:scrollView]) return;
+  CGFloat clampedTarget = MIN(MAX(_pagerTopLogicalTarget, 0), _headerHeight);
+  if (clampedTarget != _pagerTopLogicalTarget) {
+    _pagerTopLogicalTarget = clampedTarget;
+    CGFloat physicalTarget = RNCLimitRestoredScrollOffset(clampedTarget - scrollView.contentInset.top,
+      scrollView.contentSize.height, scrollView.bounds.size.height, scrollView.contentInset.top, scrollView.contentInset.bottom);
+    [scrollView setContentOffset:CGPointMake(scrollView.contentOffset.x, physicalTarget) animated:NO];
+  }
   CGFloat logical = scrollView.contentOffset.y + scrollView.contentInset.top;
   if (fabs(logical - _pagerTopLogicalTarget) > 0.5) return;
   _pageOffsets[_pagerTopPageKey] = @(_nativeSmoothHeaderScrollEnabled ? 0 : _pagerTopLogicalTarget);
@@ -5244,11 +5287,29 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
 }
 
 - (void)scrollToTop:(NSInteger)target animated:(BOOL)animated
+{
+  if (target != 0 && target != 1) return;
+  [self scrollHeaderToOffset:(target == 1 ? _headerHeight : 0) animated:animated];
+}
+
+- (void)scrollHeaderBy:(double)delta
+{
+  if (!std::isfinite(delta)) return;
+  [self scrollHeaderToOffset:MIN(MAX(_headerOffset + delta, 0), _headerHeight) animated:NO];
+}
+
+- (void)scrollHeaderToOffset:(double)offset
+{
+  if (!std::isfinite(offset)) return;
+  [self scrollHeaderToOffset:MIN(MAX(offset, 0), _headerHeight) animated:NO];
+}
+
+- (void)scrollHeaderToOffset:(CGFloat)logicalTarget animated:(BOOL)animated
 {
   [self cancelTopInsetReboundCheck];
   UIScrollView *scrollView = _observedScrollView;
   NSString *key = _observedPageKey;
-  if ((target != 0 && target != 1) || _isBeingRecycled || _transitioning || _isPagerDragging ||
+  if (_isBeingRecycled || _transitioning || _isPagerDragging ||
       _transitionPageOffsets != nil || _syntheticPageRestore || scrollView == nil || scrollView.window == nil ||
       key == nil || ![key isEqualToString:self.currentPageKey] || _observedPageIndex != _currentIndex ||
       _observedPageGeneration != _generation || self.window == nil) return;
@@ -5264,7 +5325,7 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
   [_alignedBodyKeys removeObject:key];
   [_suspendedBodyKeys removeObject:key];
   [_displayBodyOverrides removeObjectForKey:key];
-  CGFloat logicalTarget = target == 1 ? _headerHeight : 0;
+  logicalTarget = MIN(MAX(logicalTarget, 0), _headerHeight);
   _pageOffsets[key] = @(_nativeSmoothHeaderScrollEnabled ? 0 : logicalTarget);
   _pagerTopScrollView = scrollView;
   _pagerTopPageKey = [key copy];

package/ios/tests/RNCCollapsiblePagerHitTestTests.mm

@@ -2,13 +2,22 @@
 
 #import "RNCCollapsiblePagerViewComponentView.h"
 #import "RNCPagerViewComponentView.h"
+#import <React/RCTViewComponentView.h>
 #import <react/renderer/components/pagerview/Props.h>
+#import <react/renderer/components/view/ViewProps.h>
 
 using namespace facebook::react;
 
 @interface RNCCollapsiblePagerViewComponentView (ScrollEdgeTesting)
 - (void)updateTopScrollEdgeForScrollView:(UIScrollView *)scrollView;
 - (void)updateScrollEdgeContentMasks;
+- (void)layoutSharedHeaders;
+@end
+
+@interface UIView (NativeTabReservationTesting)
+- (void)updateItemsJSON:(NSString *)itemsJSON;
+- (void)setProgress:(CGFloat)progress;
+- (void)setLeftToRight:(BOOL)leftToRight;
 @end
 
 @interface RNCCollapsiblePagerHitTestTests : XCTestCase
@@ -56,6 +65,84 @@ using namespace facebook::react;
   XCTAssertEqual([self.root hitTest:CGPointMake(20, 80) withEvent:nil], self.toolbar);
 }
 
+- (void)testNativeTabReservationKeepsReactToolbarAboveTabsAndResetsInRTL
+{
+  UIView *sharedHost = [self.pager valueForKey:@"sharedHeaderHostView"];
+  UIView *tabBar = [self.pager valueForKey:@"nativeTabBarView"];
+  [tabBar updateItemsJSON:@"[{\"key\":\"a\",\"title\":\"Overview\"},"
+    @"{\"key\":\"b\",\"title\":\"Ethereum\"},"
+    @"{\"key\":\"c\",\"title\":\"BNB Chain\"},"
+    @"{\"key\":\"d\",\"title\":\"Polygon\"}]"];
+  RCTViewComponentView *sticky = [RCTViewComponentView new];
+  auto stickyProps = std::make_shared<ViewProps>();
+  stickyProps->pointerEvents = PointerEventsMode::BoxNone;
+  [sticky updateProps:stickyProps oldProps:nullptr];
+  UIButton *trailingControl = [[UIButton alloc] initWithFrame:CGRectMake(250, 0, 70, 44)];
+  [sticky addSubview:trailingControl];
+  [sharedHost addSubview:sticky];
+  [sharedHost addSubview:tabBar];
+  [self.pager setValue:sticky forKey:@"stickyHeaderView"];
+  [self.pager setValue:@0 forKey:@"headerHeight"];
+  [self.pager setValue:@44 forKey:@"stickyHeaderHeight"];
+  tabBar.hidden = NO;
+
+  [self.pager setValue:@64 forKey:@"nativeTabBarTrailingReservedWidth"];
+  [self.pager layoutSharedHeaders];
+  XCTAssertEqualWithAccuracy(CGRectGetWidth(sticky.frame), 320, 0.001);
+  XCTAssertEqualWithAccuracy(CGRectGetWidth(tabBar.frame), 256, 0.001);
+  XCTAssertEqualWithAccuracy(CGRectGetMinX(tabBar.frame), 0, 0.001);
+  XCTAssertEqual(sharedHost.subviews.lastObject, sticky);
+  XCTAssertEqual([sharedHost hitTest:CGPointMake(300, 22) withEvent:nil], trailingControl);
+  XCTAssertTrue([tabBar pointInside:CGPointMake(250, 22) withEvent:nil]);
+  [tabBar layoutIfNeeded];
+  [tabBar setProgress:3];
+  UIScrollView *tabScroll = (UIScrollView *)tabBar.subviews.firstObject;
+  NSArray<UIButton *> *buttons = [tabScroll.subviews filteredArrayUsingPredicate:
+    [NSPredicate predicateWithBlock:^BOOL(UIView *view, NSDictionary *bindings) {
+      return [view isKindOfClass:UIButton.class];
+    }]];
+  UIButton *lastTab = buttons.lastObject;
+  XCTAssertNotNil(lastTab);
+  XCTAssertGreaterThanOrEqual(CGRectGetMinX(lastTab.frame), tabScroll.contentOffset.x - 1);
+  XCTAssertLessThanOrEqual(CGRectGetMaxX(lastTab.frame),
+    tabScroll.contentOffset.x + CGRectGetWidth(tabScroll.bounds) + 1);
+
+  [self.pager setValue:@"rtl" forKey:@"layoutDirection"];
+  [tabBar setLeftToRight:NO];
+  trailingControl.frame = CGRectMake(0, 0, 70, 44);
+  [self.pager layoutSharedHeaders];
+  XCTAssertEqualWithAccuracy(CGRectGetMinX(tabBar.frame), 64, 0.001);
+  XCTAssertEqualWithAccuracy(CGRectGetMaxX(tabBar.frame), 320, 0.001);
+  XCTAssertEqual([sharedHost hitTest:CGPointMake(20, 22) withEvent:nil], trailingControl);
+
+  [self.pager setValue:@500 forKey:@"nativeTabBarTrailingReservedWidth"];
+  [self.pager layoutSharedHeaders];
+  XCTAssertEqualWithAccuracy(CGRectGetMinX(tabBar.frame), 320, 0.001);
+  XCTAssertEqualWithAccuracy(CGRectGetWidth(tabBar.frame), 0, 0.001);
+
+  [self.pager setValue:@0 forKey:@"nativeTabBarTrailingReservedWidth"];
+  [self.pager layoutSharedHeaders];
+  XCTAssertEqualWithAccuracy(CGRectGetMinX(tabBar.frame), 0, 0.001);
+  XCTAssertEqualWithAccuracy(CGRectGetWidth(tabBar.frame), 320, 0.001);
+  XCTAssertEqual(sharedHost.subviews.lastObject, tabBar);
+}
+
+- (void)testNativeTabReservationPropsRestoreDefaultOnRemoval
+{
+  auto reservedProps = std::make_shared<RNCCollapsiblePagerViewProps>();
+  reservedProps->nativeSmoothHeaderScrollEnabled = true;
+  reservedProps->nativeTabBarTrailingReservedWidth = 64;
+  [self.pager updateProps:reservedProps oldProps:nullptr];
+  XCTAssertEqualWithAccuracy(
+    [[self.pager valueForKey:@"nativeTabBarTrailingReservedWidth"] doubleValue], 64, 0.001);
+
+  auto defaultProps = std::make_shared<RNCCollapsiblePagerViewProps>();
+  defaultProps->nativeSmoothHeaderScrollEnabled = true;
+  [self.pager updateProps:defaultProps oldProps:reservedProps];
+  XCTAssertEqualWithAccuracy(
+    [[self.pager valueForKey:@"nativeTabBarTrailingReservedWidth"] doubleValue], 0, 0.001);
+}
+
 - (void)testPinnedChildOutsideHeaderHostStillReceivesViewportTouches
 {
   XCTAssertEqual([self.pager hitTest:CGPointMake(20, 90) withEvent:nil], self.sticky);

package/lib/module/CollapsiblePagerView.js

@@ -82,6 +82,12 @@ export class CollapsiblePagerView extends React.PureComponent {
   scrollToPageTop = options => {
     if (this.nativeRef) CollapsiblePagerViewNativeCommands.scrollToTop(this.nativeRef, 0, options?.animated ?? true);
   };
+  scrollHeaderBy = delta => {
+    if (this.nativeRef && Number.isFinite(delta)) CollapsiblePagerViewNativeCommands.scrollHeaderBy(this.nativeRef, delta);
+  };
+  scrollHeaderToOffset = offset => {
+    if (this.nativeRef && Number.isFinite(offset)) CollapsiblePagerViewNativeCommands.scrollHeaderToOffset(this.nativeRef, offset);
+  };
   scrollToStickyTop = options => {
     if (this.nativeRef) CollapsiblePagerViewNativeCommands.scrollToTop(this.nativeRef, 1, options?.animated ?? true);
   };
@@ -96,7 +102,7 @@ export class CollapsiblePagerView extends React.PureComponent {
   nativeTabBarEnabled() {
     return (Platform.OS === "ios" || Platform.OS === "android") && !!this.props.nativeTabBar?.items.length;
   }
-  dispatchNativeTabPageCommand(position, animated) {
+  dispatchNativeTabPageCommand(position, animated, expectedKey) {
     const commandId = ++this.nativeTabCommandId;
     this.nativeTabCommandQueuedDuringScroll = this.nativePagerScrollState !== "idle";
     this.latestNativeTabTarget = position;
@@ -104,7 +110,7 @@ export class CollapsiblePagerView extends React.PureComponent {
       transientRetainedPages: state.transientRetainedPages.includes(position) ? state.transientRetainedPages : [...state.transientRetainedPages, position]
     }), () => {
       requestAnimationFrame(() => {
-        if (commandId !== this.nativeTabCommandId || !this.nativeRef) {
+        if (commandId !== this.nativeTabCommandId || !this.nativeRef || expectedKey !== undefined && (!this.nativeTabBarEnabled() || this.props.nativeTabBar?.items[position]?.key !== expectedKey)) {
           return;
         }
         this.dispatchedNativeTabTarget = position;
@@ -186,10 +192,13 @@ 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)) {
+    if (!this.nativeTabBarEnabled() || position === null || this.props.nativeTabBar?.items[position]?.key !== event.nativeEvent.key) {
+      return;
+    }
+    if (position >= 0 && position < this.pages().length && (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 - currentPage) <= 1);
+      this.dispatchNativeTabPageCommand(position, this.props.nativeTabPressAnimationEnabled ?? Math.abs(position - currentPage) <= 1, event.nativeEvent.key);
     }
     this.props.onNativeTabPress?.(event);
   };
@@ -233,6 +242,8 @@ export class CollapsiblePagerView extends React.PureComponent {
     const deducedLayoutDirection = !layoutDirection || layoutDirection === "locale" ? I18nManager.isRTL ? "rtl" : "ltr" : layoutDirection;
     const nativeTabBarEnabled = (Platform.OS === "ios" || Platform.OS === "android") && !!nativeTabBar?.items.length;
     const nativeTabBarStyle = nativeTabBar?.style;
+    const requestedTrailingReservedWidth = nativeTabBarStyle?.trailingReservedWidth;
+    const nativeTabBarTrailingReservedWidth = typeof requestedTrailingReservedWidth === "number" && Number.isFinite(requestedTrailingReservedWidth) && requestedTrailingReservedWidth >= 0 ? requestedTrailingReservedWidth : 0;
     const nativeSubHeaderEnabled = (Platform.OS === "ios" || Platform.OS === "android") && !!nativeSubHeader?.items.length;
     const nativeSubHeaderStyle = nativeSubHeader?.style;
     const nativeSubHeaderConfig = nativeSubHeaderEnabled ? JSON.stringify({
@@ -263,6 +274,7 @@ export class CollapsiblePagerView extends React.PureComponent {
       onPageScrollStateChanged: this.onPageScrollStateChanged,
       nativeTabBarItems: nativeTabBarEnabled ? JSON.stringify(nativeTabBar.items) : undefined,
       nativeTabBarHeight: nativeTabBarEnabled ? nativeTabBarStyle?.height ?? 44 : undefined,
+      nativeTabBarTrailingReservedWidth: nativeTabBarEnabled ? nativeTabBarTrailingReservedWidth : 0,
       nativeTabBarContentPaddingHorizontal: nativeTabBarEnabled ? nativeTabBarStyle?.contentPaddingHorizontal ?? 20 : undefined,
       nativeTabBarItemSpacing: nativeTabBarEnabled ? nativeTabBarStyle?.itemSpacing ?? 8 : undefined,
       nativeTabBarFontSize: nativeTabBarEnabled ? nativeTabBarStyle?.fontSize ?? 16 : undefined,

package/lib/module/CollapsiblePagerView.web.js

@@ -335,6 +335,15 @@ export class CollapsiblePagerView extends React.PureComponent {
   scrollToPageTop = options => {
     this.scrollCurrentPageToTop(0, options?.animated ?? true);
   };
+  scrollHeaderBy = delta => {
+    if (!Number.isFinite(delta)) return;
+    const offset = Math.min(this.headerHeight, Math.max(0, this.sharedHeaderOffset + delta));
+    this.scrollCurrentPageToTop(offset, false);
+  };
+  scrollHeaderToOffset = offset => {
+    if (!Number.isFinite(offset)) return;
+    this.scrollCurrentPageToTop(Math.min(this.headerHeight, Math.max(0, offset)), false);
+  };
   scrollToStickyTop = options => {
     this.scrollCurrentPageToTop(this.headerHeight, options?.animated ?? true);
   };
@@ -386,13 +395,13 @@ export class CollapsiblePagerView extends React.PureComponent {
       this.pendingTopFrame = null;
       if (!element.isConnected || this.horizontalTouch || this.transitionTimer !== null || this.pageScrollElement(this.state.selectedPage) !== element || this.pages().map(pageKey)[this.state.selectedPage] !== key) return;
       this.pageOffsets.set(key, 0);
-      this.sharedHeaderOffset = offset;
+      this.sharedHeaderOffset = Math.min(this.headerHeight, Math.max(0, offset));
       this.bodyAlignment = {
         element,
         key
       };
       scrollElementTo(element, {
-        top: offset,
+        top: this.sharedHeaderOffset,
         behavior: animated ? "smooth" : "instant"
       });
       this.syncFallbackHeader();

package/lib/module/CollapsiblePagerViewNativeComponent.ts

@@ -67,6 +67,7 @@ export interface NativeProps extends ViewProps {
   retainedPages?: string;
   nativeTabBarItems?: string;
   nativeTabBarHeight?: Double;
+  nativeTabBarTrailingReservedWidth?: WithDefault<Double, 0>;
   nativeTabBarContentPaddingHorizontal?: Double;
   nativeTabBarItemSpacing?: Double;
   nativeTabBarFontSize?: Double;
@@ -91,6 +92,14 @@ export interface NativeProps extends ViewProps {
 type CollapsiblePagerViewNativeType = HostComponent<NativeProps>;
 
 export interface NativeCommands {
+  scrollHeaderToOffset: (
+    viewRef: React.ElementRef<CollapsiblePagerViewNativeType>,
+    offset: Double
+  ) => void;
+  scrollHeaderBy: (
+    viewRef: React.ElementRef<CollapsiblePagerViewNativeType>,
+    delta: Double
+  ) => void;
   scrollToTop: (
     viewRef: React.ElementRef<CollapsiblePagerViewNativeType>,
     target: Int32,
@@ -112,6 +121,8 @@ export interface NativeCommands {
 
 export const Commands: NativeCommands = codegenNativeCommands<NativeCommands>({
   supportedCommands: [
+    "scrollHeaderToOffset",
+    "scrollHeaderBy",
     "scrollToTop",
     "setPage",
     "setPageWithoutAnimation",

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

@@ -17,6 +17,7 @@ export type CollapsiblePagerNativeTabBarItem = Readonly<{
 }>;
 export type CollapsiblePagerNativeTabBarStyle = Readonly<{
     height?: number;
+    trailingReservedWidth?: number;
     contentPaddingHorizontal?: number;
     itemSpacing?: number;
     fontSize?: number;
@@ -56,7 +57,7 @@ export type CollapsiblePagerNativeSubHeaderConfig = Readonly<{
 }>;
 export type CollapsiblePagerViewOnNativeTabPressEvent = ReactNative.NativeSyntheticEvent<OnNativeTabPressEventData>;
 export type CollapsiblePagerViewOnNativeSubHeaderPressEvent = ReactNative.NativeSyntheticEvent<OnNativeTabPressEventData>;
-export interface CollapsiblePagerViewProps extends Omit<NativeProps, "children" | "headerHeight" | "stickyHeaderHeight" | "topScrollEdgeEffect" | "topOverlayHeight" | "externalTopOverlayTag" | "pageKeys" | "retainedPages" | "nativeTabBarItems" | "nativeTabBarHeight" | "nativeTabBarContentPaddingHorizontal" | "nativeTabBarItemSpacing" | "nativeTabBarFontSize" | "nativeTabBarFontFamily" | "nativeTabBarBackgroundColor" | "nativeTabBarActiveTextColor" | "nativeTabBarInactiveTextColor" | "nativeTabBarIndicatorColor" | "nativeTabBarIndicatorHeight" | "nativeTabBarIndicatorBottom" | "nativeSubHeaderConfig" | "nativeSubHeaderSelectedBackgroundColor" | "onNativeTabPress" | "onNativeSubHeaderPress" | "layoutDirection"> {
+export interface CollapsiblePagerViewProps extends Omit<NativeProps, "children" | "headerHeight" | "stickyHeaderHeight" | "topScrollEdgeEffect" | "topOverlayHeight" | "externalTopOverlayTag" | "pageKeys" | "retainedPages" | "nativeTabBarItems" | "nativeTabBarHeight" | "nativeTabBarTrailingReservedWidth" | "nativeTabBarContentPaddingHorizontal" | "nativeTabBarItemSpacing" | "nativeTabBarFontSize" | "nativeTabBarFontFamily" | "nativeTabBarBackgroundColor" | "nativeTabBarActiveTextColor" | "nativeTabBarInactiveTextColor" | "nativeTabBarIndicatorColor" | "nativeTabBarIndicatorHeight" | "nativeTabBarIndicatorBottom" | "nativeSubHeaderConfig" | "nativeSubHeaderSelectedBackgroundColor" | "onNativeTabPress" | "onNativeSubHeaderPress" | "layoutDirection"> {
     /** Collapsible content rendered above the sticky bar. */
     header: React.ReactNode;
     /** Bar which remains pinned after the header has collapsed. */
@@ -128,6 +129,8 @@ export declare class CollapsiblePagerView extends React.PureComponent<Collapsibl
     scrollToPageTop: (options?: Readonly<{
         animated?: boolean;
     }>) => void;
+    scrollHeaderBy: (delta: number) => void;
+    scrollHeaderToOffset: (offset: number) => void;
     scrollToStickyTop: (options?: Readonly<{
         animated?: boolean;
     }>) => void;

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

@@ -132,6 +132,8 @@ export declare class CollapsiblePagerView extends React.PureComponent<Collapsibl
     scrollToPageTop: (options?: Readonly<{
         animated?: boolean;
     }>) => void;
+    scrollHeaderBy: (delta: number) => void;
+    scrollHeaderToOffset: (offset: number) => void;
     scrollToStickyTop: (options?: Readonly<{
         animated?: boolean;
     }>) => void;

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

@@ -50,6 +50,7 @@ export interface NativeProps extends ViewProps {
     retainedPages?: string;
     nativeTabBarItems?: string;
     nativeTabBarHeight?: Double;
+    nativeTabBarTrailingReservedWidth?: WithDefault<Double, 0>;
     nativeTabBarContentPaddingHorizontal?: Double;
     nativeTabBarItemSpacing?: Double;
     nativeTabBarFontSize?: Double;
@@ -72,6 +73,8 @@ export interface NativeProps extends ViewProps {
 }
 type CollapsiblePagerViewNativeType = HostComponent<NativeProps>;
 export interface NativeCommands {
+    scrollHeaderToOffset: (viewRef: React.ElementRef<CollapsiblePagerViewNativeType>, offset: Double) => void;
+    scrollHeaderBy: (viewRef: React.ElementRef<CollapsiblePagerViewNativeType>, delta: Double) => void;
     scrollToTop: (viewRef: React.ElementRef<CollapsiblePagerViewNativeType>, target: Int32, animated: boolean) => void;
     setPage: (viewRef: React.ElementRef<CollapsiblePagerViewNativeType>, selectedPage: Int32) => void;
     setPageWithoutAnimation: (viewRef: React.ElementRef<CollapsiblePagerViewNativeType>, selectedPage: Int32) => void;

package/package.json

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

package/src/CollapsiblePagerView.tsx

@@ -33,6 +33,7 @@ export type CollapsiblePagerNativeTabBarItem = Readonly<{
 
 export type CollapsiblePagerNativeTabBarStyle = Readonly<{
   height?: number;
+  trailingReservedWidth?: number;
   contentPaddingHorizontal?: number;
   itemSpacing?: number;
   fontSize?: number;
@@ -94,6 +95,7 @@ export interface CollapsiblePagerViewProps
     | "retainedPages"
     | "nativeTabBarItems"
     | "nativeTabBarHeight"
+    | "nativeTabBarTrailingReservedWidth"
     | "nativeTabBarContentPaddingHorizontal"
     | "nativeTabBarItemSpacing"
     | "nativeTabBarFontSize"
@@ -290,6 +292,22 @@ export class CollapsiblePagerView extends React.PureComponent<
       );
   };
 
+  public scrollHeaderBy = (delta: number) => {
+    if (this.nativeRef && Number.isFinite(delta))
+      CollapsiblePagerViewNativeCommands.scrollHeaderBy(
+        this.nativeRef,
+        delta
+      );
+  };
+
+  public scrollHeaderToOffset = (offset: number) => {
+    if (this.nativeRef && Number.isFinite(offset))
+      CollapsiblePagerViewNativeCommands.scrollHeaderToOffset(
+        this.nativeRef,
+        offset
+      );
+  };
+
   public scrollToStickyTop = (options?: Readonly<{ animated?: boolean }>) => {
     if (this.nativeRef)
       CollapsiblePagerViewNativeCommands.scrollToTop(
@@ -319,7 +337,11 @@ export class CollapsiblePagerView extends React.PureComponent<
     );
   }
 
-  private dispatchNativeTabPageCommand(position: number, animated: boolean) {
+  private dispatchNativeTabPageCommand(
+    position: number,
+    animated: boolean,
+    expectedKey?: string
+  ) {
     const commandId = ++this.nativeTabCommandId;
     this.nativeTabCommandQueuedDuringScroll =
       this.nativePagerScrollState !== "idle";
@@ -332,7 +354,13 @@ export class CollapsiblePagerView extends React.PureComponent<
       }),
       () => {
         requestAnimationFrame(() => {
-          if (commandId !== this.nativeTabCommandId || !this.nativeRef) {
+          if (
+            commandId !== this.nativeTabCommandId ||
+            !this.nativeRef ||
+            (expectedKey !== undefined &&
+              (!this.nativeTabBarEnabled() ||
+                this.props.nativeTabBar?.items[position]?.key !== expectedKey))
+          ) {
             return;
           }
           this.dispatchedNativeTabTarget = position;
@@ -458,7 +486,13 @@ export class CollapsiblePagerView extends React.PureComponent<
   ) => {
     const position = pageIndex(event.nativeEvent.position);
     if (
-      position !== null &&
+      !this.nativeTabBarEnabled() ||
+      position === null ||
+      this.props.nativeTabBar?.items[position]?.key !== event.nativeEvent.key
+    ) {
+      return;
+    }
+    if (
       position >= 0 &&
       position < this.pages().length &&
       (position !== this.state.selectedPage ||
@@ -470,7 +504,8 @@ export class CollapsiblePagerView extends React.PureComponent<
       this.dispatchNativeTabPageCommand(
         position,
         this.props.nativeTabPressAnimationEnabled ??
-          Math.abs(position - currentPage) <= 1
+          Math.abs(position - currentPage) <= 1,
+        event.nativeEvent.key
       );
     }
     this.props.onNativeTabPress?.(event);
@@ -533,6 +568,14 @@ export class CollapsiblePagerView extends React.PureComponent<
       (Platform.OS === "ios" || Platform.OS === "android") &&
       !!nativeTabBar?.items.length;
     const nativeTabBarStyle = nativeTabBar?.style;
+    const requestedTrailingReservedWidth =
+      nativeTabBarStyle?.trailingReservedWidth;
+    const nativeTabBarTrailingReservedWidth =
+      typeof requestedTrailingReservedWidth === "number" &&
+      Number.isFinite(requestedTrailingReservedWidth) &&
+      requestedTrailingReservedWidth >= 0
+        ? requestedTrailingReservedWidth
+        : 0;
     const nativeSubHeaderEnabled =
       (Platform.OS === "ios" || Platform.OS === "android") &&
       !!nativeSubHeader?.items.length;
@@ -586,6 +629,9 @@ export class CollapsiblePagerView extends React.PureComponent<
         nativeTabBarHeight={
           nativeTabBarEnabled ? nativeTabBarStyle?.height ?? 44 : undefined
         }
+        nativeTabBarTrailingReservedWidth={
+          nativeTabBarEnabled ? nativeTabBarTrailingReservedWidth : 0
+        }
         nativeTabBarContentPaddingHorizontal={
           nativeTabBarEnabled
             ? nativeTabBarStyle?.contentPaddingHorizontal ?? 20

package/src/CollapsiblePagerView.web.tsx

@@ -580,6 +580,23 @@ export class CollapsiblePagerView extends React.PureComponent<
     this.scrollCurrentPageToTop(0, options?.animated ?? true);
   };
 
+  public scrollHeaderBy = (delta: number) => {
+    if (!Number.isFinite(delta)) return;
+    const offset = Math.min(
+      this.headerHeight,
+      Math.max(0, this.sharedHeaderOffset + delta)
+    );
+    this.scrollCurrentPageToTop(offset, false);
+  };
+
+  public scrollHeaderToOffset = (offset: number) => {
+    if (!Number.isFinite(offset)) return;
+    this.scrollCurrentPageToTop(
+      Math.min(this.headerHeight, Math.max(0, offset)),
+      false
+    );
+  };
+
   public scrollToStickyTop = (options?: Readonly<{ animated?: boolean }>) => {
     this.scrollCurrentPageToTop(
       this.headerHeight,
@@ -674,10 +691,10 @@ export class CollapsiblePagerView extends React.PureComponent<
       )
         return;
       this.pageOffsets.set(key, 0);
-      this.sharedHeaderOffset = offset;
+      this.sharedHeaderOffset = Math.min(this.headerHeight, Math.max(0, offset));
       this.bodyAlignment = { element, key };
       scrollElementTo(element, {
-        top: offset,
+        top: this.sharedHeaderOffset,
         behavior: animated ? "smooth" : "instant",
       });
       this.syncFallbackHeader();

package/src/CollapsiblePagerViewNativeComponent.ts

@@ -67,6 +67,7 @@ export interface NativeProps extends ViewProps {
   retainedPages?: string;
   nativeTabBarItems?: string;
   nativeTabBarHeight?: Double;
+  nativeTabBarTrailingReservedWidth?: WithDefault<Double, 0>;
   nativeTabBarContentPaddingHorizontal?: Double;
   nativeTabBarItemSpacing?: Double;
   nativeTabBarFontSize?: Double;
@@ -91,6 +92,14 @@ export interface NativeProps extends ViewProps {
 type CollapsiblePagerViewNativeType = HostComponent<NativeProps>;
 
 export interface NativeCommands {
+  scrollHeaderToOffset: (
+    viewRef: React.ElementRef<CollapsiblePagerViewNativeType>,
+    offset: Double
+  ) => void;
+  scrollHeaderBy: (
+    viewRef: React.ElementRef<CollapsiblePagerViewNativeType>,
+    delta: Double
+  ) => void;
   scrollToTop: (
     viewRef: React.ElementRef<CollapsiblePagerViewNativeType>,
     target: Int32,
@@ -112,6 +121,8 @@ export interface NativeCommands {
 
 export const Commands: NativeCommands = codegenNativeCommands<NativeCommands>({
   supportedCommands: [
+    "scrollHeaderToOffset",
+    "scrollHeaderBy",
     "scrollToTop",
     "setPage",
     "setPageWithoutAnimation",