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

package/ios/split/RNSSplitNavigationControllerFrameObserver.mm

@@ -0,0 +1,80 @@
+#import "RNSSplitNavigationControllerFrameObserver.h"
+#import "RNSSplitNavigationControllerFrameOriginChangeDelegate.h"
+
+static void *RNSSplitNavigationViewFrameContext = &RNSSplitNavigationViewFrameContext;
+
+@implementation RNSSplitNavigationControllerFrameObserver {
+  RNSSplitNavigationController *__weak _navigationController;
+  id<RNSSplitNavigationControllerFrameOriginChangeDelegate> __weak _frameOriginChangeDelegate;
+  UIView *__weak _observedView;
+}
+
+- (instancetype)initWithSplitNavigationController:(RNSSplitNavigationController *)navigationController
+                                         delegate:(id<RNSSplitNavigationControllerFrameOriginChangeDelegate>)
+                                                      frameOriginChangeDelegate
+{
+  if (self = [super init]) {
+    _navigationController = navigationController;
+    _frameOriginChangeDelegate = frameOriginChangeDelegate;
+  }
+
+  return self;
+}
+
+#pragma mark - Observing view frame changes
+
+- (void)registerForViewFrameChanges
+{
+  [self unregisterForViewFrameChanges];
+
+  UIView *view = _navigationController.viewIfLoaded;
+  if (view == nil) {
+    return;
+  }
+
+  [view addObserver:self
+         forKeyPath:@"frame"
+            options:NSKeyValueObservingOptionOld | NSKeyValueObservingOptionNew
+            context:RNSSplitNavigationViewFrameContext];
+  _observedView = view;
+}
+
+- (void)unregisterForViewFrameChanges
+{
+  [_observedView removeObserver:self forKeyPath:@"frame" context:RNSSplitNavigationViewFrameContext];
+  _observedView = nil;
+}
+
+- (void)observeValueForKeyPath:(NSString *)keyPath
+                      ofObject:(id)object
+                        change:(NSDictionary<NSKeyValueChangeKey, id> *)change
+                       context:(void *)context
+{
+  if (context != RNSSplitNavigationViewFrameContext) {
+    [super observeValueForKeyPath:keyPath ofObject:object change:change context:context];
+    return;
+  }
+
+  id oldValue = change[NSKeyValueChangeOldKey];
+  id newValue = change[NSKeyValueChangeNewKey];
+  if (![oldValue isKindOfClass:[NSValue class]] || ![newValue isKindOfClass:[NSValue class]]) {
+    return;
+  }
+
+  CGRect oldFrame = [oldValue CGRectValue];
+  CGRect newFrame = [newValue CGRectValue];
+
+  if (!CGPointEqualToPoint(oldFrame.origin, newFrame.origin)) {
+    RNSSplitNavigationController *navigationController = _navigationController;
+    if (navigationController != nil) {
+      [_frameOriginChangeDelegate splitNavigationControllerFrameOriginDidChange:navigationController];
+    }
+  }
+}
+
+- (void)dealloc
+{
+  [self unregisterForViewFrameChanges];
+}
+
+@end

package/ios/split/RNSSplitNavigationControllerFrameOriginChangeDelegate.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@class RNSSplitNavigationController;
+
+@protocol RNSSplitNavigationControllerFrameOriginChangeDelegate <NSObject>
+
+- (void)splitNavigationControllerFrameOriginDidChange:(RNSSplitNavigationController *)splitNavCtrl;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/split/RNSSplitScreenComponentView.mm

@@ -4,8 +4,7 @@
 #import <rnscreens/RNSSplitScreenComponentDescriptor.h>
 #import "RNSConversions.h"
 #import "RNSSafeAreaViewNotifications.h"
-
-#import "Swift-Bridging.h"
+#import "RNSSplitScreenController.h"
 
 namespace react = facebook::react;
 
@@ -97,13 +96,13 @@ namespace react = facebook::react;
 
 #pragma mark - Layout
 
