react-native-screens 5.0.0-alpha.2 → 5.0.0-alpha.4

package/ios/stack/screen/RNSStackScreenHeaderCoordinator.mm

@@ -1,6 +1,7 @@
 #import "RNSStackScreenHeaderCoordinator.h"
 #import <React/RCTAssert.h>
 #import <React/RCTLog.h>
+#import "RNSConversions-Stack.h"
 #import "RNSDefines.h"
 #import "RNSStackHeaderContentFactory.h"
 #import "RNSStackHeaderItemDataProviding.h"
@@ -15,6 +16,13 @@
 @implementation RNSStackScreenHeaderCoordinator {
   __weak RNSStackScreenController *_Nullable _screenController;
 
+#if !TARGET_OS_TV
+  // Navigation item of the screen below, onto which the back button
+  // configuration has been applied. Kept so that the configuration can be
+  // cleared when the owning screen is popped from the stack.
+  __weak UINavigationItem *_Nullable _backButtonConfigTargetItem;
+#endif // !TARGET_OS_TV
+
   RNSStackHeaderMenuTrackerRegistry *_Nonnull _trackerRegistry;
 
   NSMutableArray<UIBarButtonItem *> *_Nonnull _leadingBarButtonItems;
@@ -36,6 +44,17 @@
 
 #pragma mark - Public
 
+- (void)updateNavigationBarVisibilityAnimated:(BOOL)animated
+{
+  RNSStackNavigationController *navController = [self getNavigationController];
+  if (navController == nil || navController.topViewController != _screenController) {
+    return;
+  }
+
+  BOOL hidden = _configDataProvider == nil || _configDataProvider.hidden;
+  [navController.navigationBarCoordinator setHidden:hidden forNavigationController:navController animated:animated];
+}
+
 - (void)rebuild
 {
   if (_configDataProvider == nil) {
@@ -104,7 +123,10 @@
                   forController:controller];
 
   [self applyTitleMenuForController:controller];
-  [self applyNavigationBarProperties];
+  [self updateNavigationBarVisibilityAnimated:YES];
+#if !TARGET_OS_TV
+  [self updateBackButtonMenuEnabled];
+#endif // !TARGET_OS_TV
 }
 
 - (void)applyConfigProperties
@@ -114,8 +136,24 @@
   }
 
   [self applyConfigPropertiesForController:[self requireScreenController]];
-  [self applyNavigationBarProperties];
+  [self updateNavigationBarVisibilityAnimated:YES];
+#if !TARGET_OS_TV
+  [self updateBackButtonMenuEnabled];
+#endif // !TARGET_OS_TV
+}
+
+#if !TARGET_OS_TV
+- (void)updateBackButtonMenuEnabled
+{
+  RNSStackNavigationController *navController = [self getNavigationController];
+  if (navController == nil || navController.topViewController != _screenController) {
+    return;
+  }
+
+  BOOL enabled = _configDataProvider == nil || _configDataProvider.backButtonMenuEnabled;
+  [navController.navigationBarCoordinator setBackButtonMenuEnabled:enabled forNavigationController:navController];
 }
