react-native-navigation 8.8.4 → 8.8.5

package/ios/RNNBasePresenter.mm

@@ -144,6 +144,13 @@
 }
 
 - (UINavigationItem *)currentNavigationItem {
+    if ([self.boundViewController isKindOfClass:[UINavigationController class]]) {
+        UINavigationController *navigationController =
+            (UINavigationController *)self.boundViewController;
+        if (navigationController.topViewController) {
+            return navigationController.topViewController.navigationItem;
+        }
+    }
     return self.boundViewController.getCurrentChild.navigationItem;
 }
 

package/ios/RNNReactButtonView.h

@@ -6,4 +6,6 @@
 
 @interface RNNReactButtonView : RNNComponentView
 
+@property(nonatomic, copy) void (^intrinsicSizeDidChangeHandler)(CGSize intrinsicSize);
+
 @end

package/ios/RNNReactButtonView.mm

@@ -1,10 +1,13 @@
 #import "RNNReactButtonView.h"
 #import <React/RCTSurface.h>
 
+static const CGFloat kMinBarButtonSlotSize = 44.0;
+
 @implementation RNNReactButtonView {
     NSLayoutConstraint *_widthConstraint;
     NSLayoutConstraint *_heightConstraint;
-    BOOL _didCenter;
+    BOOL _didCenterHorizontally;
+    CGFloat _lastReportedWidth;
 }
 
 - (instancetype)initWithHost:(RCTHost *)host
@@ -19,14 +22,16 @@
 
     if (@available(iOS 26.0, *)) {
         if (![self designRequiresCompatibility]) {
+            self.sizeFlexibility = RCTRootViewSizeFlexibilityWidth;
             self.translatesAutoresizingMaskIntoConstraints = NO;
             _widthConstraint = [self.widthAnchor constraintEqualToConstant:0];
-            _heightConstraint = [self.heightAnchor constraintEqualToConstant:0];
+            _heightConstraint = [self.heightAnchor constraintEqualToConstant:kMinBarButtonSlotSize];
             _widthConstraint.priority = UILayoutPriorityDefaultHigh;
             _heightConstraint.priority = UILayoutPriorityDefaultHigh;
             _widthConstraint.active = YES;
             _heightConstraint.active = YES;
-            _didCenter = NO;
+            _didCenterHorizontally = NO;
+            self.delegate = self;
         }
     }
 
@@ -43,37 +48,156 @@
     return result;
 }
 
