react-native-navigation 8.8.5 → 8.8.6-snapshot.2571

package/ios/RNNAppDelegate.mm

@@ -8,6 +8,8 @@
 #import <React/RCTCxxBridgeDelegate.h>
 #endif
 #import <React/RCTLegacyViewManagerInteropComponentView.h>
+#import <React/RCTLinkingManager.h>
+#import <React/RCTRootView.h>
 #import <React/RCTSurfacePresenter.h>
 #if __has_include(<React/RCTSurfacePresenterStub.h>)
 #import <React/RCTSurfacePresenterStub.h>
@@ -36,6 +38,13 @@
 
 #import <React/RCTComponentViewFactory.h>
 
+// Deep-link URLs that arrive (openURL, universal link, or external dispatch)
+// before the React runtime is ready are queued here and flushed when Fabric
+// posts `RCTContentDidAppearNotification` — by which point
+// `RCTLinkingManager` is instantiated and JS subscribers are listening.
+static NSMutableArray<NSURL *> *gRNNPendingDeepLinkURLs = nil;
+static BOOL gRNNReactRuntimeReady = NO;
+
 
 static NSString *const kRNConcurrentRoot = @"concurrentRoot";
 
@@ -92,9 +101,73 @@ didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
     [ReactNativeNavigation bootstrapWithHost:self.reactNativeFactory.rootViewFactory.reactHost];
 #endif
     
+    [self rnn_installDeepLinkObservers];
+    
     return YES;
 }
 
