@amazon-devices/react-native-screens 2.0.1759135970 → 3.0.9000000000

package/ios/RNSScreen.mm

@@ -2,12 +2,14 @@
 
 #import "RNSScreen.h"
 #import "RNSScreenContainer.h"
+#import "RNSScreenContentWrapper.h"
 #import "RNSScreenWindowTraits.h"
 
 #ifdef RCT_NEW_ARCH_ENABLED
 #import <React/RCTConversions.h>
 #import <React/RCTFabricComponentsPlugins.h>
 #import <React/RCTRootComponentView.h>
+#import <React/RCTScrollViewComponentView.h>
 #import <React/RCTSurfaceTouchHandler.h>
 #import <react/renderer/components/rnscreens/EventEmitters.h>
 #import <react/renderer/components/rnscreens/Props.h>
@@ -17,52 +19,82 @@
 #import "RNSHeaderHeightChangeEvent.h"
 #import "RNSScreenViewEvent.h"
 #else
+#import <React/RCTScrollView.h>
 #import <React/RCTTouchHandler.h>
-#endif
+#endif // RCT_NEW_ARCH_ENABLED
 
 #import <React/RCTShadowView.h>
 #import <React/RCTUIManager.h>
+#import <React/RCTUIManagerUtils.h>
+
+#import "RNSScreenFooter.h"
 #import "RNSScreenStack.h"
 #import "RNSScreenStackHeaderConfig.h"
 
+#import "RNSDefines.h"
+#import "UIView+RNSUtility.h"
+
 #ifdef RCT_NEW_ARCH_ENABLED
 namespace react = facebook::react;
+#define ReactScrollViewBase RCTScrollViewComponentView
+#else
+#define ReactScrollViewBase RCTScrollView
 #endif // RCT_NEW_ARCH_ENABLED
 
-@interface RNSScreenView ()
+constexpr NSInteger SHEET_FIT_TO_CONTENTS = -1;
+constexpr NSInteger SHEET_LARGEST_UNDIMMED_DETENT_NONE = -1;
+
+@interface RNSScreenView () <
+    UIAdaptivePresentationControllerDelegate,
+    RNSScreenContentWrapperDelegate,
+#if !TARGET_OS_TV
+    UISheetPresentationControllerDelegate,
+#endif
 #ifdef RCT_NEW_ARCH_ENABLED
-    <RCTRNSScreenViewProtocol, UIAdaptivePresentationControllerDelegate>
+    RCTRNSScreenViewProtocol,
+    CAAnimationDelegate>
 #else
-    <UIAdaptivePresentationControllerDelegate, RCTInvalidating>
+    RCTInvalidating>
 #endif
+
 @end
 
 @implementation RNSScreenView {
-  __weak RCTBridge *_bridge;
+  __weak ReactScrollViewBase *_sheetsScrollView;
+  BOOL _didSetSheetAllowedDetentsOnController;
 #ifdef RCT_NEW_ARCH_ENABLED
   RCTSurfaceTouchHandler *_touchHandler;
   react::RNSScreenShadowNode::ConcreteState::Shared _state;
   // on fabric, they are not available by default so we need them exposed here too
   NSMutableArray<UIView *> *_reactSubviews;
+  __weak RNSScreenContentWrapper *_contentWrapper;
 #else
+  __weak RCTBridge *_bridge;
   RCTTouchHandler *_touchHandler;
   CGRect _reactFrame;
 #endif
 }
 
 #ifdef RCT_NEW_ARCH_ENABLED
+
+// Needed because of this: https://github.com/facebook/react-native/pull/37274
++ (void)load
+{
+  [super load];
+}
+
 - (instancetype)initWithFrame:(CGRect)frame
 {
   if (self = [super initWithFrame:frame]) {
     static const auto defaultProps = std::make_shared<const react::RNSScreenProps>();
     _props = defaultProps;
     _reactSubviews = [NSMutableArray new];
+    _contentWrapper = nil;
     [self initCommonProps];
   }
   return self;
 }
-#endif // RCT_NEW_ARCH_ENABLED
-
+#else
 - (instancetype)initWithBridge:(RCTBridge *)bridge
 {
   if (self = [super init]) {
@@ -72,6 +104,7 @@ namespace react = facebook::react;
 
   return self;
 }
+#endif // RCT_NEW_ARCH_ENABLED
 
 - (void)initCommonProps
 {
@@ -86,9 +119,16 @@ namespace react = facebook::react;
   _hasStatusBarHiddenSet = NO;
   _hasOrientationSet = NO;
   _hasHomeIndicatorHiddenSet = NO;
+  _activityState = RNSActivityStateUndefined;
+  _fullScreenSwipeShadowEnabled = YES;
 #if !TARGET_OS_TV
   _sheetExpandsWhenScrolledToEdge = YES;
 #endif // !TARGET_OS_TV
+  _sheetsScrollView = nil;
+  _didSetSheetAllowedDetentsOnController = NO;
+#ifdef RCT_NEW_ARCH_ENABLED
+  _markedForUnmountInCurrentTransaction = NO;
+#endif // RCT_NEW_ARCH_ENABLED
 }
 
 - (UIViewController *)reactViewController
@@ -97,24 +137,73 @@ namespace react = facebook::react;
 }
 
 #ifdef RCT_NEW_ARCH_ENABLED
+RNS_IGNORE_SUPER_CALL_BEGIN
 - (NSArray<UIView *> *)reactSubviews
 {
   return _reactSubviews;
 }
+RNS_IGNORE_SUPER_CALL_END
 #endif
 
 - (void)updateBounds
 {
 #ifdef RCT_NEW_ARCH_ENABLED
   if (_state != nullptr) {
-    auto newState = react::RNSScreenState{RCTSizeFromCGSize(self.bounds.size)};
+    RNSScreenStackHeaderConfig *config = [self findHeaderConfig];
+    // in large title, ScrollView handles the offset of content so we cannot set it here also.
+    CGFloat headerHeight =
+        config.largeTitle ? 0 : [_controller calculateHeaderHeightIsModal:self.isPresentedAsNativeModal];
+    auto newState =
+        react::RNSScreenState{RCTSizeFromCGSize(self.bounds.size), RCTPointFromCGPoint(CGPointMake(0, headerHeight))};
     _state->updateState(std::move(newState));
     UINavigationController *navctr = _controller.navigationController;
     [navctr.view setNeedsLayout];
   }
 #else
   [_bridge.uiManager setSize:self.bounds.size forView:self];
-#endif
+#endif // RCT_NEW_ARCH_ENABLED
+
+  if (_stackPresentation != RNSScreenStackPresentationFormSheet) {
+    return;
+  }
+
+  // In case of formSheet stack presentation, to mitigate view flickering
+  // (see PR with description of this problem: https://github.com/software-mansion/react-native-screens/pull/1870)
+  // we do not set `bottom: 0` in JS for wrapper of the screen content, causing React to not set
+  // strict frame every time the sheet size is updated by the code above. This approach leads however to
+  // situation where (if present) scrollview does not know its view port size resulting in buggy behaviour.
+  // That's exactly the issue we are handling below. We look for a scroll view down the view hierarchy (only going
+  // through first subviews, as the OS does something similar e.g. when looking for scrollview for large header
+  // interaction) and we set its frame to the sheet size. **This is not perfect**, as the content might jump when items
+  // are added/removed to/from the scroll view, but it's the best we got rn. See
+  // https://github.com/software-mansion/react-native-screens/pull/1852
+
+  // TODO: Consider adding a prop to control whether we want to look for a scroll view here.
+  // It might be necessary in case someone doesn't want its scroll view to span over whole
+  // height of the sheet.
+  ReactScrollViewBase *scrollView = [self findDirectLineDescendantReactScrollView];
+  if (_sheetsScrollView != scrollView) {
+    [_sheetsScrollView removeObserver:self forKeyPath:@"bounds" context:nil];
+    _sheetsScrollView = scrollView;
+
+    // We pass 0 as options, as we are not interested in receiving updated bounds value,
+    // we are going to overwrite it anyway.
+    [scrollView addObserver:self forKeyPath:@"bounds" options:0 context:nil];
+  }
+  if (scrollView != nil) {
+    [scrollView setFrame:self.frame];
+  }
+}
+
+- (void)observeValueForKeyPath:(NSString *)keyPath
+                      ofObject:(id)object
+                        change:(NSDictionary<NSKeyValueChangeKey, id> *)change
+                       context:(void *)context
+{
+  UIView *scrollview = (UIView *)object;
+  if (!CGRectEqualToRect(scrollview.frame, self.frame)) {
+    [scrollview setFrame:self.frame];
+  }
 }
 
 - (void)setStackPresentation:(RNSScreenStackPresentation)stackPresentation