+#endif // !TARGET_OS_TV
 
 /**
  Rebuilds an existing item: sets all props and applies the menu config.
@@ -266,6 +304,7 @@
   _configDataProvider = nil;
   _frameChangeDelegate = nil;
   _eventsDelegate = nil;
+  _imageLoader = nil;
 
   [_leadingBarButtonItems removeAllObjects];
   [_trailingBarButtonItems removeAllObjects];
@@ -277,6 +316,8 @@
 
   navItem.title = nil;
   navItem.titleView = nil;
+  navItem.standardAppearance = nil;
+  navItem.scrollEdgeAppearance = nil;
   [navItem setLeftBarButtonItems:@[] animated:YES];
   [navItem setRightBarButtonItems:@[] animated:YES];
 
@@ -296,14 +337,23 @@
   }
 #endif // RNS_IPHONE_OS_VERSION_AVAILABLE(26_0)
 
+#if RNS_IPHONE_OS_VERSION_AVAILABLE(27_0)
+  if (@available(iOS 27.0, *)) {
+    navItem.navigationBarMinimization = [UIBarMinimization new];
+  }
+#endif // Check for iOS >= 27
+
 #if !TARGET_OS_TV
+  navItem.prompt = nil;
   navItem.largeTitleDisplayMode = UINavigationItemLargeTitleDisplayModeNever;
+
+  [self clearAppliedBackButtonConfig];
 #endif // !TARGET_OS_TV
 
-  RNSStackNavigationController *navController = [self getNavigationController];
-  if (navController != nil) {
-    [navController.navigationBarCoordinator setHidden:NO forNavigationController:navController animated:YES];
-  }
+  [self updateNavigationBarVisibilityAnimated:YES];
+#if !TARGET_OS_TV
+  [self updateBackButtonMenuEnabled];
+#endif // !TARGET_OS_TV
 }
 
 /**
@@ -328,19 +378,52 @@
 
   if (item.menu == nil) {
     barButtonItem.menu = nil;
+  } else {
+    RNSStackHeaderMenuToggleStateTracker *tracker = [_trackerRegistry trackerForItemId:itemId];
+    __weak auto weakSelf = self;
+    [RNSStackHeaderMenuCoordinator applyMenu:item.menu
+                             toBarButtonItem:barButtonItem
+                    withHeaderEventsDelegate:_eventsDelegate
+                                stateTracker:tracker
+                             withImageLoader:_imageLoader
+                     menuInvalidatedCallback:^{
+                       [weakSelf reapplyMenuForItemWithId:itemId];
+                     }];
+  }
+
+  [self reapplyMenuRepresentationForItemWithId:itemId];
+}
+
+/**
+ Finds an existing barButtonItem and its corresponding config, then applies the menu
+ representation again. If the config is missing, it clears the representation.
+ */
+- (void)reapplyMenuRepresentationForItemWithId:(NSString *)itemId
+{
+  if (_configDataProvider == nil || itemId == nil) {
+    return;
+  }
+
+  UIBarButtonItem *barButtonItem = _barButtonItemsByItemId[itemId];
+  if (barButtonItem == nil) {
+    return;
+  }
+
+  id<RNSStackHeaderItemDataProviding> item = [self findItemWithId:itemId];
+  if (item == nil) {
     return;
   }
 
   RNSStackHeaderMenuToggleStateTracker *tracker = [_trackerRegistry trackerForItemId:itemId];
   __weak auto weakSelf = self;
-  [RNSStackHeaderMenuCoordinator applyMenu:item.menu
-                           toBarButtonItem:barButtonItem
-                  withHeaderEventsDelegate:_eventsDelegate
-                              stateTracker:tracker
-                           withImageLoader:_imageLoader
-                   menuInvalidatedCallback:^{
-                     [weakSelf reapplyMenuForItemWithId:itemId];
-                   }];
+  [RNSStackHeaderMenuCoordinator applyMenuRepresentation:item.menuRepresentation
+                                         toBarButtonItem:barButtonItem
+                                withHeaderEventsDelegate:_eventsDelegate
+                                            stateTracker:tracker
+                                         withImageLoader:_imageLoader
+                                 menuInvalidatedCallback:^{
+                                   [weakSelf reapplyMenuRepresentationForItemWithId:itemId];
+                                 }];
 }
 
 - (nullable id<RNSStackHeaderItemDataProviding>)findItemWithId:(NSString *)itemId
@@ -377,21 +460,25 @@
   return (RNSStackNavigationController *)navController;
 }
 
