react-native-screens 4.24.0 → 4.25.0-beta.2

package/ios/gamma/scroll-view-marker/RNSScrollViewMarkerComponentView.mm

@@ -0,0 +1,272 @@
+#import "RNSScrollViewMarkerComponentView.h"
+#import "RNSConversions-ScrollViewMarker.h"
+#import "RNSEnums.h"
+#import "RNSScrollEdgeEffectApplicator.h"
+#import "RNSScrollViewSeeking.h"
+
+#import <React/RCTMountingTransactionObserving.h>
+#import <react/renderer/components/rnscreens/ComponentDescriptors.h>
+#import <react/renderer/components/rnscreens/EventEmitters.h>
+#import <react/renderer/components/rnscreens/Props.h>
+
+#import <React/RCTAssert.h>
+#import <React/RCTScrollViewComponentView.h>
+
+namespace react = facebook::react;
+
+@interface RNSScrollViewMarkerComponentView () <RNSScrollEdgeEffectProviding, RCTMountingTransactionObserving>
+@end
+
+@implementation RNSScrollViewMarkerComponentView {
+  BOOL _hasAttemptedRegistration;
+  BOOL _needsEdgeEffectUpdate;
+
+  RNSScrollEdgeEffect _leftScrollEdgeEffect;
+  RNSScrollEdgeEffect _topScrollEdgeEffect;
+  RNSScrollEdgeEffect _rightScrollEdgeEffect;
+  RNSScrollEdgeEffect _bottomScrollEdgeEffect;
+}
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  if (self = [super initWithFrame:frame]) {
+    [self initState];
+  }
+  return self;
+}
+
+#pragma mark - Private
+
+- (void)initState
+{
+  [self resetProps];
+  _hasAttemptedRegistration = NO;
+  _needsEdgeEffectUpdate = NO;
+}
+
+- (void)resetProps
+{
+  static const auto defaultProps = std::make_shared<const react::RNSScrollViewMarkerProps>();
+  _props = defaultProps;
+  _leftScrollEdgeEffect = RNSScrollEdgeEffectAutomatic;
+  _topScrollEdgeEffect = RNSScrollEdgeEffectAutomatic;
+  _rightScrollEdgeEffect = RNSScrollEdgeEffectAutomatic;
+  _bottomScrollEdgeEffect = RNSScrollEdgeEffectAutomatic;
+}
+
+/**
+ * This method throws an error in debug mode in case it fails to find the ScrollView instance,
+ * as it does not make sense to use this component if the ScrollView is not there.
+ */
+- (nullable UIScrollView *)findScrollView
+{
+  // It allows 0 for cases where the child is unmounted
+  RCTAssert(
+      self.subviews.count <= 1,
+      @"[RNScreens] ScrollViewMarker expects at most a single child. Subviews: %@",
+      self.subviews);
+
+  UIScrollView *_Nullable foundScrollView = [self resolveScrollViewFromChildView:self.subviews.firstObject];
+
+  RCTAssert(foundScrollView != nil, @"[RNScreens] Failed to find ScrollView"); // debug assertion only
+  return foundScrollView;
+}
+
+- (nullable id<RNSScrollViewSeeking>)findFirstSeekingAncestor
+{
+  const UIView *superview = self.superview;
+  while (superview != nil) {
+    if ([superview respondsToSelector:@selector(registerDescendantScrollView:fromMarker:)]) {
+      return static_cast<id<RNSScrollViewSeeking>>(superview);
+    }
+    superview = superview.superview;
+  }
+  return nil;
+}
+
+- (void)maybeRegisterWithSeekingAncestor
+{
+  if (_hasAttemptedRegistration) {
+    return;
+  }
+
+  [self registerWithSeekingAncestor];
+  _hasAttemptedRegistration = YES;
+}
+
+- (void)registerWithSeekingAncestor
+{
+  UIScrollView *scrollView = [self findScrollView];
+
+  if (scrollView == nil) {
+    return;
+  }
+
+  id<RNSScrollViewSeeking> seekingAncestor = [self findFirstSeekingAncestor];
+
+  if (seekingAncestor == nil) {
+    return;
+  }
+
+  [seekingAncestor registerDescendantScrollView:scrollView fromMarker:self];
+}
+
+- (void)configureScrollView:(nullable UIScrollView *)scrollView
+{
+  if (scrollView == nil) {
+    return;
+  }
+  [RNSScrollEdgeEffectApplicator applyToScrollView:scrollView withProvider:self];
+}
+
+/**
+ * Tries to resolve UIScrollView from the passed childView.
+ *
+ * Currently it supports only direct `UIScrollView` or react-native's `<ScrollView />` component.
+ */
+- (nullable UIScrollView *)resolveScrollViewFromChildView:(nullable UIView *)childView
+{
+  if (childView == nil) {
+    return nil;
+  }
+
+  if ([childView isKindOfClass:UIScrollView.class]) {
+    return static_cast<UIScrollView *>(childView);
+  }
+
+  if ([childView isKindOfClass:RCTScrollViewComponentView.class]) {
+    return static_cast<RCTScrollViewComponentView *>(childView).scrollView;
+  }
+
+  return nil;
+}
+
+#pragma mark - Override
+
+// TODO: This will be way too late to configure options etc.
+// Potentially we want to run in the end of transaction, before containers are updated.
+- (void)willMoveToWindow:(UIWindow *)newWindow
+{
+  [super willMoveToWindow:newWindow];
+  [self maybeRegisterWithSeekingAncestor];
+}
+
+#pragma mark - RNSScrollEdgeEffectProviding
+
+- (RNSScrollEdgeEffect)leftScrollEdgeEffect
+{
+  return _leftScrollEdgeEffect;
+}
+
+- (RNSScrollEdgeEffect)topScrollEdgeEffect
+{
+  return _topScrollEdgeEffect;
+}
+
+- (RNSScrollEdgeEffect)rightScrollEdgeEffect
+{
+  return _rightScrollEdgeEffect;
+}
+
+- (RNSScrollEdgeEffect)bottomScrollEdgeEffect
+{
+  return _bottomScrollEdgeEffect;
+}
+
+#pragma mark - RCTComponentViewProtocol
+
+- (void)updateProps:(const facebook::react::Props::Shared &)props
+           oldProps:(const facebook::react::Props::Shared &)oldProps
+{
+  using namespace rnscreens::conversion;
+
+  const auto &oldComponentProps = *std::static_pointer_cast<const react::RNSScrollViewMarkerProps>(_props);
+  const auto &newComponentProps = *std::static_pointer_cast<const react::RNSScrollViewMarkerProps>(props);
+
+  if (oldComponentProps.leftScrollEdgeEffect != newComponentProps.leftScrollEdgeEffect) {
+    _leftScrollEdgeEffect = RNSScrollEdgeEffectFromSVMLeftEdgeEffect(newComponentProps.leftScrollEdgeEffect);
+    _needsEdgeEffectUpdate = true;
+  }
+
+  if (oldComponentProps.topScrollEdgeEffect != newComponentProps.topScrollEdgeEffect) {
+    _topScrollEdgeEffect = RNSScrollEdgeEffectFromSVMTopEdgeEffect(newComponentProps.topScrollEdgeEffect);
+    _needsEdgeEffectUpdate = true;
+  }
+
+  if (oldComponentProps.rightScrollEdgeEffect != newComponentProps.rightScrollEdgeEffect) {
+    _rightScrollEdgeEffect = RNSScrollEdgeEffectFromSVMRightEdgeEffect(newComponentProps.rightScrollEdgeEffect);
+    _needsEdgeEffectUpdate = true;
+  }
+
+  if (oldComponentProps.bottomScrollEdgeEffect != newComponentProps.bottomScrollEdgeEffect) {
+    _bottomScrollEdgeEffect = RNSScrollEdgeEffectFromSVMBottomEdgeEffect(newComponentProps.bottomScrollEdgeEffect);
+    _needsEdgeEffectUpdate = true;
+  }
+
+  [super updateProps:props oldProps:oldProps];
+}
+
+- (void)finalizeUpdates:(RNComponentViewUpdateMask)updateMask
+{
+  // This assumes that in first render children are mounted before props are updated.
+  // Also this handles only first render & prop value update. It does not handle case
+  // where child scrollview potentially changes. Separate question is whether we even
+  // want to handle such case.
+  if (_needsEdgeEffectUpdate) {
+    _needsEdgeEffectUpdate = NO;
+    [self configureScrollView:[self findScrollView]];
+  }
+
+  // It allows 0 for cases where the child is unmounted
+  RCTAssert(
+      self.subviews.count <= 1,
+      @"[RNScreens] ScrollViewMarker expects at most a single child. Subviews: %@",
+      self.subviews);
+
+  [super finalizeUpdates:updateMask];
+}
+
+- (void)mountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView index:(NSInteger)index
+{
+  [super mountChildComponentView:childComponentView index:index];
+}
+
+- (void)unmountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView index:(NSInteger)index
+{
+  [super unmountChildComponentView:childComponentView index:index];
+}
+
++ (BOOL)shouldBeRecycled
+{
+  return NO;
+}
+
++ (react::ComponentDescriptorProvider)componentDescriptorProvider
+{
+  return react::concreteComponentDescriptorProvider<react::RNSScrollViewMarkerComponentDescriptor>();
+}
+
+#pragma mark - RCTMountingTransactionObserving
+
+- (void)mountingTransactionDidMount:(const facebook::react::MountingTransaction &)transaction
+               withSurfaceTelemetry:(const facebook::react::SurfaceTelemetry &)surfaceTelemetry
+{
+  [self maybeRegisterWithSeekingAncestor];
+}
+
+#pragma mark - Dynamic frameworks support
+
+// Needed because of this: https://github.com/facebook/react-native/pull/37274
+#ifdef RCT_DYNAMIC_FRAMEWORKS
++ (void)load
+{
+  [super load];
+}
+#endif // RCT_DYNAMIC_FRAMEWORKS
+
+@end
+
+Class<RCTComponentViewProtocol> RNSScrollViewMarkerCls(void)
+{
+  return RNSScrollViewMarkerComponentView.class;
+}

