react-native-screens 4.12.0 → 4.13.0

package/ios/conversion/RNSConversions-BottomTabs.mm

@@ -0,0 +1,216 @@
+#import <React/RCTConversions.h>
+#import <react/renderer/imagemanager/RCTImagePrimitivesConversions.h>
+#import "RNSConversions.h"
+
+namespace rnscreens::conversion {
+
+std::optional<UIBlurEffectStyle> RNSMaybeUIBlurEffectStyleFromRNSBottomTabsTabBarBlurEffect(
+    react::RNSBottomTabsTabBarBlurEffect blurEffect)
+{
+  using enum facebook::react::RNSBottomTabsTabBarBlurEffect;
+#if !TARGET_OS_TV
+  switch (blurEffect) {
+    case None:
+      return std::nullopt;
+    case ExtraLight:
+      return {UIBlurEffectStyleExtraLight};
+    case Light:
+      return {UIBlurEffectStyleLight};
+    case Dark:
+      return {UIBlurEffectStyleDark};
+    case Regular:
+      return {UIBlurEffectStyleRegular};
+    case Prominent:
+      return {UIBlurEffectStyleProminent};
+    case SystemUltraThinMaterial:
+      return {UIBlurEffectStyleSystemUltraThinMaterial};
+    case SystemThinMaterial:
+      return {UIBlurEffectStyleSystemThinMaterial};
+    case SystemMaterial:
+      return {UIBlurEffectStyleSystemMaterial};
+    case SystemThickMaterial:
+      return {UIBlurEffectStyleSystemThickMaterial};
+    case SystemChromeMaterial:
+      return {UIBlurEffectStyleSystemChromeMaterial};
+    case SystemUltraThinMaterialLight:
+      return {UIBlurEffectStyleSystemUltraThinMaterialLight};
+    case SystemThinMaterialLight:
+      return {UIBlurEffectStyleSystemThinMaterialLight};
+    case SystemMaterialLight:
+      return {UIBlurEffectStyleSystemMaterialLight};
+    case SystemThickMaterialLight:
+      return {UIBlurEffectStyleSystemThickMaterialLight};
+    case SystemChromeMaterialLight:
+      return {UIBlurEffectStyleSystemChromeMaterialLight};
+    case SystemUltraThinMaterialDark:
+      return {UIBlurEffectStyleSystemUltraThinMaterialDark};
+    case SystemThinMaterialDark:
+      return {UIBlurEffectStyleSystemThinMaterialDark};
+    case SystemMaterialDark:
+      return {UIBlurEffectStyleSystemMaterialDark};
+    case SystemThickMaterialDark:
+      return {UIBlurEffectStyleSystemThickMaterialDark};
+    case SystemChromeMaterialDark:
+      return {UIBlurEffectStyleSystemChromeMaterialDark};
+  }
+#endif
+
+  switch (blurEffect) {
+    case None:
+      return std::nullopt;
+    case Light:
+      return {UIBlurEffectStyleLight};
+    case Dark:
+      return {UIBlurEffectStyleDark};
+    case Regular:
+      return {UIBlurEffectStyleRegular};
+    case Prominent:
+      return {UIBlurEffectStyleProminent};
+    case ExtraLight:
+      return {UIBlurEffectStyleExtraLight};
+    default:
+      return std::nullopt;
+  }
+}
+
+UIBlurEffect *RNSUIBlurEffectFromRNSBottomTabsTabBarBlurEffect(react::RNSBottomTabsTabBarBlurEffect blurEffect)
+{
+  std::optional<UIBlurEffectStyle> maybeStyle = RNSMaybeUIBlurEffectStyleFromRNSBottomTabsTabBarBlurEffect(blurEffect);
+  if (maybeStyle) {
+    return [UIBlurEffect effectWithStyle:maybeStyle.value()];
+  }
+  return nil;
+}
+
+UIOffset RNSBottomTabsTabBarItemTitlePositionAdjustmentStruct(
+    react::RNSBottomTabsTabBarItemTitlePositionAdjustmentStruct titlePositionAdjustment)
+{
+  return UIOffsetMake(titlePositionAdjustment.horizontal, titlePositionAdjustment.vertical);
+}
+
+std::optional<UIBlurEffectStyle> RNSMaybeUIBlurEffectStyleFromRNSBottomTabsScreenTabBarBlurEffect(
+    react::RNSBottomTabsScreenTabBarBlurEffect blurEffect)
+{
+  using enum facebook::react::RNSBottomTabsScreenTabBarBlurEffect;
+#if !TARGET_OS_TV
+  switch (blurEffect) {
+    case None:
+      return std::nullopt;
+    case ExtraLight:
+      return {UIBlurEffectStyleExtraLight};
+    case Light:
+      return {UIBlurEffectStyleLight};
+    case Dark:
+      return {UIBlurEffectStyleDark};
+    case Regular:
+      return {UIBlurEffectStyleRegular};
+    case Prominent:
+      return {UIBlurEffectStyleProminent};
+    case SystemUltraThinMaterial:
+      return {UIBlurEffectStyleSystemUltraThinMaterial};
+    case SystemThinMaterial:
+      return {UIBlurEffectStyleSystemThinMaterial};
+    case SystemMaterial:
+      return {UIBlurEffectStyleSystemMaterial};
+    case SystemThickMaterial:
+      return {UIBlurEffectStyleSystemThickMaterial};
+    case SystemChromeMaterial:
+      return {UIBlurEffectStyleSystemChromeMaterial};
+    case SystemUltraThinMaterialLight:
+      return {UIBlurEffectStyleSystemUltraThinMaterialLight};
+    case SystemThinMaterialLight:
+      return {UIBlurEffectStyleSystemThinMaterialLight};
+    case SystemMaterialLight:
+      return {UIBlurEffectStyleSystemMaterialLight};
+    case SystemThickMaterialLight:
+      return {UIBlurEffectStyleSystemThickMaterialLight};
+    case SystemChromeMaterialLight:
+      return {UIBlurEffectStyleSystemChromeMaterialLight};
+    case SystemUltraThinMaterialDark:
+      return {UIBlurEffectStyleSystemUltraThinMaterialDark};
+    case SystemThinMaterialDark:
+      return {UIBlurEffectStyleSystemThinMaterialDark};
+    case SystemMaterialDark:
+      return {UIBlurEffectStyleSystemMaterialDark};
+    case SystemThickMaterialDark:
+      return {UIBlurEffectStyleSystemThickMaterialDark};
+    case SystemChromeMaterialDark:
+      return {UIBlurEffectStyleSystemChromeMaterialDark};
+  }
+#endif
+
+  switch (blurEffect) {
+    case None:
+      return std::nullopt;
+    case Light:
+      return {UIBlurEffectStyleLight};
+    case Dark:
+      return {UIBlurEffectStyleDark};
+    case Regular:
+      return {UIBlurEffectStyleRegular};
+    case Prominent:
+      return {UIBlurEffectStyleProminent};
+    case ExtraLight:
+      return {UIBlurEffectStyleExtraLight};
+    default:
+      return std::nullopt;
+  }
+}
+
+UIBlurEffect *RNSUIBlurEffectFromRNSBottomTabsScreenTabBarBlurEffect(
+    react::RNSBottomTabsScreenTabBarBlurEffect blurEffect)
+{
+  std::optional<UIBlurEffectStyle> maybeStyle =
+      RNSMaybeUIBlurEffectStyleFromRNSBottomTabsScreenTabBarBlurEffect(blurEffect);
+  if (maybeStyle) {
+    return [UIBlurEffect effectWithStyle:maybeStyle.value()];
+  }
+  return nil;
+}
+
+UIOffset RNSBottomTabsScreenTabBarItemTitlePositionAdjustmentStruct(
+    react::RNSBottomTabsScreenTabBarItemTitlePositionAdjustmentStruct titlePositionAdjustment)
+{
+  return UIOffsetMake(titlePositionAdjustment.horizontal, titlePositionAdjustment.vertical);
+}
+
+RNSBottomTabsIconType RNSBottomTabsIconTypeFromIcon(react::RNSBottomTabsScreenIconType iconType)
+{
+  using enum facebook::react::RNSBottomTabsScreenIconType;
+  switch (iconType) {
+    case Image:
+      return RNSBottomTabsIconTypeImage;
+    case Template:
+      return RNSBottomTabsIconTypeTemplate;
+    case SfSymbol:
+      return RNSBottomTabsIconTypeSfSymbol;
+  }
+}
+
+RCTImageSource *RCTImageSourceFromImageSourceAndIconType(
+    const facebook::react::ImageSource *imageSource,
+    RNSBottomTabsIconType iconType)
+{
+  RCTImageSource *iconImageSource;
+
+  switch (iconType) {
+    case RNSBottomTabsIconTypeSfSymbol:
+      iconImageSource = nil;
+      break;
+
+    case RNSBottomTabsIconTypeImage:
+    case RNSBottomTabsIconTypeTemplate:
+      iconImageSource =
+          [[RCTImageSource alloc] initWithURLRequest:NSURLRequestFromImageSource(*imageSource)
+                                                size:CGSizeMake(imageSource->size.width, imageSource->size.height)
+                                               scale:imageSource->scale];
+      break;
+
+    default:
+      RCTLogError(@"[RNScreens] unsupported icon type");
+  }
+
+  return iconImageSource;
+}
+
+}; // namespace rnscreens::conversion