-- (void)applyNavigationBarProperties
-{
-  RNSStackNavigationController *navController = [self getNavigationController];
-  if (navController != nil) {
-    [navController.navigationBarCoordinator setHidden:_configDataProvider.hidden
-                              forNavigationController:navController
-                                             animated:YES];
-  }
-}
-
 - (void)applyConfigPropertiesForController:(RNSStackScreenController *)controller
 {
   UINavigationItem *navItem = controller.navigationItem;
 
   navItem.title = _configDataProvider.title;
+  navItem.standardAppearance = _configDataProvider.standardAppearance;
+  navItem.scrollEdgeAppearance = _configDataProvider.scrollEdgeAppearance;
+
+#if !TARGET_OS_TV
+  NSString *prompt = _configDataProvider.prompt;
+  if (navItem.prompt != prompt && ![navItem.prompt isEqualToString:prompt]) {
+    navItem.prompt = prompt;
+    // UIKit does not resize an already visible navigation bar when the prompt
+    // of its navigation item changes - request layout explicitly.
+    [controller.navigationController.view setNeedsLayout];
+  }
+
+  [self applyBackButtonConfigForController:controller];
+#endif // !TARGET_OS_TV
 
 #if RNS_IPHONE_OS_VERSION_AVAILABLE(26_0)
   if (@available(iOS 26.0, *)) {
@@ -401,12 +488,47 @@
   }
 #endif // RNS_IPHONE_OS_VERSION_AVAILABLE(26_0)
 
+#if RNS_IPHONE_OS_VERSION_AVAILABLE(27_0)
+  if (@available(iOS 27.0, *)) {
+    UIBarMinimization *minimization = [UIBarMinimization new];
+    minimization.minimizationBehavior = _configDataProvider.minimizationBehavior;
+    minimization.restorationBehavior = _configDataProvider.restorationBehavior;
+    navItem.navigationBarMinimization = minimization;
+  }
+#endif // Check for iOS >= 27
+
 #if !TARGET_OS_TV
   navItem.largeTitleDisplayMode = _configDataProvider.largeTitleEnabled ? UINavigationItemLargeTitleDisplayModeAlways
                                                                         : UINavigationItemLargeTitleDisplayModeNever;
 #endif // !TARGET_OS_TV
 }
 
+#if !TARGET_OS_TV
+- (void)applyBackButtonConfigForController:(RNSStackScreenController *)controller
+{
+  NSArray<UIViewController *> *viewControllers = controller.navigationController.viewControllers;
+  NSUInteger index = [viewControllers indexOfObject:controller];
+  if (index == NSNotFound || index == 0) {
+    return;
+  }
+
+  UINavigationItem *prevItem = viewControllers[index - 1].navigationItem;
+  _backButtonConfigTargetItem = prevItem;
+  prevItem.backButtonTitle = _configDataProvider.backButtonTitle;
+  prevItem.backButtonDisplayMode = _configDataProvider.backButtonDisplayMode;
+}
+#endif // !TARGET_OS_TV
+
+#if !TARGET_OS_TV
+- (void)clearAppliedBackButtonConfig
+{
+  UINavigationItem *targetItem = _backButtonConfigTargetItem;
+  _backButtonConfigTargetItem = nil;
+  targetItem.backButtonTitle = nil;
+  targetItem.backButtonDisplayMode = UINavigationItemBackButtonDisplayModeDefault;
+}
+#endif // !TARGET_OS_TV
+
 - (void)applyItemsWithTitleView:(nullable UIView *)titleView
                    subtitleView:(nullable UIView *)subtitleView
               largeSubtitleView:(nullable UIView *)largeSubtitleView
@@ -471,6 +593,25 @@
                                                                    withHeaderEventsDelegate:_eventsDelegate
                                                                             withImageLoader:_imageLoader];
 