-///
-/// This override **should be considered as a workaround** for which I made some assumptions:
-/// 1. All parents of views with associated `UINavigationController` should have the same width as the SplitView column
-/// 2. I'm greedily aligning all native components which are extending `UINavigationController` - is covers both old and
-/// new stack implementations, however, it will have an impact on any other native component which will be extending
-/// from the same class.
-///
+/**
+ * This override **should be considered as a workaround** for which I made some assumptions:
+ * 1. All parents of views with associated `UINavigationController` should have the same width as the SplitView column
+ * 2. I'm greedily aligning all native components which are extending `UINavigationController` - is covers both old and
+ * new stack implementations, however, it will have an impact on any other native component which will be extending
+ * from the same class.
+ */
 - (void)layoutSubviews
 {
   [super layoutSubviews];

package/ios/split/RNSSplitScreenController.h

@@ -0,0 +1,45 @@
+#pragma once
+
+#import <UIKit/UIKit.h>
+
+@class RNSSplitScreenComponentView;
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * @class RNSSplitScreenController
+ * @brief A UIViewController subclass that manages a Split column in a UISplitViewController.
+ *
+ * Associated with a RNSSplitScreenComponentView, it handles layout synchronization with the
+ * Shadow Tree, emits React lifecycle events, and interacts with the SplitHost hierarchy.
+ */
+@interface RNSSplitScreenController : UIViewController
+
+- (instancetype)initWithSplitScreenComponentView:(RNSSplitScreenComponentView *)splitScreenComponentView;
+
+#pragma mark - Signals
+
+/**
+ * @brief Determines if this controller is nested inside a SplitHost hierarchy.
+ *
+ * Used to differentiate between screens embedded in the native host and modal presentations.
+ *
+ * @return true if inside RNSSplitHostController, false otherwise.
+ */
+- (BOOL)isInSplitHostSubtree;
+
+- (void)setNeedsLifecycleStateUpdate;
+
+#pragma mark - Layout
+
+/**
+ * @brief Request ShadowNode state update when the Split screen frame origin has changed.
+ *
+ * @param splitViewController The UISplitViewController whose layout positioning changed, represented by
+ * RNSSplitHostController.
+ */
+- (void)columnPositioningDidChangeInSplitViewController:(UISplitViewController *)splitViewController;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/split/RNSSplitScreenController.mm

@@ -0,0 +1,130 @@
+#import "RNSSplitScreenController.h"
+
+#import <React/RCTAssert.h>
+#import "RNSSplitHostComponentView.h"
+#import "RNSSplitHostController.h"
+#import "RNSSplitScreenComponentView.h"
+
+@implementation RNSSplitScreenController {
+  RNSSplitScreenComponentView *_splitScreenComponentView;
+}
+
+- (instancetype)initWithSplitScreenComponentView:(RNSSplitScreenComponentView *)splitScreenComponentView
+{
+  if (self = [super init]) {
+    _splitScreenComponentView = splitScreenComponentView;
+  }
+
+  return self;
+}
+
+- (RNSSplitScreenShadowStateProxy *)shadowStateProxy
+{
+  return [_splitScreenComponentView shadowStateProxy];
+}
+
+- (RNSSplitScreenComponentEventEmitter *)reactEventEmitter
+{
+  return [_splitScreenComponentView reactEventEmitter];
+}
+
+/**
+ * @brief Searching for the SplitHost controller
+ *
+ * It checks whether the parent controller is our host controller.
+ * If we're outside the structure, e. g. for inspector represented as a modal,
+ * we're searching for that controller using a reference that Screen keeps for Host component view.
+ *
+ * @return If found - a RNSSplitHostController instance, otherwise nil.
+ */
+- (nullable RNSSplitHostController *)findSplitHostController
+{
+  if ([self.splitViewController isKindOfClass:RNSSplitHostController.class]) {
+    return (RNSSplitHostController *)self.splitViewController;
+  }
+
+  RNSSplitHostComponentView *splitHost = _splitScreenComponentView.splitHost;
+  if (splitHost != nil) {
+    return splitHost.splitHostController;
+  }
+
+  return nil;
+}
+
+- (BOOL)isInSplitHostSubtree
+{
+  return [self.splitViewController isKindOfClass:RNSSplitHostController.class];
+}
+
+#pragma mark - Signals
+
+- (void)setNeedsLifecycleStateUpdate
+{
+  [[self findSplitHostController] setNeedsUpdateOfChildViewControllers];
+}
+
+#pragma mark - Layout
+
+- (void)viewDidLayoutSubviews
+{
+  [super viewDidLayoutSubviews];
+
+  [self updateShadowTreeState];
+}
+
+/**
+ * @brief Handles frame layout changes and updates Shadow Tree accordingly.
+ *
+ * Requests for the ShadowNode updates through the shadow state proxy.
+ * Differentiates cases when we're in the Host hierarchy to calculate frame relatively
+ * to the Host view from the modal case where we're passing absolute layout metrics to the ShadowNode.
+ */
+- (void)updateShadowTreeState
+{
+  // For modals, which are presented outside the SplitHost subtree (and RN hierarchy),
+  // we're attaching our touch handler and we don't need to apply any offset corrections,
+  // because it's positioned relatively to our RNSSplitScreenComponentView
+  if (![self isInSplitHostSubtree]) {
+    [[self shadowStateProxy] updateShadowStateOfComponent:_splitScreenComponentView];
+    return;
+  }
+
+  UIView *ancestorView = [self findSplitHostController].view;
+  RCTAssert(ancestorView != nil, @"[RNScreens] Expected to find RNSSplitHost component for RNSSplitScreen component");
+
+  [[self shadowStateProxy] updateShadowStateOfComponent:_splitScreenComponentView inContextOfAncestorView:ancestorView];
+}
+
+- (void)columnPositioningDidChangeInSplitViewController:(UISplitViewController *)splitViewController
+{
+  [[self shadowStateProxy] updateShadowStateOfComponent:_splitScreenComponentView
+                                inContextOfAncestorView:splitViewController.view];
+}
+
+#pragma mark - Events
+
+- (void)viewWillAppear:(BOOL)animated
+{
+  [super viewWillAppear:animated];
+  [[self reactEventEmitter] emitOnWillAppear];
+}
+
+- (void)viewDidAppear:(BOOL)animated
+{
+  [super viewDidAppear:animated];
+  [[self reactEventEmitter] emitOnDidAppear];
+}
+
+- (void)viewWillDisappear:(BOOL)animated
+{
+  [super viewWillDisappear:animated];
+  [[self reactEventEmitter] emitOnWillDisappear];
+}
+
+- (void)viewDidDisappear:(BOOL)animated
+{
+  [super viewDidDisappear:animated];
+  [[self reactEventEmitter] emitOnDidDisappear];
+}
+
+@end

package/ios/stack/header/RNSStackHeaderConfigComponentView.h

@@ -21,6 +21,7 @@ NS_ASSUME_NONNULL_BEGIN
 @property (nonatomic, readonly, nullable) NSString *largeTitle;
 @property (nonatomic, readonly, nullable) NSString *largeSubtitle;
 @property (nonatomic, readonly) BOOL largeTitleEnabled;
+@property (nonatomic, readonly, nullable) RNSStackHeaderMenuData *titleMenu;
 @property (nonatomic, readonly) NSArray<id> *children;
 
 - (void)resetProps;

package/ios/stack/header/RNSStackHeaderConfigComponentView.mm

@@ -1,10 +1,13 @@
 #import "RNSStackHeaderConfigComponentView.h"
+#import "RNSConversions.h"
 #import "RNSImageLoadingHelper.h"
 #import "RNSStackHeaderConfigEventEmitter.h"
 #import "RNSStackHeaderConfigShadowStateProxy.h"
 #import "RNSStackHeaderItemComponentView.h"
 #import "RNSStackHeaderItemSpacerComponentView.h"
+#import "RNSStackHeaderMenuCoordinator.h"
 #import "RNSStackHeaderMenuFinder.h"
+#import "RNSStackHeaderMenuMapper.h"
 #import "RNSStackHeaderMenuUpdateOptions.h"
 #import "RNSStackNavigationController.h"
 #import "RNSStackScreenComponentView.h"
@@ -64,6 +67,7 @@ static void RNSAssertIsValidHeaderChild(UIView *child)
   _largeTitle = nil;
   _largeSubtitle = nil;
   _largeTitleEnabled = NO;
+  _titleMenu = nil;
 }
 
 - (NSArray<id> *)children