package/ios/conversion/RNSConversions-SplitView.mm

@@ -0,0 +1,63 @@
+#import "RNSConversions.h"
+
+namespace rnscreens::conversion {
+
+#pragma mark RN Codegen enum to internal enum conversions
+
+UISplitViewControllerSplitBehavior SplitViewSplitBehaviorFromHostProp(
+    facebook::react::RNSSplitViewHostSplitBehavior splitBehavior)
+{
+  using enum facebook::react::RNSSplitViewHostSplitBehavior;
+
+  switch (splitBehavior) {
+    case Displace:
+      return UISplitViewControllerSplitBehaviorDisplace;
+    case Overlay:
+      return UISplitViewControllerSplitBehaviorOverlay;
+    case Tile:
+      return UISplitViewControllerSplitBehaviorTile;
+    case Automatic:
+    default:
+      return UISplitViewControllerSplitBehaviorAutomatic;
+  }
+}
+
+UISplitViewControllerPrimaryEdge SplitViewPrimaryEdgeFromHostProp(
+    facebook::react::RNSSplitViewHostPrimaryEdge primaryEdge)
+{
+  using enum facebook::react::RNSSplitViewHostPrimaryEdge;
+
+  switch (primaryEdge) {
+    case Trailing:
+      return UISplitViewControllerPrimaryEdgeTrailing;
+    case Leading:
+    default:
+      return UISplitViewControllerPrimaryEdgeLeading;
+  }
+}
+
+UISplitViewControllerDisplayMode SplitViewDisplayModeFromHostProp(
+    facebook::react::RNSSplitViewHostDisplayMode displayMode)
+{
+  using enum facebook::react::RNSSplitViewHostDisplayMode;
+
+  switch (displayMode) {
+    case SecondaryOnly:
+      return UISplitViewControllerDisplayModeSecondaryOnly;
+    case OneBesideSecondary:
+      return UISplitViewControllerDisplayModeOneBesideSecondary;
+    case OneOverSecondary:
+      return UISplitViewControllerDisplayModeOneOverSecondary;
+    case TwoBesideSecondary:
+      return UISplitViewControllerDisplayModeTwoBesideSecondary;
+    case TwoOverSecondary:
+      return UISplitViewControllerDisplayModeTwoOverSecondary;
+    case TwoDisplaceSecondary:
+      return UISplitViewControllerDisplayModeTwoDisplaceSecondary;
+    case Automatic:
+    default:
+      return UISplitViewControllerDisplayModeAutomatic;
+  }
+}
+
+}; // namespace rnscreens::conversion