+#if RNS_IPHONE_OS_VERSION_AVAILABLE(26_0)
+  if (@available(iOS 26.0, *)) {
+    if (item.identifier != nil) {
+      barButtonItem.identifier = item.identifier;
+    }
+    barButtonItem.hidesSharedBackground = item.hidesSharedBackground;
+  }
+#endif // RNS_IPHONE_OS_VERSION_AVAILABLE(26_0)
+
+// tvOS and visionOS are excluded on purpose: `visibilityPriority` exists there, but the only
+// supported value is `standard`, which is already the default.
+#if RNS_IPHONE_OS_VERSION_AVAILABLE(27_0) && !TARGET_OS_TV && !TARGET_OS_VISION
+  if (@available(iOS 27.0, *)) {
+    barButtonItem.visibilityPriority =
+        rnscreens::conversion::UIBarButtonItemVisibilityPriorityFromRNSHeaderItemVisibilityPriority(
+            item.visibilityPriority);
+  }
+#endif // RNS_IPHONE_OS_VERSION_AVAILABLE(27_0) && !TARGET_OS_TV && !TARGET_OS_VISION
+
   if (item.menu != nil && item.itemId != nil) {
     RNSStackHeaderMenuToggleStateTracker *tracker = [_trackerRegistry trackerForItemId:item.itemId];
     __weak auto weakSelf = self;
@@ -485,6 +626,20 @@
                      }];
   }
 
+  if (item.menuRepresentation != nil && item.itemId != nil) {
+    RNSStackHeaderMenuToggleStateTracker *tracker = [_trackerRegistry trackerForItemId:item.itemId];
+    __weak auto weakSelf = self;
+    NSString *capturedItemId = item.itemId;
+    [RNSStackHeaderMenuCoordinator applyMenuRepresentation:item.menuRepresentation
+                                           toBarButtonItem:barButtonItem
+                                  withHeaderEventsDelegate:_eventsDelegate
+                                              stateTracker:tracker
+                                           withImageLoader:_imageLoader
+                                   menuInvalidatedCallback:^{
+                                     [weakSelf reapplyMenuRepresentationForItemWithId:capturedItemId];
+                                   }];
+  }
+
   if (item.itemId != nil) {
     _barButtonItemsByItemId[item.itemId] = barButtonItem;
   }

package/ios/tabs/RNSTabBarAppearanceCoordinator.mm

@@ -1,13 +1,29 @@
 #import "RNSTabBarAppearanceCoordinator.h"
 #import <React/RCTFont.h>
 #import <React/RCTImageLoader.h>
+#import <React/RCTLog.h>
 #import "RCTConvert+RNSTabs.h"
-#import "RNSConversions.h"
+#import "RNSConversions-Tabs.h"
+#import "RNSDefines.h"
 #import "RNSImageLoadingHelper.h"
 #import "RNSTabBarController.h"
 #import "RNSTabsHostComponentView.h"
 #import "RNSTabsScreenViewController.h"
 
+static UIImage *_Nullable RNSImageWithSymbolRenderingMode(UIImage *_Nullable image,
+                                                          RNSTabsIconSymbolRenderingMode renderingMode)
+{
+  switch (renderingMode) {
+    case RNSTabsIconSymbolRenderingModeMonochrome:
+      return [image imageWithRenderingMode:UIImageRenderingModeAlwaysTemplate];
+    case RNSTabsIconSymbolRenderingModeOriginal:
+      return [image imageWithRenderingMode:UIImageRenderingModeAlwaysOriginal];
+    case RNSTabsIconSymbolRenderingModeDefault:
+    default:
+      return image;
+  }
+}
+
 @implementation RNSTabBarAppearanceCoordinator
 
 - (void)updateAppearanceOfTabBar:(nullable UITabBar *)tabBar
@@ -55,42 +71,94 @@
               withImageLoader:imageLoader];
 }
 
