react-native-screens 3.13.0 → 3.14.1

package/ios/{RNSScreen.m → RNSScreen.mm}

@@ -2,57 +2,86 @@
 
 #import "RNSScreen.h"
 #import "RNSScreenContainer.h"
-#import "RNSScreenStack.h"
-#import "RNSScreenStackHeaderConfig.h"
 #import "RNSScreenWindowTraits.h"
 
-#import <React/RCTShadowView.h>
+#ifdef RN_FABRIC_ENABLED
+#import <React/RCTConversions.h>
+#import <React/RCTRootComponentView.h>
+#import <React/RCTSurfaceTouchHandler.h>
+#import <react/renderer/components/rnscreens/EventEmitters.h>
+#import <react/renderer/components/rnscreens/Props.h>
+#import <react/renderer/components/rnscreens/RCTComponentViewHelpers.h>
+#import <rnscreens/RNSScreenComponentDescriptor.h>
+#import "RCTFabricComponentsPlugins.h"
+#import "RNSConvert.h"
+#import "RNSScreenViewEvent.h"
+#else
 #import <React/RCTTouchHandler.h>
+#endif
+
+#import <React/RCTShadowView.h>
 #import <React/RCTUIManager.h>
+#import "RNSScreenStack.h"
+#import "RNSScreenStackHeaderConfig.h"
 
-@interface RNSScreenView () <UIAdaptivePresentationControllerDelegate, RCTInvalidating>
+@interface RNSScreenView ()
+#ifdef RN_FABRIC_ENABLED
+    <RCTRNSScreenViewProtocol, UIAdaptivePresentationControllerDelegate>
+#else
+    <UIAdaptivePresentationControllerDelegate, RCTInvalidating>
+#endif
 @end
 
 @implementation RNSScreenView {
   __weak RCTBridge *_bridge;
-  RNSScreen *_controller;
+#ifdef RN_FABRIC_ENABLED
+  RCTSurfaceTouchHandler *_touchHandler;
+  facebook::react::RNSScreenShadowNode::ConcreteState::Shared _state;
+  // on fabric, they are not available by default so we need them exposed here too
+  NSMutableArray<UIView *> *_reactSubviews;
+#else
   RCTTouchHandler *_touchHandler;
   CGRect _reactFrame;
+#endif
+}
+
+#ifdef RN_FABRIC_ENABLED
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  if (self = [super initWithFrame:frame]) {
+    static const auto defaultProps = std::make_shared<const facebook::react::RNSScreenProps>();
+    _props = defaultProps;
+    _reactSubviews = [NSMutableArray new];
+    [self initCommonProps];
+  }
+
+  return self;
 }
+#endif
 
 - (instancetype)initWithBridge:(RCTBridge *)bridge
 {
   if (self = [super init]) {
     _bridge = bridge;
-    _controller = [[RNSScreen alloc] initWithView:self];
-    _stackPresentation = RNSScreenStackPresentationPush;
-    _stackAnimation = RNSScreenStackAnimationDefault;
-    _gestureEnabled = YES;
-    _replaceAnimation = RNSScreenReplaceAnimationPop;
-    _dismissed = NO;
-    _hasStatusBarStyleSet = NO;
-    _hasStatusBarAnimationSet = NO;
-    _hasStatusBarHiddenSet = NO;
-    _hasOrientationSet = NO;
-    _hasHomeIndicatorHiddenSet = NO;
+    [self initCommonProps];
   }
 
   return self;
 }
 
-- (void)reactSetFrame:(CGRect)frame
+- (void)initCommonProps
 {
-  _reactFrame = frame;
-  UIViewController *parentVC = self.reactViewController.parentViewController;
-  if (parentVC != nil && ![parentVC isKindOfClass:[RNScreensNavigationController class]]) {
-    [super reactSetFrame:frame];
-  }
-  // when screen is mounted under RNScreensNavigationController it's size is controller
-  // by the navigation controller itself. That is, it is set to fill space of
-  // the controller. In that case we ignore react layout system from managing
-  // the screen dimensions and we wait for the screen VC to update and then we
-  // pass the dimensions to ui view manager to take into account when laying out
-  // subviews
+  _controller = [[RNSScreen alloc] initWithView:self];
+  _stackPresentation = RNSScreenStackPresentationPush;
+  _stackAnimation = RNSScreenStackAnimationDefault;
+  _gestureEnabled = YES;
+  _replaceAnimation = RNSScreenReplaceAnimationPop;
+  _dismissed = NO;
+  _hasStatusBarStyleSet = NO;
+  _hasStatusBarAnimationSet = NO;
+  _hasStatusBarHiddenSet = NO;
+  _hasOrientationSet = NO;
+  _hasHomeIndicatorHiddenSet = NO;
 }
 
 - (UIViewController *)reactViewController
@@ -60,28 +89,25 @@
   return _controller;
 }
 
-- (void)updateBounds
+#ifdef RN_FABRIC_ENABLED
+- (NSArray<UIView *> *)reactSubviews
 {
-  [_bridge.uiManager setSize:self.bounds.size forView:self];
+  return _reactSubviews;
 }
+#endif
 
-// Nil will be provided when activityState is set as an animated value and we change
-// it from JS to be a plain value (non animated).
-// In case when nil is received, we want to ignore such value and not make
-// any updates as the actual non-nil value will follow immediately.
-- (void)setActivityStateOrNil:(NSNumber *)activityStateOrNil
+- (void)updateBounds
 {
-  int activityState = [activityStateOrNil intValue];
-  if (activityStateOrNil != nil && activityState != _activityState) {
-    _activityState = activityState;
-    [_reactSuperview markChildUpdated];
+#ifdef RN_FABRIC_ENABLED
+  if (_state != nullptr) {
+    auto newState = facebook::react::RNSScreenState{RCTSizeFromCGSize(self.bounds.size)};
+    _state->updateState(std::move(newState));
+    UINavigationController *navctr = _controller.navigationController;
+    [navctr.view setNeedsLayout];
   }
-}
-
-- (void)setPointerEvents:(RCTPointerEvents)pointerEvents
-{
-  // pointer events settings are managed by the parent screen container, we ignore
-  // any attempt of setting that via React props
+#else
+  [_bridge.uiManager setSize:self.bounds.size forView:self];
+#endif
 }
 
 - (void)setStackPresentation:(RNSScreenStackPresentation)stackPresentation
@@ -131,8 +157,13 @@
     // https://developer.apple.com/documentation/uikit/uiviewcontroller/1621426-presentationcontroller?language=objc
     _controller.presentationController.delegate = self;
   } else if (_stackPresentation != RNSScreenStackPresentationPush) {
+#ifdef RN_FABRIC_ENABLED
+    // TODO: on Fabric, same controllers can be used as modals and then recycled and used a push which would result in
+    // this error. It would be good to check if it doesn't leak in such case.
+#else
     RCTLogError(
         @"Screen presentation updated from modal to push, this may likely result in a screen object leakage. If you need to change presentation style create a new screen object instead");
+#endif
   }
   _stackPresentation = stackPresentation;
 }
