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

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
@@ -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
@@ -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.

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;
 
@@ -368,7 +369,9 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
 @property (nonatomic, copy) RNCCollapsiblePagerNativeTabPressHandler onTabPress;
 - (void)updateItemsJSON:(NSString *)itemsJSON;
 - (void)updateStyleWithHeight:(CGFloat)height
+                      variant:(NSString *)variant
      contentPaddingHorizontal:(CGFloat)contentPaddingHorizontal
+       contentPaddingVertical:(CGFloat)contentPaddingVertical
                   itemSpacing:(CGFloat)itemSpacing
                      fontSize:(CGFloat)fontSize
                    fontFamily:(NSString *)fontFamily
@@ -385,12 +388,15 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
 
 @implementation RNCCollapsiblePagerNativeTabBarView {
   RNCCollapsiblePagerHorizontalScrollView *_scrollView;
+  UIView *_trackView;
   UIView *_indicatorView;
   NSArray<NSDictionary *> *_items;
   NSMutableArray<UIButton *> *_buttons;
   NSMutableArray<NSValue *> *_indicatorFrames;
   CGFloat _barHeight;
   CGFloat _contentPaddingHorizontal;
+  CGFloat _contentPaddingVertical;
+  BOOL _segmented;
   CGFloat _itemSpacing;
   CGFloat _fontSize;
   NSString *_fontFamily;
@@ -413,6 +419,8 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
     _indicatorFrames = [NSMutableArray new];
     _barHeight = 44;
     _contentPaddingHorizontal = 20;
+    _contentPaddingVertical = 0;
+    _segmented = NO;
     _itemSpacing = 8;
     _fontSize = 16;
     _activeTextColor = UIColor.labelColor;
@@ -434,6 +442,10 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
     _scrollView.delegate = self;
     [self addSubview:_scrollView];
 
+    _trackView = [UIView new];
+    _trackView.userInteractionEnabled = NO;
+    [_scrollView addSubview:_trackView];
+
     _indicatorView = [UIView new];
     _indicatorView.userInteractionEnabled = NO;
     [_scrollView addSubview:_indicatorView];
@@ -488,7 +500,9 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
 }
 
 - (void)updateStyleWithHeight:(CGFloat)height
+                      variant:(NSString *)variant
      contentPaddingHorizontal:(CGFloat)contentPaddingHorizontal
+       contentPaddingVertical:(CGFloat)contentPaddingVertical
                   itemSpacing:(CGFloat)itemSpacing
                      fontSize:(CGFloat)fontSize
                    fontFamily:(NSString *)fontFamily
@@ -500,19 +514,26 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
               indicatorBottom:(CGFloat)indicatorBottom
 {
   _barHeight = MAX(1, height);
+  BOOL wasSegmented = _segmented;
+  _segmented = [variant isEqualToString:@"segmented"];
   _contentPaddingHorizontal = MAX(0, contentPaddingHorizontal);
+  _contentPaddingVertical = MAX(0, contentPaddingVertical);
   _itemSpacing = MAX(0, itemSpacing);
   _fontSize = MAX(1, fontSize);
   _fontFamily = [fontFamily copy];
-  self.backgroundColor = backgroundColor ?: UIColor.clearColor;
+  self.backgroundColor = _segmented ? UIColor.clearColor : (backgroundColor ?: UIColor.clearColor);
   _scrollView.backgroundColor = self.backgroundColor;
+  _scrollView.scrollEnabled = !_segmented;
+  if (_segmented && !wasSegmented) [_scrollView setContentOffset:CGPointZero animated:NO];
+  _trackView.hidden = !_segmented;
+  _trackView.backgroundColor = backgroundColor ?: UIColor.clearColor;
   _activeTextColor = activeTextColor ?: UIColor.labelColor;
   _inactiveTextColor = inactiveTextColor ?: UIColor.secondaryLabelColor;
   _indicatorColor = indicatorColor ?: _activeTextColor;
   _indicatorHeight = MAX(0, indicatorHeight);
   _indicatorBottom = MAX(0, indicatorBottom);
   _indicatorView.backgroundColor = _indicatorColor;
-  _indicatorView.layer.cornerRadius = _indicatorHeight / 2;
+  _indicatorView.layer.cornerRadius = _segmented ? 0 : _indicatorHeight / 2;
   for (UIButton *button in _buttons) button.titleLabel.font = self.tabFont;
   [self setNeedsLayout];
 }