package/ios/conversion/RNSConversions.h

@@ -0,0 +1,53 @@
+#pragma once
+
+#if defined(__cplusplus)
+#import <react/renderer/components/rnscreens/Props.h>
+#import <React/RCTImageSource.h>
+#import "RNSEnums.h"
+
+namespace rnscreens::conversion {
+
+namespace react = facebook::react;
+
+std::optional<UIBlurEffectStyle>
+RNSMaybeUIBlurEffectStyleFromRNSBottomTabsTabBarBlurEffect(
+    react::RNSBottomTabsTabBarBlurEffect blurEffect);
+
+UIBlurEffect *RNSUIBlurEffectFromRNSBottomTabsTabBarBlurEffect(
+    react::RNSBottomTabsTabBarBlurEffect blurEffect);
+
+UIOffset RNSBottomTabsTabBarItemTitlePositionAdjustmentStruct(
+    react::RNSBottomTabsTabBarItemTitlePositionAdjustmentStruct
+        titlePositionAdjustment);
+
+std::optional<UIBlurEffectStyle>
+RNSMaybeUIBlurEffectStyleFromRNSBottomTabsScreenTabBarBlurEffect(
+    react::RNSBottomTabsScreenTabBarBlurEffect blurEffect);
+
+UIBlurEffect *RNSUIBlurEffectFromRNSBottomTabsScreenTabBarBlurEffect(
+    react::RNSBottomTabsScreenTabBarBlurEffect blurEffect);
+
+UIOffset RNSBottomTabsScreenTabBarItemTitlePositionAdjustmentStruct(
+    react::RNSBottomTabsScreenTabBarItemTitlePositionAdjustmentStruct
+        titlePositionAdjustment);
+
+RNSBottomTabsIconType RNSBottomTabsIconTypeFromIcon(react::RNSBottomTabsScreenIconType iconType);
+
+RCTImageSource *RCTImageSourceFromImageSourceAndIconType(
+    const facebook::react::ImageSource *imageSource,
+    RNSBottomTabsIconType iconType);
+
+#pragma mark SplitView
+
+UISplitViewControllerSplitBehavior SplitViewSplitBehaviorFromHostProp(
+    react::RNSSplitViewHostSplitBehavior behavior);
+
+UISplitViewControllerPrimaryEdge SplitViewPrimaryEdgeFromHostProp(
+    react::RNSSplitViewHostPrimaryEdge primaryEdge);
+
+UISplitViewControllerDisplayMode SplitViewDisplayModeFromHostProp(
+    react::RNSSplitViewHostDisplayMode displayMode);
+
+}; // namespace rnscreens::conversion
+
+#endif

