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

package/ios/gamma/stack/host/RNSStackHostComponentView.mm

@@ -8,22 +8,22 @@
 #import <react/renderer/components/rnscreens/Props.h>
 #import <react/renderer/components/rnscreens/RCTComponentViewHelpers.h>
 #import "RNSDefines.h"
+#import "RNSLog.h"
 
+#import "RNSStackNavigationController.h"
+#import "RNSStackOperationCoordinator.h"
 #import "RNSStackScreenComponentView.h"
 #import "Swift-Bridging.h"
 
 namespace react = facebook::react;
 
-static void dumpStackHostSubviewsState(NSArray<RNSStackScreenComponentView *> *reactSubviews);
-
 @interface RNSStackHostComponentView () <RCTMountingTransactionObserving>
 @end
 
 @implementation RNSStackHostComponentView {
-  RNSStackController *_Nonnull _controller;
-  NSMutableArray<RNSStackScreenComponentView *> *_Nonnull _reactSubviews;
-
-  bool _hasModifiedReactSubviewsInCurrentTransaction;
+  RNSStackNavigationController *_Nonnull _stackNavigationController;
+  RNSStackOperationCoordinator *_Nonnull _stackOperationCoordinator;
+  NSMutableArray<RNSStackScreenComponentView *> *_Nonnull _renderedScreens;
 }
 
 - (instancetype)initWithFrame:(CGRect)frame
@@ -36,53 +36,35 @@ static void dumpStackHostSubviewsState(NSArray<RNSStackScreenComponentView *> *r
 
 - (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;
-  }
+  _stackNavigationController = [RNSStackNavigationController new];
+  _stackOperationCoordinator = [RNSStackOperationCoordinator new];
+  _renderedScreens = [NSMutableArray new];
 }
 
-RNS_IGNORE_SUPER_CALL_BEGIN
-- (nonnull NSMutableArray<RNSStackScreenComponentView *> *)reactSubviews
-{
-  return _reactSubviews;
-}
-RNS_IGNORE_SUPER_CALL_END
+#pragma mark - UIKit Callbacks
 
-- (nonnull RNSStackController *)stackController
+- (void)didMoveToWindow
 {
-  RCTAssert(_controller != nil, @"[RNScreens] Controller must not be nil");
-  return _controller;
+  RNSLog(@"[RNScreens] StackHost [%ld] attached to window", self.tag);
+  [self reactAddControllerToClosestParent:_stackNavigationController];
 }
 
 #pragma mark - Communication with StackScreen
 
 - (void)stackScreenChangedActivityMode:(nonnull RNSStackScreenComponentView *)stackScreen
 {
-  [_controller setNeedsUpdateOfChildViewControllers];
+  RCTAssert(stackScreen != nil, @"[RNScreens] Expected non nill stackScreen");
+  switch (stackScreen.activityMode) {
+    case RNSStackScreenActivityModeAttached:
+      [_stackOperationCoordinator addPushOperation:stackScreen];
+      break;
+    case RNSStackScreenActivityModeDetached:
+      [_stackOperationCoordinator addPopOperation:stackScreen];
+      break;
+    default:
+      RCTAssert(NO, @"[RNScreens] Unexpected value of activityMode: %d", stackScreen.activityMode);
+      return;
+  }
 }
 
 #pragma mark - RCTComponentViewProtocol
@@ -97,15 +79,8 @@ RNS_IGNORE_SUPER_CALL_END
 
   auto *childScreen = static_cast<RNSStackScreenComponentView *>(childComponentView);
   childScreen.stackHost = self;
-  [_reactSubviews insertObject:childScreen atIndex:index];
-  _hasModifiedReactSubviewsInCurrentTransaction = true;
-
-  NSLog(
-      @"StackHost [%ld] mount: StackScreen [%ld] (%@) at %ld",
-      self.tag,
-      childComponentView.tag,
-      childScreen.screenKey,
-      index);
+  [_renderedScreens insertObject:childScreen atIndex:index];
+  [self addPushOperationIfNeeded:childScreen];
 }
 
 - (void)unmountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView index:(NSInteger)index
