@onekeyfe/react-native-pager-view 6.7.0-15 → 6.7.0-17

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

@@ -239,6 +239,18 @@ class CollapsiblePagerViewManager : ViewGroupManager<CollapsiblePagerHost>(),
     view.applyNativeHeaderStyle()
   }
 
+  @ReactProp(name = "nativeTabBarVariant")
+  override fun setNativeTabBarVariant(view: CollapsiblePagerHost?, value: String?) {
+    view ?: return
+    view.nativeTabBarVariant = if (value == "segmented") "segmented" else "underline"
+    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?,
@@ -249,6 +261,13 @@ class CollapsiblePagerViewManager : ViewGroupManager<CollapsiblePagerHost>(),
     view.applyNativeHeaderStyle()
   }
 
+  @ReactProp(name = "nativeTabBarContentPaddingVertical")
+  override fun setNativeTabBarContentPaddingVertical(view: CollapsiblePagerHost?, value: Double) {
+    view ?: return
+    view.nativeTabBarContentPaddingVertical = if (value.isFinite()) value.coerceAtLeast(0.0) else 0.0
+    view.applyNativeHeaderStyle()
+  }
+
   @ReactProp(name = "nativeTabBarItemSpacing")
   override fun setNativeTabBarItemSpacing(view: CollapsiblePagerHost?, value: Double) {
     view ?: return
@@ -343,6 +362,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
@@ -452,6 +496,40 @@ The attached UIKit regression intentionally constrains the real pager pan to two
 required touches to prove the no-pan path; it is distinct from natural Home OS
 input, coalesced-event delivery, and physical-device acceptance.
 
+## Native segmented tab bar
+
+Status: implemented locally. Focused production-class iOS XCTest and Android
+instrumentation checks pass; consuming App interaction acceptance is separate.
+`nativeTabBar.style.variant` accepts `"underline"` (the default) or
+`"segmented"` on iOS and Android. The optional
+`nativeTabBar.style.contentPaddingVertical` is a nonnegative logical inset,
+defaulting to zero. Omitting both fields preserves the existing content-width,
+horizontally scrollable underline bar. Web ignores `nativeTabBar` and retains
+its caller-rendered sticky header.
+
+In segmented mode, the existing `height` is the entire tab slot. The track
+fills the space inside `contentPaddingHorizontal` and
+`contentPaddingVertical`, uses `backgroundColor`, and has a fully rounded
+outline. Its visible items divide the track into equal-width segments in their
+current order, including after item insertion, removal, relabeling, or resize.
+The thumb uses `indicatorColor`, is inset two logical points from its segment,
+and is fully rounded. Segment titles use the existing font and active/inactive
+text colors, remain single-line with truncation, and retain their existing
+accessibility labels, test IDs, and native press event keys. The segmented bar
+does not scroll horizontally; `itemSpacing`, `indicatorHeight`, and
+`indicatorBottom` apply only to underline mode. The pager's native fractional
+page progress moves the thumb continuously between equal-width segments and
+interpolates text emphasis without per-frame JavaScript updates. It settles at
+the actual selected page after a completed or cancelled gesture. RTL reverses
+physical segment order without changing logical page keys or indices.
+
+Switching variants or removing the native tab bar clears the previous visual
+state. The existing native press command, page callbacks, retention, vertical
+header geometry, and Web behavior remain unchanged. Acceptance requires
+focused native geometry/progress/press checks on iOS and Android, including
+two or three segments, dynamic labels/items, RTL, narrow widths, and variant
+switching. Type forwarding alone does not prove rendered behavior.
+
 ## Native tab-press animation default
 
 Behavior change: previously an omitted `nativeTabPressAnimationEnabled` animated
@@ -472,6 +550,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.
@@ -817,6 +917,51 @@ fallback debounce, including replacement-state restoration. Other collection
 fallbacks keep that safety delay. Caller insets and retained logical offsets
 remain governed by the existing restoration policy.
 
+When the active scroll owner is removed before its replacement becomes usable,
+the pager MUST retain bounded recovery (at most 12 retries per recovery round,
+spaced 100 ms apart). Clearing the completed mount's reattachment flag MUST NOT
+cancel that recovery. A replacement that becomes usable during that round,
+without another Fabric insertion, MUST receive the observer, shared headers,
+insets and retained collapse state. Page selection changes and recycling
+invalidate stale retry callbacks. Repeated mount attempts MUST NOT reset the
+retry budget. Once all 12 retries have been scheduled, an Insert whose parent is
+in the current page subtree MUST reopen recovery if that page retains a released
+scroll owner, including when the final retry callback is still pending. Reopening
+invalidates the old callback before clearing its scheduled state. The Insert
+MUST be recorded during a horizontal drag or transition, while observer and shared
+header attachment remain deferred until selection settles. Cancelling the drag
+on the same page MUST retain the reopened recovery round. Empty transactions,
+removals and inserts outside the current page MUST NOT reopen the budget. Owned
+`NativeScroller` and `NativeList` hosts additionally emit push readiness
+notifications when their scroll views attach and obtain positive bounds so late
+replacements recover immediately even without another Fabric insertion or after
+the retry budget expires; static pages with neither an unready scroll host nor a
+released scroll owner do not schedule retry timers.
+
+Status of transition-time and pending-final-retry recovery: implemented and
+UIKit regression verified on iOS 26.5 (2026-10-27). Both new regressions fail
+before the fix and pass afterward. Cancellation settles on the source page
+before the replacement becomes usable; the pending-final-retry case makes the
+replacement usable after the old timer's deadline. Observer and shared header
+ownership stay detached during the drag, then recover with the retained collapse.
+The full Pager suite executes 85 tests, with one iOS-27-only skip and no failures.
+
+Status of exhausted-budget recovery: implemented and UIKit regression verified
+on iOS 26.5 (2026-10-27). The regression exhausts the initial round, checks that
+empty transactions, removals and offscreen inserts do not reopen it, then inserts
+a current-page replacement whose scroller appears after did-mount. It fails
+before the fix and passes afterward, including preservation of an active round
+and restoration of the observer, shared headers and retained collapse. The full
+Pager suite executes 83 tests, with one iOS-27-only skip and no failures.
+
+Status of replacement recovery: implemented and runtime verified on iOS 26.5
+(2026-10-23). The late-replacement UIKit regression fails before the fix and
+passes afterward; the full Pager suite executes 82 tests, with one iOS-27-only
+skip and no failures. In the consuming app based on x at b0789571d8 with SDK
+6.7.0-9 and this local native change, two empty Favorites-to-Wallet-add-to-Market
+cycles and a Trending/Favorites round trip keep the first row aligned with the
+sticky header. The previously observed 212-point gap is absent.
+
 This is a UI-thread, main-runtime native coordination change with no new props,
 events, background-runtime work, persistence or retained strong view cache.
 Android already prepares discovered scroll children before draw and is unchanged;