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

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

@@ -3,8 +3,6 @@
 #import "RNSEnums.h"
 #import "RNSReactBaseView.h"
 #import "RNSSafeAreaProviding.h"
-#import "RNSSplitScreenComponentEventEmitter.h"
-#import "RNSSplitScreenShadowStateProxy.h"
 
 NS_ASSUME_NONNULL_BEGIN
 
@@ -25,26 +23,6 @@ NS_ASSUME_NONNULL_BEGIN
 
 @end
 
-#pragma mark - ShadowTreeState
-
-/**
- * @category ShadowTreeState
- * @brief Interactions between the host component and the associated ShadowNode.
- */
-@interface RNSSplitScreenComponentView ()
-
-/**
- * @brief Getter for the proxy object that interfaces with the Shadow Tree state for this screen.
- *
- * The ShadowStateProxy is the object that's responsible for sending layout updates coming from the Host tree to the
- * ShadowTree.
- *
- * @return A pointer to a RNSSplitScreenShadowStateProxy instance.
- */
-- (nonnull RNSSplitScreenShadowStateProxy *)shadowStateProxy;
-
-@end
-
 #pragma mark - Props
 
 /**
@@ -60,21 +38,4 @@ NS_ASSUME_NONNULL_BEGIN
 
 @end
 
-#pragma mark - Events
-
-/**
- * @category Events
- * @brief APIs related to event emission to React Native.
- */
-@interface RNSSplitScreenComponentView ()
-
-/**
- * @brief Getter for the component's event emitter used for emitting events to React.
- *
- * @return A pointer to RNSSplitScreenComponentEventEmitter instance.
- */
-- (nonnull RNSSplitScreenComponentEventEmitter *)reactEventEmitter;
-
-@end
-
 NS_ASSUME_NONNULL_END

package/ios/split/RNSSplitScreenComponentView.mm

@@ -1,14 +1,18 @@
 #import "RNSSplitScreenComponentView.h"
 #import <React/RCTAssert.h>
 #import <React/RCTSurfaceTouchHandler.h>
-#import <rnscreens/RNSSplitScreenComponentDescriptor.h>
-#import "RNSConversions.h"
+#import <react/renderer/components/rnscreens/RNSSplitScreenComponentDescriptor.h>
+#import "RNSConversions-SplitView.h"
 #import "RNSSafeAreaViewNotifications.h"
-
-#import "Swift-Bridging.h"
+#import "RNSSplitScreenComponentEventEmitter.h"
+#import "RNSSplitScreenController.h"
+#import "RNSSplitScreenShadowStateProxy.h"
 
 namespace react = facebook::react;
 
+@interface RNSSplitScreenComponentView () <RNSSplitScreenControllerDelegate>
+@end
+
 @implementation RNSSplitScreenComponentView {
   RNSSplitScreenComponentEventEmitter *_Nonnull _reactEventEmitter;
   RNSSplitScreenController *_Nullable _controller;
@@ -50,6 +54,7 @@ namespace react = facebook::react;
 {
   _controller = [[RNSSplitScreenController alloc] initWithSplitScreenComponentView:self];
   _controller.view = self;
+  _controller.delegate = self;
 }
 
 - (void)didMoveToWindow
@@ -97,32 +102,43 @@ 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];
 }
 
-#pragma mark - ShadowTreeState
+#pragma mark - RNSSplitScreenControllerDelegate
+
+- (void)splitScreenController:(RNSSplitScreenController *)controller didChangeColumnFrame:(CGRect)frame
+{
+  [_shadowStateProxy updateShadowStateWithFrame:frame];
+}
 
-- (nonnull RNSSplitScreenShadowStateProxy *)shadowStateProxy
+- (void)splitScreenControllerWillAppear:(RNSSplitScreenController *)controller
 {
-  RCTAssert(_shadowStateProxy != nil, @"[RNScreens] Attempt to access uninitialized _shadowStateProxy");
-  return _shadowStateProxy;
+  [_reactEventEmitter emitOnWillAppear];
 }
 