@@ -177,6 +208,19 @@
   _replaceAnimation = replaceAnimation;
 }
 
+// Nil will be provided when activityState is set as an animated value and we change
+// it from JS to be a plain value (non animated).
+// In case when nil is received, we want to ignore such value and not make
+// any updates as the actual non-nil value will follow immediately.
+- (void)setActivityStateOrNil:(NSNumber *)activityStateOrNil
+{
+  int activityState = [activityStateOrNil intValue];
+  if (activityStateOrNil != nil && activityState != -1 && activityState != _activityState) {
+    _activityState = activityState;
+    [_reactSuperview markChildUpdated];
+  }
+}
+
 #if !TARGET_OS_TV
 - (void)setStatusBarStyle:(RNSStatusBarStyle)statusBarStyle
 {
@@ -230,13 +274,17 @@
   }
 }
 
-- (void)notifyFinishTransitioning
-{
-  [_controller notifyFinishTransitioning];
-}
-
 - (void)notifyDismissedWithCount:(int)dismissCount
 {
+#ifdef RN_FABRIC_ENABLED
+  // If screen is already unmounted then there will be no event emitter
+  // it will be cleaned in prepareForRecycle
+  if (_eventEmitter != nullptr) {
+    std::dynamic_pointer_cast<const facebook::react::RNSScreenEventEmitter>(_eventEmitter)
+        ->onDismissed(facebook::react::RNSScreenEventEmitter::OnDismissed{.dismissCount = dismissCount});
+  }
+#else
+  // TODO: hopefully problems connected to dismissed prop are only the case on paper
   _dismissed = YES;
   if (self.onDismissed) {
     dispatch_async(dispatch_get_main_queue(), ^{
@@ -245,27 +293,75 @@
       }
     });
   }
+#endif
+}
+
+- (void)notifyDismissCancelledWithDismissCount:(int)dismissCount
+{
+#ifdef RN_FABRIC_ENABLED
+  // If screen is already unmounted then there will be no event emitter
+  // it will be cleaned in prepareForRecycle
+  if (_eventEmitter != nullptr) {
+    std::dynamic_pointer_cast<const facebook::react::RNSScreenEventEmitter>(_eventEmitter)
+        ->onNativeDismissCancelled(
+            facebook::react::RNSScreenEventEmitter::OnNativeDismissCancelled{.dismissCount = dismissCount});
+  }
+#else
+  if (self.onNativeDismissCancelled) {
+    self.onNativeDismissCancelled(@{@"dismissCount" : @(dismissCount)});
+  }
+#endif
 }
 
 - (void)notifyWillAppear
 {
+#ifdef RN_FABRIC_ENABLED
+  // If screen is already unmounted then there will be no event emitter
+  // it will be cleaned in prepareForRecycle
+  if (_eventEmitter != nullptr) {
+    std::dynamic_pointer_cast<const facebook::react::RNSScreenEventEmitter>(_eventEmitter)
+        ->onWillAppear(facebook::react::RNSScreenEventEmitter::OnWillAppear{});
+  }
+  [self updateLayoutMetrics:_newLayoutMetrics oldLayoutMetrics:_oldLayoutMetrics];
+#else
   if (self.onWillAppear) {
     self.onWillAppear(nil);
   }
   // we do it here too because at this moment the `parentViewController` is already not nil,
   // so if the parent is not UINavCtr, the frame will be updated to the correct one.
   [self reactSetFrame:_reactFrame];
+#endif
 }
 
 - (void)notifyWillDisappear
 {
+  if (_hideKeyboardOnSwipe) {
+    [self endEditing:YES];
+  }
+#ifdef RN_FABRIC_ENABLED
+  // If screen is already unmounted then there will be no event emitter
+  // it will be cleaned in prepareForRecycle
+  if (_eventEmitter != nullptr) {
+    std::dynamic_pointer_cast<const facebook::react::RNSScreenEventEmitter>(_eventEmitter)
+        ->onWillDisappear(facebook::react::RNSScreenEventEmitter::OnWillDisappear{});
+  }
+#else
   if (self.onWillDisappear) {
     self.onWillDisappear(nil);
   }
+#endif
 }
 
 - (void)notifyAppear
 {
+#ifdef RN_FABRIC_ENABLED
+  // If screen is already unmounted then there will be no event emitter
+  // it will be cleaned in prepareForRecycle
+  if (_eventEmitter != nullptr) {
+    std::dynamic_pointer_cast<const facebook::react::RNSScreenEventEmitter>(_eventEmitter)
+        ->onAppear(facebook::react::RNSScreenEventEmitter::OnAppear{});
+  }
+#else
   if (self.onAppear) {
     dispatch_async(dispatch_get_main_queue(), ^{
       if (self.onAppear) {
@@ -273,41 +369,39 @@
       }
     });
   }
+#endif
 }
 
 - (void)notifyDisappear
 {
+#ifdef RN_FABRIC_ENABLED
+  // If screen is already unmounted then there will be no event emitter
+  // it will be cleaned in prepareForRecycle
+  if (_eventEmitter != nullptr) {
+    std::dynamic_pointer_cast<const facebook::react::RNSScreenEventEmitter>(_eventEmitter)
+        ->onDisappear(facebook::react::RNSScreenEventEmitter::OnDisappear{});
+  }
+#else
   if (self.onDisappear) {
     self.onDisappear(nil);
   }
-}
-
-- (void)notifyDismissCancelledWithDismissCount:(int)dismissCount
-{
-  if (self.onNativeDismissCancelled) {
-    self.onNativeDismissCancelled(@{@"dismissCount" : @(dismissCount)});
-  }
-}
-
-- (void)notifyTransitionProgress:(double)progress closing:(BOOL)closing goingForward:(BOOL)goingForward
-{
-  if (self.onTransitionProgress) {
-    self.onTransitionProgress(@{
-      @"progress" : @(progress),
-      @"closing" : @(closing ? 1 : 0),
-      @"goingForward" : @(goingForward ? 1 : 0),
-    });
-  }
+#endif
 }
 
 - (BOOL)isMountedUnderScreenOrReactRoot
 {
+#ifdef RN_FABRIC_ENABLED
+#define RNS_EXPECTED_VIEW RCTRootComponentView
+#else
+#define RNS_EXPECTED_VIEW RCTRootView
+#endif
   for (UIView *parent = self.superview; parent != nil; parent = parent.superview) {
-    if ([parent isKindOfClass:[RCTRootView class]] || [parent isKindOfClass:[RNSScreenView class]]) {
+    if ([parent isKindOfClass:[RNS_EXPECTED_VIEW class]] || [parent isKindOfClass:[RNSScreenView class]]) {
       return YES;
     }
   }
   return NO;
+#undef RNS_EXPECTED_VIEW
 }
 
 - (void)didMoveToWindow
@@ -317,7 +411,11 @@
   // root application window.
   if (self.window != nil && ![self isMountedUnderScreenOrReactRoot]) {
     if (_touchHandler == nil) {
+#ifdef RN_FABRIC_ENABLED
+      _touchHandler = [RCTSurfaceTouchHandler new];
+#else
       _touchHandler = [[RCTTouchHandler alloc] initWithBridge:_bridge];
+#endif
     }
     [_touchHandler attachToView:self];
   } else {
@@ -325,6 +423,54 @@
   }
 }
 
