react-native-screens 4.12.0 → 4.13.0

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

@@ -0,0 +1,31 @@
+import Foundation
+import UIKit
+
+protocol RNSSplitViewNavigationControllerViewFrameObserver: AnyObject {
+  func splitViewNavCtrlViewDidChangeFrameOrigin(
+    _ splitViewNavCtrl: RNSSplitViewNavigationController)
+}
+
+@objc
+public class RNSSplitViewNavigationController: UINavigationController {
+  private var viewFrameObservation: NSKeyValueObservation?
+  weak var viewFrameOriginChangeObserver: RNSSplitViewNavigationControllerViewFrameObserver?
+
+  override public func viewDidLoad() {
+    super.viewDidLoad()
+
+    viewFrameObservation?.invalidate()
+    viewFrameObservation = self.view.observe(\.frame, options: [.old, .new]) {
+      [weak self] (view, change) in
+      guard let oldFrame = change.oldValue, let newFrame = change.newValue else { return }
+
+      if oldFrame.origin != newFrame.origin {
+        self?.onViewOriginChange()
+      }
+    }
+  }
+
+  private func onViewOriginChange() {
+    viewFrameOriginChangeObserver?.splitViewNavCtrlViewDidChangeFrameOrigin(self)
+  }
+}

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

@@ -0,0 +1,24 @@
+#import "RNSReactBaseView.h"
+#import "RNSSplitViewScreenShadowStateProxy.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@class RNSSplitViewHostComponentView;
+@class RNSSplitViewScreenController;
+
+@interface RNSSplitViewScreenComponentView : RNSReactBaseView
+
+@property (nonatomic, strong, readonly, nonnull) RNSSplitViewScreenController *controller;
+@property (nonatomic, weak, readwrite, nullable) RNSSplitViewHostComponentView *splitViewHost;
+
+@end
+
+#pragma mark - ShadowTreeState
+
+@interface RNSSplitViewScreenComponentView ()
+
+- (nonnull RNSSplitViewScreenShadowStateProxy *)shadowStateProxy;
+
+@end
+
+NS_ASSUME_NONNULL_END

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

@@ -0,0 +1,106 @@
+#import "RNSSplitViewScreenComponentView.h"
+#import <React/RCTAssert.h>
+#import <React/RCTSurfaceTouchHandler.h>
+#import <rnscreens/RNSSplitViewScreenComponentDescriptor.h>
+
+#import "Swift-Bridging.h"
+
+namespace react = facebook::react;
+
+@implementation RNSSplitViewScreenComponentView {
+  RNSSplitViewScreenController *_Nullable _controller;
+  RNSSplitViewScreenShadowStateProxy *_Nonnull _shadowStateProxy;
+  RCTSurfaceTouchHandler *_Nullable _touchHandler;
+}
+
+- (RNSSplitViewScreenController *)controller
+{
+  RCTAssert(
+      _controller != nil,
+      @"[RNScreens] Attempt to access RNSSplitViewScreenController before RNSSplitViewScreenComponentView was initialized. (for: %@)",
+      self);
+  return _controller;
+}
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  if (self = [super initWithFrame:frame]) {
+    [self initState];
+  }
+
+  return self;
+}
+
+- (void)initState
+{
+  [self setupController];
+
+  _shadowStateProxy = [RNSSplitViewScreenShadowStateProxy new];
+}
+
+- (void)setupController
+{
+  _controller = [[RNSSplitViewScreenController alloc] initWithSplitViewScreenComponentView:self];
+  _controller.view = self;
+}
+
+- (void)didMoveToWindow
+{
+  // Starting from iOS 26, a new column type called 'inspector' was introduced.
+  // This column can be displayed as a modal, independent of the React Native view hierarchy.
+  // In contrast, prior to iOS 26, all SplitView columns were placed under RCTSurface,
+  // meaning that touches were handler by RN handlers.
+  if (@available(iOS 26.0, *)) {
+    // If the current controller’s splitViewController is of type RNSSplitViewHostController,
+    // we know that we're still inside the RN hierarchy,
+    // so there's no need to enforce additional touch event support.
+    if ([_controller isInSplitViewHostSubtree]) {
+      return;
+    }
+
+    if (self.window != nil) {
+      if (_touchHandler == nil) {
+        _touchHandler = [RCTSurfaceTouchHandler new];
+      }
+      [_touchHandler attachToView:self];
+    } else {
+      [_touchHandler detachFromView:self];
+    }
+  }
+}
+
+#pragma mark - ShadowTreeState
+
+- (nonnull RNSSplitViewScreenShadowStateProxy *)shadowStateProxy
+{
+  RCTAssert(_shadowStateProxy != nil, @"[RNScreens] Attempt to access uninitialized _shadowStateProxy");
+  return _shadowStateProxy;
+}
+
+#pragma mark - RCTViewComponentViewProtocol
+
++ (react::ComponentDescriptorProvider)componentDescriptorProvider
+{
+  return react::concreteComponentDescriptorProvider<react::RNSSplitViewScreenComponentDescriptor>();
+}
+
++ (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)updateState:(react::State::Shared const &)state oldState:(react::State::Shared const &)oldState
+{
+  [super updateState:state oldState:oldState];
+
+  [_shadowStateProxy updateState:state oldState:oldState];
+}
+
+@end
+
+Class<RCTComponentViewProtocol> RNSSplitViewScreenCls(void)
+{
+  return RNSSplitViewScreenComponentView.class;
+}

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

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

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

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

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