+- (UIView *)surfaceHostView {
+#ifdef RCT_NEW_ARCH_ENABLED
+    UIView *surfaceView = (UIView *)self.surface.view;
+    if (surfaceView != nil && surfaceView.superview == self) {
+        return surfaceView;
+    }
+#endif
+    return self.subviews.firstObject;
+}
+
+- (void)accumulateLeafBoundsInContainer:(UIView *)container unionRect:(CGRect *)unionRect {
+    for (UIView *subview in container.subviews) {
+        if (subview.hidden || subview.alpha < 0.01) {
+            continue;
+        }
+        if (subview.subviews.count == 0) {
+            CGRect rect = [subview convertRect:subview.bounds toView:self];
+            if (rect.size.width > 0 && rect.size.height > 0) {
+                *unionRect = CGRectIsNull(*unionRect) ? rect : CGRectUnion(*unionRect, rect);
+            }
+        } else {
+            [self accumulateLeafBoundsInContainer:subview unionRect:unionRect];
+        }
+    }
+}
+
+- (CGRect)visibleLeafContentBounds {
+    CGRect unionRect = CGRectNull;
+    UIView *surfaceView = [self surfaceHostView];
+    if (surfaceView) {
+        [self accumulateLeafBoundsInContainer:surfaceView unionRect:&unionRect];
+    }
+    if (CGRectIsNull(unionRect)) {
+        [self accumulateLeafBoundsInContainer:self unionRect:&unionRect];
+    }
+    return CGRectIsNull(unionRect) ? CGRectZero : unionRect;
+}
+
+- (CGSize)measuredSurfaceContentSize {
+    CGSize intrinsic = CGSizeZero;
+#ifdef RCT_NEW_ARCH_ENABLED
+    intrinsic = self.surface.intrinsicSize;
+#else
+    intrinsic = self.intrinsicContentSize;
+#endif
+    if (intrinsic.width <= 0 || intrinsic.height <= 0) {
+        return CGSizeZero;
+    }
+
+    CGFloat maxWidth = self.bounds.size.width > 0 ? self.bounds.size.width : CGFLOAT_MAX;
+    CGSize fit = [self sizeThatFits:CGSizeMake(maxWidth, CGFLOAT_MAX)];
+    if (fit.height > 0 && fit.height < intrinsic.height - 0.5) {
+        intrinsic.height = fit.height;
+    }
+    return intrinsic;
+}
+
+- (void)centerSurfaceContentIfNeeded {
+    if (self.bounds.size.width <= 0 || self.bounds.size.height <= 0) {
+        return;
+    }
+
+    UIView *surfaceView = [self surfaceHostView];
+    if (!surfaceView || surfaceView == self) {
+        return;
+    }
+
+    CGRect surfaceFrame = surfaceView.frame;
+    if (surfaceFrame.size.width <= 0) {
+        surfaceFrame.size.width = self.bounds.size.width;
+    }
+    if (surfaceFrame.size.height <= 0) {
+        surfaceFrame.size.height = self.bounds.size.height;
+    }
+    surfaceView.frame = CGRectMake(0, 0, surfaceFrame.size.width, surfaceFrame.size.height);
+
+    CGRect contentBounds = [self visibleLeafContentBounds];
+    if (!CGRectIsEmpty(contentBounds)) {
+        CGFloat targetY = (self.bounds.size.height - contentBounds.size.height) / 2.0;
+        CGFloat deltaY = targetY - contentBounds.origin.y;
+        if (fabs(deltaY) > 0.5) {
+            surfaceView.frame = CGRectOffset(surfaceView.frame, 0, deltaY);
+        }
+        return;
+    }
+
+    CGSize contentSize = [self measuredSurfaceContentSize];
+    if (contentSize.height > 0 && self.bounds.size.height > contentSize.height + 0.5) {
+        CGFloat ty = (self.bounds.size.height - contentSize.height) / 2.0;
+        surfaceView.frame = CGRectMake(0, ty, self.bounds.size.width, contentSize.height);
+    }
+}
+
+- (void)handleIntrinsicSizeChange:(CGSize)intrinsicSize {
+    if (intrinsicSize.width <= 0 || intrinsicSize.height <= 0) {
+        return;
+    }
+
+    CGFloat width = MAX(intrinsicSize.width, kMinBarButtonSlotSize);
+    if (_widthConstraint && _heightConstraint) {
+        _widthConstraint.constant = width;
+        _heightConstraint.constant = kMinBarButtonSlotSize;
+    }
+
+    if (self.intrinsicSizeDidChangeHandler && width > kMinBarButtonSlotSize &&
+        width > _lastReportedWidth) {
+        _lastReportedWidth = width;
+        self.intrinsicSizeDidChangeHandler(intrinsicSize);
+    }
+
+    [self setNeedsLayout];
+}
+
 - (void)didMountComponentsWithRootTag:(NSInteger)rootTag {
     if (self.surface.rootTag == rootTag) {
         [super didMountComponentsWithRootTag:rootTag];
         [self sizeToFit];
-        if (@available(iOS 26.0, *)) {
-            if (![self designRequiresCompatibility]) {
-                [self updateConstraintsToFitSize];
-            }
-        }
+        [self setNeedsLayout];
     }
 }
 