@@ -571,6 +592,33 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
 {
   [super layoutSubviews];
   _scrollView.frame = self.bounds;
+  if (_segmented) {
+    CGFloat width = CGRectGetWidth(self.bounds);
+    CGFloat height = CGRectGetHeight(self.bounds);
+    CGFloat insetX = MIN(_contentPaddingHorizontal, width / 2);
+    CGFloat insetY = MIN(_contentPaddingVertical, height / 2);
+    CGRect trackFrame = CGRectMake(insetX, insetY,
+      MAX(0, width - 2 * insetX), MAX(0, height - 2 * insetY));
+    _trackView.frame = trackFrame;
+    _trackView.layer.cornerRadius = CGRectGetHeight(trackFrame) / 2;
+    _scrollView.contentSize = self.bounds.size;
+    [_indicatorFrames removeAllObjects];
+    NSUInteger count = _buttons.count;
+    [_buttons enumerateObjectsUsingBlock:^(UIButton *button, NSUInteger index, BOOL *stop) {
+      CGFloat first = CGRectGetMinX(trackFrame) + CGRectGetWidth(trackFrame) * index / count;
+      CGFloat last = CGRectGetMinX(trackFrame) + CGRectGetWidth(trackFrame) * (index + 1) / count;
+      CGFloat x = self->_leftToRight ? first : CGRectGetMaxX(trackFrame) - (last - CGRectGetMinX(trackFrame));
+      CGFloat end = self->_leftToRight ? last : CGRectGetMaxX(trackFrame) - (first - CGRectGetMinX(trackFrame));
+      button.frame = CGRectMake(x, CGRectGetMinY(trackFrame), MAX(0, end - x), CGRectGetHeight(trackFrame));
+      CGRect thumbFrame = CGRectMake(x + 2, CGRectGetMinY(trackFrame) + 2,
+        MAX(0, CGRectGetWidth(button.frame) - 4), MAX(0, CGRectGetHeight(trackFrame) - 4));
+      [self->_indicatorFrames addObject:[NSValue valueWithCGRect:thumbFrame]];
+    }];
+    _indicatorView.layer.cornerRadius = MAX(0, CGRectGetHeight(trackFrame) - 4) / 2;
+    [self updatePresentation];
+    return;
+  }
+  _trackView.frame = CGRectZero;
   UIFont *font = self.tabFont;
   NSMutableArray<NSNumber *> *widths = [NSMutableArray arrayWithCapacity:_buttons.count];
   CGFloat itemsWidth = 0;
@@ -634,10 +682,10 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
     CGRectGetMinX(fromFrame) + (CGRectGetMinX(toFrame) - CGRectGetMinX(fromFrame)) * fraction,
     CGRectGetMinY(fromFrame),
     CGRectGetWidth(fromFrame) + (CGRectGetWidth(toFrame) - CGRectGetWidth(fromFrame)) * fraction,
-    _indicatorHeight
+    _segmented ? CGRectGetHeight(fromFrame) : _indicatorHeight
   );
   _indicatorView.frame = indicatorFrame;
-  _indicatorView.hidden = _indicatorHeight <= 0;
+  _indicatorView.hidden = CGRectGetHeight(indicatorFrame) <= 0;
 
   NSInteger selectedIndex = (NSInteger)round(progress);
   [_buttons enumerateObjectsUsingBlock:^(UIButton *button, NSUInteger index, BOOL *stop) {
@@ -654,7 +702,7 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
       : UIAccessibilityTraitButton;
   }];
 