@@ -0,0 +1,86 @@
+import Foundation
+import UIKit
+
+@objc
+public class RNSSplitViewScreenController: UIViewController {
+  let splitViewScreenComponentView: RNSSplitViewScreenComponentView
+
+  private var shadowStateProxy: RNSSplitViewScreenShadowStateProxy {
+    return splitViewScreenComponentView.shadowStateProxy()
+  }
+
+  @objc public required init(splitViewScreenComponentView: RNSSplitViewScreenComponentView) {
+    self.splitViewScreenComponentView = splitViewScreenComponentView
+    super.init(nibName: nil, bundle: nil)
+  }
+
+  required init?(coder aDecoder: NSCoder) {
+    return nil
+  }
+
+  func findSplitViewHostController() -> RNSSplitViewHostController? {
+    if let splitViewHostController = self.splitViewController as? RNSSplitViewHostController {
+      return splitViewHostController
+    }
+
+    if let splitViewHost = self.splitViewScreenComponentView.splitViewHost {
+      return splitViewHost.splitViewHostController
+    }
+
+    return nil
+  }
+
+  /// Checks whether `self` is attached under a parent split view controller
+  /// that is presented by SplitViewHost. This might not be the case, for example,
+  /// when `self` is presented as a modal.
+  @objc
+  public func isInSplitViewHostSubtree() -> Bool {
+    return self.splitViewController is RNSSplitViewHostController
+  }
+
+  // MARK: Signals
+
+  @objc
+  public func setNeedsLifecycleStateUpdate() {
+    findSplitViewHostController()?.setNeedsUpdateOfChildViewControllers()
+  }
+
+  // MARK: Layout
+
+  @objc
+  public override func viewDidLayoutSubviews() {
+    super.viewDidLayoutSubviews()
+    if #available(iOS 26.0, *) {
+      // For modals, which are presented outside the SplitViewHost subtree (and RN hierarchy),
+      // we're attaching our touch handler adn we don't need to apply any offset corrections,
+      // because it's positioned relatively to our RNSSplitViewScreenComponentView
+      if isInSplitViewHostSubtree() {
+        let ancestorView = findSplitViewHostController()?.view
+
+        assert(
+          ancestorView != nil,
+          "[RNScreens] Expected to find RNSSplitViewHost component for RNSSplitViewScreen component"
+        )
+
+        shadowStateProxy.updateShadowState(
+          ofComponent: splitViewScreenComponentView,
+          inContextOfAncestorView: ancestorView!
+        )
+      } else {
+        shadowStateProxy.updateShadowState(
+          ofComponent: splitViewScreenComponentView
+        )
+      }
+    }
+
+    //      TODO: to be removed - only for testing purposes for inspector column
+    //    if #available(iOS 26.0, *) {
+    //      findSplitViewHostController()?.show(.inspector)
+    //    }
+  }
+
+  func columnPositioningDidChangeIn(splitViewController: UISplitViewController) {
+    shadowStateProxy.updateShadowState(
+      ofComponent: splitViewScreenComponentView, inContextOfAncestorView: splitViewController.view)
+  }
+}

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