@@ -270,7 +274,8 @@ static void RNSAssertIsValidHeaderChild(UIView *child)
   }
 
   RNSMenuElementLocator *locator = [RNSStackHeaderMenuFinder findMenuElementWithId:menuItemId
-                                                                     inHeaderItems:[self headerItems]];
+                                                                     inHeaderItems:[self headerItems]
+                                                                         titleMenu:_titleMenu];
   if (locator == nil) {
     RCTLogWarn(@"[RNScreens] setMenuItemOptions: element with id \"%@\" not found", menuItemId);
     return;
@@ -285,15 +290,15 @@ static void RNSAssertIsValidHeaderChild(UIView *child)
   RNSStackHeaderMenuItemData *newItemData = [RNSMenuItemUpdateOptions applyOptions:updateOptions
                                                                         toMenuItem:oldItemData];
 
-  if (updateOptions.hasToggleState) {
+  if (updateOptions.hasToggleState && locator.rootMenu != nil && locator.trackerItemId != nil) {
     BOOL isToggle = oldItemData.itemType == RNSMenuItemTypeToggle ||
-        (oldItemData.itemType == RNSMenuItemTypeAutomatic && locator.headerItem.menu != nil &&
-         [RNSStackHeaderMenuFinder singleSelectionRootForElementWithId:menuItemId
-                                                                inMenu:locator.headerItem.menu] != nil);
+        (oldItemData.itemType == RNSMenuItemTypeAutomatic &&
+         [RNSStackHeaderMenuFinder singleSelectionRootForElementWithId:menuItemId inMenu:locator.rootMenu] != nil);
     if (isToggle) {
       [[self headerCoordinator] setToggleState:updateOptions.toggleState
                               forMenuElementId:menuItemId
-                                    withItemId:locator.headerItem.itemId
+                                 trackerItemId:locator.trackerItemId
+                                      rootMenu:locator.rootMenu
                                     parentMenu:locator.searchResult.parentMenu];
     }
   }
@@ -308,8 +313,15 @@ static void RNSAssertIsValidHeaderChild(UIView *child)
                        parentMenu:locator.searchResult.parentMenu];
       break;
     case RNSMenuElementPositionTitle:
+      if (locator.searchResult.parentMenu != nil) {
+        _titleMenu = [RNSStackHeaderMenuCoordinator menu:_titleMenu
+                                    replacingChildWithId:menuItemId
+                                             withElement:newItemData];
+      }
+      [[self headerCoordinator] reapplyTitleMenu];
+      break;
     case RNSMenuElementPositionOverflow:
-      // TODO: handle title menu and overflow menu
+      // TODO: handle overflow menu
       break;
   }
 }