package/ios/gamma/scroll-view-marker/RNSScrollViewSeeking.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#import <Foundation/Foundation.h>
+
+@class RNSScrollViewMarkerComponentView;
+
+@protocol RNSScrollViewSeeking <NSObject>
+
+/**
+ *  Call this method to register a ScrollView wrapped by marker with an interested component (receiver).
+ */
+- (void)registerDescendantScrollView:(nonnull UIScrollView *)scrollView
+                          fromMarker:(nonnull RNSScrollViewMarkerComponentView *)marker;
+
+@end

package/ios/gamma/split/RNSSplitAppearanceApplicator.swift

@@ -0,0 +1,194 @@
+///
+/// @brief - Class responsible for applying all upcoming updates to SplitView.
+///
+/// This class is synchronizing UISplitViewController configuration props which are affecting the SplitView appearance with props passed to RNSSplitHostComponentView from the ElementTree.
+///
+class RNSSplitAppearanceApplicator {
+  ///
+  /// @brief Function responsible for applying all updates to SplitView in correct order
+  ///
+  /// It requests calling proper callbacks with batched SplitView updates on the AppearanceCoordinator object
+  ///
+  /// @param splitHost The view representing JS component which is sending updates.
+  /// @param splitHostController The controller associated with the SplitView component which receives updates and manages the native layer.
+  /// @param appearanceCoordinator The coordinator which is checking whether the update needs to be applied and if so, it executes the callback passed by this class.
+  ///
+  public func updateAppearanceIfNeeded(
+    _ splitHost: RNSSplitHostComponentView,
+    _ splitHostController: RNSSplitHostController,
+    _ appearanceCoordinator: RNSSplitAppearanceCoordinator
+  ) {
+    appearanceCoordinator.updateIfNeeded(.generalUpdate) { [weak self] in
+      guard let self = self
+      else {
+        return
+      }
+
+      self.updateSplitViewConfiguration(for: splitHost, withController: splitHostController)
+    }
+
+    appearanceCoordinator.updateIfNeeded(.secondaryScreenNavBarUpdate) { [weak self] in
+      guard let self = self
+      else {
+        return
+      }
+
+      splitHostController.refreshSecondaryNavBar()
+    }
+
+    appearanceCoordinator.updateIfNeeded(.displayModeUpdate) { [weak self] in
+      guard let self = self
+      else {
+        return
+      }
+
+      self.updateSplitViewDisplayMode(for: splitHost, withController: splitHostController)
+    }
+
+    appearanceCoordinator.updateIfNeeded(.orientationUpdate) { [] in
+      RNSScreenWindowTraits.enforceDesiredDeviceOrientation()
+    }
+  }
+
+  ///
+  /// @brief Function that applies all basic updates.
+  ///
+  /// It calls all setters on RNSSplitHostController that doesn't require any custom logic and conditions to be met.
+  ///
+  /// @param splitHost The view representing JS component which is sending updates.
+  /// @param splitHostController The controller associated with the SplitView component which receives updates and manages the native layer.
+  ///
+  private func updateSplitViewConfiguration(
+    for splitHost: RNSSplitHostComponentView,
+    withController splitHostController: RNSSplitHostController
+  ) {
+    // Step 1 - general settings
+    splitHostController.displayModeButtonVisibility = splitHost.displayModeButtonVisibility
+    splitHostController.preferredSplitBehavior = splitHost.preferredSplitBehavior
+    #if !os(tvOS)
+      splitHostController.primaryBackgroundStyle = splitHost.primaryBackgroundStyle
+    #endif
+    splitHostController.presentsWithGesture = splitHost.presentsWithGesture
+    splitHostController.primaryEdge = splitHost.primaryEdge
+    splitHostController.showsSecondaryOnlyButton = splitHost.showSecondaryToggleButton
+
+    // Step 2.1 - validating column constraints
+    validateColumnConstraints(
+      minWidth: splitHost.minimumPrimaryColumnWidth,
+      maxWidth: splitHost.maximumPrimaryColumnWidth)
+
+    validateColumnConstraints(
+      minWidth: splitHost.minimumSupplementaryColumnWidth,
+      maxWidth: splitHost.maximumSupplementaryColumnWidth)
+
+    #if compiler(>=6.2) && !os(tvOS)
+      if #available(iOS 26.0, *) {
+        validateColumnConstraints(
+          minWidth: splitHost.minimumInspectorColumnWidth,
+          maxWidth: splitHost.maximumInspectorColumnWidth)
+      }
+    #endif
+
+    // Step 2.2 - applying updates to columns
+    if splitHost.minimumPrimaryColumnWidth >= 0 {
+      splitHostController.minimumPrimaryColumnWidth = splitHost.minimumPrimaryColumnWidth
+    }
+
+    if splitHost.maximumPrimaryColumnWidth >= 0 {
+      splitHostController.maximumPrimaryColumnWidth = splitHost.maximumPrimaryColumnWidth
+    }
+
+    if splitHost.preferredPrimaryColumnWidthOrFraction >= 0
+      && splitHost.preferredPrimaryColumnWidthOrFraction < 1
+    {
+      splitHostController.preferredPrimaryColumnWidthFraction =
+        splitHost.preferredPrimaryColumnWidthOrFraction
+    } else if splitHost.preferredPrimaryColumnWidthOrFraction >= 1 {
+      splitHostController.preferredPrimaryColumnWidth =
+        splitHost.preferredPrimaryColumnWidthOrFraction
+    }
+
+    if splitHost.minimumSupplementaryColumnWidth >= 0 {
+      splitHostController.minimumSupplementaryColumnWidth =
+        splitHost.minimumSupplementaryColumnWidth
+    }
+
+    if splitHost.maximumSupplementaryColumnWidth >= 0 {
+      splitHostController.maximumSupplementaryColumnWidth =
+        splitHost.maximumSupplementaryColumnWidth
+    }
+
+    if splitHost.preferredSupplementaryColumnWidthOrFraction >= 0
+      && splitHost.preferredSupplementaryColumnWidthOrFraction < 1
+    {
+      splitHostController.preferredSupplementaryColumnWidthFraction =
+        splitHost.preferredSupplementaryColumnWidthOrFraction
+    } else if splitHost.preferredSupplementaryColumnWidthOrFraction >= 1 {
+      splitHostController.preferredSupplementaryColumnWidth =
+        splitHost.preferredSupplementaryColumnWidthOrFraction
+    }
+
+    #if compiler(>=6.2) && !os(tvOS)
+      if #available(iOS 26.0, *) {
+        if splitHost.minimumSecondaryColumnWidth >= 0 {
+          splitHostController.minimumSecondaryColumnWidth = splitHost.minimumSecondaryColumnWidth
+        }
+
+        if splitHost.preferredSecondaryColumnWidthOrFraction >= 0
+          && splitHost.preferredSecondaryColumnWidthOrFraction < 1
+        {
+          splitHostController.preferredSecondaryColumnWidthFraction =
+            splitHost.preferredSecondaryColumnWidthOrFraction
+        } else if splitHost.preferredSecondaryColumnWidthOrFraction >= 1 {
+          splitHostController.preferredSecondaryColumnWidth =
+            splitHost.preferredSecondaryColumnWidthOrFraction
+        }
+
+        if splitHost.minimumInspectorColumnWidth >= 0 {
+          splitHostController.minimumInspectorColumnWidth = splitHost.minimumInspectorColumnWidth
+        }
+
+        if splitHost.maximumInspectorColumnWidth >= 0 {
+          splitHostController.maximumInspectorColumnWidth = splitHost.maximumInspectorColumnWidth
+        }
+
+        if splitHost.preferredInspectorColumnWidthOrFraction >= 0
+          && splitHost.preferredInspectorColumnWidthOrFraction < 1
+        {
+          splitHostController.preferredInspectorColumnWidthFraction =
+            splitHost.preferredInspectorColumnWidthOrFraction
+        } else if splitHost.preferredInspectorColumnWidthOrFraction >= 1 {
+          splitHostController.preferredInspectorColumnWidth =
+            splitHost.preferredInspectorColumnWidthOrFraction
+        }
+      }
+    #endif
+
+    // Step 2.3 - manipulating with inspector column
+    splitHostController.toggleSplitViewInspector(splitHost.showInspector)
+  }
+
+  ///
+  /// @brief Function that updates `preferredDisplayMode` property on SplitView.
+  ///
+  /// `preferredDisplayMode` needs to have a dedicated flag to prevent updates from the JS, when other props updates the appearance.
+  /// It is crucial in the case, when `preferredDisplayMode` has changed due to some transition that was executed natively, e. g. after showing/hiding a column by a swipe.
+  /// In that case, any prop update incoming, would reset `preferredDisplayMode` to the state from JS, what doesn't look good.
+  ///
+  /// @param splitHost The view representing JS component which is sending updates.
+  /// @param splitHostController The controller associated with the SplitView component which receives updates and manages the native layer.
+  ///
+  func updateSplitViewDisplayMode(
+    for splitHost: RNSSplitHostComponentView,
+    withController splitHostController: RNSSplitHostController
+  ) {
+    splitHostController.preferredDisplayMode = splitHost.preferredDisplayMode
+  }
+
+  func validateColumnConstraints(minWidth: CGFloat, maxWidth: CGFloat) {
+    assert(
+      minWidth <= maxWidth,
+      "[RNScreens] Split column constraints are invalid: minWidth \(minWidth) cannot be greater than maxWidth \(maxWidth)"
+    )
+  }
+}