+#ifdef RN_FABRIC_ENABLED
+- (RCTSurfaceTouchHandler *)touchHandler
+#else
+- (RCTTouchHandler *)touchHandler
+#endif
+{
+  if (_touchHandler != nil) {
+    return _touchHandler;
+  }
+  UIView *parent = [self superview];
+  while (parent != nil && ![parent respondsToSelector:@selector(touchHandler)])
+    parent = parent.superview;
+  if (parent != nil) {
+    return [parent performSelector:@selector(touchHandler)];
+  }
+  return nil;
+}
+
+- (void)notifyFinishTransitioning
+{
+  [_controller notifyFinishTransitioning];
+}
+
+- (void)notifyTransitionProgress:(double)progress closing:(BOOL)closing goingForward:(BOOL)goingForward
+{
+#ifdef RN_FABRIC_ENABLED
+  if (_eventEmitter != nullptr) {
+    std::dynamic_pointer_cast<const facebook::react::RNSScreenEventEmitter>(_eventEmitter)
+        ->onTransitionProgress(facebook::react::RNSScreenEventEmitter::OnTransitionProgress{
+            .progress = progress, .closing = closing ? 1 : 0, .goingForward = goingForward ? 1 : 0});
+  }
+  RNSScreenViewEvent *event = [[RNSScreenViewEvent alloc] initWithEventName:@"onTransitionProgress"
+                                                                   reactTag:[NSNumber numberWithInt:self.tag]
+                                                                   progress:progress
+                                                                    closing:closing
+                                                               goingForward:goingForward];
+  [[RCTBridge currentBridge].eventDispatcher sendEvent:event];
+#else
+  if (self.onTransitionProgress) {
+    self.onTransitionProgress(@{
+      @"progress" : @(progress),
+      @"closing" : @(closing ? 1 : 0),
+      @"goingForward" : @(goingForward ? 1 : 0),
+    });
+  }
+#endif
+}
+
 - (void)presentationControllerWillDismiss:(UIPresentationController *)presentationController
 {
   // We need to call both "cancel" and "reset" here because RN's gesture recognizer
@@ -337,24 +483,15 @@
   // pulling down starting at some touchable item. Without "reset" the touchable
   // will never go back from highlighted state even when the modal start sliding
   // down.
+#ifdef RN_FABRIC_ENABLED
+  [_touchHandler setEnabled:NO];
+  [_touchHandler setEnabled:YES];
+#else
   [_touchHandler cancel];
+#endif
   [_touchHandler reset];
 }
 
-- (RCTTouchHandler *)touchHandler
-{
-  if (_touchHandler != nil) {
-    return _touchHandler;
-  }
-  UIView *parent = [self superview];
-  while (parent != nil && ![parent respondsToSelector:@selector(touchHandler)])
-    parent = parent.superview;
-  if (parent != nil) {
-    return [parent performSelector:@selector(touchHandler)];
-  }
-  return nil;
-}
-
 - (BOOL)presentationControllerShouldDismiss:(UIPresentationController *)presentationController
 {
   if (_preventNativeDismiss) {
@@ -371,211 +508,212 @@
   }
 }
 
-- (void)invalidate
-{
-  _controller = nil;
-}
-
-@end
+#pragma mark - Fabric specific
+#ifdef RN_FABRIC_ENABLED
 