@@ -322,7 +334,8 @@ static void RNSAssertIsValidHeaderChild(UIView *child)
   }
 
   RNSMenuElementLocator *locator = [RNSStackHeaderMenuFinder findMenuElementWithId:menuElementId
-                                                                     inHeaderItems:[self headerItems]];
+                                                                     inHeaderItems:[self headerItems]
+                                                                         titleMenu:_titleMenu];
   if (locator == nil) {
     RCTLogWarn(@"[RNScreens] setMenuOptions: element with id \"%@\" not found", menuElementId);
     return;
@@ -346,8 +359,17 @@ static void RNSAssertIsValidHeaderChild(UIView *child)
                        parentMenu:locator.searchResult.parentMenu];
       break;
     case RNSMenuElementPositionTitle:
+      if (locator.searchResult.parentMenu == nil) {
+        _titleMenu = (RNSStackHeaderMenuData *)newMenuItem;
+      } else {
+        _titleMenu = [RNSStackHeaderMenuCoordinator menu:_titleMenu
+                                    replacingChildWithId:menuElementId
+                                             withElement:newMenuItem];
+      }
+      [[self headerCoordinator] reapplyTitleMenu];
+      break;
     case RNSMenuElementPositionOverflow:
-      // TODO: handle title menu and overflow menu
+      // TODO: handle overflow menu
       break;
   }
 }