@@ -117,16 +92,20 @@ RNS_IGNORE_SUPER_CALL_END
       RNSStackScreenComponentView.class);
 
   auto *childScreen = static_cast<RNSStackScreenComponentView *>(childComponentView);
-  [_reactSubviews removeObject:childScreen];
+  [_renderedScreens removeObject:childScreen];
   childScreen.stackHost = nil;
-  _hasModifiedReactSubviewsInCurrentTransaction = true;
-
-  NSLog(
-      @"StackHost [%ld] unmount: StackScreen [%ld] (%@) at %ld",
-      self.tag,
-      childComponentView.tag,
-      childScreen.screenKey,
-      index);
+  [self addPopOperationIfNeeded:childScreen];
+}
+
+- (void)addPopOperationIfNeeded:(nonnull RNSStackScreenComponentView *)stackScreen
+{
+  if (stackScreen.activityMode == RNSStackScreenActivityModeAttached && !stackScreen.isNativelyDismissed) {
+    // This shouldn't happen in typical scenarios but it can happen with fast-refresh.
+    [_stackOperationCoordinator addPopOperation:stackScreen];
+  } else {
+    RNSLog(
+        @"[RNScreens] ignoring pop operation of %@, already not attached or natively dismissed", stackScreen.screenKey);
+  }
 }
 
 + (react::ComponentDescriptorProvider)componentDescriptorProvider
@@ -141,40 +120,55 @@ RNS_IGNORE_SUPER_CALL_END
   return NO;
 }
 
-#pragma mark - RCTMountingTransactionObserving
+#pragma mark - Utils
+
+- (void)addPushOperationIfNeeded:(nonnull RNSStackScreenComponentView *)stackScreen
+{
+  if (stackScreen.activityMode == RNSStackScreenActivityModeAttached) {
+    [_stackOperationCoordinator addPushOperation:stackScreen];
+  }
+}
 
-- (void)mountingTransactionWillMount:(const facebook::react::MountingTransaction &)transaction
-                withSurfaceTelemetry:(const facebook::react::SurfaceTelemetry &)surfaceTelemetry
+- (void)reactAddControllerToClosestParent:(nonnull UIViewController *)controller
 {
-  _hasModifiedReactSubviewsInCurrentTransaction = false;
-  [_controller reactMountingTransactionWillMount];
+  RCTAssert(controller != nil, @"[RNScreens] Attempt to move to a nullish 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;
+  }
 }
 
+#pragma mark - RCTMountingTransactionObserving
+
 - (void)mountingTransactionDidMount:(const facebook::react::MountingTransaction &)transaction
                withSurfaceTelemetry:(const facebook::react::SurfaceTelemetry &)surfaceTelemetry
 {
-  if (_hasModifiedReactSubviewsInCurrentTransaction) {
-    [_controller setNeedsUpdateOfChildViewControllers];
-    dumpStackHostSubviewsState(_reactSubviews);
-  }
-  [_controller reactMountingTransactionDidMount];
+  [_stackOperationCoordinator executePendingOperationsIfNeeded:_stackNavigationController
+                                           withRenderedScreens:_renderedScreens];
 }
 
-@end
+#pragma mark - Dynamic frameworks support
 
-Class<RCTComponentViewProtocol> RNSStackHostCls(void)
+// Needed because of this: https://github.com/facebook/react-native/pull/37274
+#ifdef RCT_DYNAMIC_FRAMEWORKS
++ (void)load
 {
-  return RNSStackHostComponentView.class;
+  [super load];
 }
+#endif // RCT_DYNAMIC_FRAMEWORKS
+
+@end
 