-  if (_shouldCenterSelectedItem && !_scrollView.tracking && !_scrollView.dragging &&
+  if (_shouldCenterSelectedItem && !_segmented && !_scrollView.tracking && !_scrollView.dragging &&
       !_scrollView.decelerating && CGRectGetWidth(_scrollView.bounds) > 0) {
     CGFloat maximumOffset = MAX(0, _scrollView.contentSize.width - CGRectGetWidth(_scrollView.bounds));
     CGFloat desiredOffset = RNCClamp(
@@ -1471,6 +1519,7 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
 - (void)liftSharedHeadersForPagerTransition:(NSString *)reason;
 - (void)restoreSharedHeadersToContainer;
 - (void)layoutSharedHeaders;
+- (void)bringReservedStickyControlToFront;
 - (void)restorePinnedStickyHeader;
 - (void)updatePinnedStickyHeader;
 - (UIScrollView *)currentVerticalScrollViewForParentPager;
@@ -1558,6 +1607,7 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
   NSUInteger _pendingTopInsetReboundGeneration;
   NSTimer *_topInsetReboundTimer;
   CGFloat _nativeTabBarHeight;
+  CGFloat _nativeTabBarTrailingReservedWidth;
   CGFloat _nativeSubHeaderHeight;
   CGFloat _headerOffset;
   BOOL _scrollEnabled;
@@ -2479,6 +2529,7 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
   }
   [_nativeTabBarView updateAncestorGesturePrecedence];
   [_nativeSubHeaderView updateAncestorGesturePrecedence];
+  [self bringReservedStickyControlToFront];
 }
 
 - (void)restoreSharedHeadersToContainer
@@ -2584,10 +2635,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 +2653,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 +2719,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 +2742,7 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
   }
   [_nativeTabBarView updateAncestorGesturePrecedence];
   [_nativeSubHeaderView updateAncestorGesturePrecedence];
+  [self bringReservedStickyControlToFront];
   [self updateTopScrollEdgeForScrollView:_observedScrollView];
   [self logHomeVisualGeometry:shouldPin ? @"pin" : @"unpin"
                     scrollView:_observedScrollView];
@@ -3050,6 +3122,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 +3335,7 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
   _homeVisualLastLayoutLog = 0;
   _homeVisualLastGeometrySignature = nil;
   _nativeTabBarHeight = 44;
+  _nativeTabBarTrailingReservedWidth = 0;
   _nativeSubHeaderHeight = 74;
   _headerOffset = 0;
   _currentLogicalOffset = 0;
@@ -3343,6 +3417,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) {
@@ -3423,7 +3504,9 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
   }
   if (_needsPropsReapply ||
       oldViewProps.nativeTabBarHeight != newViewProps.nativeTabBarHeight ||
+      oldViewProps.nativeTabBarVariant != newViewProps.nativeTabBarVariant ||
       oldViewProps.nativeTabBarContentPaddingHorizontal != newViewProps.nativeTabBarContentPaddingHorizontal ||
+      oldViewProps.nativeTabBarContentPaddingVertical != newViewProps.nativeTabBarContentPaddingVertical ||
       oldViewProps.nativeTabBarItemSpacing != newViewProps.nativeTabBarItemSpacing ||
       oldViewProps.nativeTabBarFontSize != newViewProps.nativeTabBarFontSize ||
       oldViewProps.nativeTabBarFontFamily != newViewProps.nativeTabBarFontFamily ||
@@ -3440,7 +3523,9 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
     NSString *fontFamily = RCTNSStringFromString(newViewProps.nativeTabBarFontFamily);
     [_nativeTabBarView
       updateStyleWithHeight:_nativeTabBarHeight
+      variant:RCTNSStringFromString(newViewProps.nativeTabBarVariant)
       contentPaddingHorizontal:MAX(0, newViewProps.nativeTabBarContentPaddingHorizontal)
+      contentPaddingVertical:MAX(0, newViewProps.nativeTabBarContentPaddingVertical)
       itemSpacing:MAX(0, newViewProps.nativeTabBarItemSpacing)
       fontSize:newViewProps.nativeTabBarFontSize > 0 ? newViewProps.nativeTabBarFontSize : 16
       fontFamily:fontFamily
@@ -3474,6 +3559,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 +4524,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 +5320,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 +5338,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 +5376,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];