@@ -396,6 +418,8 @@ static void RNSAssertIsValidHeaderChild(UIView *child)
   const auto &newHeaderProps = *std::static_pointer_cast<const react::RNSStackHeaderConfigIOSProps>(props);
   const auto &oldHeaderProps = *std::static_pointer_cast<const react::RNSStackHeaderConfigIOSProps>(_props);
 
+  BOOL titleMenuDidChange = NO;
+
   if (oldHeaderProps.title != newHeaderProps.title) {
     _title = RCTNSStringFromStringNilIfEmpty(newHeaderProps.title);
   }
@@ -420,9 +444,23 @@ static void RNSAssertIsValidHeaderChild(UIView *child)
     _largeTitleEnabled = newHeaderProps.largeTitleEnabled;
   }
 
+  if (oldHeaderProps.titleMenu != newHeaderProps.titleMenu) {
+    _titleMenu = [RNSStackHeaderMenuMapper
+        menuFromDictionary:rnscreens::conversion::RNSConvertFollyDynamicToId(newHeaderProps.titleMenu)];
+    titleMenuDidChange = YES;
+  }
+
   [super updateProps:props oldProps:oldProps];
 
   [[self headerCoordinator] applyConfigProperties];
+
+  if (titleMenuDidChange) {
+    // title menu is a prop on the navigation item, not on one of the bar button items
+    // thus it is not configured with matching RNSStackHeaderItemComponentView
+    // but here directly
+    [[self headerCoordinator] resetTitleMenuTracker];
+    [[self headerCoordinator] reapplyTitleMenu];
+  }
 }
 
 + (react::ComponentDescriptorProvider)componentDescriptorProvider

package/ios/stack/header/RNSStackHeaderConfigDataProviding.h

@@ -2,6 +2,8 @@
 
 #import <UIKit/UIKit.h>
 
+@class RNSStackHeaderMenuData;
+
 NS_ASSUME_NONNULL_BEGIN
 
 @protocol RNSStackHeaderConfigDataProviding <NSObject>
@@ -12,6 +14,7 @@ NS_ASSUME_NONNULL_BEGIN
 @property (nonatomic, readonly, nullable) NSString *largeTitle;
 @property (nonatomic, readonly, nullable) NSString *largeSubtitle;
 @property (nonatomic, readonly) BOOL largeTitleEnabled;
+@property (nonatomic, readonly, nullable) RNSStackHeaderMenuData *titleMenu;
 
 /**
  Children are expected to conform to either RNSStackHeaderItemDataProviding

package/ios/stack/header/RNSStackHeaderMenuCoordinator.h

@@ -35,6 +35,15 @@ NS_ASSUME_NONNULL_BEGIN
  */
 + (NSArray<NSString *> *)getToggleItemsIdsInMenu:(RNSStackHeaderMenuData *)menu;
 