-- (void)updateConstraintsToFitSize {
-    CGSize size = self.frame.size;
-    if (size.width > 0 && size.height > 0) {
-        _widthConstraint.constant = size.width;
-        _heightConstraint.constant = size.height;
-    }
+#ifdef RCT_NEW_ARCH_ENABLED
+- (void)surface:(RCTSurface *)surface didChangeIntrinsicSize:(CGSize)intrinsicSize {
+    [self handleIntrinsicSizeChange:intrinsicSize];
+}
+#else
+- (void)rootViewDidChangeIntrinsicSize:(RCTRootView *)rootView {
+    [self handleIntrinsicSizeChange:rootView.intrinsicContentSize];
+    [rootView setNeedsUpdateConstraints];
+    [rootView updateConstraintsIfNeeded];
 }
+#endif
 
 - (void)layoutSubviews {
     [super layoutSubviews];
     if (@available(iOS 26.0, *)) {
-        if ([self designRequiresCompatibility]) return;
-        if (!_didCenter && self.superview && self.frame.size.width > 0) {
+        if ([self designRequiresCompatibility]) {
+            return;
+        }
+
+        [self centerSurfaceContentIfNeeded];
+
+        if (!_didCenterHorizontally && self.superview && self.frame.size.width > 0) {
             CGFloat wrapperWidth = self.superview.bounds.size.width;
             CGFloat selfWidth = self.frame.size.width;
-            if (wrapperWidth > selfWidth) {
-                _didCenter = YES;
+            if (wrapperWidth > selfWidth + 0.5) {
+                _didCenterHorizontally = YES;
                 CGFloat tx = (wrapperWidth - selfWidth) / 2.0;
-                self.layer.affineTransform = CGAffineTransformMakeTranslation(tx, 0);
+                CGAffineTransform transform = self.layer.affineTransform;
+                self.layer.affineTransform = CGAffineTransformMakeTranslation(tx, transform.ty);
             }
         }
     }

package/ios/RNNStackController.mm

@@ -28,6 +28,13 @@
     return self;
 }
 
+- (void)pushViewController:(UIViewController *)viewController animated:(BOOL)animated {
+    if (@available(iOS 26.0, *)) {
+        [self.presenter applyTopBarBackgroundBeforeShowingViewController:viewController];
+    }
+    [super pushViewController:viewController animated:animated];
+}
+
 - (void)viewDidLayoutSubviews {
     [super viewDidLayoutSubviews];
     [self.presenter applyOptionsOnViewDidLayoutSubviews:self.resolveOptions];

package/ios/RNNStackPresenter.h

@@ -1,6 +1,7 @@
 #import "RNNBasePresenter.h"
 #import "RNNComponentViewCreator.h"
 #import "RNNReactComponentRegistry.h"
+#import <UIKit/UIKit.h>
 
 @interface RNNStackPresenter : RNNBasePresenter
 
@@ -9,6 +10,9 @@
 
 - (void)applyOptionsBeforePopping:(RNNNavigationOptions *)options;
 
+- (void)applyTopBarBackgroundBeforeShowingViewController:(UIViewController *)viewController
+    API_AVAILABLE(ios(26.0));
+
 - (BOOL)shouldPopItem:(UINavigationItem *)item options:(RNNNavigationOptions *)options;
 
 @end

package/ios/RNNStackPresenter.mm

@@ -101,6 +101,14 @@
     [_topBarPresenter applyOptionsBeforePopping:options.topBar];
 }
 
+- (void)applyTopBarBackgroundBeforeShowingViewController:(UIViewController *)viewController {
+    if (@available(iOS 26.0, *)) {
+        RNNNavigationOptions *withDefault = viewController.resolveOptionsWithDefault;
+        [_topBarPresenter applyBackgroundForTransitionToViewController:viewController
+                                                         topBarOptions:withDefault.topBar];
+    }
+}
+
 - (void)mergeOptions:(RNNNavigationOptions *)mergeOptions
      resolvedOptions:(RNNNavigationOptions *)resolvedOptions {
     [super mergeOptions:mergeOptions resolvedOptions:resolvedOptions];

package/ios/RNNUIBarButtonItem.h

@@ -7,13 +7,7 @@
 
 typedef void (^RNNButtonPressCallback)(NSString *buttonId);
 
-@interface RNNUIBarButtonItem : UIBarButtonItem <
-#ifdef RCT_NEW_ARCH_ENABLED
-RCTSurfaceDelegate
-#else
-RCTRootViewDelegate
-#endif
->
+@interface RNNUIBarButtonItem : UIBarButtonItem
 
 @property(nonatomic, strong) NSString *buttonId;
 

package/ios/RNNUIBarButtonItem.mm

@@ -7,6 +7,8 @@
 #import <React/RCTSurface.h>
 #endif
 
+static const CGFloat kMinBarButtonSlotSize = 44.0;
+
 @interface RNNUIBarButtonItem ()
 
 @property(nonatomic, strong) NSLayoutConstraint *widthConstraint;
@@ -18,6 +20,7 @@
 @implementation RNNUIBarButtonItem {
     RNNIconCreator *_iconCreator;
     RNNButtonOptions *_buttonOptions;
+    BOOL _didApplyWidthResize;
 }
 
 - (instancetype)init {
@@ -94,6 +97,49 @@
     return self;
 }
 
+- (BOOL)designRequiresCompatibility {
+    static BOOL checked = NO;
+    static BOOL result = NO;
+    if (!checked) {
+        checked = YES;
+        result = [[[NSBundle mainBundle] objectForInfoDictionaryKey:@"UIDesignRequiresCompatibility"] boolValue];
+    }
+    return result;
+}
+
+- (void)applyCustomViewIntrinsicSize:(CGSize)intrinsicSize {
+    if (!self.widthConstraint || !self.heightConstraint || intrinsicSize.width <= 0) {
+        return;
+    }
+
+    CGFloat width = MAX(intrinsicSize.width, kMinBarButtonSlotSize);
+    if (_didApplyWidthResize && width <= self.widthConstraint.constant) {
+        return;
+    }
+
+    if (self.widthConstraint.constant == width) {
+        _didApplyWidthResize = YES;
+        return;
+    }
+
+    self.widthConstraint.constant = width;
+    _didApplyWidthResize = YES;
+
+    [self.customView setNeedsLayout];
+    [self invalidateNavigationBarLayout];
+}
+
+- (void)invalidateNavigationBarLayout {
+    UIView *view = self.customView;
+    while (view) {
+        if ([view isKindOfClass:[UINavigationBar class]]) {
+            [view setNeedsLayout];
+            return;
+        }
+        view = view.superview;
+    }
+}
+
 - (instancetype)initWithCustomView:(RNNReactView *)reactView
                      buttonOptions:(RNNButtonOptions *)buttonOptions
                            onPress:(RNNButtonPressCallback)onPress {
@@ -106,16 +152,25 @@
         // back in via the hideSharedBackground option.
         self.hidesSharedBackground =
             [buttonOptions.hideSharedBackground withDefault:YES];
-        // Pin the custom view to a stable 44pt bar-item size so the navbar
-        // reserves the final slot up-front (incl. during push-transition
-        // snapshots) and doesn't relayout once React mounts. Without this,
-        // React's post-mount sizeToFit changes bounds, the navbar relayouts,
-        // and the customView visibly snaps from a 0x0 / wrong-position state
-        // to its centered final frame. React content centers within via its
-        // own flex layout.
-        reactView.translatesAutoresizingMaskIntoConstraints = NO;
-        [reactView.widthAnchor constraintEqualToConstant:44].active = YES;
-        [reactView.heightAnchor constraintEqualToConstant:44].active = YES;
+        if (![self designRequiresCompatibility]) {
+            // Reserve a stable 44pt slot for push-transition snapshots, then grow
+            // width once when React reports intrinsic size (e.g. wide pickers).
+            // Height stays 44; vertical alignment is handled in React.
+            reactView.translatesAutoresizingMaskIntoConstraints = NO;
+            self.widthConstraint = [reactView.widthAnchor constraintEqualToConstant:kMinBarButtonSlotSize];
+            self.heightConstraint = [reactView.heightAnchor constraintEqualToConstant:kMinBarButtonSlotSize];
+            self.widthConstraint.priority = UILayoutPriorityRequired;
+            self.heightConstraint.priority = UILayoutPriorityRequired;
+            self.widthConstraint.active = YES;
+            self.heightConstraint.active = YES;
+            if ([reactView isKindOfClass:[RNNReactButtonView class]]) {
+                RNNReactButtonView *buttonView = (RNNReactButtonView *)reactView;
+                __weak RNNUIBarButtonItem *weakSelf = self;
+                buttonView.intrinsicSizeDidChangeHandler = ^(CGSize intrinsicSize) {
+                    [weakSelf applyCustomViewIntrinsicSize:intrinsicSize];
+                };
+            }
+        }
     }
     [self applyOptions:buttonOptions];
     self.onPress = onPress;
@@ -219,26 +274,6 @@
 }
 
 
-#ifdef RCT_NEW_ARCH_ENABLED
-// TODO: Verify
-- (void)surface:(RCTSurface *)surface didChangeIntrinsicSize:(CGSize)intrinsicSize {
-	self.widthConstraint.constant = intrinsicSize.width;
-	self.heightConstraint.constant = intrinsicSize.height;
-	[surface setSize:intrinsicSize];
-	//[rootView setNeedsUpdateConstraints];
-	//[rootView updateConstraintsIfNeeded];
-	//surface.hidden = NO;
-}
-#else
-- (void)rootViewDidChangeIntrinsicSize:(RCTRootView *)rootView {
-    self.widthConstraint.constant = rootView.intrinsicContentSize.width;
-    self.heightConstraint.constant = rootView.intrinsicContentSize.height;
-    [rootView setNeedsUpdateConstraints];
-    [rootView updateConstraintsIfNeeded];
-    rootView.hidden = NO;
-}
-#endif
-
 - (void)onButtonPressed:(RNNUIBarButtonItem *)barButtonItem {
     self.onPress(self.buttonId);
 }

package/ios/TopBarAppearancePresenter.mm

@@ -1,9 +1,18 @@
 #import "TopBarAppearancePresenter.h"
 #import "RNNFontAttributesCreator.h"
+#import "UIColor+RNNUtils.h"
+#import "UIImage+utils.h"
 #import "UIViewController+LayoutProtocol.h"
 
 @interface TopBarAppearancePresenter ()
 
+- (void)applyBackgroundToNavigationItem:(UINavigationItem *)item topBarOptions:(RNNTopBarOptions *)options;
+- (void)syncNavigationBarAppearanceFromNavigationItem:(UINavigationItem *)item;
+- (void)applyBackgroundToAppearance:(UINavigationBarAppearance *)appearance
+                   withOpaqueColor:(UIColor *)color
+                        transparent:(BOOL)transparent
+                        translucent:(BOOL)translucent;
+
 @end
 
 @implementation TopBarAppearancePresenter
@@ -11,6 +20,97 @@
 @synthesize borderColor = _borderColor;
 @synthesize scrollEdgeBorderColor = _scrollEdgeBorderColor;
 
+- (void)applyBackgroundToNavigationItem:(UINavigationItem *)item topBarOptions:(RNNTopBarOptions *)options {
+    UIColor *color = [options.background.color withDefault:nil];
+    BOOL transparent = color.isTransparent;
+    BOOL translucent = [options.background.translucent withDefault:NO];
+
+    if (!item.standardAppearance) {
+        item.standardAppearance = [UINavigationBarAppearance new];
+    }
+    if (!item.scrollEdgeAppearance) {
+        item.scrollEdgeAppearance = [UINavigationBarAppearance new];
+    }
+    [self applyBackgroundToAppearance:item.standardAppearance
+                        withOpaqueColor:color
+                             transparent:transparent
+                              translucent:translucent];
+    [self applyBackgroundToAppearance:item.scrollEdgeAppearance
+                        withOpaqueColor:color
+                             transparent:transparent
+                              translucent:translucent];
+
+    if ([options.scrollEdgeAppearance.active withDefault:NO]) {
+        UIColor *scrollEdgeColor = [options.scrollEdgeAppearance.background.color withDefault:nil];
+        BOOL scrollEdgeTransparent = scrollEdgeColor.isTransparent;
+        BOOL scrollEdgeTranslucent =
+            [options.scrollEdgeAppearance.background.translucent withDefault:translucent];
+        UIColor *resolvedScrollEdgeColor = scrollEdgeColor ?: color;
+        [self applyBackgroundToAppearance:item.scrollEdgeAppearance
+                            withOpaqueColor:resolvedScrollEdgeColor
+                                 transparent:scrollEdgeTransparent
+                                  translucent:scrollEdgeTranslucent];
+    }
+
+    if (@available(iOS 26.0, *)) {
+        [self syncNavigationBarAppearanceFromNavigationItem:item];
+    }
+}
+
+- (void)applyBackgroundForTransitionToViewController:(UIViewController *)viewController
+                                       topBarOptions:(RNNTopBarOptions *)options {
+    if (@available(iOS 26.0, *)) {
+        [self applyBackgroundToNavigationItem:viewController.navigationItem topBarOptions:options];
+    }
+}
+
+- (void)syncNavigationBarAppearanceFromNavigationItem:(UINavigationItem *)item {
+    UINavigationBar *navigationBar = self.navigationController.navigationBar;
+    if (item.standardAppearance) {
+        navigationBar.standardAppearance = [item.standardAppearance copy];
+    }
+    UINavigationBarAppearance *scrollEdgeAppearance =
+        item.scrollEdgeAppearance ?: item.standardAppearance;
+    if (scrollEdgeAppearance) {
+        navigationBar.scrollEdgeAppearance = [scrollEdgeAppearance copy];
+    }
+}
+
+- (void)applyBackgroundToAppearance:(UINavigationBarAppearance *)appearance
+                   withOpaqueColor:(UIColor *)color
+                        transparent:(BOOL)transparent
+                        translucent:(BOOL)translucent {
+    if (transparent || color.isTransparent) {
+        [appearance configureWithTransparentBackground];
+        if (@available(iOS 26.0, *)) {
+            appearance.backgroundEffect = nil;
+            appearance.backgroundColor = UIColor.clearColor;
+            appearance.backgroundImage = nil;
+        }
+        return;
+    }
+
+    if (color) {
+        if (@available(iOS 26.0, *)) {
+            [appearance configureWithTransparentBackground];
+            appearance.backgroundEffect = nil;
+            appearance.shadowColor = nil;
+            appearance.backgroundColor = color;
+            appearance.backgroundImage = [UIImage imageWithSize:CGSizeMake(1, 1) color:color];
+        } else {
+            [appearance configureWithOpaqueBackground];
+            appearance.backgroundColor = color;
+        }
+        return;
+    }
+
+    if (translucent) {
+        [appearance configureWithDefaultBackground];
+    } else {
+        [appearance configureWithOpaqueBackground];
+    }
+}
+
 - (void)applyOptions:(RNNTopBarOptions *)options {
     [self setTranslucent:[options.background.translucent withDefault:NO]];
     [self
@@ -77,36 +177,24 @@
 }
 
 - (void)updateScrollEdgeAppearance {
-    if (self.scrollEdgeTransparent) {
-        [self.getScrollEdgeAppearance configureWithTransparentBackground];
-    } else if (self.scrollEdgeAppearanceColor) {
-        [self.getScrollEdgeAppearance configureWithOpaqueBackground];
-        [self.getScrollEdgeAppearance setBackgroundColor:self.scrollEdgeAppearanceColor];
-    } else if (self.scrollEdgeTranslucent) {
-        [self.getScrollEdgeAppearance configureWithDefaultBackground];
-    } else {
-        [self.getScrollEdgeAppearance configureWithOpaqueBackground];
-        if (self.backgroundColor) {
-            [self.getScrollEdgeAppearance setBackgroundColor:self.backgroundColor];
-        }
-    }
+    UIColor *color = self.scrollEdgeAppearanceColor ?: self.backgroundColor;
+    [self applyBackgroundToAppearance:self.getScrollEdgeAppearance
+                        withOpaqueColor:color
+                             transparent:self.scrollEdgeTransparent
+                              translucent:self.scrollEdgeTranslucent];
 }
 
 - (void)updateBackgroundAppearance {
-    if (self.transparent) {
-        [self.getAppearance configureWithTransparentBackground];
-        [self.getScrollEdgeAppearance configureWithTransparentBackground];
-    } else if (self.backgroundColor) {
-        [self.getAppearance configureWithOpaqueBackground];
-        [self.getScrollEdgeAppearance configureWithOpaqueBackground];
-        [self.getAppearance setBackgroundColor:self.backgroundColor];
-        [self.getScrollEdgeAppearance setBackgroundColor:self.backgroundColor];
-    } else if (self.translucent) {
-        [self.getAppearance configureWithDefaultBackground];
-        [self.getScrollEdgeAppearance configureWithDefaultBackground];
-    } else {
-        [self.getAppearance configureWithOpaqueBackground];
-        [self.getScrollEdgeAppearance configureWithOpaqueBackground];
+    [self applyBackgroundToAppearance:self.getAppearance
+                        withOpaqueColor:self.backgroundColor
+                             transparent:self.transparent
+                              translucent:self.translucent];
+    [self applyBackgroundToAppearance:self.getScrollEdgeAppearance
+                        withOpaqueColor:self.backgroundColor
+                             transparent:self.transparent
+                              translucent:self.translucent];
+    if (@available(iOS 26.0, *)) {
+        [self syncNavigationBarAppearanceFromNavigationItem:self.currentNavigationItem];
     }
 }
 

package/ios/TopBarPresenter.h

@@ -1,12 +1,18 @@
 #import "RNNBasePresenter.h"
 #import "RNNTopBarOptions.h"
+#import <UIKit/UIKit.h>
 
 @interface TopBarPresenter : RNNBasePresenter
 
+- (UINavigationController *)navigationController;
+
 - (void)applyOptions:(RNNTopBarOptions *)options;
 
 - (void)applyOptionsBeforePopping:(RNNTopBarOptions *)options;
 
+- (void)applyBackgroundForTransitionToViewController:(UIViewController *)viewController
+                                       topBarOptions:(RNNTopBarOptions *)options API_AVAILABLE(ios(26.0));
+
 - (void)mergeOptions:(RNNTopBarOptions *)options withDefault:(RNNTopBarOptions *)defaultOptions;
 
 - (instancetype)initWithNavigationController:(UINavigationController *)boundNavigationController;

package/ios/TopBarPresenter.mm

@@ -71,6 +71,10 @@
     [self.navigationController.navigationBar setBackIndicatorTransitionMaskImage:image];
 }
 
+- (void)applyBackgroundForTransitionToViewController:(UIViewController *)viewController
+                                       topBarOptions:(RNNTopBarOptions *)options {
+}
+
 - (void)setBackgroundColor:(UIColor *)backgroundColor {
     _backgroundColor = backgroundColor;
     [self updateBackgroundAppearance];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-navigation",
-  "version": "8.8.4",
+  "version": "8.8.5",
   "description": "React Native Navigation - truly native navigation for iOS and Android",
   "license": "MIT",
   "nativePackage": true,