@@ -0,0 +1,35 @@
+#import <Foundation/Foundation.h>
+
+#if defined(__cplusplus)
+#import <react/renderer/core/State.h>
+
+namespace react = facebook::react;
+#endif // __cplusplus
+
+NS_ASSUME_NONNULL_BEGIN
+
+@class RNSSplitViewScreenComponentView;
+
+@interface RNSSplitViewScreenShadowStateProxy : NSObject
+
+- (void)updateShadowStateOfComponent:(RNSSplitViewScreenComponentView *)screenComponentView;
+
+- (void)updateShadowStateOfComponent:(RNSSplitViewScreenComponentView *)screenComponentView
+             inContextOfAncestorView:(UIView *_Nullable)ancestorView;
+
+- (void)updateShadowStateWithFrame:(CGRect)frame;
+
+@end
+
+#pragma mark - Hidden from Swift
+
+#if defined(__cplusplus)
+
+@interface RNSSplitViewScreenShadowStateProxy ()
+
+- (void)updateState:(react::State::Shared const &)state oldState:(react::State::Shared const &)oldState;
+
+@end
+
+#endif // __cplusplus
+NS_ASSUME_NONNULL_END

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

@@ -0,0 +1,56 @@
+#import "RNSSplitViewScreenShadowStateProxy.h"
+
+#import <React/RCTConversions.h>
+#import <rnscreens/RNSSplitViewScreenShadowNode.h>
+#import "RNSSplitViewScreenComponentView.h"
+
+namespace react = facebook::react;
+
+@implementation RNSSplitViewScreenShadowStateProxy {
+  react::RNSSplitViewScreenShadowNode::ConcreteState::Shared _state;
+  CGRect _lastScheduledFrame;
+}
+
+- (instancetype)init
+{
+  if (self = [super init]) {
+    _lastScheduledFrame = CGRectNull;
+  }
+
+  return self;
+}
+
+- (void)updateShadowStateOfComponent:(RNSSplitViewScreenComponentView *)screenComponentView
+{
+  [self updateShadowStateOfComponent:screenComponentView inContextOfAncestorView:nil];
+}
+
+- (void)updateShadowStateOfComponent:(RNSSplitViewScreenComponentView *)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) {
+    return;
+  }
+
+  if (!CGRectEqualToRect(frame, _lastScheduledFrame)) {
+    auto newState = react::RNSSplitViewScreenState{RCTSizeFromCGSize(frame.size), RCTPointFromCGPoint(frame.origin)};
+    _state->updateState(std::move(newState));
+    _lastScheduledFrame = frame;
+  }
+}
+
+- (void)updateState:(react::State::Shared const &)state oldState:(react::State::Shared const &)oldState
+{
+  _state = std::static_pointer_cast<const react::RNSSplitViewScreenShadowNode::ConcreteState>(state);
+}
+
+@end

package/ios/gamma/stack/RNSScreenStackHostComponentView.h

@@ -0,0 +1,16 @@
+#import "RNSReactBaseView.h"
+#import "RNSStackScreenComponentView.h"
+
+@class RNSStackController;
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface RNSScreenStackHostComponentView : RNSReactBaseView
+
+@property (nonatomic, nonnull, strong, readonly) RNSStackController *stackController;
+
+- (nonnull NSMutableArray<RNSStackScreenComponentView *> *)reactSubviews;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/gamma/stack/RNSScreenStackHostComponentView.mm