-#pragma mark - Events
+- (void)splitScreenControllerDidAppear:(RNSSplitScreenController *)controller
+{
+  [_reactEventEmitter emitOnDidAppear];
+}
+
+- (void)splitScreenControllerWillDisappear:(RNSSplitScreenController *)controller
+{
+  [_reactEventEmitter emitOnWillDisappear];
+}
 
-- (nonnull RNSSplitScreenComponentEventEmitter *)reactEventEmitter
+- (void)splitScreenControllerDidDisappear:(RNSSplitScreenController *)controller
 {
-  RCTAssert(_reactEventEmitter != nil, @"[RNScreens] Attempt to access uninitialized _reactEventEmitter");
-  return _reactEventEmitter;
+  [_reactEventEmitter emitOnDidDisappear];
 }
 
 #pragma mark - RNSSafeAreaProviding

package/ios/split/RNSSplitScreenController.h

@@ -0,0 +1,68 @@
+#pragma once
+
+#import <UIKit/UIKit.h>
+
+@class RNSSplitScreenComponentView;
+@class RNSSplitScreenController;
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * @protocol RNSSplitScreenControllerDelegate
+ * @brief Receives layout and lifecycle notifications of a Split column from its controller.
+ */
+@protocol RNSSplitScreenControllerDelegate <NSObject>
+
+/**
+ * @brief Called whenever the column frame changes.
+ *
+ * @param frame The column frame in the coordinate space of the SplitHost controller's view, or the column view frame
+ * as is when the column is presented outside the SplitHost subtree (e.g. the inspector as a modal).
+ */
+- (void)splitScreenController:(RNSSplitScreenController *)controller didChangeColumnFrame:(CGRect)frame;
+
+- (void)splitScreenControllerWillAppear:(RNSSplitScreenController *)controller;
+- (void)splitScreenControllerDidAppear:(RNSSplitScreenController *)controller;
+- (void)splitScreenControllerWillDisappear:(RNSSplitScreenController *)controller;
+- (void)splitScreenControllerDidDisappear:(RNSSplitScreenController *)controller;
+
+@end
+
+/**
+ * @class RNSSplitScreenController
+ * @brief A UIViewController subclass that manages a Split column in a UISplitViewController.
+ *
+ * It observes the column layout and lifecycle and reports them to its delegate.
+ */
+@interface RNSSplitScreenController : UIViewController
+
+@property (nonatomic, weak, nullable) id<RNSSplitScreenControllerDelegate> delegate;
+
+- (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 Reports the column frame change after the Split repositioned its columns.
+ *
+ * @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,113 @@
+#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;
+}
+
+/**
+ * @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];
+
+  // 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]) {
+    [_delegate splitScreenController:self didChangeColumnFrame:self.view.frame];
+    return;
+  }
+
+  UIView *ancestorView = [self findSplitHostController].view;
+  RCTAssert(ancestorView != nil, @"[RNScreens] Expected to find RNSSplitHost component for RNSSplitScreen component");
+
+  [self reportColumnFrameInContextOfView:ancestorView];
+}
+
+- (void)columnPositioningDidChangeInSplitViewController:(UISplitViewController *)splitViewController
+{
+  [self reportColumnFrameInContextOfView:splitViewController.view];
+}
+
+- (void)reportColumnFrameInContextOfView:(UIView *)ancestorView
+{
+  CGRect frame = [self.view convertRect:self.view.frame toView:ancestorView];
+  [_delegate splitScreenController:self didChangeColumnFrame:frame];
+}
+
+#pragma mark - Events
+
+- (void)viewWillAppear:(BOOL)animated
+{
+  [super viewWillAppear:animated];
+  [_delegate splitScreenControllerWillAppear:self];
+}
+
+- (void)viewDidAppear:(BOOL)animated
+{
+  [super viewDidAppear:animated];
+  [_delegate splitScreenControllerDidAppear:self];
+}
+
+- (void)viewWillDisappear:(BOOL)animated
+{
+  [super viewWillDisappear:animated];
+  [_delegate splitScreenControllerWillDisappear:self];
+}
+
+- (void)viewDidDisappear:(BOOL)animated
+{
+  [super viewDidDisappear:animated];
+  [_delegate splitScreenControllerDidDisappear:self];
+}
+
+@end

package/ios/split/RNSSplitScreenShadowStateProxy.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #import <Foundation/Foundation.h>
+#import <UIKit/UIKit.h>
 
 #if defined(__cplusplus)
 #import <react/renderer/core/State.h>
@@ -10,8 +11,6 @@ namespace react = facebook::react;
 
 NS_ASSUME_NONNULL_BEGIN
 
-@class RNSSplitScreenComponentView;
-
 /**
  * @class RNSSplitScreenShadowStateProxy
  * @brief Manages communication between native UIView layout and associated React Native ShadowNode state.
@@ -21,44 +20,6 @@ NS_ASSUME_NONNULL_BEGIN
  */
 @interface RNSSplitScreenShadowStateProxy : NSObject
 