package/ios/gamma/split/RNSSplitAppearanceCoordinator.swift

@@ -0,0 +1,26 @@
+///
+/// @brief - A class that is responsible for coordinating SplitHost appearance updates.
+///
+/// It collects flags for Split appearance update actions and invalidates them.
+/// It's also responsible for executing callbacks when the action is requested.
+///
+final class RNSSplitAppearanceCoordinator {
+  var updateFlags: RNSSplitAppearanceUpdateFlags = []
+
+  public func needs(_ updateFlag: RNSSplitAppearanceUpdateFlags) {
+    updateFlags.insert(updateFlag)
+  }
+
+  public func updateIfNeeded(
+    _ updateFlag: RNSSplitAppearanceUpdateFlags, _ updateCallback: () -> Void
+  ) {
+    if isNeeded(updateFlag) {
+      updateFlags.remove(updateFlag)
+      updateCallback()
+    }
+  }
+
+  func isNeeded(_ updateFlag: RNSSplitAppearanceUpdateFlags) -> Bool {
+    updateFlags.contains(updateFlag)
+  }
+}

package/ios/gamma/split/RNSSplitAppearanceUpdateFlags.swift

@@ -0,0 +1,11 @@
+///
+/// @brief - A collection of flags, which can be invalidated on RNSSplitHostController to apply proper updates to SplitView
+///
+struct RNSSplitAppearanceUpdateFlags: OptionSet {
+  let rawValue: UInt8
+
+  static let generalUpdate = RNSSplitAppearanceUpdateFlags(rawValue: 1 << 0)
+  static let secondaryScreenNavBarUpdate = RNSSplitAppearanceUpdateFlags(rawValue: 1 << 1)
+  static let displayModeUpdate = RNSSplitAppearanceUpdateFlags(rawValue: 1 << 2)
+  static let orientationUpdate = RNSSplitAppearanceUpdateFlags(rawValue: 1 << 3)
+}

