first commit

node_modules/react-native-screens/ios/gamma/stack/screen/RNSStackScreenComponentEventEmitter.h

@@ -0,0 +1,41 @@
+#pragma once
+
+#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;
+- (BOOL)emitOnDismiss;
+- (BOOL)emitOnNativeDismiss;
+
+@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

node_modules/react-native-screens/ios/gamma/stack/screen/RNSStackScreenComponentEventEmitter.mm

@@ -0,0 +1,82 @@
+#import "RNSStackScreenComponentEventEmitter.h"
+
+#import <React/RCTConversions.h>
+#import <React/RCTLog.h>
+#import <react/renderer/components/rnscreens/EventEmitters.h>
+
+@implementation RNSStackScreenComponentEventEmitter {
+  std::shared_ptr<const react::RNSStackScreenEventEmitter> _reactEventEmitter;
+}
+
+- (BOOL)emitOnWillAppear
+{
+  if (_reactEventEmitter != nullptr) {
+    _reactEventEmitter->onWillAppear({});
+    return YES;
+  } else {
+    RCTLogWarn(@"[RNScreens] Skipped OnWillAppear event emission due to nullish emitter");
+    return NO;
+  }
+}
+
+- (BOOL)emitOnDidAppear
+{
+  if (_reactEventEmitter != nullptr) {
+    _reactEventEmitter->onDidAppear({});
+    return YES;
+  } else {
+    RCTLogWarn(@"[RNScreens] Skipped OnDidAppear event emission due to nullish emitter");
+    return NO;
+  }
+}
+
+- (BOOL)emitOnWillDisappear
+{
+  if (_reactEventEmitter != nullptr) {
+    _reactEventEmitter->onWillDisappear({});
+    return YES;
+  } else {
+    RCTLogWarn(@"[RNScreens] Skipped OnWillDisappear event emission due to nullish emitter");
+    return NO;
+  }
+}
+
+- (BOOL)emitOnDidDisappear
+{
+  if (_reactEventEmitter != nullptr) {
+    _reactEventEmitter->onDidDisappear({});
+    return YES;
+  } else {
+    RCTLogWarn(@"[RNScreens] Skipped OnDidDisappear event emission due to nullish emitter");
+    return NO;
+  }
+}
+
+- (BOOL)emitOnDismiss
+{
+  if (_reactEventEmitter != nullptr) {
+    _reactEventEmitter->onDismiss({.isNativeDismiss = false});
+    return YES;
+  } else {
+    RCTLogWarn(@"[RNScreens] Skipped OnDismiss event emission due to nullish emitter");
+    return NO;
+  }
+}
+
+- (BOOL)emitOnNativeDismiss
+{
+  if (_reactEventEmitter != nullptr) {
+    _reactEventEmitter->onDismiss({.isNativeDismiss = true});
+    return YES;
+  } else {
+    RCTLogWarn(@"[RNScreens] Skipped OnDismiss (native) event emission due to nullish emitter");
+    return NO;
+  }
+}
+
+- (void)updateEventEmitter:(const std::shared_ptr<const react::RNSStackScreenEventEmitter> &)emitter
+{
+  _reactEventEmitter = emitter;
+}
+
+@end

node_modules/react-native-screens/ios/gamma/stack/screen/RNSStackScreenComponentView.h

@@ -0,0 +1,43 @@
+#pragma once
+
+#import "RNSReactBaseView.h"
+#import "RNSStackScreenComponentEventEmitter.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@class RNSStackScreenController;
+@class RNSStackHostComponentView;
+
+typedef NS_ENUM(int, RNSStackScreenActivityMode) {
+  RNSStackScreenActivityModeDetached = 0,
+  RNSStackScreenActivityModeAttached = 1,
+};
+
+@interface RNSStackScreenComponentView : RNSReactBaseView
+
+@property (nonatomic, weak, readwrite, nullable) RNSStackHostComponentView *stackHost;
+@property (nonatomic, strong, readonly, nonnull) RNSStackScreenController *controller;
+
+@end
+
+#pragma mark - Props
+
+@interface RNSStackScreenComponentView ()
+
+@property (nonatomic, strong, readonly, nullable) NSString *screenKey;
+@property (nonatomic, readonly) RNSStackScreenActivityMode activityMode;
+
+@end
+
+#pragma mark - Events
+
+@interface RNSStackScreenComponentView ()
+
+/**
+ * Use returned object to emit appropriate React Events to Element Tree.
+ */
+- (nonnull RNSStackScreenComponentEventEmitter *)reactEventEmitter;
+
+@end
+
+NS_ASSUME_NONNULL_END

node_modules/react-native-screens/ios/gamma/stack/screen/RNSStackScreenComponentView.mm