-static void dumpStackHostSubviewsState(NSArray<RNSStackScreenComponentView *> *reactSubviews)
+Class<RCTComponentViewProtocol> RNSStackHostCls(void)
 {
-  NSMutableArray<NSString *> *descs = [[NSMutableArray alloc] initWithCapacity:reactSubviews.count];
-  for (RNSStackScreenComponentView *screen in reactSubviews) {
-    [descs addObject:[NSString stringWithFormat:@"StackScreen [%ld] %@ activityMode=%d",
-                                                screen.tag,
-                                                screen.screenKey,
-                                                screen.activityMode]];
-  }
-  NSLog(@"%@", descs);
+  return RNSStackHostComponentView.class;
 }

package/ios/gamma/stack/host/RNSStackNavigationController.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#include "RNSStackScreenComponentView.h"
+
+@interface RNSStackNavigationController : UINavigationController
+
+- (void)enqueuePushOperation:(nonnull RNSStackScreenComponentView *)stackScreen;
+
+- (void)enqueuePopOperation:(nonnull RNSStackScreenComponentView *)stackScreen;
+
+- (void)performContainerUpdateIfNeeded;
+
+@end

package/ios/gamma/stack/host/RNSStackNavigationController.mm

@@ -0,0 +1,82 @@
+#import "RNSStackNavigationController.h"
+#import "RNSLog.h"
+#import "RNSStackOperation.h"
+#import "React/RCTAssert.h"
+
+@implementation RNSStackNavigationController {
+  NSMutableArray<RNSPushOperation *> *_Nonnull _pendingPushOperations;
+  NSMutableArray<RNSPopOperation *> *_Nonnull _pendingPopOperations;
+}
+
+- (instancetype)init
+{
+  if (self = [super init]) {
+    [self initState];
+  }
+  return self;
+}
+
+- (void)initState
+{
+  _pendingPushOperations = [NSMutableArray array];
+  _pendingPopOperations = [NSMutableArray array];
+}
+
+- (BOOL)hasPendingOperations
+{
+  return _pendingPushOperations.count > 0 || _pendingPopOperations.count > 0;
+}
+
+- (void)enqueuePushOperation:(nonnull RNSStackScreenComponentView *)stackScreen
+{
+  RNSPushOperation *operation = [[RNSPushOperation alloc] initWithScreen:stackScreen];
+  [_pendingPushOperations addObject:operation];
+}
+
+- (void)enqueuePopOperation:(nonnull RNSStackScreenComponentView *)stackScreen
+{
+  RNSPopOperation *operation = [[RNSPopOperation alloc] initWithScreen:stackScreen];
+  [_pendingPopOperations addObject:operation];
+}
+
+- (void)performContainerUpdateIfNeeded
+{
+  // NOTE: We consider UINavigationController.viewControllers to be part of
+  // the internal state of our stack implementation and expect it to be
+  // *synchronously* updated by UIKit while we perform our pop and push operations
+  //
+  // The assertions below work under this assumption
+
+  if (![self hasPendingOperations]) {
+    return;
+  }
+
+  for (RNSPopOperation *op in _pendingPopOperations) {
+    UIViewController *controller = static_cast<UIViewController *>(op.stackScreen.controller);
+    RCTAssert([self.viewControllers count] > 1, @"[RNScreens] Attempt to pop last screen from the stack");
+    RCTAssert(self.topViewController == controller, @"[RNScreens] Attempt to pop non-top screen");
+    [self popViewControllerAnimated:YES];
+  }
+
+  for (RNSPushOperation *op in _pendingPushOperations) {
+    UIViewController *controller = static_cast<UIViewController *>(op.stackScreen.controller);
+    [self pushViewController:controller animated:YES];
+  }
+
+  RCTAssert([self.viewControllers count] > 0, @"[RNScreens] Stack should never be empty after updates");
+
+  [self dumpStackModel];
+
+  [_pendingPopOperations removeAllObjects];
+  [_pendingPushOperations removeAllObjects];
+}
+
+- (void)dumpStackModel
+{
+  RNSLog(@"[RNScreens] StackContainer [%ld] MODEL BEGIN", self.view.tag);
+  for (UIViewController *viewController in self.viewControllers) {
+    RNSLog(@"[RNScreens] %@", static_cast<RNSStackScreenComponentView *>(viewController.view).screenKey);
+  }
+}
+
+@end