package/ios/gamma/ReactMountingTransactionObserving.swift

@@ -0,0 +1,7 @@
+import Foundation
+
+@objc
+public protocol ReactMountingTransactionObserving {
+  func reactMountingTransactionWillMount()
+  func reactMountingTransactionDidMount()
+}

package/ios/gamma/split-view/RNSSplitViewHostComponentView.h

@@ -0,0 +1,29 @@
+#import "RNSEnums.h"
+#import "RNSReactBaseView.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@class RNSSplitViewHostController;
+@class RNSSplitViewScreenComponentView;
+
+@interface RNSSplitViewHostComponentView : RNSReactBaseView
+
+- (nonnull NSMutableArray<RNSSplitViewScreenComponentView *> *)reactSubviews;
+
+@property (nonatomic, nonnull, strong, readonly) RNSSplitViewHostController *splitViewHostController;
+
+@end
+
+#pragma mark - Props
+
+@interface RNSSplitViewHostComponentView ()
+
+@property (nonatomic, readonly) UISplitViewControllerSplitBehavior splitBehavior;
+@property (nonatomic, readonly) UISplitViewControllerPrimaryEdge primaryEdge;
+@property (nonatomic, readonly) UISplitViewControllerDisplayMode displayMode;
+@property (nonatomic, readonly) BOOL presentsWithGesture;
+@property (nonatomic, readonly) BOOL showSecondaryToggleButton;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/gamma/split-view/RNSSplitViewHostComponentView.mm