+/**
+ * Builds a UIMenu from the given menu data. Used for `UINavigationItem.titleMenuProvider`.
+ */
++ (UIMenu *)buildUIMenuFromData:(RNSStackHeaderMenuData *)data
+       withHeaderEventsDelegate:(id<RNSStackHeaderEventsDelegate>)delegate
+                   stateTracker:(RNSStackHeaderMenuToggleStateTracker *)tracker
+                withImageLoader:(id<RNSImageLoading>)imageLoader
+        menuInvalidatedCallback:(nullable void (^)(void))onMenuInvalidated;
+
 /**
  * Constructs a new menu tree with the child matching `elementId` replaced by `newElement`.
  * Returns the original menu unchanged if no matching child is found in the subtree.

package/ios/stack/header/RNSStackHeaderMenuCoordinator.mm

@@ -88,6 +88,21 @@
   return [UIMenu menuWithTitle:data.title image:menuImage identifier:nil options:options children:elements];
 }
 
++ (UIMenu *)buildUIMenuFromData:(RNSStackHeaderMenuData *)data
+       withHeaderEventsDelegate:(id<RNSStackHeaderEventsDelegate>)delegate
+                   stateTracker:(RNSStackHeaderMenuToggleStateTracker *)tracker
+                withImageLoader:(id<RNSImageLoading>)imageLoader
+        menuInvalidatedCallback:(nullable void (^)(void))onMenuInvalidated
+{
+  return [self buildMenuFromData:data
+                withHeaderEventsDelegate:delegate
+                            stateTracker:tracker
+                     singleSelectionRoot:nil
+      initialSingleSelectionStateClaimed:NULL
+                         withImageLoader:imageLoader
+                 menuInvalidatedCallback:onMenuInvalidated];
+}
+
 + (nullable UIMenuElement *)buildElementFromData:(id<RNSStackHeaderMenuElement>)element
                         withHeaderEventsDelegate:(id<RNSStackHeaderEventsDelegate>)delegate
                                     stateTracker:(RNSStackHeaderMenuToggleStateTracker *)tracker

package/ios/stack/header/RNSStackHeaderMenuFinder.h

@@ -7,6 +7,8 @@
 
 NS_ASSUME_NONNULL_BEGIN
 
+static NSString *const RNSTitleMenuTrackerItemId = @"__titleMenu__";
+
 @interface RNSStackHeaderMenuElementSearchResult : NSObject
 
 @property (nonatomic, strong, readonly) id<RNSStackHeaderMenuElement> element;
@@ -29,19 +31,32 @@ typedef NS_ENUM(NSInteger, RNSMenuElementPosition) {
 @property (nonatomic, readonly) RNSMenuElementPosition position;
 @property (nonatomic, weak, readonly, nullable) id<RNSStackHeaderItemDataProviding> headerItem;
 
+/**
+ * Root menu tree that contains the found element. Used for singleSelectionRoot lookups.
+ */
+@property (nonatomic, strong, readonly, nullable) RNSStackHeaderMenuData *rootMenu;
+
+/**
+ * Tracker key for the toggle state tracker registry.
+ */
+@property (nonatomic, copy, readonly, nullable) NSString *trackerItemId;
+
 - (instancetype)initWithSearchResult:(RNSStackHeaderMenuElementSearchResult *)searchResult
                             position:(RNSMenuElementPosition)position
-                          headerItem:(nullable id<RNSStackHeaderItemDataProviding>)headerItem;
+                          headerItem:(nullable id<RNSStackHeaderItemDataProviding>)headerItem
+                            rootMenu:(nullable RNSStackHeaderMenuData *)rootMenu
+                       trackerItemId:(nullable NSString *)trackerItemId;
 
 @end
 
 @interface RNSStackHeaderMenuFinder : NSObject
 
 /**
- * Searches all header items' menus for a menu element with the given ID.
+ * Searches all header items' menus and the title menu for a menu element with the given ID.
  */
 + (nullable RNSMenuElementLocator *)findMenuElementWithId:(NSString *)elementId