package/ios/gamma/{split-view/RNSSplitViewHostComponentEventEmitter.h → split/RNSSplitHostComponentEventEmitter.h}

@@ -12,10 +12,10 @@ namespace react = facebook::react;
 NS_ASSUME_NONNULL_BEGIN
 
 /**
- * @class RNSSplitViewHostComponentEventEmitter
+ * @class RNSSplitHostComponentEventEmitter
  * @brief Responsible for emitting events from the native SplitView to the React Element Tree.
  */
-@interface RNSSplitViewHostComponentEventEmitter : NSObject
+@interface RNSSplitHostComponentEventEmitter : NSObject
 
 /**
  * @brief Emits the onCollapse event to notify associated component instance that the SplitView has collapsed.
@@ -55,14 +55,14 @@ NS_ASSUME_NONNULL_BEGIN
 
 #if defined(__cplusplus)
 
-@interface RNSSplitViewHostComponentEventEmitter ()
+@interface RNSSplitHostComponentEventEmitter ()
 
 /**
  * @brief Sets the underlying C++ event emitter used for dispatching events to React.
  *
- * @param emitter A shared pointer to a RNSSplitViewHostEventEmitter instance.
+ * @param emitter A shared pointer to a RNSSplitHostEventEmitter instance.
  */
-- (void)updateEventEmitter:(const std::shared_ptr<const react::RNSSplitViewHostEventEmitter> &)emitter;
+- (void)updateEventEmitter:(const std::shared_ptr<const react::RNSSplitHostEventEmitter> &)emitter;
 
 @end
 