+#pragma mark - Deep linking
+
+// Forward OS-delivered custom-scheme URLs to React Native's Linking module.
+- (BOOL)application:(UIApplication *)application
+            openURL:(NSURL *)url
+            options:(NSDictionary<UIApplicationOpenURLOptionsKey, id> *)options {
+    [self dispatchDeepLinkURL:url];
+    return YES;
+}
+
+// Forward universal links (associated domains) to React Native's Linking
+// module by extracting the underlying https URL and routing it through the
+// same pre-bridge queue as everything else.
+- (BOOL)application:(UIApplication *)application
+   continueUserActivity:(NSUserActivity *)userActivity
+     restorationHandler:
+         (void (^)(NSArray<id<UIUserActivityRestoring>> *_Nullable))restorationHandler {
+    if ([userActivity.activityType isEqualToString:NSUserActivityTypeBrowsingWeb]) {
+        [self dispatchDeepLinkURL:userActivity.webpageURL];
+        return YES;
+    }
+    return NO;
+}
+
+- (void)dispatchDeepLinkURL:(NSURL *)url {
+    if (url == nil) {
+        return;
+    }
+    if (gRNNReactRuntimeReady) {
+        [RCTLinkingManager application:[UIApplication sharedApplication]
+                               openURL:url
+                               options:@{}];
+        return;
+    }
+    if (gRNNPendingDeepLinkURLs == nil) {
+        gRNNPendingDeepLinkURLs = [NSMutableArray array];
+    }
+    [gRNNPendingDeepLinkURLs addObject:url];
+}
+
+- (void)rnn_installDeepLinkObservers {
+    // `RCTContentDidAppearNotification` is posted by Fabric's root view
+    // once content has rendered. RNN forces bridgeless/new-arch, so the
+    // legacy `RCTJavaScriptDidLoadNotification` never fires; we rely on
+    // this Fabric signal exclusively.
+    [[NSNotificationCenter defaultCenter] addObserver:self
+                                             selector:@selector(rnn_handleReactRuntimeReady:)
+                                                 name:RCTContentDidAppearNotification
+                                               object:nil];
+}
+
+- (void)rnn_handleReactRuntimeReady:(NSNotification *)notification {
+    gRNNReactRuntimeReady = YES;
+    NSArray<NSURL *> *pending = [gRNNPendingDeepLinkURLs copy];
+    [gRNNPendingDeepLinkURLs removeAllObjects];
+    for (NSURL *url in pending) {
+        [RCTLinkingManager application:[UIApplication sharedApplication]
+                               openURL:url
+                               options:@{}];
+    }
+}
+
 
 #if !RNN_RN_VERSION_79_OR_NEWER
 - (NSURL *)sourceURLForBridge:(RCTBridge *)bridge {

package/ios/RNNBottomTabOptions.h

@@ -1,3 +1,4 @@
+#import "RNNComponentOptions.h"
 #import "RNNOptions.h"
 
 @class DotIndicatorOptions;
@@ -5,6 +6,7 @@
 @interface RNNBottomTabOptions : RNNOptions
 
 @property(nonatomic) NSUInteger tag;
+@property(nonatomic, strong) RNNComponentOptions *component;
 @property(nonatomic, strong) Text *text;
 @property(nonatomic, strong) Text *badge;
 @property(nonatomic, strong) Color *badgeColor;

package/ios/RNNBottomTabOptions.mm

@@ -8,6 +8,9 @@
     self = [super initWithDict:dict];
     self.tag = arc4random();
 
+    self.component =
+        [[RNNComponentOptions alloc] initWithDict:[dict objectForKey:@"component"]];
+
     self.text = [TextParser parse:dict key:@"text"];
     self.badge = [TextParser parse:dict key:@"badge"];
     self.fontFamily = [TextParser parse:dict key:@"fontFamily"];
@@ -38,6 +41,7 @@
 
 - (void)mergeOptions:(RNNBottomTabOptions *)options {
     [self.dotIndicator mergeOptions:options.dotIndicator];
+    [self.component mergeOptions:options.component];
 
     if (options.text.hasValue)
         self.text = options.text;
@@ -88,7 +92,7 @@
            self.iconColor.hasValue || self.selectedIconColor.hasValue ||
            self.selectedTextColor.hasValue || self.iconInsets.hasValue || self.textColor.hasValue ||
            self.visible.hasValue || self.selectTabOnPress.hasValue || self.sfSymbol.hasValue ||
-           self.sfSelectedSymbol.hasValue || self.role.hasValue;
+           self.sfSelectedSymbol.hasValue || self.role.hasValue || self.component.hasValue;
 }
 
 @end

package/ios/RNNBottomTabsController.h

@@ -3,6 +3,7 @@
 #import "RNNBottomTabsPresenter.h"
 #import "RNNDotIndicatorPresenter.h"
 #import "RNNEventEmitter.h"
+#import "RNNReactComponentRegistry.h"
 #import "UIViewController+LayoutProtocol.h"
 #import <UIKit/UIKit.h>
 
@@ -16,6 +17,7 @@
                          presenter:(RNNBasePresenter *)presenter
                 bottomTabPresenter:(BottomTabPresenter *)bottomTabPresenter
              dotIndicatorPresenter:(RNNDotIndicatorPresenter *)dotIndicatorPresenter
+                 componentRegistry:(RNNReactComponentRegistry *)componentRegistry
                       eventEmitter:(RNNEventEmitter *)eventEmitter
               childViewControllers:(NSArray *)childViewControllers
                 bottomTabsAttacher:(BottomTabsBaseAttacher *)bottomTabsAttacher;

package/ios/RNNBottomTabsController.mm

@@ -1,7 +1,10 @@
 #import "RNNBottomTabsController.h"
+#import "RNNBottomTabsCustomRow.h"
+#import "RNNCustomTabBarItemView.h"
 #import "RNNTabBarItemCreator.h"
 #import "UITabBarController+RNNOptions.h"
 #import "UITabBarController+RNNUtils.h"
+#import <React/RCTLog.h>
 
 @interface RNNBottomTabsController ()
 @property(nonatomic, strong) BottomTabPresenter *bottomTabPresenter;
@@ -21,6 +24,10 @@
     BOOL _didFinishSetup;
     BOOL _rnnDidApplyInitialTabBarSelectionFix;
     BOOL _rnnSuppressTabSelectionEvents;
+    RNNReactComponentRegistry *_componentRegistry;
+    NSMutableArray<RNNCustomTabBarItemView *> *_customTabItemViews;
+    BOOL _useCustomItemViews;
+    RNNBottomTabsCustomRow *_customRow;
 }
 
 - (instancetype)initWithLayoutInfo:(RNNLayoutInfo *)layoutInfo
@@ -30,14 +37,18 @@
                          presenter:(RNNBasePresenter *)presenter
                 bottomTabPresenter:(BottomTabPresenter *)bottomTabPresenter
              dotIndicatorPresenter:(RNNDotIndicatorPresenter *)dotIndicatorPresenter