package/ios/gamma/stack/host/RNSStackOperation.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#import "RNSStackScreenComponentView.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface RNSStackOperation : NSObject
+
+@property (nonatomic, strong, readonly) RNSStackScreenComponentView *stackScreen;
+
+- (instancetype)initWithScreen:(nonnull RNSStackScreenComponentView *)stackScreen;
+
+@end
+
+@interface RNSPushOperation : RNSStackOperation
+
+@end
+
+@interface RNSPopOperation : RNSStackOperation
+
+@property (nonatomic, strong, readonly) RNSStackScreenComponentView *stackScreen;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/gamma/stack/host/RNSStackOperation.mm

@@ -0,0 +1,21 @@
+#import "RNSStackOperation.h"
+#import <React/RCTAssert.h>
+
+@implementation RNSStackOperation
+
+- (instancetype)initWithScreen:(nonnull RNSStackScreenComponentView *)stackScreen
+{
+  RCTAssert(stackScreen != nil, @"[RNScreens] Expected nonnull stackScreen!");
+  if (self = [super init]) {
+    _stackScreen = stackScreen;
+  }
+  return self;
+}
+
+@end
+
+@implementation RNSPushOperation
+@end
+
+@implementation RNSPopOperation
+@end

package/ios/gamma/stack/host/RNSStackOperationCoordinator.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#import "RNSStackNavigationController.h"
+#import "RNSStackScreenComponentView.h"
+
+@interface RNSStackOperationCoordinator : NSObject
+
+- (void)addPushOperation:(nonnull RNSStackScreenComponentView *)screen;
+
+- (void)addPopOperation:(nonnull RNSStackScreenComponentView *)screen;
+
+- (void)executePendingOperationsIfNeeded:(nonnull RNSStackNavigationController *)controller
+                     withRenderedScreens:(nonnull NSMutableArray<RNSStackScreenComponentView *> *)renderedScreens;
+
+@end

package/ios/gamma/stack/host/RNSStackOperationCoordinator.mm

@@ -0,0 +1,78 @@
+#import "RNSStackOperationCoordinator.h"
+#import "RNSStackNavigationController.h"
+#import "RNSStackOperation.h"
+#import "RNSStackScreenComponentView.h"
+
+@implementation RNSStackOperationCoordinator {
+  NSMutableArray<RNSPushOperation *> *_Nonnull _pendingPushOperations;
+  NSMutableArray<RNSPopOperation *> *_Nonnull _pendingPopOperations;
+}
+
+- (instancetype)init
+{
+  if (self = [super init]) {
+    [self initState];
+  }
+  return self;
+}
+
+- (void)initState
+{
+  _pendingPushOperations = [NSMutableArray array];
+  _pendingPopOperations = [NSMutableArray array];
+}
+
+- (BOOL)hasPendingOperations
+{
+  return _pendingPushOperations.count > 0 || _pendingPopOperations.count > 0;
+}
+
+- (void)addPushOperation:(nonnull RNSStackScreenComponentView *)stackScreen
+{
+  RNSPushOperation *operation = [[RNSPushOperation alloc] initWithScreen:stackScreen];
+  [_pendingPushOperations addObject:operation];
+}
+
+- (void)addPopOperation:(nonnull RNSStackScreenComponentView *)stackScreen
+{
+  RNSPopOperation *operation = [[RNSPopOperation alloc] initWithScreen:stackScreen];
+  [_pendingPopOperations addObject:operation];
+}
+
+- (void)executePendingOperationsIfNeeded:(nonnull RNSStackNavigationController *)controller
+                     withRenderedScreens:(nonnull NSMutableArray<RNSStackScreenComponentView *> *)renderedScreens
+{
+  if (![self hasPendingOperations]) {
+    return;
+  }
+
+  auto popOperations = [[[self orderedOperations:(NSMutableArray<RNSStackOperation *> *)_pendingPopOperations
+                                 withIndicesFrom:renderedScreens] reverseObjectEnumerator] allObjects];
+
+  for (RNSStackOperation *operation in popOperations) {
+    [controller enqueuePopOperation:static_cast<RNSPopOperation *>(operation).stackScreen];
+  }
+
+  auto pushOperations = [self orderedOperations:(NSMutableArray<RNSStackOperation *> *)_pendingPushOperations
+                                withIndicesFrom:renderedScreens];
+
+  for (RNSStackOperation *operation in pushOperations) {
+    [controller enqueuePushOperation:static_cast<RNSPushOperation *>(operation).stackScreen];
+  }
+
+  [controller performContainerUpdateIfNeeded];
+
+  [_pendingPopOperations removeAllObjects];
+  [_pendingPushOperations removeAllObjects];
+}
+
+- (NSArray<RNSStackOperation *> *)orderedOperations:(nonnull NSMutableArray<RNSStackOperation *> *)operations
+                                    withIndicesFrom:
+                                        (nonnull NSMutableArray<RNSStackScreenComponentView *> *)stackScreens
+{
+  return [operations sortedArrayUsingComparator:^NSComparisonResult(RNSStackOperation *obj1, RNSStackOperation *obj2) {
+    return [@([stackScreens indexOfObject:obj1.stackScreen]) compare:@([stackScreens indexOfObject:obj2.stackScreen])];
+  }];
+}
+
+@end