package/ios/gamma/{split-view/RNSSplitViewHostComponentEventEmitter.mm → split/RNSSplitHostComponentEventEmitter.mm}

@@ -1,10 +1,10 @@
-#import "RNSSplitViewHostComponentEventEmitter.h"
+#import "RNSSplitHostComponentEventEmitter.h"
 #import <React/RCTConversions.h>
 #import <React/RCTLog.h>
 #import "RNSConversions.h"
 
-@implementation RNSSplitViewHostComponentEventEmitter {
-  std::shared_ptr<const react::RNSSplitViewHostEventEmitter> _reactEventEmitter;
+@implementation RNSSplitHostComponentEventEmitter {
+  std::shared_ptr<const react::RNSSplitHostEventEmitter> _reactEventEmitter;
 }
 
 - (BOOL)emitOnCollapse
@@ -54,7 +54,7 @@
   }
 }
 
-- (void)updateEventEmitter:(const std::shared_ptr<const react::RNSSplitViewHostEventEmitter> &)emitter
+- (void)updateEventEmitter:(const std::shared_ptr<const react::RNSSplitHostEventEmitter> &)emitter
 {
   _reactEventEmitter = emitter;
 }

package/ios/gamma/{split-view/RNSSplitViewHostComponentView.h → split/RNSSplitHostComponentView.h}