@@ -0,0 +1,143 @@
+#import "RNSScreenStackHostComponentView.h"
+
+#import <React/RCTConversions.h>
+#import <React/RCTMountingTransactionObserving.h>
+#import <React/UIView+React.h>
+#import <react/renderer/components/rnscreens/ComponentDescriptors.h>
+#import <react/renderer/components/rnscreens/EventEmitters.h>
+#import <react/renderer/components/rnscreens/Props.h>
+#import <react/renderer/components/rnscreens/RCTComponentViewHelpers.h>
+#import "RNSDefines.h"
+
+#import "Swift-Bridging.h"
+
+namespace react = facebook::react;
+
+@interface RNSScreenStackHostComponentView () <RCTMountingTransactionObserving>
+@end
+
+@implementation RNSScreenStackHostComponentView {
+  RNSStackController *_Nonnull _controller;
+  NSMutableArray<RNSStackScreenComponentView *> *_Nonnull _reactSubviews;
+
+  bool _hasModifiedReactSubviewsInCurrentTransaction;
+}
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  if (self = [super initWithFrame:frame]) {
+    [self initState];
+  }
+  return self;
+}
+
+- (void)initState
+{
+  _controller = [[RNSStackController alloc] initWithStackHostComponentView:self];
+  _hasModifiedReactSubviewsInCurrentTransaction = false;
+  _reactSubviews = [NSMutableArray new];
+}
+
+- (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<RNSStackScreenComponentView *> *)reactSubviews
+{
+  return _reactSubviews;
+}
+RNS_IGNORE_SUPER_CALL_END
+
+- (nonnull RNSStackController *)stackController
+{
+  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:RNSStackScreenComponentView.class],
+      @"[RNScreens] Attempt to mount child of unsupported type: %@, expected %@",
+      childComponentView.class,
+      RNSStackScreenComponentView.class);
+
+  auto *childScreen = static_cast<RNSStackScreenComponentView *>(childComponentView);
+  childScreen.stackHost = self;
+  [_reactSubviews insertObject:childScreen atIndex:index];
+  _hasModifiedReactSubviewsInCurrentTransaction = true;
+}
+
+- (void)unmountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView index:(NSInteger)index
+{
+  RCTAssert(
+      [childComponentView isKindOfClass:RNSStackScreenComponentView.class],
+      @"[RNScreens] Attempt to unmount child of unsupported type: %@, expected %@",
+      childComponentView.class,
+      RNSStackScreenComponentView.class);
+
+  auto *childScreen = static_cast<RNSStackScreenComponentView *>(childComponentView);
+  [_reactSubviews removeObject:childScreen];
+  childScreen.stackHost = nil;
+  _hasModifiedReactSubviewsInCurrentTransaction = true;
+}
+
++ (react::ComponentDescriptorProvider)componentDescriptorProvider
+{
+  return react::concreteComponentDescriptorProvider<react::RNSScreenStackHostComponentDescriptor>();
+}
+
++ (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;
+}
+
+#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> RNSScreenStackHostCls(void)
+{
+  return RNSScreenStackHostComponentView.class;
+}

package/ios/gamma/stack/RNSScreenStackHostComponentViewManager.h

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

package/ios/gamma/stack/RNSScreenStackHostComponentViewManager.mm

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

package/ios/gamma/stack/RNSStackController.swift

@@ -0,0 +1,65 @@
+import Foundation
+import UIKit
+
+@objc
+public class RNSStackController: UINavigationController, ReactMountingTransactionObserving {
+  private var needsChildViewControllersUpdate = false
+  private let screenStackHostComponentView: RNSScreenStackHostComponentView
+
+  @objc public required init(stackHostComponentView: RNSScreenStackHostComponentView) {
+    self.screenStackHostComponentView = stackHostComponentView
+    super.init(nibName: nil, bundle: nil)
+  }
+
+  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 activeControllers = sourceAllViewControllers()
+      .filter { screenCtrl in screenCtrl.screenStackComponentView.maxLifecycleState == .attached }
+
+    setViewControllers(activeControllers, animated: true)
+
+    needsChildViewControllersUpdate = false
+  }
+
+  private func sourceAllViewControllers() -> [RNSStackScreenController] {
+    let screenStackComponents =
+      screenStackHostComponentView.reactSubviews() as! [RNSStackScreenComponentView]
+    return screenStackComponents.lazy.map(\.controller)
+  }
+
+  // MARK: ReactMountingTransactionObserving
+
+  @objc
+  public func reactMountingTransactionWillMount() {
+    // noop
+  }
+
+  @objc
+  public func reactMountingTransactionDidMount() {
+    updateChildViewControllersIfNeeded()
+  }
+}

package/ios/gamma/stack/RNSStackScreenComponentEventEmitter.h

@@ -0,0 +1,37 @@
+#import <Foundation/Foundation.h>
+
+// Hide C++ symbols from C compiler used when building Swift module
+#if defined(__cplusplus)
+#import <react/renderer/components/rnscreens/EventEmitters.h>
+
+namespace react = facebook::react;
+#endif // __cplusplus
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * These methods can be called to send an appropriate event to ElementTree.
+ * Returned value denotes whether the event has been successfully dispatched to React event pipeline.
+ * The returned value of `true` does not mean, that the event has been successfully delivered.
+ */
+@interface RNSStackScreenComponentEventEmitter : NSObject
+
+- (BOOL)emitOnWillAppear;
+- (BOOL)emitOnDidAppear;
+- (BOOL)emitOnWillDisappear;
+- (BOOL)emitOnDidDisappear;
+
+@end
+
+#pragma mark - Hidden from Swift
+
+#if defined(__cplusplus)
+
+@interface RNSStackScreenComponentEventEmitter ()
+
+- (void)updateEventEmitter:(const std::shared_ptr<const react::RNSStackScreenEventEmitter> &)emitter;
+
+@end
+
+#endif // __cplusplus
+NS_ASSUME_NONNULL_END