-                                            inHeaderItems:(NSArray<id<RNSStackHeaderItemDataProviding>> *)items;
+                                            inHeaderItems:(NSArray<id<RNSStackHeaderItemDataProviding>> *)items
+                                                titleMenu:(nullable RNSStackHeaderMenuData *)titleMenu;
 
 /**
  * Recursively searches a single menu tree for an element with the given ID.

package/ios/stack/header/RNSStackHeaderMenuFinder.mm

@@ -23,11 +23,15 @@
 - (instancetype)initWithSearchResult:(RNSStackHeaderMenuElementSearchResult *)searchResult
                             position:(RNSMenuElementPosition)position
                           headerItem:(nullable id<RNSStackHeaderItemDataProviding>)headerItem
+                            rootMenu:(nullable RNSStackHeaderMenuData *)rootMenu
+                       trackerItemId:(nullable NSString *)trackerItemId
 {
   if (self = [super init]) {
     _searchResult = searchResult;
     _position = position;
     _headerItem = headerItem;
+    _rootMenu = rootMenu;
+    _trackerItemId = [trackerItemId copy];
   }
   return self;
 }
@@ -40,6 +44,7 @@
 
 + (nullable RNSMenuElementLocator *)findMenuElementWithId:(NSString *)elementId
                                             inHeaderItems:(NSArray<id<RNSStackHeaderItemDataProviding>> *)items
+                                                titleMenu:(nullable RNSStackHeaderMenuData *)titleMenu
 {
   for (id<RNSStackHeaderItemDataProviding> item in items) {
     if (item.menu == nil || item.itemId == nil) {
@@ -49,11 +54,24 @@
     if (result != nil) {
       return [[RNSMenuElementLocator alloc] initWithSearchResult:result
                                                         position:RNSMenuElementPositionItem
-                                                      headerItem:item];
+                                                      headerItem:item
+                                                        rootMenu:item.menu
+                                                   trackerItemId:item.itemId];
     }
   }
-  // TODO: search title menu (RNSMenuElementPositionTitle)
-  // and overflow menu (RNSMenuElementPositionOverflow)
+
+  if (titleMenu != nil) {
+    RNSStackHeaderMenuElementSearchResult *result = [self findElementWithId:elementId inMenu:titleMenu];
+    if (result != nil) {
+      return [[RNSMenuElementLocator alloc] initWithSearchResult:result
+                                                        position:RNSMenuElementPositionTitle
+                                                      headerItem:nil
+                                                        rootMenu:titleMenu
+                                                   trackerItemId:RNSTitleMenuTrackerItemId];
+    }
+  }
+
+  // TODO: search overflow menu (RNSMenuElementPositionOverflow)
   return nil;
 }
 

package/ios/stack/host/RNSStackHostComponentView.mm

@@ -15,7 +15,6 @@
 #import "RNSStackNavigationController.h"
 #import "RNSStackOperationCoordinator.h"
 #import "RNSStackScreenComponentView.h"
-#import "Swift-Bridging.h"
 
 namespace react = facebook::react;
 
@@ -38,6 +37,9 @@ namespace react = facebook::react;
 
 - (void)initState
 {
+  static const auto defaultProps = std::make_shared<const react::RNSStackHostProps>();
+  _props = defaultProps;
+
   _stackNavigationController = [RNSStackNavigationController new];
   _stackOperationCoordinator = [RNSStackOperationCoordinator new];
   _renderedScreens = [NSMutableArray new];

package/ios/stack/host/RNSStackNavigationController.mm

@@ -1,11 +1,11 @@
 #import "RNSStackNavigationController.h"
+#import <React/RCTAssert.h>
 #import "RNSContainer.h"
 #import "RNSLog.h"
 #import "RNSParentContainerItemRegistry.h"
 #import "RNSStackOperation.h"
 #import "RNSStackScreenController.h"
 #import "RNSViewFrameChangeDelegate.h"
-#import "React/RCTAssert.h"
 
 @implementation RNSStackNavigationController {
   NSMutableArray<RNSPushOperation *> *_Nonnull _pendingPushOperations;

package/ios/stack/screen/RNSStackScreenComponentView.mm

@@ -16,8 +16,6 @@
 #import "RNSStackScreenController.h"
 #import "RNSStackScreenHeaderCoordinator.h"
 
-#import "Swift-Bridging.h"
-
 namespace react = facebook::react;
 
 @interface RNSStackScreenComponentView () <RCTMountingTransactionObserving, RNSScrollViewSeeking>

package/ios/stack/screen/RNSStackScreenHeaderCoordinator.h

@@ -30,9 +30,14 @@ NS_ASSUME_NONNULL_BEGIN
 
 - (void)resetTrackerForItemWithId:(nullable NSString *)itemId;
 
+- (void)reapplyTitleMenu;
+
+- (void)resetTitleMenuTracker;
+
 - (void)setToggleState:(BOOL)state
       forMenuElementId:(NSString *)elementId
-            withItemId:(NSString *)itemId
+         trackerItemId:(NSString *)trackerItemId
+              rootMenu:(RNSStackHeaderMenuData *)rootMenu
             parentMenu:(nullable RNSStackHeaderMenuData *)parentMenu;
 
 - (void)clearHeaderConfiguration;