-@implementation RNSScreen {
-  __weak id _previousFirstResponder;
-  CGRect _lastViewFrame;
-  UIView *_fakeView;
-  CADisplayLink *_animationTimer;
-  CGFloat _currentAlpha;
-  BOOL _closing;
-  BOOL _goingForward;
-  int _dismissCount;
-  BOOL _isSwiping;
-  BOOL _shouldNotify;
++ (facebook::react::ComponentDescriptorProvider)componentDescriptorProvider
+{
+  return facebook::react::concreteComponentDescriptorProvider<facebook::react::RNSScreenComponentDescriptor>();
 }
 
-- (instancetype)initWithView:(UIView *)view
+- (void)mountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView index:(NSInteger)index
 {
-  if (self = [super init]) {
-    self.view = view;
-    _shouldNotify = YES;
-    _fakeView = [UIView new];
+  [super mountChildComponentView:childComponentView index:index];
+  if ([childComponentView isKindOfClass:[RNSScreenStackHeaderConfig class]]) {
+    _config = childComponentView;
+    ((RNSScreenStackHeaderConfig *)childComponentView).screenView = self;
   }
-  return self;
+  [_reactSubviews insertObject:childComponentView atIndex:index];
 }
 
-#if !TARGET_OS_TV
-- (UIViewController *)childViewControllerForStatusBarStyle
+- (void)unmountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView index:(NSInteger)index
 {
-  UIViewController *vc = [self findChildVCForConfigAndTrait:RNSWindowTraitStyle includingModals:NO];
-  return vc == self ? nil : vc;
+  if ([childComponentView isKindOfClass:[RNSScreenStackHeaderConfig class]]) {
+    _config = nil;
+  }
+  [_reactSubviews removeObject:childComponentView];
+  [super unmountChildComponentView:childComponentView index:index];
 }
 
-- (UIStatusBarStyle)preferredStatusBarStyle
-{
-  return [RNSScreenWindowTraits statusBarStyleForRNSStatusBarStyle:((RNSScreenView *)self.view).statusBarStyle];
-}
+#pragma mark - RCTComponentViewProtocol
 
-- (UIViewController *)childViewControllerForStatusBarHidden
+- (void)prepareForRecycle
 {
-  UIViewController *vc = [self findChildVCForConfigAndTrait:RNSWindowTraitHidden includingModals:NO];
-  return vc == self ? nil : vc;
+  [super prepareForRecycle];
+  // TODO: Make sure that there is no edge case when this should be uncommented
+  // _controller=nil;
+  _dismissed = NO;
+  _state.reset();
+  _touchHandler = nil;
 }
 
-- (BOOL)prefersStatusBarHidden
+- (void)updateProps:(facebook::react::Props::Shared const &)props
+           oldProps:(facebook::react::Props::Shared const &)oldProps
 {
-  return ((RNSScreenView *)self.view).statusBarHidden;
-}
+  const auto &oldScreenProps = *std::static_pointer_cast<const facebook::react::RNSScreenProps>(_props);
+  const auto &newScreenProps = *std::static_pointer_cast<const facebook::react::RNSScreenProps>(props);
 
-- (UIStatusBarAnimation)preferredStatusBarUpdateAnimation
-{
-  UIViewController *vc = [self findChildVCForConfigAndTrait:RNSWindowTraitAnimation includingModals:NO];
+  [self setFullScreenSwipeEnabled:newScreenProps.fullScreenSwipeEnabled];
 
-  if ([vc isKindOfClass:[RNSScreen class]]) {
-    return ((RNSScreenView *)vc.view).statusBarAnimation;
+  [self setGestureEnabled:newScreenProps.gestureEnabled];
+
+  [self setTransitionDuration:[NSNumber numberWithInt:newScreenProps.transitionDuration]];
+
+  [self setHideKeyboardOnSwipe:newScreenProps.hideKeyboardOnSwipe];
+
+  [self setCustomAnimationOnSwipe:newScreenProps.customAnimationOnSwipe];
+
+  [self
+      setGestureResponseDistance:[RNSConvert
+                                     gestureResponseDistanceDictFromCppStruct:newScreenProps.gestureResponseDistance]];
+
+  [self setPreventNativeDismiss:newScreenProps.preventNativeDismiss];
+
+  [self setActivityStateOrNil:[NSNumber numberWithFloat:newScreenProps.activityState]];
+
+  [self setSwipeDirection:[RNSConvert RNSScreenSwipeDirectionFromCppEquivalent:newScreenProps.swipeDirection]];
+
+#if !TARGET_OS_TV
+  if (newScreenProps.statusBarHidden != oldScreenProps.statusBarHidden) {
+    [self setStatusBarHidden:newScreenProps.statusBarHidden];
   }
-  return UIStatusBarAnimationFade;
-}
 
-- (UIInterfaceOrientationMask)supportedInterfaceOrientations
-{
-  UIViewController *vc = [self findChildVCForConfigAndTrait:RNSWindowTraitOrientation includingModals:YES];
+  if (newScreenProps.statusBarStyle != oldScreenProps.statusBarStyle) {
+    [self setStatusBarStyle:[RCTConvert
+                                RNSStatusBarStyle:RCTNSStringFromStringNilIfEmpty(newScreenProps.statusBarStyle)]];
+  }
 
-  if ([vc isKindOfClass:[RNSScreen class]]) {
-    return ((RNSScreenView *)vc.view).screenOrientation;
+  if (newScreenProps.statusBarAnimation != oldScreenProps.statusBarAnimation) {
+    [self setStatusBarAnimation:[RCTConvert UIStatusBarAnimation:RCTNSStringFromStringNilIfEmpty(
+                                                                     newScreenProps.statusBarAnimation)]];
   }
-  return UIInterfaceOrientationMaskAllButUpsideDown;
+
+  if (newScreenProps.screenOrientation != oldScreenProps.screenOrientation) {
+    [self setScreenOrientation:[RCTConvert UIInterfaceOrientationMask:RCTNSStringFromStringNilIfEmpty(
+                                                                          newScreenProps.screenOrientation)]];
+  }
+
+  if (newScreenProps.homeIndicatorHidden != oldScreenProps.homeIndicatorHidden) {
+    [self setHomeIndicatorHidden:newScreenProps.homeIndicatorHidden];
+  }
+#endif
+
+  if (newScreenProps.stackPresentation != oldScreenProps.stackPresentation) {
+    [self
+        setStackPresentation:[RNSConvert RNSScreenStackPresentationFromCppEquivalent:newScreenProps.stackPresentation]];
+  }
+
+  if (newScreenProps.stackAnimation != oldScreenProps.stackAnimation) {
+    [self setStackAnimation:[RNSConvert RNSScreenStackAnimationFromCppEquivalent:newScreenProps.stackAnimation]];
+  }
+
+  if (newScreenProps.replaceAnimation != oldScreenProps.replaceAnimation) {
+    [self setReplaceAnimation:[RNSConvert RNSScreenReplaceAnimationFromCppEquivalent:newScreenProps.replaceAnimation]];
+  }
+
+  [super updateProps:props oldProps:oldProps];
 }
 
-- (UIViewController *)childViewControllerForHomeIndicatorAutoHidden
+- (void)updateState:(facebook::react::State::Shared const &)state
+           oldState:(facebook::react::State::Shared const &)oldState
 {
-  UIViewController *vc = [self findChildVCForConfigAndTrait:RNSWindowTraitHomeIndicatorHidden includingModals:YES];
-  return vc == self ? nil : vc;
+  _state = std::static_pointer_cast<const facebook::react::RNSScreenShadowNode::ConcreteState>(state);
 }
 
-- (BOOL)prefersHomeIndicatorAutoHidden
+- (void)updateLayoutMetrics:(const facebook::react::LayoutMetrics &)layoutMetrics
+           oldLayoutMetrics:(const facebook::react::LayoutMetrics &)oldLayoutMetrics
 {
-  return ((RNSScreenView *)self.view).homeIndicatorHidden;
+  _newLayoutMetrics = layoutMetrics;
+  _oldLayoutMetrics = oldLayoutMetrics;
+  UIViewController *parentVC = self.reactViewController.parentViewController;
+  if (parentVC != nil && ![parentVC isKindOfClass:[RNScreensNavigationController class]]) {
+    [super updateLayoutMetrics:layoutMetrics oldLayoutMetrics:oldLayoutMetrics];
+  }
+  // when screen is mounted under RNScreensNavigationController it's size is controller
+  // by the navigation controller itself. That is, it is set to fill space of
+  // the controller. In that case we ignore react layout system from managing
+  // the screen dimensions and we wait for the screen VC to update and then we
+  // pass the dimensions to ui view manager to take into account when laying out
+  // subviews
+  // Explanation taken from `reactSetFrame`, which is old arch equivalent of this code.
 }
 
-// if the returned vc is a child, it means that it can provide config;
-// if the returned vc is self, it means that there is no child for config and self has config to provide,
-// so we return self which results in asking self for preferredStatusBarStyle/Animation etc.;
-// if the returned vc is nil, it means none of children could provide config and self does not have config either,
-// so if it was asked by parent, it will fallback to parent's option, or use default option if it is the top Screen
-- (UIViewController *)findChildVCForConfigAndTrait:(RNSWindowTrait)trait includingModals:(BOOL)includingModals
-{
-  UIViewController *lastViewController = [[self childViewControllers] lastObject];
-  if ([self.presentedViewController isKindOfClass:[RNSScreen class]]) {
-    lastViewController = self.presentedViewController;
-    // we don't want to allow controlling of status bar appearance when we present non-fullScreen modal
-    // and it is not possible if `modalPresentationCapturesStatusBarAppearance` is not set to YES, so even
-    // if we went into a modal here and ask it, it wouldn't take any effect. For fullScreen modals, the system
-    // asks them by itself, so we can stop traversing here.
-    // for screen orientation, we need to start the search again from that modal
-    return !includingModals
-        ? nil
-        : [(RNSScreen *)lastViewController findChildVCForConfigAndTrait:trait includingModals:includingModals]
-            ?: lastViewController;
-  }
+#pragma mark - Paper specific
+#else
 
-  UIViewController *selfOrNil = [self hasTraitSet:trait] ? self : nil;
-  if (lastViewController == nil) {
-    return selfOrNil;
-  } else {
-    if ([lastViewController conformsToProtocol:@protocol(RNScreensViewControllerDelegate)]) {
-      // If there is a child (should be VC of ScreenContainer or ScreenStack), that has a child that could provide the
-      // trait, we recursively go into its findChildVCForConfig, and if one of the children has the trait set, we return
-      // it, otherwise we return self if this VC has config, and nil if it doesn't we use
-      // `childViewControllerForStatusBarStyle` for all options since the behavior is the same for all of them
-      UIViewController *childScreen = [lastViewController childViewControllerForStatusBarStyle];
-      if ([childScreen isKindOfClass:[RNSScreen class]]) {
-        return [(RNSScreen *)childScreen findChildVCForConfigAndTrait:trait includingModals:includingModals]
-            ?: selfOrNil;
-      } else {
-        return selfOrNil;
-      }
-    } else {
-      // child vc is not from this library, so we don't ask it
-      return selfOrNil;
-    }
-  }
+- (void)setPointerEvents:(RCTPointerEvents)pointerEvents
+{
+  // pointer events settings are managed by the parent screen container, we ignore
+  // any attempt of setting that via React props
 }
 
-- (BOOL)hasTraitSet:(RNSWindowTrait)trait
+- (void)reactSetFrame:(CGRect)frame
 {
-  switch (trait) {
-    case RNSWindowTraitStyle: {
-      return ((RNSScreenView *)self.view).hasStatusBarStyleSet;
-    }
-    case RNSWindowTraitAnimation: {
-      return ((RNSScreenView *)self.view).hasStatusBarAnimationSet;
-    }
-    case RNSWindowTraitHidden: {
-      return ((RNSScreenView *)self.view).hasStatusBarHiddenSet;
-    }
-    case RNSWindowTraitOrientation: {
-      return ((RNSScreenView *)self.view).hasOrientationSet;
-    }
-    case RNSWindowTraitHomeIndicatorHidden: {
-      return ((RNSScreenView *)self.view).hasHomeIndicatorHiddenSet;
-    }
-    default: {
-      RCTLogError(@"Unknown trait passed: %d", (int)trait);
-    }
+  _reactFrame = frame;
+  UIViewController *parentVC = self.reactViewController.parentViewController;
+  if (parentVC != nil && ![parentVC isKindOfClass:[RNScreensNavigationController class]]) {
+    [super reactSetFrame:frame];
   }
-  return NO;
+  // when screen is mounted under RNScreensNavigationController it's size is controller
+  // by the navigation controller itself. That is, it is set to fill space of
+  // the controller. In that case we ignore react layout system from managing
+  // the screen dimensions and we wait for the screen VC to update and then we
+  // pass the dimensions to ui view manager to take into account when laying out
+  // subviews
 }
 
+- (void)invalidate
+{
+  _controller = nil;
+}
 #endif
 
-- (void)viewDidLayoutSubviews
-{
-  [super viewDidLayoutSubviews];
+@end
 
-  // The below code makes the screen view adapt dimensions provided by the system. We take these
-  // into account only when the view is mounted under RNScreensNavigationController in which case system
-  // provides additional padding to account for possible header, and in the case when screen is
-  // shown as a native modal, as the final dimensions of the modal on iOS 12+ are shorter than the
-  // screen size
-  BOOL isDisplayedWithinUINavController =
-      [self.parentViewController isKindOfClass:[RNScreensNavigationController class]];
-  BOOL isPresentedAsNativeModal = self.parentViewController == nil && self.presentingViewController != nil;
-  if ((isDisplayedWithinUINavController || isPresentedAsNativeModal) &&
-      !CGRectEqualToRect(_lastViewFrame, self.view.frame)) {
-    _lastViewFrame = self.view.frame;
-    [((RNSScreenView *)self.viewIfLoaded) updateBounds];
-  }
+#ifdef RN_FABRIC_ENABLED
+Class<RCTComponentViewProtocol> RNSScreenCls(void)
+{
+  return RNSScreenView.class;
 }
+#endif
 
-- (id)findFirstResponder:(UIView *)parent
-{
-  if (parent.isFirstResponder) {
-    return parent;
-  }
-  for (UIView *subView in parent.subviews) {
-    id responder = [self findFirstResponder:subView];
-    if (responder != nil) {
-      return responder;
-    }
-  }
-  return nil;
+#pragma mark - RNSScreen
+
+@implementation RNSScreen {
+  __weak id _previousFirstResponder;
+  CGRect _lastViewFrame;
+  RNSScreenView *_initialView;
+  UIView *_fakeView;
+  CADisplayLink *_animationTimer;
+  CGFloat _currentAlpha;
+  BOOL _closing;
+  BOOL _goingForward;
+  int _dismissCount;
+  BOOL _isSwiping;
+  BOOL _shouldNotify;
 }
 
-- (void)willMoveToParentViewController:(UIViewController *)parent
+#pragma mark - Common
+
+- (instancetype)initWithView:(UIView *)view
 {
-  [super willMoveToParentViewController:parent];
-  if (parent == nil) {
-    id responder = [self findFirstResponder:self.view];
-    if (responder != nil) {
-      _previousFirstResponder = responder;
-    }
+  if (self = [super init]) {
+    self.view = view;
+    _fakeView = [UIView new];
+    _shouldNotify = YES;
+#ifdef RN_FABRIC_ENABLED
+    _initialView = (RNSScreenView *)view;
+#endif
   }
+  return self;
 }
 
+// TODO: Find out why this is executed when screen is going out
 - (void)viewWillAppear:(BOOL)animated
 {
   [super viewWillAppear:animated];
-
   if (!_isSwiping) {
-    [((RNSScreenView *)self.view) notifyWillAppear];
+    [self.screenView notifyWillAppear];
     if (self.transitionCoordinator.isInteractive) {
       // we started dismissing with swipe gesture
       _isSwiping = YES;
@@ -587,7 +725,6 @@
   }
 
   [self hideHeaderIfNecessary];
-
   // as per documentation of these methods
   _goingForward = [self isBeingPresented] || [self isMovingToParentViewController];
 
@@ -599,46 +736,16 @@
   }
 }
 
-- (void)hideHeaderIfNecessary
-{
-#if !TARGET_OS_TV
-  // On iOS >=13, there is a bug when user transitions from screen with active search bar to screen without header
-  // In that case default iOS header will be shown. To fix this we hide header when the screens that appears has header
-  // hidden and search bar was active on previous screen. We need to do it asynchronously, because default header is
-  // added after viewWillAppear.
-  if (@available(iOS 13.0, *)) {
-    NSUInteger currentIndex = [self.navigationController.viewControllers indexOfObject:self];
-
-    if (currentIndex > 0 && [self.view.reactSubviews[0] isKindOfClass:[RNSScreenStackHeaderConfig class]]) {
-      UINavigationItem *prevNavigationItem =
-          [self.navigationController.viewControllers objectAtIndex:currentIndex - 1].navigationItem;
-      RNSScreenStackHeaderConfig *config = ((RNSScreenStackHeaderConfig *)self.view.reactSubviews[0]);
-
-      BOOL wasSearchBarActive = prevNavigationItem.searchController.active;
-      BOOL shouldHideHeader = config.hide;
-
-      if (wasSearchBarActive && shouldHideHeader) {
-        dispatch_time_t popTime = dispatch_time(DISPATCH_TIME_NOW, 0);
-        dispatch_after(popTime, dispatch_get_main_queue(), ^(void) {
-          [self.navigationController setNavigationBarHidden:YES animated:NO];
-        });
-      }
-    }
-  }
-#endif
-}
-
 - (void)viewWillDisappear:(BOOL)animated
 {
   [super viewWillDisappear:animated];
-
   if (!self.transitionCoordinator.isInteractive) {
     // user might have long pressed ios 14 back button item,
     // so he can go back more than one screen and we need to dismiss more screens in JS stack then.
     // We check it by calculating the difference between the index of currently displayed screen
     // and the index of the target screen, which is the view of topViewController at this point.
     // If the value is lower than 1, it means we are dismissing a modal, or navigating forward, or going back with JS.
-    int selfIndex = [self getIndexOfView:self.view];
+    int selfIndex = [self getIndexOfView:self.screenView];
     int targetIndex = [self getIndexOfView:self.navigationController.topViewController.view];
     _dismissCount = selfIndex - targetIndex > 0 ? selfIndex - targetIndex : 1;
   } else {
@@ -647,7 +754,7 @@
 
   // same flow as in viewWillAppear
   if (!_isSwiping) {
-    [((RNSScreenView *)self.view) notifyWillDisappear];
+    [self.screenView notifyWillDisappear];
     if (self.transitionCoordinator.isInteractive) {
       _isSwiping = YES;
     }
@@ -668,11 +775,10 @@
 - (void)viewDidAppear:(BOOL)animated
 {
   [super viewDidAppear:animated];
-
   if (!_isSwiping || _shouldNotify) {
     // we are going forward or dismissing without swipe
     // or successfully swiped back
-    [((RNSScreenView *)self.view) notifyAppear];
+    [self.screenView notifyAppear];
     [self notifyTransitionProgress:1.0 closing:NO goingForward:_goingForward];
   }
 
@@ -683,54 +789,57 @@
 - (void)viewDidDisappear:(BOOL)animated
 {
   [super viewDidDisappear:animated];
-
+#ifdef RN_FABRIC_ENABLED
+  [self resetViewToScreen];
+#endif
   if (self.parentViewController == nil && self.presentingViewController == nil) {
-    if (((RNSScreenView *)self.view).preventNativeDismiss) {
+    if (self.screenView.preventNativeDismiss) {
       // if we want to prevent the native dismiss, we do not send dismissal event,
       // but instead call `updateContainer`, which restores the JS navigation stack
-      [((RNSScreenView *)self.view).reactSuperview updateContainer];
-      [((RNSScreenView *)self.view) notifyDismissCancelledWithDismissCount:_dismissCount];
+      [self.screenView.reactSuperview updateContainer];
+      [self.screenView notifyDismissCancelledWithDismissCount:_dismissCount];
     } else {
       // screen dismissed, send event
-      [((RNSScreenView *)self.view) notifyDismissedWithCount:_dismissCount];
+      [self.screenView notifyDismissedWithCount:_dismissCount];
     }
   }
-
   // same flow as in viewDidAppear
   if (!_isSwiping || _shouldNotify) {
-    [((RNSScreenView *)self.view) notifyDisappear];
+    [self.screenView notifyDisappear];
     [self notifyTransitionProgress:1.0 closing:YES goingForward:_goingForward];
   }
 
   _isSwiping = NO;
   _shouldNotify = YES;
-
-  [self traverseForScrollView:self.view];
+#ifdef RN_FABRIC_ENABLED
+#else
+  [self traverseForScrollView:self.screenView];
+#endif
 }
 
-- (void)traverseForScrollView:(UIView *)view
+- (void)viewDidLayoutSubviews
 {
-  if (![[self.view valueForKey:@"_bridge"] valueForKey:@"_jsThread"]) {
-    // we don't want to send `scrollViewDidEndDecelerating` event to JS before the JS thread is ready
-    return;
-  }
-  if ([view isKindOfClass:[UIScrollView class]] &&
-      ([[(UIScrollView *)view delegate] respondsToSelector:@selector(scrollViewDidEndDecelerating:)])) {
-    [[(UIScrollView *)view delegate] scrollViewDidEndDecelerating:(id)view];
-  }
-  [view.subviews enumerateObjectsUsingBlock:^(__kindof UIView *_Nonnull obj, NSUInteger idx, BOOL *_Nonnull stop) {
-    [self traverseForScrollView:obj];
-  }];
-}
+  [super viewDidLayoutSubviews];
 
-- (int)getIndexOfView:(UIView *)view
-{
-  return (int)[[self.view.reactSuperview reactSubviews] indexOfObject:view];
-}
+  // The below code makes the screen view adapt dimensions provided by the system. We take these
+  // into account only when the view is mounted under RNScreensNavigationController in which case system
+  // provides additional padding to account for possible header, and in the case when screen is
+  // shown as a native modal, as the final dimensions of the modal on iOS 12+ are shorter than the
+  // screen size
+  BOOL isDisplayedWithinUINavController =
+      [self.parentViewController isKindOfClass:[RNScreensNavigationController class]];
+  BOOL isPresentedAsNativeModal = self.parentViewController == nil && self.presentingViewController != nil;
 
-- (int)getParentChildrenCount
-{
-  return (int)[[self.view.reactSuperview reactSubviews] count];
+  if (isDisplayedWithinUINavController || isPresentedAsNativeModal) {
+#ifdef RN_FABRIC_ENABLED
+    [self.screenView updateBounds];
+#else
+    if (!CGRectEqualToRect(_lastViewFrame, self.screenView.frame)) {
+      _lastViewFrame = self.screenView.frame;
+      [((RNSScreenView *)self.viewIfLoaded) updateBounds];
+    }
+#endif
+  }
 }
 
 - (void)notifyFinishTransitioning
@@ -741,6 +850,31 @@
   [RNSScreenWindowTraits updateWindowTraits];
 }
 
+- (void)willMoveToParentViewController:(UIViewController *)parent
+{
+  [super willMoveToParentViewController:parent];
+  if (parent == nil) {
+    id responder = [self findFirstResponder:self.screenView];
+    if (responder != nil) {
+      _previousFirstResponder = responder;
+    }
+  }
+}
+
+- (id)findFirstResponder:(UIView *)parent
+{
+  if (parent.isFirstResponder) {
+    return parent;
+  }
+  for (UIView *subView in parent.subviews) {
+    id responder = [self findFirstResponder:subView];
+    if (responder != nil) {
+      return responder;
+    }
+  }
+  return nil;
+}
+
 #pragma mark - transition progress related methods
 
 - (void)setupProgressNotification
@@ -775,9 +909,240 @@
 
 - (void)notifyTransitionProgress:(double)progress closing:(BOOL)closing goingForward:(BOOL)goingForward
 {
-  [((RNSScreenView *)self.view) notifyTransitionProgress:progress closing:closing goingForward:goingForward];
+  if ([self.view isKindOfClass:[RNSScreenView class]]) {
+    // if the view is already snapshot, there is not sense in sending progress since on JS side
+    // the component is already not present
+    [(RNSScreenView *)self.view notifyTransitionProgress:progress closing:closing goingForward:goingForward];
+  }
+}
+
+#if !TARGET_OS_TV
+// if the returned vc is a child, it means that it can provide config;
+// if the returned vc is self, it means that there is no child for config and self has config to provide,
+// so we return self which results in asking self for preferredStatusBarStyle/Animation etc.;
+// if the returned vc is nil, it means none of children could provide config and self does not have config either,
+// so if it was asked by parent, it will fallback to parent's option, or use default option if it is the top Screen
+- (UIViewController *)findChildVCForConfigAndTrait:(RNSWindowTrait)trait includingModals:(BOOL)includingModals
+{
+  UIViewController *lastViewController = [[self childViewControllers] lastObject];
+  if ([self.presentedViewController isKindOfClass:[RNSScreen class]]) {
+    lastViewController = self.presentedViewController;
+    // we don't want to allow controlling of status bar appearance when we present non-fullScreen modal
+    // and it is not possible if `modalPresentationCapturesStatusBarAppearance` is not set to YES, so even
+    // if we went into a modal here and ask it, it wouldn't take any effect. For fullScreen modals, the system
+    // asks them by itself, so we can stop traversing here.
+    // for screen orientation, we need to start the search again from that modal
+    return !includingModals
+        ? nil
+        : [(RNSScreen *)lastViewController findChildVCForConfigAndTrait:trait includingModals:includingModals]
+            ?: lastViewController;
+  }
+
+  UIViewController *selfOrNil = [self hasTraitSet:trait] ? self : nil;
+  if (lastViewController == nil) {
+    return selfOrNil;
+  } else {
+    if ([lastViewController conformsToProtocol:@protocol(RNScreensViewControllerDelegate)]) {
+      // If there is a child (should be VC of ScreenContainer or ScreenStack), that has a child that could provide the
+      // trait, we recursively go into its findChildVCForConfig, and if one of the children has the trait set, we return
+      // it, otherwise we return self if this VC has config, and nil if it doesn't we use
+      // `childViewControllerForStatusBarStyle` for all options since the behavior is the same for all of them
+      UIViewController *childScreen = [lastViewController childViewControllerForStatusBarStyle];
+      if ([childScreen isKindOfClass:[RNSScreen class]]) {
+        return [(RNSScreen *)childScreen findChildVCForConfigAndTrait:trait includingModals:includingModals]
+            ?: selfOrNil;
+      } else {
+        return selfOrNil;
+      }
+    } else {
+      // child vc is not from this library, so we don't ask it
+      return selfOrNil;
+    }
+  }
+}
+
+- (BOOL)hasTraitSet:(RNSWindowTrait)trait
+{
+  switch (trait) {
+    case RNSWindowTraitStyle: {
+      return self.screenView.hasStatusBarStyleSet;
+    }
+    case RNSWindowTraitAnimation: {
+      return self.screenView.hasStatusBarAnimationSet;
+    }
+    case RNSWindowTraitHidden: {
+      return self.screenView.hasStatusBarHiddenSet;
+    }
+    case RNSWindowTraitOrientation: {
+      return self.screenView.hasOrientationSet;
+    }
+    case RNSWindowTraitHomeIndicatorHidden: {
+      return self.screenView.hasHomeIndicatorHiddenSet;
+    }
+    default: {
+      RCTLogError(@"Unknown trait passed: %d", (int)trait);
+    }
+  }
+  return NO;
+}
+
+- (UIViewController *)childViewControllerForStatusBarHidden
+{
+  UIViewController *vc = [self findChildVCForConfigAndTrait:RNSWindowTraitHidden includingModals:NO];
+  return vc == self ? nil : vc;
+}
+
+- (BOOL)prefersStatusBarHidden
+{
+  return self.screenView.statusBarHidden;
+}
+
+- (UIViewController *)childViewControllerForStatusBarStyle
+{
+  UIViewController *vc = [self findChildVCForConfigAndTrait:RNSWindowTraitStyle includingModals:NO];
+  return vc == self ? nil : vc;
+}
+
+- (UIStatusBarStyle)preferredStatusBarStyle
+{
+  return [RNSScreenWindowTraits statusBarStyleForRNSStatusBarStyle:self.screenView.statusBarStyle];
+}
+
+- (UIStatusBarAnimation)preferredStatusBarUpdateAnimation
+{
+  UIViewController *vc = [self findChildVCForConfigAndTrait:RNSWindowTraitAnimation includingModals:NO];
+
+  if ([vc isKindOfClass:[RNSScreen class]]) {
+    return ((RNSScreen *)vc).screenView.statusBarAnimation;
+  }
+  return UIStatusBarAnimationFade;
+}
+
+- (UIInterfaceOrientationMask)supportedInterfaceOrientations
+{
+  UIViewController *vc = [self findChildVCForConfigAndTrait:RNSWindowTraitOrientation includingModals:YES];
+
+  if ([vc isKindOfClass:[RNSScreen class]]) {
+    return ((RNSScreen *)vc).screenView.screenOrientation;
+  }
+  return UIInterfaceOrientationMaskAllButUpsideDown;
+}
+
+- (UIViewController *)childViewControllerForHomeIndicatorAutoHidden
+{
+  UIViewController *vc = [self findChildVCForConfigAndTrait:RNSWindowTraitHomeIndicatorHidden includingModals:YES];
+  return vc == self ? nil : vc;
+}
+
+- (BOOL)prefersHomeIndicatorAutoHidden
+{
+  return self.screenView.homeIndicatorHidden;
 }
 
+- (int)getIndexOfView:(UIView *)view
+{
+  return (int)[[self.screenView.reactSuperview reactSubviews] indexOfObject:view];
+}
+
+- (int)getParentChildrenCount
+{
+  return (int)[[self.screenView.reactSuperview reactSubviews] count];
+}
+#endif
+
+// since on Fabric the view of controller can be a snapshot of type `UIView`,
+// when we want to check props of ScreenView, we need to get them from _initialView
+- (RNSScreenView *)screenView
+{
+#ifdef RN_FABRIC_ENABLED
+  return _initialView;
+#else
+  return (RNSScreenView *)self.view;
+#endif
+}
+
+- (void)hideHeaderIfNecessary
+{
+#if !TARGET_OS_TV
+  // On iOS >=13, there is a bug when user transitions from screen with active search bar to screen without header
+  // In that case default iOS header will be shown. To fix this we hide header when the screens that appears has header
+  // hidden and search bar was active on previous screen. We need to do it asynchronously, because default header is
+  // added after viewWillAppear.
+  if (@available(iOS 13.0, *)) {
+    NSUInteger currentIndex = [self.navigationController.viewControllers indexOfObject:self];
+
+    // we need to check whether reactSubviews array is empty, because on Fabric child nodes are unmounted first ->
+    // reactSubviews array may be empty
+    if (currentIndex > 0 && [self.screenView.reactSubviews count] > 0 &&
+        [self.screenView.reactSubviews[0] isKindOfClass:[RNSScreenStackHeaderConfig class]]) {
+      UINavigationItem *prevNavigationItem =
+          [self.navigationController.viewControllers objectAtIndex:currentIndex - 1].navigationItem;
+      RNSScreenStackHeaderConfig *config = ((RNSScreenStackHeaderConfig *)self.screenView.reactSubviews[0]);
+
+      BOOL wasSearchBarActive = prevNavigationItem.searchController.active;
+
+#ifdef RN_FABRIC_ENABLED
+      BOOL shouldHideHeader = !config.show;
+#else
+      BOOL shouldHideHeader = config.hide;
+#endif
+
+      if (wasSearchBarActive && shouldHideHeader) {
+        dispatch_time_t popTime = dispatch_time(DISPATCH_TIME_NOW, 0);
+        dispatch_after(popTime, dispatch_get_main_queue(), ^(void) {
+          [self.navigationController setNavigationBarHidden:YES animated:NO];
+        });
+      }
+    }
+  }
+#endif
+}
+
+#ifdef RN_FABRIC_ENABLED
+#pragma mark - Fabric specific
+
+- (void)setViewToSnapshot:(UIView *)snapshot
+{
+  // modals of native stack seem not to support
+  // changing their view by just setting the view
+  if (_initialView.stackPresentation != RNSScreenStackPresentationPush) {
+    UIView *superView = self.view.superview;
+    [self.view removeFromSuperview];
+    self.view = snapshot;
+    [superView addSubview:self.view];
+  } else {
+    [self.view removeFromSuperview];
+    self.view = snapshot;
+  }
+}
+
+- (void)resetViewToScreen
+{
+  if (self.view != _initialView) {
+    [self.view removeFromSuperview];
+    self.view = _initialView;
+  }
+}
+
+#else
+#pragma mark - Paper specific
+
+- (void)traverseForScrollView:(UIView *)view
+{
+  if (![[self.view valueForKey:@"_bridge"] valueForKey:@"_jsThread"]) {
+    // we don't want to send `scrollViewDidEndDecelerating` event to JS before the JS thread is ready
+    return;
+  }
+  if ([view isKindOfClass:[UIScrollView class]] &&
+      ([[(UIScrollView *)view delegate] respondsToSelector:@selector(scrollViewDidEndDecelerating:)])) {
+    [[(UIScrollView *)view delegate] scrollViewDidEndDecelerating:(id)view];
+  }
+  [view.subviews enumerateObjectsUsingBlock:^(__kindof UIView *_Nonnull obj, NSUInteger idx, BOOL *_Nonnull stop) {
+    [self traverseForScrollView:obj];
+  }];
+}
+#endif
+
 @end
 
 @implementation RNSScreenManager
@@ -789,6 +1154,8 @@ RCT_REMAP_VIEW_PROPERTY(activityState, activityStateOrNil, NSNumber)
 RCT_EXPORT_VIEW_PROPERTY(customAnimationOnSwipe, BOOL);
 RCT_EXPORT_VIEW_PROPERTY(fullScreenSwipeEnabled, BOOL);
 RCT_EXPORT_VIEW_PROPERTY(gestureEnabled, BOOL)
+RCT_EXPORT_VIEW_PROPERTY(gestureResponseDistance, NSDictionary)
+RCT_EXPORT_VIEW_PROPERTY(hideKeyboardOnSwipe, BOOL)
 RCT_EXPORT_VIEW_PROPERTY(preventNativeDismiss, BOOL)
 RCT_EXPORT_VIEW_PROPERTY(replaceAnimation, RNSScreenReplaceAnimation)
 RCT_EXPORT_VIEW_PROPERTY(stackPresentation, RNSScreenStackPresentation)
@@ -870,6 +1237,16 @@ RCT_ENUM_CONVERTER(
     integerValue)
 
 #if !TARGET_OS_TV
+RCT_ENUM_CONVERTER(
+    UIStatusBarAnimation,
+    (@{
+      @"none" : @(UIStatusBarAnimationNone),
+      @"fade" : @(UIStatusBarAnimationFade),
+      @"slide" : @(UIStatusBarAnimationSlide)
+    }),
+    UIStatusBarAnimationNone,
+    integerValue)
+
 RCT_ENUM_CONVERTER(
     RNSStatusBarStyle,
     (@{