+                 componentRegistry:(RNNReactComponentRegistry *)componentRegistry
                       eventEmitter:(RNNEventEmitter *)eventEmitter
               childViewControllers:(NSArray *)childViewControllers
                 bottomTabsAttacher:(BottomTabsBaseAttacher *)bottomTabsAttacher {
     _bottomTabsAttacher = bottomTabsAttacher;
     _bottomTabPresenter = bottomTabPresenter;
     _dotIndicatorPresenter = dotIndicatorPresenter;
+    _componentRegistry = componentRegistry;
     _options = options;
     _didFinishSetup = NO;
+    _customTabItemViews = [NSMutableArray new];
+    _useCustomItemViews = NO;
 
     IntNumber *currentTabIndex = options.bottomTabs.currentTabIndex;
     if ([currentTabIndex hasValue]) {
@@ -88,14 +99,20 @@
         [selectedChild pushViewController: [UIViewController new] animated:NO];
         [selectedChild popViewControllerAnimated:NO];
     }
+
+    if (_useCustomItemViews) {
+        [self ensureCustomRowAttached];
+        [self layoutCustomRow];
+    }
 }
 
 - (void)viewDidAppear:(BOOL)animated {
     [super viewDidAppear:animated];
     // iOS 26: first layout can misplace tab item titles; cycling selection (then restoring) forces a
     // correct layout without user interaction. Defer so all tab children are in the hierarchy.
+    // Skipped when custom item views are active — the native tab bar visuals are hidden anyway.
     if (@available(iOS 26.0, *)) {
-        if (!_rnnDidApplyInitialTabBarSelectionFix) {
+        if (!_useCustomItemViews && !_rnnDidApplyInitialTabBarSelectionFix) {
             _rnnDidApplyInitialTabBarSelectionFix = YES;
             __weak RNNBottomTabsController *weakSelf = self;
             dispatch_async(dispatch_get_main_queue(), ^{
@@ -128,13 +145,182 @@
 
 - (void)createTabBarItems:(NSArray<UIViewController *> *)childViewControllers {
     _bottomTabPresenter.tabCreator.searchRoleUsed = NO;
+    [self resolveCustomItemViewMode:childViewControllers];
+    _bottomTabPresenter.useCustomItemViews = _useCustomItemViews;
     for (UIViewController *child in childViewControllers) {
         [_bottomTabPresenter applyOptions:child.resolveOptions child:child];
     }
 
+    if (_useCustomItemViews) {
+        [self buildCustomTabItemViews:childViewControllers];
+        [self applyCustomItemViewsTabBarConfiguration];
+        [self ensureCustomRowAttached];
+    }
+
     [self syncTabBarItemTestIDs];
 }
 
+- (void)applyCustomItemViewsTabBarConfiguration {
+    // Hide the native tab bar visuals so our custom row is the only thing
+    // shown. The bar itself stays in the view hierarchy so that
+    // `UITabBarController` keeps reserving the bottom safe-area inset for
+    // the selected child controller and exposes the right frame for the
+    // row to match.
+    for (UIView *subview in self.tabBar.subviews) {
+        subview.hidden = YES;
+    }
+    self.tabBar.tintColor = UIColor.clearColor;
+    self.tabBar.unselectedItemTintColor = UIColor.clearColor;
+    self.tabBar.backgroundColor = UIColor.clearColor;
+}
+
+- (void)resolveCustomItemViewMode:(NSArray<UIViewController *> *)childViewControllers {
+    if (childViewControllers.count == 0) {
+        _useCustomItemViews = NO;
+        return;
+    }
+
+    NSUInteger withComponent = 0;
+    for (UIViewController *child in childViewControllers) {
+        RNNNavigationOptions *resolved = child.resolveOptions;
+        if (resolved.bottomTab.component.name.hasValue) {
+            withComponent++;
+        }
+    }
+
+    if (withComponent == 0) {
+        _useCustomItemViews = NO;
+        return;
+    }
+
+    if (withComponent != childViewControllers.count) {
+        RCTLogWarn(
+            @"[RNN] Mixed bottomTab.component usage detected (%lu of %lu tabs). All tabs must "
+            @"declare a component or none — falling back to native rendering for all tabs.",
+            (unsigned long)withComponent, (unsigned long)childViewControllers.count);
+        _useCustomItemViews = NO;
+        return;
+    }
+
+    _useCustomItemViews = YES;
+}
+
+- (void)buildCustomTabItemViews:(NSArray<UIViewController *> *)childViewControllers {
+    [self destroyCustomTabItemViews];
+
+    NSString *parentComponentId = self.layoutInfo.componentId;
+    for (NSUInteger i = 0; i < childViewControllers.count; i++) {
+        UIViewController *child = childViewControllers[i];
+        RNNNavigationOptions *resolved = child.resolveOptions;
+        RNNComponentOptions *componentOptions = resolved.bottomTab.component;
+
+        RNNReactView *reactView =
+            [_componentRegistry createComponentIfNotExists:componentOptions
+                                         parentComponentId:parentComponentId
+                                             componentType:RNNComponentTypeBottomTabItem
+                                       reactViewReadyBlock:nil];
+
+        NSString *badge = [resolved.bottomTab.badge withDefault:nil];
+        RNNCustomTabBarItemView *itemView =
+            [[RNNCustomTabBarItemView alloc] initWithReactView:reactView
+                                                      tabIndex:i
+                                                      selected:(i == _currentTabIndex)
+                                                         badge:badge];
+        [_customTabItemViews addObject:itemView];
+    }
+}
+
+- (void)destroyCustomTabItemViews {
+    for (RNNCustomTabBarItemView *itemView in _customTabItemViews) {
+        [itemView removeFromSuperview];
+    }
+    [_customTabItemViews removeAllObjects];
+    [_customRow removeFromSuperview];
+    _customRow = nil;
+}
+
+- (void)ensureCustomRowAttached {
+    if (!_useCustomItemViews) {
+        return;
+    }
+    if (!_customRow) {
+        _customRow = [[RNNBottomTabsCustomRow alloc] initWithFrame:CGRectZero];
+        __weak RNNBottomTabsController *weakSelf = self;
+        _customRow.onTapAtIndex = ^(NSUInteger index) {
+            [weakSelf handleCustomRowTapAtIndex:index];
+        };
+    }
+    [_customRow setItemViews:_customTabItemViews];
+    [_customRow applyOptions:_options.bottomTabs.customRow];
+    if (_customRow.superview != self.view) {
+        [self.view addSubview:_customRow];
+    } else {
+        [self.view bringSubviewToFront:_customRow];
+    }
+}
+
+- (void)layoutCustomRow {
+    if (!_useCustomItemViews || !_customRow) {
+        return;
+    }
+    CGRect tabBarFrame = self.tabBar.frame;
+    if (CGRectIsEmpty(tabBarFrame)) {
+        return;
+    }
+    CGRect tabBarInView = [self.view convertRect:tabBarFrame fromView:self.tabBar.superview];
+
+    CGFloat desiredHeight = [_customRow
+        desiredRowHeightForNativeTabBarHeight:tabBarInView.size.height
+                                   safeBottom:0];
+
+    CGFloat bottomMargin = [_customRow effectiveBottomMargin];
+    CGFloat rowBottom;
+    UIWindow *window = self.view.window;
+    if (window) {
+        // Map the window's safe-area bottom into this controller's view — reliable
+        // for modals where `self.view.safeAreaInsets` is often zero.
+        CGFloat yInWindow = CGRectGetHeight(window.bounds) - window.safeAreaInsets.bottom;
+        CGPoint pInView = [self.view convertPoint:CGPointMake(0, yInWindow) fromView:window];
+        rowBottom = pInView.y - bottomMargin;
+    } else {
+        rowBottom = CGRectGetMaxY(self.view.safeAreaLayoutGuide.layoutFrame) - bottomMargin;
+    }
+
+    CGRect rowFrame = CGRectMake(tabBarInView.origin.x, rowBottom - desiredHeight,
+                                 tabBarInView.size.width, desiredHeight);
+
+    _customRow.frame = rowFrame;
+    _customRow.hidden = self.tabBar.hidden;
+    [_customRow setSelectedIndex:_currentTabIndex];
+}
+
+- (void)handleCustomRowTapAtIndex:(NSUInteger)index {
+    if (index >= self.childViewControllers.count) {
+        return;
+    }
+    UIViewController *target = self.childViewControllers[index];
+    [self.eventEmitter sendBottomTabPressed:@(index)];
+    BOOL select = [[target resolveOptions].bottomTab.selectTabOnPress withDefault:YES];
+    if (!select) {
+        return;
+    }
+    NSUInteger previous = _currentTabIndex;
+    [self setSelectedIndex:index];
+    if (!_rnnSuppressTabSelectionEvents) {
+        [self.eventEmitter sendBottomTabSelected:@(index) unselected:@(previous)];
+    }
+}
+
+- (void)updateCustomTabItemSelection {
+    if (!_useCustomItemViews) {
+        return;
+    }
+    for (NSUInteger i = 0; i < _customTabItemViews.count; i++) {
+        [_customTabItemViews[i] setSelected:(i == _currentTabIndex)];
+    }
+    [_customRow setSelectedIndex:_currentTabIndex];
+}
+
 - (void)mergeChildOptions:(RNNNavigationOptions *)options child:(UIViewController *)child {
     [super mergeChildOptions:options child:child];
     UIViewController *childViewController = [self findViewController:child];
@@ -145,6 +331,13 @@
                          resolvedOptions:childViewController.resolveOptions
                                    child:childViewController];
 
+    if (_useCustomItemViews && options.bottomTab.badge.hasValue) {
+        NSUInteger index = [self.childViewControllers indexOfObject:childViewController];
+        if (index != NSNotFound && index < _customTabItemViews.count) {
+            [_customTabItemViews[index] setBadge:[options.bottomTab.badge withDefault:nil]];
+        }
+    }
+
     [self syncTabBarItemTestIDs];
 }
 
@@ -161,6 +354,12 @@
     [self syncTabBarItemTestIDs];
     [self.presenter viewDidLayoutSubviews];
     [_dotIndicatorPresenter bottomTabsDidLayoutSubviews:self];
+    if (_useCustomItemViews) {
+        // Re-hide native subviews; UIKit recreates them on bounds changes.
+        [self applyCustomItemViewsTabBarConfiguration];
+        [self ensureCustomRowAttached];
+        [self layoutCustomRow];
+    }
 }
 
 - (UIViewController *)getCurrentChild {
@@ -195,6 +394,7 @@
     }
 
     [super setSelectedIndex:_currentTabIndex];
+    [self updateCustomTabItemSelection];
 }
 
 - (UIViewController *)selectedViewController {
@@ -205,6 +405,7 @@
     _previousTabIndex = _currentTabIndex;
     _currentTabIndex = [self.childViewControllers indexOfObject:selectedViewController];
     [super setSelectedViewController:selectedViewController];
+    [self updateCustomTabItemSelection];
 }
 
 - (void)setTabBarVisible:(BOOL)visible animated:(BOOL)animated {
@@ -283,4 +484,11 @@
     return [self.presenter hidesBottomBarWhenPushed];
 }
 
+- (void)dealloc {
+    [self destroyCustomTabItemViews];
+    if (_componentRegistry && self.layoutInfo.componentId) {
+        [_componentRegistry clearComponentsForParentId:self.layoutInfo.componentId];
+    }
+}
+
 @end

package/ios/RNNBottomTabsCustomRow.h

@@ -0,0 +1,57 @@
+#import "RNNBottomTabsCustomRowOptions.h"
+#import "RNNCustomTabBarItemView.h"
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * Replaces the visual content of `UITabBar` when `bottomTab.component` is
+ * declared on every tab. Hosts the React-rendered cell views in equal-width
+ * slots and dispatches taps back to the bottom-tabs controller.
+ *
+ * The native `UITabBar` is kept (with its visuals hidden) so that
+ * `UITabBarController` keeps managing the bottom safe-area inset for the
+ * selected child controller — this row is laid out on top of it.
+ *
+ * Visual chrome (height, background, corner radius, margins) is configured
+ * via `RNNBottomTabsCustomRowOptions` and pushed in by the controller.
+ */
+@interface RNNBottomTabsCustomRow : UIView
+
+/**
+ * Block invoked when the user taps a cell. The argument is the 0-based index
+ * of the tapped cell.
+ */
+@property(nonatomic, copy, nullable) void (^onTapAtIndex)(NSUInteger index);
+
+/**
+ * Replaces the cells displayed by this row. The previously held views are
+ * removed from the hierarchy. Each cell is rendered at equal width inside
+ * the content rect (safe area is reserved in the row frame, not inset here).
+ */
+- (void)setItemViews:(NSArray<RNNCustomTabBarItemView *> *)itemViews;
+
+/**
+ * Forwards the selected state to each hosted item view.
+ */
+- (void)setSelectedIndex:(NSUInteger)selectedIndex;
+
+/**
+ * Applies user-supplied chrome options (background, corner radius, margins).
+ * Pass `nil` (or an options instance with no values) to use defaults.
+ */
+- (void)applyOptions:(nullable RNNBottomTabsCustomRowOptions *)options;
+
+/**
+ * Returns the chrome height (plus bottom margin). The controller positions
+ * the row above the home-indicator safe area.
+ */
+- (CGFloat)desiredRowHeightForNativeTabBarHeight:(CGFloat)nativeTabBarHeight
+                                       safeBottom:(CGFloat)safeBottom;
+
+/** User `bottomMargin` option, or 0. */
+- (CGFloat)effectiveBottomMargin;
+
+@end
+
+NS_ASSUME_NONNULL_END