-/**
- * @brief Triggers a shadow state update for the given SplitScreen component.
- *
- * Internally uses the component’s frame in UIWindow coordinates to update the Shadow Tree state.
- *
- * @param screenComponentView An instance of RNSSplitScreenComponentView whose state should be updated.
- */
-- (void)updateShadowStateOfComponent:(RNSSplitScreenComponentView *)screenComponentView;
-
-/**
- * @brief Triggers a shadow state update for the given SplitScreen component in the context of a given ancestor
- * view.
- *
- * Converts the split view screen's local frame to coordinates of the specified ancestor view
- * before applying the update to the Shadow Tree. If the ancestor haven't been defined frame is calculated relatively to
- * the UIWindow.
- *
- * @param screenComponentView An instance of RNSSplitScreenComponentView whose state should be updated.
- * @param ancestorView An optional UIView in whose coordinate space the frame should be computed.
- */
-- (void)updateShadowStateOfComponent:(RNSSplitScreenComponentView *)screenComponentView
-             inContextOfAncestorView:(UIView *_Nullable)ancestorView;
-
-/**
- * @brief Send an update to ShadowNode state with given frame if needed.
- *
- * Converts the frame to coordinates of the specified ancestor view,
- * before applying the update to the Shadow Tree.
- *
- * @param screenComponentView an instance of RNSSplitScreenComponentView whose state should be updated,
- * @param frame frame to update the shadow state with; it must be in coordinate system of `screenComponentView`,
- * @param ancestorView coordinate-system provider view, relative to which the frame should be converted before sending
- * the update.
- */
-- (void)updateShadowStateOfComponent:(RNSSplitScreenComponentView *)screenComponentView
-                           withFrame:(CGRect)frame
-             inContextOfAncestorView:(nonnull UIView *)ancestorView;
-
 /**
  * @brief Send an update to ShadowNode state with given layout metrics.
  *

package/ios/split/RNSSplitScreenShadowStateProxy.mm

@@ -1,9 +1,8 @@
 #import "RNSSplitScreenShadowStateProxy.h"
-#import "RNSSplitScreenComponentView.h"
 
 #import <React/RCTAssert.h>
 #import <React/RCTConversions.h>
-#import <rnscreens/RNSSplitScreenShadowNode.h>
+#import <react/renderer/components/rnscreens/RNSSplitScreenShadowNode.h>
 
 namespace react = facebook::react;
 
@@ -21,21 +20,6 @@ namespace react = facebook::react;
   return self;
 }
 
-- (void)updateShadowStateOfComponent:(RNSSplitScreenComponentView *)screenComponentView
-{
-  [self updateShadowStateOfComponent:screenComponentView inContextOfAncestorView:nil];
-}
-
-- (void)updateShadowStateOfComponent:(RNSSplitScreenComponentView *)screenComponentView
-             inContextOfAncestorView:(UIView *_Nullable)ancestorView
-{
-  CGRect frame = screenComponentView.frame;
-  if (ancestorView != nil) {
-    frame = [screenComponentView convertRect:frame toView:ancestorView];
-  }
-  [self updateShadowStateWithFrame:frame];
-}
-
 - (void)updateShadowStateWithFrame:(CGRect)frame
 {
   if (_state == nullptr) {
@@ -50,15 +34,6 @@ namespace react = facebook::react;
   }
 }
 
-- (void)updateShadowStateOfComponent:(RNSSplitScreenComponentView *)screenComponentView
-                           withFrame:(CGRect)frame
-             inContextOfAncestorView:(nonnull UIView *)ancestorView
-{
-  RCTAssert(ancestorView != nil, @"[RNScreens] ancestorView must not be nil");
-  CGRect convertedFrame = [screenComponentView convertRect:frame toView:ancestorView];
-  [self updateShadowStateWithFrame:convertedFrame];
-}
-
 - (void)updateState:(react::State::Shared const &)state oldState:(react::State::Shared const &)oldState
 {
   _state = std::static_pointer_cast<const react::RNSSplitScreenShadowNode::ConcreteState>(state);

package/ios/split/conversion/RNSConversions-SplitView.h

@@ -0,0 +1,56 @@
+#pragma once
+
+#if defined(__cplusplus)
+
+#import <UIKit/UIKit.h>
+#import <react/renderer/components/rnscreens/Props.h>
+#import <optional>
+#import <string>
+#import "RNSEnums.h"
+
+namespace rnscreens::conversion {
+
+namespace react = facebook::react;
+
+#pragma mark SplitHost props
+
+UISplitViewControllerSplitBehavior SplitViewPreferredSplitBehaviorFromHostProp(
+    react::RNSSplitHostPreferredSplitBehavior behavior);
+
+UISplitViewControllerPrimaryEdge SplitViewPrimaryEdgeFromHostProp(
+    react::RNSSplitHostPrimaryEdge primaryEdge);
+
+UISplitViewControllerDisplayMode SplitViewPreferredDisplayModeFromHostProp(
+    react::RNSSplitHostPreferredDisplayMode displayMode);
+
+#if !TARGET_OS_TV
+UISplitViewControllerBackgroundStyle
+SplitViewPrimaryBackgroundStyleFromHostProp(
+    react::RNSSplitHostPrimaryBackgroundStyle primaryBackgroundStyle);
+#endif // !TARGET_OS_TV
+
+UISplitViewControllerDisplayModeButtonVisibility
+SplitViewDisplayModeButtonVisibilityFromHostProp(
+    react::RNSSplitHostDisplayModeButtonVisibility displayModeButtonVisibility);
+
+std::string UISplitViewControllerDisplayModeToString(
+    UISplitViewControllerDisplayMode displayMode);
+
+std::optional<UISplitViewControllerColumn>
+SplitViewTopColumnForCollapsingFromHostProp(
+    react::RNSSplitHostTopColumnForCollapsing topColumnForCollapsing);
+
+RNSOrientation RNSOrientationFromRNSSplitHostOrientation(
+    react::RNSSplitHostOrientation orientation);
+
+UIUserInterfaceStyle UIUserInterfaceStyleFromHostProp(
+    react::RNSSplitHostColorScheme colorScheme);
+
+#pragma mark SplitScreen props
+
+RNSSplitScreenColumnType RNSSplitScreenColumnTypeFromScreenProp(
+    react::RNSSplitScreenColumnType columnType);
+
+}; // namespace rnscreens::conversion
+
+#endif // defined(__cplusplus)

package/ios/{conversion → split/conversion}/RNSConversions-SplitView.mm

@@ -1,7 +1,10 @@
-#import "RNSConversions.h"
+#import "RNSConversions-SplitView.h"
+#import <React/RCTLog.h>
 
 namespace rnscreens::conversion {
 
+namespace react = facebook::react;
+
 #pragma mark SplitHost props
 
 UISplitViewControllerSplitBehavior SplitViewPreferredSplitBehaviorFromHostProp(

package/ios/stack/conversion/RNSConversions-Stack.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#if defined(__cplusplus)
+
+#import <react/renderer/components/rnscreens/Props.h>
+#import "RNSHeaderItemPlacement.h"
+#import "RNSHeaderItemSpacerPlacement.h"
+#import "RNSStackScreenComponentView.h"
+
+namespace rnscreens::conversion {
+
+namespace react = facebook::react;
+
+RNSStackScreenActivityMode
+RNSStackScreenActivityModeFromReactRNSStackScreenActivityMode(
+    react::RNSStackScreenActivityMode mode);
+
+RNSHeaderItemPlacement
+RNSHeaderItemPlacementFromReactRNSStackHeaderItemIOSPlacement(
+    react::RNSStackHeaderItemIOSPlacement placement);
+
+RNSHeaderItemSpacerPlacement
+RNSHeaderItemSpacerPlacementFromReactRNSStackHeaderItemSpacerIOSPlacement(
+    react::RNSStackHeaderItemSpacerIOSPlacement placement);
+
+UINavigationItemBackButtonDisplayMode
+UINavigationItemBackButtonDisplayModeFromReactRNSStackHeaderConfigIOSBackButtonDisplayMode(
+    react::RNSStackHeaderConfigIOSBackButtonDisplayMode displayMode);
+
+}; // namespace rnscreens::conversion
+
+#endif // defined(__cplusplus)

package/ios/stack/conversion/RNSConversions-Stack.mm

@@ -0,0 +1,55 @@
+#import "RNSConversions-Stack.h"
+
+namespace rnscreens::conversion {
+
+namespace react = facebook::react;
+
+RNSStackScreenActivityMode RNSStackScreenActivityModeFromReactRNSStackScreenActivityMode(
+    react::RNSStackScreenActivityMode mode)
+{
+  return static_cast<RNSStackScreenActivityMode>(mode);
+}
+
+RNSHeaderItemPlacement RNSHeaderItemPlacementFromReactRNSStackHeaderItemIOSPlacement(
+    react::RNSStackHeaderItemIOSPlacement placement)
+{
+  switch (placement) {
+    case react::RNSStackHeaderItemIOSPlacement::Leading:
+      return RNSHeaderItemPlacementLeading;
+    case react::RNSStackHeaderItemIOSPlacement::Trailing:
+      return RNSHeaderItemPlacementTrailing;
+    case react::RNSStackHeaderItemIOSPlacement::Title:
+      return RNSHeaderItemPlacementTitle;
+    case react::RNSStackHeaderItemIOSPlacement::Subtitle:
+      return RNSHeaderItemPlacementSubtitle;
+    case react::RNSStackHeaderItemIOSPlacement::LargeSubtitle:
+      return RNSHeaderItemPlacementLargeSubtitle;
+  }
+}
+
+RNSHeaderItemSpacerPlacement RNSHeaderItemSpacerPlacementFromReactRNSStackHeaderItemSpacerIOSPlacement(
+    react::RNSStackHeaderItemSpacerIOSPlacement placement)
+{
+  switch (placement) {
+    case react::RNSStackHeaderItemSpacerIOSPlacement::Leading:
+      return RNSHeaderItemSpacerPlacementLeading;
+    case react::RNSStackHeaderItemSpacerIOSPlacement::Trailing:
+      return RNSHeaderItemSpacerPlacementTrailing;
+  }
+}
+
+UINavigationItemBackButtonDisplayMode
+UINavigationItemBackButtonDisplayModeFromReactRNSStackHeaderConfigIOSBackButtonDisplayMode(
+    react::RNSStackHeaderConfigIOSBackButtonDisplayMode displayMode)
+{
+  switch (displayMode) {
+    case react::RNSStackHeaderConfigIOSBackButtonDisplayMode::Default:
+      return UINavigationItemBackButtonDisplayModeDefault;
+    case react::RNSStackHeaderConfigIOSBackButtonDisplayMode::Generic:
+      return UINavigationItemBackButtonDisplayModeGeneric;
+    case react::RNSStackHeaderConfigIOSBackButtonDisplayMode::Minimal:
+      return UINavigationItemBackButtonDisplayModeMinimal;
+  }
+}
+
+}; // namespace rnscreens::conversion