package/ios/gamma/stack/screen/RNSStackScreenComponentView.h

@@ -17,6 +17,7 @@ typedef NS_ENUM(int, RNSStackScreenActivityMode) {
 
 @property (nonatomic, weak, readwrite, nullable) RNSStackHostComponentView *stackHost;
 @property (nonatomic, strong, readonly, nonnull) RNSStackScreenController *controller;
+@property (nonatomic) BOOL isNativelyDismissed;
 
 @end
 

package/ios/gamma/stack/screen/RNSStackScreenComponentView.mm

@@ -5,9 +5,11 @@
 #import <react/renderer/components/rnscreens/EventEmitters.h>
 #import <react/renderer/components/rnscreens/Props.h>
 #import <react/renderer/components/rnscreens/RCTComponentViewHelpers.h>
+#import <rnscreens/RNSStackScreenComponentDescriptor.h>
 
 #import "RNSConversions-Stack.h"
 #import "RNSStackHostComponentView.h"
+#import "RNSStackScreenController.h"
 
 #import "Swift-Bridging.h"
 
@@ -43,11 +45,12 @@ namespace react = facebook::react;
   _reactEventEmitter = [RNSStackScreenComponentEventEmitter new];
 
   _hasUpdatedActivityMode = NO;
+  _isNativelyDismissed = NO;
 }
 
 - (void)resetProps
 {
-  static const auto defaultProps = std::make_shared<const react::RNSScreenStackProps>();
+  static const auto defaultProps = std::make_shared<const react::RNSStackScreenProps>();
   _props = defaultProps;
 
   // container state
@@ -136,6 +139,16 @@ namespace react = facebook::react;
   [self invalidateImpl];
 }
 
+#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> RNSStackScreenCls(void)

package/ios/gamma/stack/screen/RNSStackScreenController.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@class RNSStackScreenComponentView;
+
+@interface RNSStackScreenController : UIViewController
+
+- (instancetype)initWithComponentView:(RNSStackScreenComponentView *)componentView;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/gamma/stack/screen/RNSStackScreenController.mm