@@ -3,25 +3,25 @@
 #import "RNSDefines.h"
 #import "RNSEnums.h"
 #import "RNSReactBaseView.h"
-#import "RNSSplitViewHostComponentEventEmitter.h"
+#import "RNSSplitHostComponentEventEmitter.h"
 
 NS_ASSUME_NONNULL_BEGIN
 
-@class RNSSplitViewHostController;
-@class RNSSplitViewScreenComponentView;
+@class RNSSplitHostController;
+@class RNSSplitScreenComponentView;
 
 /**
- * @class RNSSplitViewHostComponentView
+ * @class RNSSplitHostComponentView
  * @brief A view component representing top-level native component for SplitView.
  *
  * Responsible for managing multi-column layouts via associated native UISplitViewController.
  * Manages updates to the layout properties, column configuration, and event emission.
  */
-@interface RNSSplitViewHostComponentView : RNSReactBaseView
+@interface RNSSplitHostComponentView : RNSReactBaseView
 
-- (nonnull NSMutableArray<RNSSplitViewScreenComponentView *> *)reactSubviews;
+- (nonnull NSMutableArray<RNSSplitScreenComponentView *> *)reactSubviews;
 
-@property (nonatomic, nonnull, strong, readonly) RNSSplitViewHostController *splitViewHostController;
+@property (nonatomic, nonnull, strong, readonly) RNSSplitHostController *splitHostController;
 
 @end
 
@@ -31,7 +31,7 @@ NS_ASSUME_NONNULL_BEGIN
  * @category Props
  * @brief Definitions for React Native props.
  */
-@interface RNSSplitViewHostComponentView ()
+@interface RNSSplitHostComponentView ()
 
 @property (nonatomic, readonly) UISplitViewControllerSplitBehavior preferredSplitBehavior;
 @property (nonatomic, readonly) UISplitViewControllerPrimaryEdge primaryEdge;
@@ -71,9 +71,9 @@ NS_ASSUME_NONNULL_BEGIN
  * @category Events
  * @brief APIs related to event emission to React Native.
  */
-@interface RNSSplitViewHostComponentView ()
+@interface RNSSplitHostComponentView ()
 
-- (nonnull RNSSplitViewHostComponentEventEmitter *)reactEventEmitter;
+- (nonnull RNSSplitHostComponentEventEmitter *)reactEventEmitter;
 
 @end