@@ -0,0 +1,209 @@
+#import "RNSSplitViewHostComponentView.h"
+#import <React/RCTAssert.h>
+#import <React/RCTMountingTransactionObserving.h>
+#import <React/UIView+React.h>
+#import <react/renderer/components/rnscreens/ComponentDescriptors.h>
+
+#import "RNSConversions.h"
+#import "RNSDefines.h"
+#import "RNSSplitViewScreenComponentView.h"
+#import "Swift-Bridging.h"
+
+namespace react = facebook::react;
+
+@interface RNSSplitViewHostComponentView () <RCTMountingTransactionObserving>
+@end
+
+@implementation RNSSplitViewHostComponentView {
+  RNSSplitViewHostController *_Nonnull _controller;
+  NSMutableArray<RNSSplitViewScreenComponentView *> *_Nonnull _reactSubviews;
+
+  bool _hasModifiedReactSubviewsInCurrentTransaction;
+  // We need this information to warn users about dynamic changes to behavior being currently unsupported.
+  bool _isShowSecondaryToggleButtonSet;
+}
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  if (self = [super initWithFrame:frame]) {
+    [self initState];
+  }
+  return self;
+}
+
+- (void)initState
+{
+  [self resetProps];
+  //    TODO: For now I'm hardcoding style in init, but style cannot be updated outside controller's constructor, thus
+  //    we'll need to delay the initialization unitl Screen components will be mounted
+  _controller =
+      [[RNSSplitViewHostController alloc] initWithSplitViewHostComponentView:self
+                                                                       style:UISplitViewControllerStyleTripleColumn];
+  _hasModifiedReactSubviewsInCurrentTransaction = false;
+  _reactSubviews = [NSMutableArray new];
+}
+
+- (void)resetProps
+{
+  static const auto defaultProps = std::make_shared<const react::RNSSplitViewHostProps>();
+  _props = defaultProps;
+
+  _splitBehavior = UISplitViewControllerSplitBehaviorAutomatic;
+  _primaryEdge = UISplitViewControllerPrimaryEdgeLeading;
+  _displayMode = UISplitViewControllerDisplayModeAutomatic;
+  _presentsWithGesture = true;
+  _showSecondaryToggleButton = false;
+
+  _isShowSecondaryToggleButtonSet = false;
+}
+
+- (void)didMoveToWindow
+{
+  RCTAssert(_controller != nil, @"[RNScreens] Controller must not be nil while attaching to window");
+
+  [self reactAddControllerToClosestParent:_controller];
+}
+
+- (void)reactAddControllerToClosestParent:(UIViewController *)controller
+{
+  if (!controller.parentViewController) {
+    UIView *parentView = (UIView *)self.reactSuperview;
+    while (parentView) {
+      if (parentView.reactViewController) {
+        [parentView.reactViewController addChildViewController:controller];
+        [self addSubview:controller.view];
+        [controller didMoveToParentViewController:parentView.reactViewController];
+        break;
+      }
+      parentView = (UIView *)parentView.reactSuperview;
+    }
+    return;
+  }
+}
+
+RNS_IGNORE_SUPER_CALL_BEGIN
+- (nonnull NSMutableArray<RNSSplitViewScreenComponentView *> *)reactSubviews
+{
+  RCTAssert(
+      _reactSubviews != nil,
+      @"[RNScreens] Attempt to work with non-initialized list of RNSSplitViewScreenComponentView subviews. (for: %@)",
+      self);
+  return _reactSubviews;
+}
+RNS_IGNORE_SUPER_CALL_END
+
+- (nonnull RNSSplitViewHostController *)splitViewHostController
+{
+  RCTAssert(_controller != nil, @"[RNScreens] Controller must not be nil");
+  return _controller;
+}
+
+#pragma mark - RCTViewComponentViewProtocol
+
+- (void)mountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView index:(NSInteger)index
+{
+  RCTAssert(
+      [childComponentView isKindOfClass:RNSSplitViewScreenComponentView.class],
+      @"[RNScreens] Attempt to mount child of unsupported type: %@, expected %@",
+      childComponentView.class,
+      RNSSplitViewScreenComponentView.class);
+
+  auto *childScreen = static_cast<RNSSplitViewScreenComponentView *>(childComponentView);
+  childScreen.splitViewHost = self;
+  [_reactSubviews insertObject:childScreen atIndex:index];
+  _hasModifiedReactSubviewsInCurrentTransaction = true;
+}
+
+- (void)unmountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView index:(NSInteger)index
+{
+  RCTAssert(
+      [childComponentView isKindOfClass:RNSSplitViewScreenComponentView.class],
+      @"[RNScreens] Attempt to unmount child of unsupported type: %@, expected %@",
+      childComponentView.class,
+      RNSSplitViewScreenComponentView.class);
+
+  auto *childScreen = static_cast<RNSSplitViewScreenComponentView *>(childComponentView);
+  childScreen.splitViewHost = nil;
+  [_reactSubviews removeObject:childScreen];
+  _hasModifiedReactSubviewsInCurrentTransaction = true;
+}
+
++ (react::ComponentDescriptorProvider)componentDescriptorProvider
+{
+  return react::concreteComponentDescriptorProvider<react::RNSSplitViewHostComponentDescriptor>();
+}
+
++ (BOOL)shouldBeRecycled
+{
+  // There won't be tens of instances of this component usually & it's easier for now.
+  // We could consider enabling it someday though.
+  return NO;
+}
+
+- (void)updateProps:(const facebook::react::Props::Shared &)props
+           oldProps:(const facebook::react::Props::Shared &)oldProps
+{
+  const auto &oldComponentProps = *std::static_pointer_cast<const react::RNSSplitViewHostProps>(_props);
+  const auto &newComponentProps = *std::static_pointer_cast<const react::RNSSplitViewHostProps>(props);
+
+  if (oldComponentProps.splitBehavior != newComponentProps.splitBehavior) {
+    _splitBehavior = rnscreens::conversion::SplitViewSplitBehaviorFromHostProp(newComponentProps.splitBehavior);
+    _controller.preferredSplitBehavior = _splitBehavior;
+  }
+
+  if (oldComponentProps.primaryEdge != newComponentProps.primaryEdge) {
+    _primaryEdge = rnscreens::conversion::SplitViewPrimaryEdgeFromHostProp(newComponentProps.primaryEdge);
+    _controller.primaryEdge = _primaryEdge;
+  }
+
+  if (oldComponentProps.displayMode != newComponentProps.displayMode) {
+    _displayMode = rnscreens::conversion::SplitViewDisplayModeFromHostProp(newComponentProps.displayMode);
+    _controller.preferredDisplayMode = _displayMode;
+  }
+
+  if (oldComponentProps.presentsWithGesture != newComponentProps.presentsWithGesture) {
+    _presentsWithGesture = newComponentProps.presentsWithGesture;
+    _controller.presentsWithGesture = _presentsWithGesture;
+  }
+
+  if (oldComponentProps.showSecondaryToggleButton != newComponentProps.showSecondaryToggleButton) {
+    _showSecondaryToggleButton = newComponentProps.showSecondaryToggleButton;
+    _controller.showsSecondaryOnlyButton = _showSecondaryToggleButton;
+
+    if (_isShowSecondaryToggleButtonSet) {
+      RCTLogWarn(@"[RNScreens] changing showSecondaryToggleButton dynamically is currently unsupported");
+    }
+  }
+
+  // This flag is set to true when showsSecondaryOnlyButton prop is assigned for the first time.
+  // This allows us to identify any subsequent changes to this prop,
+  // enabling us to warn users that dynamic changes are not supported.
+  _isShowSecondaryToggleButtonSet = true;
+
+  [super updateProps:props oldProps:oldProps];
+}
+
+#pragma mark - RCTMountingTransactionObserving
+
+- (void)mountingTransactionWillMount:(const facebook::react::MountingTransaction &)transaction
+                withSurfaceTelemetry:(const facebook::react::SurfaceTelemetry &)surfaceTelemetry
+{
+  _hasModifiedReactSubviewsInCurrentTransaction = false;
+  [_controller reactMountingTransactionWillMount];
+}
+
+- (void)mountingTransactionDidMount:(const facebook::react::MountingTransaction &)transaction
+               withSurfaceTelemetry:(const facebook::react::SurfaceTelemetry &)surfaceTelemetry
+{
+  if (_hasModifiedReactSubviewsInCurrentTransaction) {
+    [_controller setNeedsUpdateOfChildViewControllers];
+  }
+  [_controller reactMountingTransactionDidMount];
+}
+
+@end
+
+Class<RCTComponentViewProtocol> RNSSplitViewHostCls(void)
+{
+  return RNSSplitViewHostComponentView.class;
+}