@@ -166,12 +255,10 @@ namespace react = facebook::react;
     _controller.presentationController.delegate = self;
   } else if (_stackPresentation != RNSScreenStackPresentationPush) {
 #ifdef RCT_NEW_ARCH_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
+#endif // RCT_NEW_ARCH_ENABLED
   }
   _stackPresentation = stackPresentation;
 }
@@ -194,6 +281,7 @@ namespace react = facebook::react;
     case RNSScreenStackAnimationSimplePush:
     case RNSScreenStackAnimationSlideFromBottom:
     case RNSScreenStackAnimationFadeFromBottom:
+    case RNSScreenStackAnimationSlideFromLeft:
       // Default
       break;
   }
@@ -224,12 +312,26 @@ namespace react = facebook::react;
 {
   int activityState = [activityStateOrNil intValue];
   if (activityStateOrNil != nil && activityState != -1 && activityState != _activityState) {
+    [self maybeAssertActivityStateProgressionOldValue:_activityState newValue:activityState];
     _activityState = activityState;
     [_reactSuperview markChildUpdated];
   }
 }
 
-#if !TARGET_OS_TV
+- (void)maybeAssertActivityStateProgressionOldValue:(int)oldValue newValue:(int)newValue
+{
+  if (self.isNativeStackScreen && newValue < oldValue) {
+    RCTLogError(@"[RNScreens] activityState can only progress in NativeStack");
+  }
+}
+
+/// Note that this method works only after the screen is actually mounted under a screen stack view.
+- (BOOL)isNativeStackScreen
+{
+  return [_reactSuperview isKindOfClass:RNSScreenStackView.class];
+}
+
+#if !TARGET_OS_TV && !TARGET_OS_VISION
 - (void)setStatusBarStyle:(RNSStatusBarStyle)statusBarStyle
 {
   _hasStatusBarStyleSet = YES;
@@ -251,6 +353,13 @@ namespace react = facebook::react;
   _statusBarHidden = statusBarHidden;
   [RNSScreenWindowTraits assertViewControllerBasedStatusBarAppearenceSet];
   [RNSScreenWindowTraits updateStatusBarAppearance];
+
+  // As the status bar could change its visibility, we need to calculate header
+  // height for the correct value in `onHeaderHeightChange` event when navigation
+  // bar is not visible.
+  if (self.controller.navigationController.navigationBarHidden && !self.isModal) {
+    [self.controller calculateAndNotifyHeaderHeightChangeIsModal:NO];
+  }
 }
 
 - (void)setScreenOrientation:(UIInterfaceOrientationMask)screenOrientation
@@ -268,13 +377,48 @@ namespace react = facebook::react;
 }
 #endif
 
+RNS_IGNORE_SUPER_CALL_BEGIN
 - (UIView *)reactSuperview
 {
   return _reactSuperview;
 }