@@ -0,0 +1,66 @@
+#import "RNSStackScreenController.h"
+#import "RNSLog.h"
+#import "RNSStackHostComponentView.h"
+#import "RNSStackNavigationController.h"
+#import "RNSStackScreenComponentEventEmitter.h"
+#import "RNSStackScreenComponentView.h"
+
+@implementation RNSStackScreenController {
+  RNSStackScreenComponentView *_Nonnull _screenView;
+}
+
+- (instancetype)initWithComponentView:(RNSStackScreenComponentView *)componentView
+{
+  if (self = [super initWithNibName:nil bundle:nil]) {
+    _screenView = componentView;
+  }
+  return self;
+}
+
+- (RNSStackScreenComponentEventEmitter *)reactEventEmitter
+{
+  return [_screenView reactEventEmitter];
+}
+
+#pragma mark - Lifecycle Events
+
+- (void)viewWillAppear:(BOOL)animated
+{
+  [super viewWillAppear:animated];
+  [[self reactEventEmitter] emitOnWillAppear];
+}
+
+- (void)viewDidAppear:(BOOL)animated
+{
+  [super viewDidAppear:animated];
+  [[self reactEventEmitter] emitOnDidAppear];
+}
+
+- (void)viewWillDisappear:(BOOL)animated
+{
+  [super viewWillDisappear:animated];
+  [[self reactEventEmitter] emitOnWillDisappear];
+}
+
+- (void)viewDidDisappear:(BOOL)animated
+{
+  [super viewDidDisappear:animated];
+  [[self reactEventEmitter] emitOnDidDisappear];
+}
+
+- (void)didMoveToParentViewController:(UIViewController *)parent
+{
+  RNSLog(@"[RNScreens] Screen view with tag=%ld didMoveToParentViewController %@", (long)_screenView.tag, parent);
+  [super didMoveToParentViewController:parent];
+
+  if (parent == nil) {
+    if (_screenView.activityMode == RNSStackScreenActivityModeDetached) {
+      [[self reactEventEmitter] emitOnDismiss];
+    } else {
+      _screenView.isNativelyDismissed = YES;
+      [[self reactEventEmitter] emitOnNativeDismiss];
+    }
+  }
+}
+
+@end

package/ios/helpers/scroll-view/RNSScrollEdgeEffectApplicator.h

@@ -10,5 +10,6 @@
 @end
 
 @interface RNSScrollEdgeEffectApplicator : NSObject
-+ (void)applyToScrollView:(UIScrollView *)scrollView withProvider:(id<RNSScrollEdgeEffectProviding>)provider;
++ (void)applyToScrollView:(nonnull UIScrollView *)scrollView
+             withProvider:(nonnull id<RNSScrollEdgeEffectProviding>)provider;
 @end

package/ios/helpers/scroll-view/RNSScrollEdgeEffectApplicator.mm

@@ -5,7 +5,8 @@
 
 @implementation RNSScrollEdgeEffectApplicator
 
-+ (void)applyToScrollView:(UIScrollView *)scrollView withProvider:(id<RNSScrollEdgeEffectProviding>)provider
++ (void)applyToScrollView:(nonnull UIScrollView *)scrollView
+             withProvider:(nonnull id<RNSScrollEdgeEffectProviding>)provider
 {
 #if RNS_IPHONE_OS_VERSION_AVAILABLE(26_0)
   if (@available(iOS 26, *)) {

package/ios/safe-area/RNSSafeAreaViewComponentView.h

@@ -5,11 +5,6 @@
 
 #import <UIKit/UIKit.h>
 #import "RNSReactBaseView.h"
-#import "RNSSafeAreaViewEdges.h"
-
-#if !RCT_NEW_ARCH_ENABLED
-#import <React/RCTBridge.h>
-#endif // !RCT_NEW_ARCH_ENABLED
 
 NS_ASSUME_NONNULL_BEGIN
 
@@ -17,16 +12,4 @@ NS_ASSUME_NONNULL_BEGIN
 
 @end
 
-#pragma mark - Paper specific
-
-#if !RCT_NEW_ARCH_ENABLED
-@interface RNSSafeAreaViewComponentView ()
-
-- (instancetype)initWithBridge:(RCTBridge *)bridge;
-
-@property (nonatomic, assign) RNSSafeAreaViewEdges edges;
-
-@end
-#endif // !RCT_NEW_ARCH_ENABLED
-
 NS_ASSUME_NONNULL_END