@@ -0,0 +1,144 @@
+#import "RNSStackScreenComponentView.h"
+#import <React/RCTConversions.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/renderer/components/rnscreens/RCTComponentViewHelpers.h>
+
+#import "RNSConversions-Stack.h"
+#import "RNSStackHostComponentView.h"
+
+#import "Swift-Bridging.h"
+
+namespace react = facebook::react;
+
+@interface RNSStackScreenComponentView () <RCTMountingTransactionObserving>
+@end
+
+#pragma mark - View implementation
+
+@implementation RNSStackScreenComponentView {
+  RNSStackScreenController *_Nonnull _controller;
+  RNSStackScreenComponentEventEmitter *_Nonnull _reactEventEmitter;
+
+  // Flags
+  BOOL _hasUpdatedActivityMode;
+}
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  if (self = [super initWithFrame:frame]) {
+    [self initState];
+  }
+
+  return self;
+}
+
+- (void)initState
+{
+  [self resetProps];
+  [self setupController];
+
+  _reactEventEmitter = [RNSStackScreenComponentEventEmitter new];
+
+  _hasUpdatedActivityMode = NO;
+}
+
+- (void)resetProps
+{
+  static const auto defaultProps = std::make_shared<const react::RNSScreenStackProps>();
+  _props = defaultProps;
+
+  // container state
+  _screenKey = nil;
+  _activityMode = RNSStackScreenActivityModeDetached;
+}
+
+- (void)setupController
+{
+  _controller = [[RNSStackScreenController alloc] initWithComponentView:self];
+  _controller.view = self;
+}
+
+- (void)invalidateImpl
+{
+  // We want to run after container updates are performed (transitions etc.)
+  __weak auto weakSelf = self;
+  dispatch_async(dispatch_get_main_queue(), ^{
+    auto strongSelf = weakSelf;
+    if (strongSelf) {
+      strongSelf->_controller = nil;
+    }
+  });
+}
+
+#pragma mark - Events
+
+- (nonnull RNSStackScreenComponentEventEmitter *)reactEventEmitter
+{
+  RCTAssert(_reactEventEmitter != nil, @"[RNScreens] Attempt to access uninitialized _reactEventEmitter");
+  return _reactEventEmitter;
+}
+
+#pragma mark - RCTComponentViewProtocol
+
+- (void)updateProps:(const facebook::react::Props::Shared &)props
+           oldProps:(const facebook::react::Props::Shared &)oldProps
+{
+  const auto &oldComponentProps = *std::static_pointer_cast<const react::RNSStackScreenProps>(_props);
+  const auto &newComponentProps = *std::static_pointer_cast<const react::RNSStackScreenProps>(props);
+
+  if (oldComponentProps.activityMode != newComponentProps.activityMode) {
+    _activityMode = rnscreens::conversion::convert<RNSStackScreenActivityMode>(newComponentProps.activityMode);
+    _hasUpdatedActivityMode = YES;
+  }
+
+  if (oldComponentProps.screenKey != newComponentProps.screenKey) {
+    RCTAssert(_screenKey == nil, @"[RNScreens] ScreenController cannot change its screenKey");
+    _screenKey = RCTNSStringFromStringNilIfEmpty(newComponentProps.screenKey);
+  }
+
+  [super updateProps:props oldProps:oldProps];
+}
+
+- (void)finalizeUpdates:(RNComponentViewUpdateMask)updateMask
+{
+  if (_hasUpdatedActivityMode) {
+    _hasUpdatedActivityMode = NO;
+    [self.stackHost stackScreenChangedActivityMode:self];
+  }
+
+  [super finalizeUpdates:updateMask];
+}
+
+- (void)updateEventEmitter:(const facebook::react::EventEmitter::Shared &)eventEmitter
+{
+  [super updateEventEmitter:eventEmitter];
+  [_reactEventEmitter
+      updateEventEmitter:std::static_pointer_cast<const react::RNSStackScreenEventEmitter>(eventEmitter)];
+}
+
++ (react::ComponentDescriptorProvider)componentDescriptorProvider
+{
+  return react::concreteComponentDescriptorProvider<react::RNSStackScreenComponentDescriptor>();
+}
+
++ (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)invalidate
+{
+  [self invalidateImpl];
+}
+
+@end
+
+Class<RCTComponentViewProtocol> RNSStackScreenCls(void)
+{
+  return RNSStackScreenComponentView.class;
+}

node_modules/react-native-screens/ios/gamma/stack/screen/RNSStackScreenComponentViewManager.h

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

node_modules/react-native-screens/ios/gamma/stack/screen/RNSStackScreenComponentViewManager.mm

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

node_modules/react-native-screens/ios/gamma/stack/screen/RNSStackScreenController.swift

@@ -0,0 +1,64 @@
+import Foundation
+import UIKit
+
+@objc
+public class RNSStackScreenController: UIViewController {
+  let screen: RNSStackScreenComponentView
+  private var reactEventEmitter: RNSStackScreenComponentEventEmitter {
+    return screen.reactEventEmitter()
+  }
+
+  @objc public required init(componentView: RNSStackScreenComponentView) {
+    self.screen = componentView
+    super.init(nibName: nil, bundle: nil)
+  }
+
+  required init?(coder aDecoder: NSCoder) {
+    return nil
+  }
+
+  func findStackController() -> RNSStackController? {
+    if let navCtrl = self.navigationController {
+      return navCtrl as? RNSStackController
+    }
+
+    if let stackHost = self.screen.stackHost {
+      return stackHost.stackController
+    }
+
+    return nil
+  }
+
+  // MARK: Signals
+
+  // MARK: Events
+
+  public override func viewWillAppear(_ animated: Bool) {
+    reactEventEmitter.emitOnWillAppear()
+  }
+
+  public override func viewDidAppear(_ animated: Bool) {
+    reactEventEmitter.emitOnDidAppear()
+  }
+
+  public override func viewWillDisappear(_ animated: Bool) {
+    reactEventEmitter.emitOnWillDisappear()
+  }
+
+  public override func viewDidDisappear(_ animated: Bool) {
+    reactEventEmitter.emitOnDidDisappear()
+  }
+
+  public override func didMove(toParent parent: UIViewController?) {
+    print("ScreenCtrl [\(self.screen.tag)] didMoveToParent \(String(describing: parent))")
+    super.didMove(toParent: parent)
+
+    if parent == nil {
+      if self.screen.activityMode == .detached {
+        reactEventEmitter.emitOnDismiss()
+      } else {
+        reactEventEmitter.emitOnNativeDismiss()
+      }
+    }
+  }
+}