+RNS_IGNORE_SUPER_CALL_END
+
+/// This is RNSScreenContentWrapperDelegate method, where we do get notified when React did update frame of our child.
+- (void)reactDidSetFrame:(CGRect)reactFrame forContentWrapper:(RNSScreenContentWrapper *)contentWrapepr
+{
+  if (self.stackPresentation != RNSScreenStackPresentationFormSheet || _didSetSheetAllowedDetentsOnController == YES) {
+    return;
+  }
+
+  _didSetSheetAllowedDetentsOnController = YES;
+
+#if !TARGET_OS_TV && !TARGET_OS_VISION && defined(__IPHONE_OS_VERSION_MAX_ALLOWED) && defined(__IPHONE_16_0) && \
+    __IPHONE_OS_VERSION_MAX_ALLOWED >= __IPHONE_16_0
+  if (@available(iOS 16.0, *)) {
+    UISheetPresentationController *sheetController = _controller.sheetPresentationController;
+    if (sheetController == nil) {
+      RCTLogError(@"[RNScreens] sheetPresentationController is null when attempting to set allowed detents");
+      return;
+    }
+
+    if (_sheetAllowedDetents.count > 0 && _sheetAllowedDetents[0].intValue == SHEET_FIT_TO_CONTENTS) {
+      auto detents = [self detentsFromMaxHeights:@[ [NSNumber numberWithFloat:reactFrame.size.height] ]];
+      [self setAllowedDetentsForSheet:sheetController to:detents animate:YES];
+    }
+  }
+#endif // Check for iOS >= 16 && !TARGET_OS_TV
+}
 
 - (void)addSubview:(UIView *)view
 {
+  /// This system method is called on Paper only. Fabric uses `-[insertSubview:atIndex:]`.
+  if ([view isKindOfClass:RNSScreenContentWrapper.class] &&
+      self.stackPresentation == RNSScreenStackPresentationFormSheet) {
+    auto contentWrapper = (RNSScreenContentWrapper *)view;
+    contentWrapper.delegate = self;
+  }
+
   if (![view isKindOfClass:[RNSScreenStackHeaderConfig class]]) {
     [super addSubview:view];
   } else {
@@ -286,7 +430,6 @@ namespace react = facebook::react;
 {
 #ifdef RCT_NEW_ARCH_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 react::RNSScreenEventEmitter>(_eventEmitter)
         ->onDismissed(react::RNSScreenEventEmitter::OnDismissed{.dismissCount = dismissCount});
@@ -308,7 +451,6 @@ namespace react = facebook::react;
 {
 #ifdef RCT_NEW_ARCH_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 react::RNSScreenEventEmitter>(_eventEmitter)
         ->onNativeDismissCancelled(
@@ -325,7 +467,6 @@ namespace react = facebook::react;
 {
 #ifdef RCT_NEW_ARCH_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 react::RNSScreenEventEmitter>(_eventEmitter)
         ->onWillAppear(react::RNSScreenEventEmitter::OnWillAppear{});
@@ -348,7 +489,6 @@ namespace react = facebook::react;
   }
 #ifdef RCT_NEW_ARCH_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 react::RNSScreenEventEmitter>(_eventEmitter)
         ->onWillDisappear(react::RNSScreenEventEmitter::OnWillDisappear{});
@@ -364,7 +504,6 @@ namespace react = facebook::react;
 {
 #ifdef RCT_NEW_ARCH_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 react::RNSScreenEventEmitter>(_eventEmitter)
         ->onAppear(react::RNSScreenEventEmitter::OnAppear{});
@@ -384,7 +523,6 @@ namespace react = facebook::react;
 {
 #ifdef RCT_NEW_ARCH_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 react::RNSScreenEventEmitter>(_eventEmitter)
         ->onDisappear(react::RNSScreenEventEmitter::OnDisappear{});
@@ -396,20 +534,38 @@ namespace react = facebook::react;
 #endif
 }
 
+- (void)notifySheetDetentChangeToIndex:(NSInteger)newDetentIndex isStable:(BOOL)isStable
+{
+#ifdef RCT_NEW_ARCH_ENABLED
+  if (_eventEmitter != nullptr) {
+    int index = newDetentIndex;
+    std::dynamic_pointer_cast<const react::RNSScreenEventEmitter>(_eventEmitter)
+        ->onSheetDetentChanged(
+            react::RNSScreenEventEmitter::OnSheetDetentChanged{.index = index, .isStable = isStable});
+  }
+#else
+  if (self.onSheetDetentChanged) {
+    self.onSheetDetentChanged(@{
+      @"index" : @(newDetentIndex),
+      @"isStable" : @(YES),
+    });
+  }
+#endif
+}
+
 - (void)notifyHeaderHeightChange:(double)headerHeight
 {
 #ifdef RCT_NEW_ARCH_ENABLED
   if (_eventEmitter != nullptr) {
-    std::dynamic_pointer_cast<const facebook::react::RNSScreenEventEmitter>(_eventEmitter)
-        ->onHeaderHeightChange(
-            facebook::react::RNSScreenEventEmitter::OnHeaderHeightChange{.headerHeight = headerHeight});
+    std::dynamic_pointer_cast<const react::RNSScreenEventEmitter>(_eventEmitter)
+        ->onHeaderHeightChange(react::RNSScreenEventEmitter::OnHeaderHeightChange{.headerHeight = headerHeight});
   }
 
   RNSHeaderHeightChangeEvent *event =
       [[RNSHeaderHeightChangeEvent alloc] initWithEventName:@"onHeaderHeightChange"
                                                    reactTag:[NSNumber numberWithInt:self.tag]
                                                headerHeight:headerHeight];
-  [[RCTBridge currentBridge].eventDispatcher sendEvent:event];
+  [self postNotificationForEventDispatcherObserversWithEvent:event];
 #else
   if (self.onHeaderHeightChange) {
     self.onHeaderHeightChange(@{
@@ -468,22 +624,13 @@ namespace react = facebook::react;
   }
 }
 
-#ifdef RCT_NEW_ARCH_ENABLED
-- (RCTSurfaceTouchHandler *)touchHandler
-#else
-- (RCTTouchHandler *)touchHandler
-#endif
+- (nullable RNS_TOUCH_HANDLER_ARCH_TYPE *)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;
+
+  return [self rnscreens_findTouchHandlerInAncestorChain];
 }
 
 - (void)notifyFinishTransitioning
@@ -504,7 +651,7 @@ namespace react = facebook::react;
                                                                    progress:progress
                                                                     closing:closing
                                                                goingForward:goingForward];
-  [[RCTBridge currentBridge].eventDispatcher sendEvent:event];
+  [self postNotificationForEventDispatcherObserversWithEvent:event];
 #else
   if (self.onTransitionProgress) {
     self.onTransitionProgress(@{
@@ -540,12 +687,24 @@ namespace react = facebook::react;
 - (BOOL)presentationControllerShouldDismiss:(UIPresentationController *)presentationController
 {
   if (_preventNativeDismiss) {
-    [self notifyDismissCancelledWithDismissCount:1];
     return NO;
   }
   return _gestureEnabled;
 }
 
+#if defined(__IPHONE_OS_VERSION_MAX_ALLOWED) && defined(__IPHONE_13_0) && \
+    __IPHONE_OS_VERSION_MAX_ALLOWED >= __IPHONE_13_0
+- (void)presentationControllerDidAttemptToDismiss:(UIPresentationController *)presentationController
+{
+  // NOTE(kkafar): We should consider depracating the use of gesture cancel here & align
+  // with usePreventRemove API of react-navigation v7.
+  [self notifyGestureCancel];
+  if (_preventNativeDismiss) {
+    [self notifyDismissCancelledWithDismissCount:1];
+  }
+}
+#endif
+
 - (void)presentationControllerDidDismiss:(UIPresentationController *)presentationController
 {
   if ([_reactSuperview respondsToSelector:@selector(presentationControllerDidDismiss:)]) {
@@ -553,13 +712,32 @@ namespace react = facebook::react;
   }
 }
 
-- (RNSScreenStackHeaderConfig *_Nullable)findHeaderConfig
+- (nullable RNSScreenStackHeaderConfig *)findHeaderConfig
 {
+  // Fast path
+  if ([self.reactSubviews.lastObject isKindOfClass:RNSScreenStackHeaderConfig.class]) {
+    return (RNSScreenStackHeaderConfig *)self.reactSubviews.lastObject;
+  }
+
   for (UIView *view in self.reactSubviews) {
     if ([view isKindOfClass:RNSScreenStackHeaderConfig.class]) {
       return (RNSScreenStackHeaderConfig *)view;
     }
   }
+
+  return nil;
+}
+
+/// Looks for RCTScrollView in direct line - goes through the subviews at index 0 down the view hierarchy.
+- (nullable ReactScrollViewBase *)findDirectLineDescendantReactScrollView
+{
+  UIView *firstSubview = self;
+  while (firstSubview.subviews.count > 0) {
+    firstSubview = firstSubview.subviews[0];
+    if ([firstSubview isKindOfClass:ReactScrollViewBase.class]) {
+      return (ReactScrollViewBase *)firstSubview;
+    }
+  }
   return nil;
 }
 
@@ -591,75 +769,361 @@ namespace react = facebook::react;
       self.controller.modalPresentationStyle == UIModalPresentationOverCurrentContext;
 }
 
-#if !TARGET_OS_TV
+- (void)invalidate
+{
+  _controller = nil;
+  [_sheetsScrollView removeObserver:self forKeyPath:@"bounds" context:nil];
+}
+
+#if !TARGET_OS_TV && !TARGET_OS_VISION
+
+- (void)setPropertyForSheet:(UISheetPresentationController *)sheet
+                  withBlock:(void (^)(void))block
+                    animate:(BOOL)animate API_AVAILABLE(ios(15.0))
+{
+  if (animate) {
+    [sheet animateChanges:block];
+  } else {
+    block();
+  }
+}
+
+- (void)setAllowedDetentsForSheet:(UISheetPresentationController *)sheet
+                               to:(NSArray<UISheetPresentationControllerDetent *> *)detents
+                          animate:(BOOL)animate API_AVAILABLE(ios(15.0))
+{
+  [self setPropertyForSheet:sheet
+                  withBlock:^{
+                    sheet.detents = detents;
+                  }
+                    animate:animate];
+}
+
+- (void)setSelectedDetentForSheet:(UISheetPresentationController *)sheet
+                               to:(UISheetPresentationControllerDetentIdentifier)detent
+                          animate:(BOOL)animate API_AVAILABLE(ios(15.0))
+{
+  if (sheet.selectedDetentIdentifier != detent) {
+    [self setPropertyForSheet:sheet
+                    withBlock:^{
+                      sheet.selectedDetentIdentifier = detent;
+                    }
+                      animate:animate];
+  }
+}
+
+- (void)setCornerRadiusForSheet:(UISheetPresentationController *)sheet
+                             to:(CGFloat)radius
+                        animate:(BOOL)animate API_AVAILABLE(ios(15.0))
+{
+  if (sheet.preferredCornerRadius != radius) {
+    [self setPropertyForSheet:sheet
+                    withBlock:^{
+                      sheet.preferredCornerRadius =
+                          radius < 0 ? UISheetPresentationControllerAutomaticDimension : radius;
+                    }
+                      animate:animate];
+  }
+}
+
+- (void)setGrabberVisibleForSheet:(UISheetPresentationController *)sheet
+                               to:(BOOL)visible
+                          animate:(BOOL)animate API_AVAILABLE(ios(15.0))
+{
+  if (sheet.prefersGrabberVisible != visible) {
+    [self setPropertyForSheet:sheet
+                    withBlock:^{
+                      sheet.prefersGrabberVisible = visible;
+                    }
+                      animate:animate];
+  }
+}
+
+- (void)setLargestUndimmedDetentForSheet:(UISheetPresentationController *)sheet
+                                      to:(UISheetPresentationControllerDetentIdentifier)detent
+                                 animate:(BOOL)animate API_AVAILABLE(ios(15.0))
+{
+  if (sheet.largestUndimmedDetentIdentifier != detent) {
+    [self setPropertyForSheet:sheet
+                    withBlock:^{
+                      sheet.largestUndimmedDetentIdentifier = detent;
+                    }
+                      animate:animate];
+  }
+}
+
+#if defined(__IPHONE_OS_VERSION_MAX_ALLOWED) && defined(__IPHONE_15_0) && \
+    __IPHONE_OS_VERSION_MAX_ALLOWED >= __IPHONE_15_0
+- (NSInteger)detentIndexFromDetentIdentifier:(UISheetPresentationControllerDetentIdentifier)identifier
+    API_AVAILABLE(ios(15.0))
+{
+  // We first check if we are running on iOS 16+ as the API is different
+#if defined(__IPHONE_OS_VERSION_MAX_ALLOWED) && defined(__IPHONE_16_0) && \
+    __IPHONE_OS_VERSION_MAX_ALLOWED >= __IPHONE_16_0
+  if (_sheetAllowedDetents.count > 0) {
+    // We should be running on custom detents in this case, thus identifier should be a stringified number.
+    return identifier.integerValue;
+  } else
+#endif // iOS 16 check
+  {
+    // We're using system defined identifiers.
+    if (_sheetAllowedDetents.count >= 2 || _sheetAllowedDetents.count == 0) {
+      if (identifier == UISheetPresentationControllerDetentIdentifierMedium) {
+        return 0;
+      } else if (identifier == UISheetPresentationControllerDetentIdentifierLarge) {
+        return 1;
+      } else {
+        RCTLogError(@"[RNScreens] Unexpected detent identifier %@", identifier);
+      }
+    } else {
+      // There is only single option.
+      return 0;
+    }
+  }
+  return 0;
+}
+
+- (void)sheetPresentationControllerDidChangeSelectedDetentIdentifier:
+    (UISheetPresentationController *)sheetPresentationController API_AVAILABLE(ios(15.0))
+{
+  UISheetPresentationControllerDetentIdentifier ident = sheetPresentationController.selectedDetentIdentifier;
+  [self notifySheetDetentChangeToIndex:[self detentIndexFromDetentIdentifier:ident] isStable:YES];
+}
+#endif // iOS 15 check
+
 /**
  * Updates settings for sheet presentation controller.
  * Note that this method should not be called inside `stackPresentation` setter, because on Paper we don't have
- * guarantee that values of all related props had been updated earlier.
+ * guarantee that values of all related props had been updated earlier. It should be invoked from `didSetProps`.
+ * On Fabric we have control over prop-setting process but it might be reasonable to run it from `finalizeUpdates`.
  */
-- (void)updatePresentationStyle
+- (void)updateFormSheetPresentationStyle
 {
+  if (_stackPresentation != RNSScreenStackPresentationFormSheet) {
+    return;
+  }
 #if defined(__IPHONE_OS_VERSION_MAX_ALLOWED) && defined(__IPHONE_15_0) && \
     __IPHONE_OS_VERSION_MAX_ALLOWED >= __IPHONE_15_0
+  int firstDimmedDetentIndex = _sheetAllowedDetents.count;
+
+  // Whether we use system (iOS 15) detents or custom (iOS 16+).
+  // Custom detents are in use if we are on iOS 16+ and we have at least single detent
+  // defined in the detents array. In any other case we do use system defined detents.
+  bool systemDetentsInUse = false;
+
   if (@available(iOS 15.0, *)) {
     UISheetPresentationController *sheet = _controller.sheetPresentationController;
-    if (_stackPresentation == RNSScreenStackPresentationFormSheet && sheet != nil) {
-      sheet.prefersScrollingExpandsWhenScrolledToEdge = _sheetExpandsWhenScrolledToEdge;
-      sheet.prefersGrabberVisible = _sheetGrabberVisible;
-      sheet.preferredCornerRadius =
-          _sheetCornerRadius < 0 ? UISheetPresentationControllerAutomaticDimension : _sheetCornerRadius;
-
-      if (_sheetLargestUndimmedDetent == RNSScreenDetentTypeMedium) {
-        sheet.largestUndimmedDetentIdentifier = UISheetPresentationControllerDetentIdentifierMedium;
-      } else if (_sheetLargestUndimmedDetent == RNSScreenDetentTypeLarge) {
-        sheet.largestUndimmedDetentIdentifier = UISheetPresentationControllerDetentIdentifierLarge;
-      } else if (_sheetLargestUndimmedDetent == RNSScreenDetentTypeAll) {
-        sheet.largestUndimmedDetentIdentifier = nil;
+    if (sheet == nil) {
+      return;
+    }
+    sheet.delegate = self;
+#if defined(__IPHONE_OS_VERSION_MAX_ALLOWED) && defined(__IPHONE_16_0) && \
+    __IPHONE_OS_VERSION_MAX_ALLOWED >= __IPHONE_16_0
+    if (@available(iOS 16.0, *)) {
+      if (_sheetAllowedDetents.count > 0) {
+        if (_sheetAllowedDetents.count == 1 && [_sheetAllowedDetents[0] integerValue] == SHEET_FIT_TO_CONTENTS) {
+          // This is `fitToContents` case, where sheet should be just high to display its contents.
+          // Paper: we do not set anything here, we will set once React computed layout of our React's children, namely
+          // RNSScreenContentWrapper, which in case of formSheet presentation style does have exactly the same frame as
+          // actual content. The update will be triggered once our child is mounted and laid out by React.
+          // Fabric: in this very moment our children are already mounted & laid out. In the very end of this method,
+          // after all other configuration is applied we trigger content wrapper to send us update on its frame.
+        } else {
+          [self setAllowedDetentsForSheet:sheet
+                                       to:[self detentsFromMaxHeightFractions:_sheetAllowedDetents]
+                                  animate:NO];
+        }
+      }
+    } else
+#endif // Check for iOS >= 16
+    {
+      systemDetentsInUse = true;
+      if (_sheetAllowedDetents.count == 0) {
+        [self setAllowedDetentsForSheet:sheet
+                                     to:@[
+                                       UISheetPresentationControllerDetent.mediumDetent,
+                                       UISheetPresentationControllerDetent.largeDetent
+                                     ]
+                                animate:YES];
+      } else if (_sheetAllowedDetents.count >= 2) {
+        float firstDetentFraction = _sheetAllowedDetents[0].floatValue;
+        float secondDetentFraction = _sheetAllowedDetents[1].floatValue;
+        firstDimmedDetentIndex = 2;
+
+        if (firstDetentFraction < secondDetentFraction) {
+          [self setAllowedDetentsForSheet:sheet
+                                       to:@[
+                                         UISheetPresentationControllerDetent.mediumDetent,
+                                         UISheetPresentationControllerDetent.largeDetent
+                                       ]
+                                  animate:YES];
+        } else {
+          RCTLogError(@"[RNScreens] The values in sheetAllowedDetents array must be sorted");
+        }
       } else {
-        RCTLogError(@"Unhandled value of sheetLargestUndimmedDetent passed");
+        float firstDetentFraction = _sheetAllowedDetents[0].floatValue;
+        if (firstDetentFraction == SHEET_FIT_TO_CONTENTS) {
+          RCTLogError(@"[RNScreens] Unsupported on iOS versions below 16");
+        } else if (firstDetentFraction < 1.0) {
+          [self setAllowedDetentsForSheet:sheet to:@[ UISheetPresentationControllerDetent.mediumDetent ] animate:YES];
+          [self setSelectedDetentForSheet:sheet to:UISheetPresentationControllerDetentIdentifierMedium animate:YES];
+        } else {
+          [self setAllowedDetentsForSheet:sheet to:@[ UISheetPresentationControllerDetent.largeDetent ] animate:YES];
+          [self setSelectedDetentForSheet:sheet to:UISheetPresentationControllerDetentIdentifierLarge animate:YES];
+        }
       }
+    }
 
-      if (_sheetAllowedDetents == RNSScreenDetentTypeMedium) {
-        sheet.detents = @[ UISheetPresentationControllerDetent.mediumDetent ];
-        if (sheet.selectedDetentIdentifier != UISheetPresentationControllerDetentIdentifierMedium) {
-          [sheet animateChanges:^{
-            sheet.selectedDetentIdentifier = UISheetPresentationControllerDetentIdentifierMedium;
-          }];
+    if (_sheetInitialDetent > 0 && _sheetInitialDetent < _sheetAllowedDetents.count) {
+#if defined(__IPHONE_OS_VERSION_MAX_ALLOWED) && defined(__IPHONE_16_0) && \
+    __IPHONE_OS_VERSION_MAX_ALLOWED >= __IPHONE_16_0
+      if (@available(iOS 16.0, *)) {
+        UISheetPresentationControllerDetent *detent = sheet.detents[_sheetInitialDetent];
+        [self setSelectedDetentForSheet:sheet to:detent.identifier animate:YES];
+      } else
+#endif // Check for iOS >= 16
+      {
+        if (_sheetInitialDetent < 2) {
+          [self setSelectedDetentForSheet:sheet to:UISheetPresentationControllerDetentIdentifierLarge animate:YES];
+        } else {
+          RCTLogError(
+              @"[RNScreens] sheetInitialDetent out of bounds, on iOS versions below 16 sheetAllowedDetents is ignored in favor of an array of two system-defined detents");
         }
-      } else if (_sheetAllowedDetents == RNSScreenDetentTypeLarge) {
-        sheet.detents = @[ UISheetPresentationControllerDetent.largeDetent ];
-        if (sheet.selectedDetentIdentifier != UISheetPresentationControllerDetentIdentifierLarge) {
-          [sheet animateChanges:^{
-            sheet.selectedDetentIdentifier = UISheetPresentationControllerDetentIdentifierLarge;
-          }];
+      }
+    } else if (_sheetInitialDetent != 0) {
+      RCTLogError(@"[RNScreens] sheetInitialDetent out of bounds for sheetAllowedDetents array");
+    }
+
+    sheet.prefersScrollingExpandsWhenScrolledToEdge = _sheetExpandsWhenScrolledToEdge;
+    [self setGrabberVisibleForSheet:sheet to:_sheetGrabberVisible animate:YES];
+    [self setCornerRadiusForSheet:sheet to:_sheetCornerRadius animate:YES];
+
+    // lud - largest undimmed detent
+    // First we try to take value from the prop or default.
+    int ludIndex = _sheetLargestUndimmedDetent != nil ? _sheetLargestUndimmedDetent.intValue : -1;
+    // Rationalize the value in case the user set something that did not make sense.
+    ludIndex = ludIndex >= firstDimmedDetentIndex ? firstDimmedDetentIndex - 1 : ludIndex;
+    if (ludIndex == SHEET_LARGEST_UNDIMMED_DETENT_NONE) {
+      [self setLargestUndimmedDetentForSheet:sheet to:nil animate:YES];
+    } else if (ludIndex >= 0) {
+      if (systemDetentsInUse) {
+        // We're on iOS 15 or do not have custom detents specified by the user.
+        if (firstDimmedDetentIndex == 0 || (firstDimmedDetentIndex == 1 && _sheetAllowedDetents[0].floatValue < 1.0)) {
+          // There are no detents specified or there is exactly one & it is less than 1.0 we default to medium.
+          [self setLargestUndimmedDetentForSheet:sheet
+                                              to:UISheetPresentationControllerDetentIdentifierMedium
+                                         animate:YES];
+        } else {
+          [self setLargestUndimmedDetentForSheet:sheet
+                                              to:UISheetPresentationControllerDetentIdentifierLarge
+                                         animate:YES];
         }
-      } else if (_sheetAllowedDetents == RNSScreenDetentTypeAll) {
-        sheet.detents =
-            @[ UISheetPresentationControllerDetent.mediumDetent, UISheetPresentationControllerDetent.largeDetent ];
       } else {
-        RCTLogError(@"Unhandled value of sheetAllowedDetents passed");
+        // We're on iOS 16+ & have custom detents.
+        [self setLargestUndimmedDetentForSheet:sheet to:[NSNumber numberWithInt:ludIndex].stringValue animate:YES];
       }
+    } else {
+      RCTLogError(@"[RNScreens] Value of sheetLargestUndimmedDetent prop must be >= -1");
     }
   }
-#endif // Check for max allowed iOS version
+
+#ifdef RCT_NEW_ARCH_ENABLED
+  // We trigger update from content wrapper, because on Fabric we update props after the children are mounted & laid
+  // out.
+  [self->_contentWrapper triggerDelegateUpdate];
+#endif // RCT_NEW_ARCH_ENABLED
+#endif // Check for iOS >= 15
 }
-#endif // !TARGET_OS_TV
+
+#if defined(__IPHONE_OS_VERSION_MAX_ALLOWED) && defined(__IPHONE_16_0) && \
+    __IPHONE_OS_VERSION_MAX_ALLOWED >= __IPHONE_16_0
+
+/**
+ * Creates array of detent objects based on provided `values` & `resolver`. Since we need to name the detents to be able
+ * to later refer to them, this method names the detents by stringifying their indices, e.g. detent on index 2 will be
+ * named "2".
+ */
+- (NSArray<UISheetPresentationControllerDetent *> *)
+    detentsFromValues:(NSArray<NSNumber *> *)values
+         withResolver:(CGFloat (^)(id<UISheetPresentationControllerDetentResolutionContext>, NSNumber *))resolver
+    API_AVAILABLE(ios(16.0))
+{
+  NSMutableArray<UISheetPresentationControllerDetent *> *customDetents =
+      [NSMutableArray arrayWithCapacity:values.count];
+  [values enumerateObjectsUsingBlock:^(NSNumber *value, NSUInteger index, BOOL *stop) {
+    UISheetPresentationControllerDetentIdentifier ident = [[NSNumber numberWithInt:index] stringValue];
+    [customDetents addObject:[UISheetPresentationControllerDetent
+                                 customDetentWithIdentifier:ident
+                                                   resolver:^CGFloat(
+                                                       id<UISheetPresentationControllerDetentResolutionContext> ctx) {
+                                                     return resolver(ctx, value);
+                                                   }]];
+  }];
+  return customDetents;
+}
+
+- (NSArray<UISheetPresentationControllerDetent *> *)detentsFromMaxHeightFractions:(NSArray<NSNumber *> *)fractions
+    API_AVAILABLE(ios(16.0))
+{
+  return [self
+      detentsFromValues:fractions
+           withResolver:^CGFloat(id<UISheetPresentationControllerDetentResolutionContext> ctx, NSNumber *fraction) {
+             return MIN(ctx.maximumDetentValue, ctx.maximumDetentValue * fraction.floatValue);
+           }];
+}
+
+- (NSArray<UISheetPresentationControllerDetent *> *)detentsFromMaxHeights:(NSArray<NSNumber *> *)maxHeights
+    API_AVAILABLE(ios(16.0))
+{
+  return
+      [self detentsFromValues:maxHeights
+                 withResolver:^CGFloat(id<UISheetPresentationControllerDetentResolutionContext> ctx, NSNumber *height) {
+                   return MIN(ctx.maximumDetentValue, height.floatValue);
+                 }];
+}
+
+#endif // Check for iOS >= 16
+
+#endif // !TARGET_OS_TV && !TARGET_OS_VISION
 
 #pragma mark - Fabric specific
 #ifdef RCT_NEW_ARCH_ENABLED
 
+- (void)postNotificationForEventDispatcherObserversWithEvent:(NSObject<RCTEvent> *)event
+{
+  NSDictionary *userInfo = [NSDictionary dictionaryWithObjectsAndKeys:event, @"event", nil];
+  [[NSNotificationCenter defaultCenter] postNotificationName:@"RCTNotifyEventDispatcherObserversOfEvent_DEPRECATED"
+                                                      object:nil
+                                                    userInfo:userInfo];
+}
+
 - (BOOL)hasHeaderConfig
 {
   return _config != nil;
 }
 
+- (void)willBeUnmountedInUpcomingTransaction
+{
+  _markedForUnmountInCurrentTransaction = YES;
+}
+
 + (react::ComponentDescriptorProvider)componentDescriptorProvider
 {
   return react::concreteComponentDescriptorProvider<react::RNSScreenComponentDescriptor>();
 }
 
++ (BOOL)shouldBeRecycled
+{
+  return NO;
+}
+
 - (void)mountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView index:(NSInteger)index
 {
+  if ([childComponentView isKindOfClass:RNSScreenContentWrapper.class]) {
+    auto contentWrapper = (RNSScreenContentWrapper *)childComponentView;
+    contentWrapper.delegate = self;
+    _contentWrapper = contentWrapper;
+  }
   if ([childComponentView isKindOfClass:[RNSScreenStackHeaderConfig class]]) {
     _config = (RNSScreenStackHeaderConfig *)childComponentView;
     _config.screenView = self;
@@ -673,33 +1137,16 @@ namespace react = facebook::react;
   if ([childComponentView isKindOfClass:[RNSScreenStackHeaderConfig class]]) {
     _config = nil;
   }
+  if ([childComponentView isKindOfClass:[RNSScreenContentWrapper class]]) {
+    _contentWrapper.delegate = nil;
+    _contentWrapper = nil;
+  }
   [_reactSubviews removeObject:childComponentView];
   [super unmountChildComponentView:childComponentView index:index];
 }
 
 #pragma mark - RCTComponentViewProtocol
 
-- (void)prepareForRecycle
-{
-  [super prepareForRecycle];
-  // TODO: Make sure that there is no edge case when this should be uncommented
-  // _controller=nil;
-  _dismissed = NO;
-  _state.reset();
-  _touchHandler = nil;
-
-  // We set this prop to default value here to workaround view-recycling.
-  // Let's assume the view has had _stackPresentation == <some modal stack presentation> set
-  // before below line was executed. Then, when instantiated again (with the same modal presentation)
-  // updateProps:oldProps: method would be called and setter for stack presentation would not be called.
-  // This is crucial as in that setter we register `self.controller` as a delegate
-  // (UIAdaptivePresentationControllerDelegate) to presentation controller and this leads to buggy modal behaviour as we
-  // rely on UIAdaptivePresentationControllerDelegate callbacks. Restoring the default value and then comparing against
-  // it in updateProps:oldProps: allows for setter to be called, however if there was some additional logic to execute
-  // when stackPresentation is set to "push" the setter would not be triggered.
-  _stackPresentation = RNSScreenStackPresentationPush;
-}
-
 - (void)updateProps:(react::Props::Shared const &)props oldProps:(react::Props::Shared const &)oldProps
 {
   const auto &oldScreenProps = *std::static_pointer_cast<const react::RNSScreenProps>(_props);
@@ -707,6 +1154,8 @@ namespace react = facebook::react;
 
   [self setFullScreenSwipeEnabled:newScreenProps.fullScreenSwipeEnabled];
 
+  [self setFullScreenSwipeShadowEnabled:newScreenProps.fullScreenSwipeShadowEnabled];
+
   [self setGestureEnabled:newScreenProps.gestureEnabled];
 
   [self setTransitionDuration:[NSNumber numberWithInt:newScreenProps.transitionDuration]];
@@ -754,21 +1203,21 @@ namespace react = facebook::react;
   [self setSheetExpandsWhenScrolledToEdge:newScreenProps.sheetExpandsWhenScrolledToEdge];
 
   if (newScreenProps.sheetAllowedDetents != oldScreenProps.sheetAllowedDetents) {
-    [self setSheetAllowedDetents:[RNSConvert RNSScreenDetentTypeFromAllowedDetents:newScreenProps.sheetAllowedDetents]];
+    [self setSheetAllowedDetents:[RNSConvert detentFractionsArrayFromVector:newScreenProps.sheetAllowedDetents]];
+  }
+
+  if (newScreenProps.sheetInitialDetent != oldScreenProps.sheetInitialDetent) {
+    [self setSheetInitialDetent:newScreenProps.sheetInitialDetent];
   }
 
   if (newScreenProps.sheetLargestUndimmedDetent != oldScreenProps.sheetLargestUndimmedDetent) {
-    [self setSheetLargestUndimmedDetent:
-              [RNSConvert RNSScreenDetentTypeFromLargestUndimmedDetent:newScreenProps.sheetLargestUndimmedDetent]];
+    [self setSheetLargestUndimmedDetent:[NSNumber numberWithInt:newScreenProps.sheetLargestUndimmedDetent]];
   }
 #endif // !TARGET_OS_TV
 
-  // Notice that we compare against _stackPresentation, not oldScreenProps.stackPresentation.
-  // See comment in prepareForRecycle method for explanation.
-  RNSScreenStackPresentation newStackPresentation =
-      [RNSConvert RNSScreenStackPresentationFromCppEquivalent:newScreenProps.stackPresentation];
-  if (newStackPresentation != _stackPresentation) {
-    [self setStackPresentation:newStackPresentation];
+  if (newScreenProps.stackPresentation != oldScreenProps.stackPresentation) {
+    [self
+        setStackPresentation:[RNSConvert RNSScreenStackPresentationFromCppEquivalent:newScreenProps.stackPresentation]];
   }
 
   if (newScreenProps.stackAnimation != oldScreenProps.stackAnimation) {
@@ -793,7 +1242,7 @@ namespace react = facebook::react;
   _newLayoutMetrics = layoutMetrics;
   _oldLayoutMetrics = oldLayoutMetrics;
   UIViewController *parentVC = self.reactViewController.parentViewController;
-  if (parentVC != nil && ![parentVC isKindOfClass:[RNSNavigationController class]]) {
+  if (parentVC == nil || ![parentVC isKindOfClass:[RNSNavigationController class]]) {
     [super updateLayoutMetrics:layoutMetrics oldLayoutMetrics:oldLayoutMetrics];
   }
   // when screen is mounted under RNSNavigationController it's size is controller
@@ -808,8 +1257,8 @@ namespace react = facebook::react;
 - (void)finalizeUpdates:(RNComponentViewUpdateMask)updateMask
 {
   [super finalizeUpdates:updateMask];
-#if !TARGET_OS_TV
-  [self updatePresentationStyle];
+#if !TARGET_OS_TV && !TARGET_OS_VISION
+  [self updateFormSheetPresentationStyle];
 #endif // !TARGET_OS_TV
 }
 
@@ -819,8 +1268,10 @@ namespace react = facebook::react;
 - (void)didSetProps:(NSArray<NSString *> *)changedProps
 {
   [super didSetProps:changedProps];
-#if !TARGET_OS_TV
-  [self updatePresentationStyle];
+#if !TARGET_OS_TV && !TARGET_OS_VISION
+  if (self.stackPresentation == RNSScreenStackPresentationFormSheet) {
+    [self updateFormSheetPresentationStyle];
+  }
 #endif // !TARGET_OS_TV
 }
 
@@ -845,10 +1296,6 @@ namespace react = facebook::react;
   // subviews
 }
 
-- (void)invalidate
-{
-  _controller = nil;
-}
 #endif
 
 @end
@@ -975,9 +1422,6 @@ Class<RCTComponentViewProtocol> RNSScreenCls(void)
 - (void)viewDidDisappear:(BOOL)animated
 {
   [super viewDidDisappear:animated];
-#ifdef RCT_NEW_ARCH_ENABLED
-  [self resetViewToScreen];
-#endif
   if (self.parentViewController == nil && self.presentingViewController == nil) {
     if (self.screenView.preventNativeDismiss) {
       // if we want to prevent the native dismiss, we do not send dismissal event,
@@ -1031,6 +1475,12 @@ Class<RCTComponentViewProtocol> RNSScreenCls(void)
   }
 }
 
+- (BOOL)isModalWithHeader
+{
+  return self.screenView.isModal && self.childViewControllers.count == 1 &&
+      [self.childViewControllers[0] isKindOfClass:UINavigationController.class];
+}
+
 // Checks whether this screen has any child view controllers of type RNSNavigationController.
 // Useful for checking if this screen has nested stack or is displayed at the top.
 - (BOOL)hasNestedStack
@@ -1044,33 +1494,9 @@ Class<RCTComponentViewProtocol> RNSScreenCls(void)
   return NO;
 }
 
-- (CGFloat)getCalculatedHeaderHeightIsModal:(BOOL)isModal
+- (CGSize)getStatusBarHeightIsModal:(BOOL)isModal
 {
-  CGFloat navbarHeight = self.navigationController.navigationBar.frame.size.height;
-
-  // In case where screen is a modal, we want to calculate just its childViewController's height
-  if (isModal && self.childViewControllers.count > 0 &&
-      [self.childViewControllers[0] isKindOfClass:UINavigationController.class]) {
-    UINavigationController *childNavCtr = self.childViewControllers[0];
-    navbarHeight = childNavCtr.navigationBar.frame.size.height;
-  }
-
-  return navbarHeight;
-}
-
-- (CGSize)getCalculatedStatusBarHeightIsModal:(BOOL)isModal
-{
-#if !TARGET_OS_TV
-  BOOL isDraggableModal = isModal && ![self.screenView isFullscreenModal];
-  BOOL isDraggableModalWithChildViewCtr =
-      isDraggableModal && self.childViewControllers.count > 0 && self.childViewControllers[0] != nil;
-
-  // When modal is floating (we can grab its header), we don't want to calculate status bar in it.
-  // Thus, we return '0' as a height of status bar.
-  if (isDraggableModalWithChildViewCtr || self.screenView.isTransparentModal) {
-    return CGSizeMake(0, 0);
-  }
-
+#if !TARGET_OS_TV && !TARGET_OS_VISION
   CGSize fallbackStatusBarSize = [[UIApplication sharedApplication] statusBarFrame].size;
 
 #if defined(__IPHONE_OS_VERSION_MAX_ALLOWED) && defined(__IPHONE_13_0) && \
@@ -1087,21 +1513,51 @@ Class<RCTComponentViewProtocol> RNSScreenCls(void)
 #endif /* Check for iOS 13.0 */
 
 #else
-  // On TVOS, status bar doesn't exist
+  // TVOS does not have status bar.
   return CGSizeMake(0, 0);
 #endif // !TARGET_OS_TV
 }
 
+- (UINavigationController *)getVisibleNavigationControllerIsModal:(BOOL)isModal
+{
+  UINavigationController *navctr = self.navigationController;
+
+  if (isModal) {
+    // In case where screen is a modal, we want to calculate childViewController's
+    // navigation bar height instead of the navigation controller from RNSScreen.
+    if (self.isModalWithHeader) {
+      navctr = self.childViewControllers[0];
+    } else {
+      // If the modal does not meet requirements (there's no RNSNavigationController which means that probably it
+      // doesn't have header or there are more than one RNSNavigationController which is invalid) we don't want to
+      // return anything.
+      return nil;
+    }
+  }
+
+  return navctr;
+}
+
 - (CGFloat)calculateHeaderHeightIsModal:(BOOL)isModal
 {
-  CGFloat navbarHeight = [self getCalculatedHeaderHeightIsModal:isModal];
-  CGSize statusBarSize = [self getCalculatedStatusBarHeightIsModal:isModal];
+  UINavigationController *navctr = [self getVisibleNavigationControllerIsModal:isModal];
+
+  // If there's no navigation controller for the modal (or the navigation bar is hidden), we simply don't want to
+  // return header height, as modal possibly does not have header when navigation controller is nil,
+  // and we don't want to count status bar if navigation bar is hidden (inset could be negative).
+  if (navctr == nil || navctr.isNavigationBarHidden) {
+    return 0;
+  }
+
+  CGFloat navbarHeight = navctr.navigationBar.frame.size.height;
+#if !TARGET_OS_TV
+  CGFloat navbarInset = navctr.navigationBar.frame.origin.y;
+#else
+  // On TVOS there's no inset of navigation bar.
+  CGFloat navbarInset = 0;
+#endif // !TARGET_OS_TV
 
-  // Unfortunately, UIKit doesn't care about switching width and height options on screen rotation.
-  // We should check if user has rotated its screen, so we're choosing the minimum value between the
-  // width and height.
-  CGFloat statusBarHeight = MIN(statusBarSize.width, statusBarSize.height);
-  return navbarHeight + statusBarHeight;
+  return navbarHeight + navbarInset;
 }
 
 - (void)calculateAndNotifyHeaderHeightChangeIsModal:(BOOL)isModal
@@ -1195,15 +1651,28 @@ Class<RCTComponentViewProtocol> RNSScreenCls(void)
   UIViewController *lastViewController = [[self childViewControllers] lastObject];
   if ([self.presentedViewController isKindOfClass:[RNSScreen class]]) {
     lastViewController = self.presentedViewController;
+
+    if (!includingModals) {
+      return nil;
+    }
+
     // 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 *modalOrChild = [(RNSScreen *)lastViewController findChildVCForConfigAndTrait:trait
+                                                                                   includingModals:includingModals];
+    if (modalOrChild != nil) {
+      return modalOrChild;
+    }
+
+    // if searched VC was not found, we don't want to search for configs of child VCs any longer,
+    // and we don't want to rely on lastViewController.
+    // That's because the modal did not find a child VC that has an orientation set,
+    // and it doesn't itself have an orientation set. Hence, we fallback to the standard behavior.
+    // Please keep in mind that this behavior might be wrong and could lead to undiscovered bugs.
+    // For more information, see https://github.com/software-mansion/react-native-screens/pull/2008.
   }
 
   UIViewController *selfOrNil = [self hasTraitSet:trait] ? self : nil;
@@ -1366,26 +1835,15 @@ Class<RCTComponentViewProtocol> RNSScreenCls(void)
 #ifdef RCT_NEW_ARCH_ENABLED
 #pragma mark - Fabric specific
 
-- (void)setViewToSnapshot:(UIView *)snapshot
+- (void)setViewToSnapshot
 {
-  // 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;
+  UIView *superView = self.view.superview;
+  // if we dismissed the view natively, it will already be detached from view hierarchy
+  if (self.view.window != nil) {
+    UIView *snapshot = [self.view snapshotViewAfterScreenUpdates:NO];
     [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;
+    [superView addSubview:snapshot];
   }
 }
 
@@ -1398,6 +1856,15 @@ Class<RCTComponentViewProtocol> RNSScreenCls(void)
     // we don't want to send `scrollViewDidEndDecelerating` event to JS before the JS thread is ready
     return;
   }
+
+  if ([NSStringFromClass([view class]) isEqualToString:@"AVPlayerView"]) {
+    // Traversing through AVPlayerView is an uncommon edge case that causes the disappearing screen
+    // to an excessive traversal through all video player elements
+    // (e.g., for react-native-video, this includes all controls and additional video views).
+    // Thus, we want to avoid unnecessary traversals through these views.
+    return;
+  }
+
   if ([view isKindOfClass:[UIScrollView class]] &&
       ([[(UIScrollView *)view delegate] respondsToSelector:@selector(scrollViewDidEndDecelerating:)])) {
     [[(UIScrollView *)view delegate] scrollViewDidEndDecelerating:(id)view];
@@ -1418,6 +1885,7 @@ RCT_EXPORT_MODULE()
 RCT_REMAP_VIEW_PROPERTY(activityState, activityStateOrNil, NSNumber)
 RCT_EXPORT_VIEW_PROPERTY(customAnimationOnSwipe, BOOL);
 RCT_EXPORT_VIEW_PROPERTY(fullScreenSwipeEnabled, BOOL);
+RCT_EXPORT_VIEW_PROPERTY(fullScreenSwipeShadowEnabled, BOOL);
 RCT_EXPORT_VIEW_PROPERTY(gestureEnabled, BOOL)
 RCT_EXPORT_VIEW_PROPERTY(gestureResponseDistance, NSDictionary)
 RCT_EXPORT_VIEW_PROPERTY(hideKeyboardOnSwipe, BOOL)
@@ -1437,6 +1905,7 @@ RCT_EXPORT_VIEW_PROPERTY(onTransitionProgress, RCTDirectEventBlock);
 RCT_EXPORT_VIEW_PROPERTY(onWillAppear, RCTDirectEventBlock);
 RCT_EXPORT_VIEW_PROPERTY(onWillDisappear, RCTDirectEventBlock);
 RCT_EXPORT_VIEW_PROPERTY(onGestureCancel, RCTDirectEventBlock);
+RCT_EXPORT_VIEW_PROPERTY(onSheetDetentChanged, RCTDirectEventBlock);
 
 #if !TARGET_OS_TV
 RCT_EXPORT_VIEW_PROPERTY(screenOrientation, UIInterfaceOrientationMask)
@@ -1445,14 +1914,15 @@ RCT_EXPORT_VIEW_PROPERTY(statusBarHidden, BOOL)
 RCT_EXPORT_VIEW_PROPERTY(statusBarStyle, RNSStatusBarStyle)
 RCT_EXPORT_VIEW_PROPERTY(homeIndicatorHidden, BOOL)
 
-RCT_EXPORT_VIEW_PROPERTY(sheetAllowedDetents, RNSScreenDetentType);
-RCT_EXPORT_VIEW_PROPERTY(sheetLargestUndimmedDetent, RNSScreenDetentType);
+RCT_EXPORT_VIEW_PROPERTY(sheetAllowedDetents, NSArray<NSNumber *> *);
+RCT_EXPORT_VIEW_PROPERTY(sheetLargestUndimmedDetent, NSNumber *);
 RCT_EXPORT_VIEW_PROPERTY(sheetGrabberVisible, BOOL);
 RCT_EXPORT_VIEW_PROPERTY(sheetCornerRadius, CGFloat);
+RCT_EXPORT_VIEW_PROPERTY(sheetInitialDetent, NSInteger);
 RCT_EXPORT_VIEW_PROPERTY(sheetExpandsWhenScrolledToEdge, BOOL);
 #endif
 
-#if !TARGET_OS_TV
+#if !TARGET_OS_TV && !TARGET_OS_VISION
 // See:
 // 1. https://github.com/software-mansion/react-native-screens/pull/1543
 // 2. https://github.com/software-mansion/react-native-screens/pull/1596
@@ -1475,10 +1945,13 @@ RCT_EXPORT_VIEW_PROPERTY(sheetExpandsWhenScrolledToEdge, BOOL);
 }
 #endif // !TARGET_OS_TV
 
+#ifdef RCT_NEW_ARCH_ENABLED
+#else
 - (UIView *)view
 {
   return [[RNSScreenView alloc] initWithBridge:self.bridge];
 }
+#endif
 
 + (BOOL)requiresMainQueueSetup
 {
@@ -1517,7 +1990,9 @@ RCT_ENUM_CONVERTER(
       @"simple_push" : @(RNSScreenStackAnimationSimplePush),
       @"slide_from_bottom" : @(RNSScreenStackAnimationSlideFromBottom),
       @"slide_from_right" : @(RNSScreenStackAnimationDefault),
-      @"slide_from_left" : @(RNSScreenStackAnimationDefault),
+      @"slide_from_left" : @(RNSScreenStackAnimationSlideFromLeft),
+      @"ios_from_right" : @(RNSScreenStackAnimationDefault),
+      @"ios_from_left" : @(RNSScreenStackAnimationSlideFromLeft),
     }),
     RNSScreenStackAnimationDefault,
     integerValue)
@@ -1597,3 +2072,7 @@ RCT_ENUM_CONVERTER(
 #endif
 
 @end
+
+// So that the define-macro is not leaked out of this file.
+// This one is defined in very top of the file depending on RN architecture.
+#undef ReactScrollViewBase