package/ios/gamma/split-view/RNSSplitViewHostComponentViewManager.h

@@ -0,0 +1,11 @@
+#pragma once
+
+#import <React/RCTViewManager.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface RNSSplitViewHostComponentViewManager : RCTViewManager
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/gamma/split-view/RNSSplitViewHostComponentViewManager.mm

@@ -0,0 +1,7 @@
+#import "RNSSplitViewHostComponentViewManager.h"
+
+@implementation RNSSplitViewHostComponentViewManager
+
+RCT_EXPORT_MODULE(RNSSplitViewHostComponentViewManager)
+
+@end

package/ios/gamma/split-view/RNSSplitViewHostController.swift

@@ -0,0 +1,98 @@
+import Foundation
+import UIKit
+
+@objc
+public class RNSSplitViewHostController: UISplitViewController, ReactMountingTransactionObserving {
+  private var needsChildViewControllersUpdate = false
+  private let splitViewHostComponentView: RNSSplitViewHostComponentView
+
+  @objc public init(
+    splitViewHostComponentView: RNSSplitViewHostComponentView, style: UISplitViewController.Style
+  ) {
+    self.splitViewHostComponentView = splitViewHostComponentView
+    super.init(style: style)
+  }
+
+  required init?(coder aDecoder: NSCoder) {
+    return nil
+  }
+
+  // MARK: Signals
+
+  @objc
+  public func setNeedsUpdateOfChildViewControllers() {
+    needsChildViewControllersUpdate = true
+  }
+
+  // MARK: Updating
+
+  @objc
+  public func updateChildViewControllersIfNeeded() {
+    if needsChildViewControllersUpdate {
+      updateChildViewControllers()
+    }
+  }
+
+  @objc
+  public func updateChildViewControllers() {
+    precondition(
+      needsChildViewControllersUpdate,
+      "[RNScreens] Child view controller must be invalidated when update is forced!")
+
+    let currentSubviews =
+      splitViewHostComponentView.reactSubviews() as! [RNSSplitViewScreenComponentView]
+    let currentViewControllers = currentSubviews.map {
+      RNSSplitViewNavigationController(rootViewController: $0.controller)
+    }
+
+    viewControllers = currentViewControllers
+
+    for controller in currentViewControllers {
+      controller.viewFrameOriginChangeObserver = self
+    }
+
+    needsChildViewControllersUpdate = false
+  }
+
+  // MARK: ReactMountingTransactionObserving
+
+  @objc
+  public func reactMountingTransactionWillMount() {
+    // noop
+  }
+
+  @objc
+  public func reactMountingTransactionDidMount() {
+    updateChildViewControllersIfNeeded()
+  }
+}
+
+extension RNSSplitViewHostController {
+  var splitViewScreenControllers: [RNSSplitViewScreenController] {
+    return viewControllers.lazy.map { viewController in
+      assert(
+        viewController is RNSSplitViewNavigationController,
+        "[RNScreens] Expected RNSSplitViewNavigationController but got \(type(of: viewController))")
+
+      let splitViewNavigationController = viewController as! RNSSplitViewNavigationController
+      let splitViewNavigationControllerTopViewController = splitViewNavigationController
+        .topViewController
+      assert(
+        splitViewNavigationControllerTopViewController is RNSSplitViewScreenController,
+        "[RNScreens] Expected RNSSplitViewScreenController but got \(type(of: splitViewNavigationControllerTopViewController))"
+      )
+
+      return splitViewNavigationControllerTopViewController as! RNSSplitViewScreenController
+    }
+  }
+}
+
+extension RNSSplitViewHostController: RNSSplitViewNavigationControllerViewFrameObserver {
+  func splitViewNavCtrlViewDidChangeFrameOrigin(
+    _ splitViewNavCtrl: RNSSplitViewNavigationController
+  ) {
+    for controller in self.splitViewScreenControllers {
+      controller.columnPositioningDidChangeIn(splitViewController: self)
+    }
+  }
+}