+/// Sets the normal icon on both the item (renders the iPhone bar) and the UITab (renders the
+/// iPad floating bar / sidebar, which never reads the item).
+- (void)setTabImage:(nullable UIImage *)image
+      forTabBarItem:(nonnull UITabBarItem *)tabBarItem
+         screenView:(nullable RNSTabsScreenComponentView *)screenView
+{
+#if RNS_UITAB_API_SDK_AVAILABLE
+  if (RNS_UITAB_API_ENABLED) {
+    screenView.controller.tab.image = image;
+  }
+#endif // RNS_UITAB_API_SDK_AVAILABLE
+  // This needs to be called after tab.image assignment
+  // (see https://github.com/software-mansion/react-native-screens/pull/4813)
+  tabBarItem.image = image;
+}
+
 - (void)setIconsForTabBarItem:(UITabBarItem *)tabBarItem
                fromScreenView:(RNSTabsScreenComponentView *)screenView
               withImageLoader:(RCTImageLoader *_Nullable)imageLoader
 {
   if (screenView.iconType == RNSTabsIconTypeSfSymbol || screenView.iconType == RNSTabsIconTypeXcasset) {
     if (screenView.iconResourceName != nil) {
+      UIImage *image;
       if (screenView.iconType == RNSTabsIconTypeSfSymbol) {
-        tabBarItem.image = [UIImage systemImageNamed:screenView.iconResourceName];
+        image = [RNSImageLoadingHelper symbolImageNamed:screenView.iconResourceName];
+        if (image == nil) {
+          RCTLogWarn(@"[RNScreens] Failed to load SF Symbol \"%@\" for tab bar item", screenView.iconResourceName);
+        }
       } else {
-        tabBarItem.image = [UIImage imageNamed:screenView.iconResourceName];
+        image = [UIImage imageNamed:screenView.iconResourceName];
+        if (image == nil) {
+          RCTLogWarn(@"[RNScreens] Failed to load xcasset \"%@\" for tab bar item", screenView.iconResourceName);
+        }
       }
+      [self setTabImage:RNSImageWithSymbolRenderingMode(image, screenView.iconSymbolRenderingMode)
+          forTabBarItem:tabBarItem
+             screenView:screenView];
     } else if (screenView.systemItem != RNSTabsScreenSystemItemNone) {
       // Restore default system item icon
-      UITabBarSystemItem systemItem =
+      std::optional<UITabBarSystemItem> systemItem =
           rnscreens::conversion::RNSTabsScreenSystemItemToUITabBarSystemItem(screenView.systemItem);
-      tabBarItem.image = [[UITabBarItem alloc] initWithTabBarSystemItem:systemItem tag:0].image;
+      if (!systemItem) {
+        RCTLogError(
+            @"[RNScreens] Conversion from tabs screen systemItem to UITabBarSystemItem failed for systemItem [%ld]",
+            (long)screenView.systemItem);
+        return;
+      }
+      UIImage *_Nullable systemItemImage =
+          [[UITabBarItem alloc] initWithTabBarSystemItem:systemItem.value() tag:0].image;
+      [self setTabImage:systemItemImage forTabBarItem:tabBarItem screenView:screenView];
     } else {
-      tabBarItem.image = nil;
+      [self setTabImage:nil forTabBarItem:tabBarItem screenView:screenView];
     }
 
     if (screenView.selectedIconResourceName != nil) {
+      UIImage *selectedImage;
       if (screenView.iconType == RNSTabsIconTypeSfSymbol) {
-        tabBarItem.selectedImage = [UIImage systemImageNamed:screenView.selectedIconResourceName];
+        selectedImage = [RNSImageLoadingHelper symbolImageNamed:screenView.selectedIconResourceName];
+        if (selectedImage == nil) {
+          RCTLogWarn(@"[RNScreens] Failed to load SF Symbol \"%@\" for selected tab bar item",
+                     screenView.selectedIconResourceName);
+        }
       } else {
-        tabBarItem.selectedImage = [UIImage imageNamed:screenView.selectedIconResourceName];
+        selectedImage = [UIImage imageNamed:screenView.selectedIconResourceName];
+        if (selectedImage == nil) {
+          RCTLogWarn(@"[RNScreens] Failed to load xcasset \"%@\" for selected tab bar item",
+                     screenView.selectedIconResourceName);
+        }
       }
+      tabBarItem.selectedImage =
+          RNSImageWithSymbolRenderingMode(selectedImage, screenView.selectedIconSymbolRenderingMode);
     } else if (screenView.systemItem != RNSTabsScreenSystemItemNone) {
       // Restore default system item icon
-      UITabBarSystemItem systemItem =
+      std::optional<UITabBarSystemItem> systemItem =
           rnscreens::conversion::RNSTabsScreenSystemItemToUITabBarSystemItem(screenView.systemItem);
-      tabBarItem.selectedImage = [[UITabBarItem alloc] initWithTabBarSystemItem:systemItem tag:0].selectedImage;
+      if (!systemItem) {
+        RCTLogError(
+            @"[RNScreens] Conversion from tabs screen systemItem to UITabBarSystemItem failed for systemItem [%ld]",
+            (long)screenView.systemItem);
+        return;
+      }
+      tabBarItem.selectedImage = [[UITabBarItem alloc] initWithTabBarSystemItem:systemItem.value() tag:0].selectedImage;
     } else {
       tabBarItem.selectedImage = nil;
     }
   } else if (imageLoader != nil) {
-    bool isTemplate = screenView.iconType == RNSTabsIconTypeTemplate;
+    bool isTemplate = screenView.iconImageRenderingMode == RNSTabsIconImageRenderingModeTemplate;
+    bool isSelectedTemplate = screenView.selectedIconImageRenderingMode == RNSTabsIconImageRenderingModeTemplate;
 
     // Weak-capture to avoid updating a tab bar item whose internal
     // view hierarchy has been torn down (iOS 26 UIKit regression:
@@ -110,14 +178,14 @@
                                             forScreenView:weakScreenView];
                                  }];
     } else {
-      tabBarItem.image = nil;
+      [self setTabImage:nil forTabBarItem:tabBarItem screenView:screenView];
     }
 
     // Selected icon
     if (screenView.selectedIconImageSource != nil) {
       [RNSImageLoadingHelper loadImageFromSource:screenView.selectedIconImageSource
                                  withImageLoader:imageLoader
-                                      asTemplate:isTemplate
+                                      asTemplate:isSelectedTemplate
                                  completionBlock:^(UIImage *image) {
                                    [self updateTabBarItem:weakTabBarItem
                                                 withImage:image
@@ -132,6 +200,22 @@
   }
 }
 
+/// Whether the screen is still managed by a tab bar controller. On the UITab path the controller of
+/// a tab that overflows into More has no parent until the tab is first shown (UIKit parents it
+/// lazily), but its `UITab` is installed - the tab is the liveness check there, not the parent.
+- (BOOL)isScreenControllerAttachedToTabBarController:(nullable RNSTabsScreenViewController *)screenController
+{
+  if (screenController == nil) {
+    return NO;
+  }
+#if RNS_UITAB_API_SDK_AVAILABLE
+  if (RNS_UITAB_API_ENABLED) {
+    return screenController.tab.tabBarController != nil;
+  }
+#endif // RNS_UITAB_API_SDK_AVAILABLE
+  return screenController.parentViewController != nil;
+}
+
 - (void)updateTabBarItem:(nullable UITabBarItem *)tabBarItem
                withImage:(nullable UIImage *)image
               isSelected:(BOOL)isSelected
@@ -144,16 +228,26 @@
     return;
   }
 
-  UIViewController *screenParentViewController = [screenView.controller parentViewController];
-  if (screenParentViewController == nil) {
+  if (![self isScreenControllerAttachedToTabBarController:screenView.controller]) {
     return;
   }
 
   if (isSelected) {
     tabBarItem.selectedImage = image;
   } else {
-    tabBarItem.image = image;
+    [self setTabImage:image forTabBarItem:tabBarItem screenView:screenView];
+  }
+
+  UIViewController *screenParentViewController = [screenView.controller parentViewController];
+#if RNS_UITAB_API_SDK_AVAILABLE
+  if (RNS_UITAB_API_ENABLED) {
+    if (screenParentViewController == nil) {
+      // A tab that overflows into More and has not been shown yet - UIKit parents it lazily. Its
+      // icon lives in the More list, not in the bar, so there is nothing to lay out.
+      return;
+    }
   }
+#endif // RNS_UITAB_API_SDK_AVAILABLE
 
   // A layout pass is required because the image might be loaded asynchronously,
   // after the tab bar has already been attached to the window.

package/ios/tabs/RNSTabBarItemCoordinator.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#import <Foundation/Foundation.h>
+#import "RNSTabsScreenViewController.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface RNSTabBarItemCoordinator : NSObject
+
+- (void)createTabBarItemsForTabScreenControllers:(nullable NSArray<RNSTabsScreenViewController *> *)tabScreenCtrls;
+
+- (void)updateTabBarItemsForTabScreenControllers:(nullable NSArray<RNSTabsScreenViewController *> *)tabScreenCtrls;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/tabs/RNSTabBarItemCoordinator.mm

@@ -0,0 +1,143 @@
+#import "RNSTabBarItemCoordinator.h"
+#import <React/RCTLog.h>
+#import "RNSConversions-Tabs.h"
+#import "RNSDefines.h"
+#import "RNSTabsScreenComponentView.h"
+
+@implementation RNSTabBarItemCoordinator
+
+/**
+ * Creates UITabBarItem instance with set systemItem. Needs to be called before UITab creation for the same
+ * viewController.
+ */
+- (void)createTabBarItemsForTabScreenControllers:(nullable NSArray<RNSTabsScreenViewController *> *)tabScreenCtrls
+{
+  for (RNSTabsScreenViewController *tabScreenCtrl in tabScreenCtrls) {
+    RNSTabsScreenComponentView *screenView = tabScreenCtrl.tabScreenComponentView;
+    if (screenView == nil) {
+      RCTLogWarn(@"[RNScreens] Nullish component view of TabScreen while tab bar item creation!");
+      continue;
+    }
+
+    if (screenView.tabBarItemNeedsRecreation) {
+      screenView.tabBarItemNeedsRecreation = NO;
+      [self createTabBarItemForTabScreenController:tabScreenCtrl];
+    }
+  }
+}
+
+/**
+ * Updates the runtime properties of UITabBarItem: title and badge. If used with UITab API, it should be called after
+ * the tab is built.
+ */
+- (void)updateTabBarItemsForTabScreenControllers:(nullable NSArray<RNSTabsScreenViewController *> *)tabScreenCtrls
+{
+  for (RNSTabsScreenViewController *tabScreenCtrl in tabScreenCtrls) {
+    RNSTabsScreenComponentView *screenView = tabScreenCtrl.tabScreenComponentView;
+    if (screenView == nil) {
+      RCTLogWarn(@"[RNScreens] Nullish component view of TabScreen while tab bar item update!");
+      continue;
+    }
+
+    if (screenView.tabBarItemNeedsUpdate) {
+      screenView.tabBarItemNeedsUpdate = NO;
+      [self updateTabBarItemForTabScreenController:tabScreenCtrl];
+    }
+  }
+}
+
+- (void)createTabBarItemForTabScreenController:(nonnull RNSTabsScreenViewController *)tabScreenCtrl
+{
+  RNSTabsScreenComponentView *screenView = tabScreenCtrl.tabScreenComponentView;
+
+  UITabBarItem *tabBarItem = nil;
+  if (screenView.systemItem != RNSTabsScreenSystemItemNone) {
+    std::optional<UITabBarSystemItem> systemItem =
+        rnscreens::conversion::RNSTabsScreenSystemItemToUITabBarSystemItem(screenView.systemItem);
+    if (!systemItem) {
+      RCTLogError(
+          @"[RNScreens] Conversion from tabs screen systemItem to UITabBarSystemItem failed for systemItem [%ld]",
+          (long)screenView.systemItem);
+      return;
+    }
+    tabBarItem = [[UITabBarItem alloc] initWithTabBarSystemItem:systemItem.value() tag:0];
+  } else {
+    tabBarItem = [[UITabBarItem alloc] init];
+  }
+
+  [self applyTabBarItemRepaintWorkaroundForTabScreenController:tabScreenCtrl];
+  tabScreenCtrl.tabBarItem = tabBarItem;
+}
+
+/**
+ * TODO: This is an ugly workaround and I would love to see it replaced.
+ * With UITab-managed children (iOS >= 26.1) any change to the systemItem for the first time
+ * results in missing icon and wrong title. Assigning a throwaway item first flips the internal logic
+ * so that the real assignment that follows paints synchronously.
+ * Remove once UIKit internals no longer require it.
+ */
+- (void)applyTabBarItemRepaintWorkaroundForTabScreenController:(nonnull RNSTabsScreenViewController *)tabScreenCtrl
+{
+#if RNS_UITAB_API_SDK_AVAILABLE
+  if (RNS_UITAB_API_ENABLED) {
+    tabScreenCtrl.tabBarItem = [[UITabBarItem alloc] init];
+  }
+#endif // RNS_UITAB_API_SDK_AVAILABLE
+}
+
+- (void)updateTabBarItemForTabScreenController:(nonnull RNSTabsScreenViewController *)tabScreenCtrl
+{
+  RNSTabsScreenComponentView *screenView = tabScreenCtrl.tabScreenComponentView;
+
+  NSString *evaluatedTitle = screenView.title;
+  if (screenView.title == nil && screenView.systemItem != RNSTabsScreenSystemItemNone) {
+    // Restore default system item title
+    std::optional<UITabBarSystemItem> systemItem =
+        rnscreens::conversion::RNSTabsScreenSystemItemToUITabBarSystemItem(screenView.systemItem);
+    if (!systemItem) {
+      RCTLogError(
+          @"[RNScreens] Conversion from tabs screen systemItem to UITabBarSystemItem failed for systemItem [%ld]",
+          (long)screenView.systemItem);
+      return;
+    }
+    evaluatedTitle = [[UITabBarItem alloc] initWithTabBarSystemItem:systemItem.value() tag:0].title;
+  }
+
+  [self updateTabBarItemTitle:evaluatedTitle forTabScreenController:tabScreenCtrl];
+  [self updateTabBarItemBadge:screenView.badgeValue forTabScreenController:tabScreenCtrl];
+}
+
+- (void)updateTabBarItemTitle:(NSString *)newTitle
+       forTabScreenController:(nonnull RNSTabsScreenViewController *)tabScreenCtrl
+{
+  // Setting controller title updates also controller's tabBarItem.title but only if there
+  // is a change to controller title. After creating new tabBarItem, controller title
+  // remains the same but tabBarItem.title is nil. For consistency, we always
+  // update both.
+  if (![tabScreenCtrl.tabBarItem.title isEqualToString:newTitle] || ![tabScreenCtrl.title isEqualToString:newTitle]) {
+    tabScreenCtrl.title = newTitle;
+    tabScreenCtrl.tabBarItem.title = newTitle;
+#if RNS_UITAB_API_SDK_AVAILABLE
+    if (RNS_UITAB_API_ENABLED) {
+      // iPad sources the rendered title from the tab, not the item.
+      tabScreenCtrl.tab.title = newTitle;
+    }
+#endif // RNS_UITAB_API_SDK_AVAILABLE
+  }
+}
+
+- (void)updateTabBarItemBadge:(NSString *)badgeValue
+       forTabScreenController:(nonnull RNSTabsScreenViewController *)tabScreenCtrl
+{
+  if (![tabScreenCtrl.tabBarItem.badgeValue isEqualToString:badgeValue]) {
+    // The badge must land on both the item (viewController API) and the tab (UITab API) to render.
+    tabScreenCtrl.tabBarItem.badgeValue = badgeValue;
+#if RNS_UITAB_API_SDK_AVAILABLE
+    if (RNS_UITAB_API_ENABLED) {
+      tabScreenCtrl.tab.badgeValue = badgeValue;
+    }
+#endif // RNS_UITAB_API_SDK_AVAILABLE
+  }
+}
+
+@end

package/ios/tabs/bottom-accessory/RNSTabsBottomAccessoryComponentView.h

@@ -5,7 +5,7 @@
 #import "RNSTabsHostComponentView.h"
 
 #if defined(__cplusplus)
-#import <rnscreens/RNSTabsBottomAccessoryComponentDescriptor.h>
+#import <react/renderer/components/rnscreens/RNSTabsBottomAccessoryComponentDescriptor.h>
 #endif // defined(__cplusplus)
 
 NS_ASSUME_NONNULL_BEGIN