react-native-screens 4.0.0-beta.9 → 4.0.0

package/android/src/main/jni/CMakeLists.txt

@@ -38,25 +38,34 @@ target_include_directories(
   ${LIB_ANDROID_GENERATED_COMPONENTS_DIR}
 )
 
-target_link_libraries(
-  ${LIB_TARGET_NAME}
-  fbjni
-  folly_runtime
-  glog
-  jsi
-  react_codegen_rncore
-  react_debug
-  react_nativemodule_core
-  react_render_core
-  react_render_debug
-  react_render_graphics
-  react_render_mapbuffer
-  react_render_componentregistry
-  react_utils
-  rrc_view
-  turbomodulejsijni
-  yoga
-)
+if(ReactAndroid_VERSION_MINOR GREATER_EQUAL 76)
+  target_link_libraries(
+    ${LIB_TARGET_NAME}
+    ReactAndroid::reactnative
+    ReactAndroid::jsi
+    fbjni::fbjni
+  )
+else()
+  target_link_libraries(
+    ${LIB_TARGET_NAME}
+    fbjni
+    folly_runtime
+    glog
+    jsi
+    react_codegen_rncore
+    react_debug
+    react_nativemodule_core
+    react_render_core
+    react_render_debug
+    react_render_graphics
+    react_render_mapbuffer
+    react_render_componentregistry
+    react_utils
+    rrc_view
+    turbomodulejsijni
+    yoga
+  )
+endif()
 
 target_compile_options(
   ${LIB_TARGET_NAME}

package/android/src/paper/java/com/facebook/react/viewmanagers/RNSScreenManagerDelegate.java

@@ -52,7 +52,7 @@ public class RNSScreenManagerDelegate<T extends View, U extends BaseViewManagerI
         mViewManager.setFullScreenSwipeEnabled(view, value == null ? false : (boolean) value);
         break;
       case "fullScreenSwipeShadowEnabled":
-        mViewManager.setFullScreenSwipeShadowEnabled(view, value == null ? false : (boolean) value);
+        mViewManager.setFullScreenSwipeShadowEnabled(view, value == null ? true : (boolean) value);
         break;
       case "homeIndicatorHidden":
         mViewManager.setHomeIndicatorHidden(view, value == null ? false : (boolean) value);
@@ -91,7 +91,7 @@ public class RNSScreenManagerDelegate<T extends View, U extends BaseViewManagerI
         mViewManager.setStackAnimation(view, (String) value);
         break;
       case "transitionDuration":
-        mViewManager.setTransitionDuration(view, value == null ? 350 : ((Double) value).intValue());
+        mViewManager.setTransitionDuration(view, value == null ? 500 : ((Double) value).intValue());
         break;
       case "replaceAnimation":
         mViewManager.setReplaceAnimation(view, (String) value);

package/ios/RNSConvert.h

@@ -1,12 +1,17 @@
-#ifdef RCT_NEW_ARCH_ENABLED
 #import <UIKit/UIKit.h>
+#ifdef RCT_NEW_ARCH_ENABLED
 #import <react/renderer/components/rnscreens/Props.h>
+#endif // RCT_NEW_ARCH_ENABLED
 #import "RNSEnums.h"
 
+#ifdef RCT_NEW_ARCH_ENABLED
 namespace react = facebook::react;
+#endif // RCT_NEW_ARCH_ENABLED
 
 @interface RNSConvert : NSObject
 
+#ifdef RCT_NEW_ARCH_ENABLED
+
 + (UISemanticContentAttribute)UISemanticContentAttributeFromCppEquivalent:
     (react::RNSScreenStackHeaderConfigDirection)direction;
 
@@ -42,8 +47,12 @@ namespace react = facebook::react;
 
 + (NSMutableArray<NSNumber *> *)arrayFromVector:(const std::vector<CGFloat> &)vector;
 
-+ (UIBlurEffectStyle)UIBlurEffectStyleFromCppEquivalent:(react::RNSScreenStackHeaderConfigBlurEffect)blurEffect;
-
-@end
++ (RNSBlurEffectStyle)RNSBlurEffectStyleFromCppEquivalent:(react::RNSScreenStackHeaderConfigBlurEffect)blurEffect;
 
 #endif // RCT_NEW_ARCH_ENABLED
+
+/// This method fails (by assertion) when `blurEffect == RNSBlurEffectStyleNone` which has no counter part in the UIKit
+/// type.
++ (UIBlurEffectStyle)tryConvertRNSBlurEffectStyleToUIBlurEffectStyle:(RNSBlurEffectStyle)blurEffect;
+
+@end

package/ios/RNSConvert.mm

@@ -1,8 +1,12 @@
 #import "RNSConvert.h"
 
-#ifdef RCT_NEW_ARCH_ENABLED
+#ifndef RCT_NEW_ARCH_ENABLED
+#import <React/RCTAssert.h>
+#endif // !RCT_NEW_ARCH_ENABLED
+
 @implementation RNSConvert
 
+#ifdef RCT_NEW_ARCH_ENABLED
 + (UISemanticContentAttribute)UISemanticContentAttributeFromCppEquivalent:
     (react::RNSScreenStackHeaderConfigDirection)direction
 {
@@ -173,71 +177,89 @@
   return array;
 }
 
-+ (UIBlurEffectStyle)UIBlurEffectStyleFromCppEquivalent:(react::RNSScreenStackHeaderConfigBlurEffect)blurEffect
++ (RNSBlurEffectStyle)RNSBlurEffectStyleFromCppEquivalent:(react::RNSScreenStackHeaderConfigBlurEffect)blurEffect
 {
 #if !TARGET_OS_TV && defined(__IPHONE_OS_VERSION_MAX_ALLOWED) && defined(__IPHONE_13_0) && \
     __IPHONE_OS_VERSION_MAX_ALLOWED >= __IPHONE_13_0
   if (@available(iOS 13.0, *)) {
     switch (blurEffect) {
+      case react::RNSScreenStackHeaderConfigBlurEffect::None:
+        return RNSBlurEffectStyleNone;
       case react::RNSScreenStackHeaderConfigBlurEffect::ExtraLight:
-        return UIBlurEffectStyleExtraLight;
+        return RNSBlurEffectStyleExtraLight;
       case react::RNSScreenStackHeaderConfigBlurEffect::Light:
-        return UIBlurEffectStyleLight;
+        return RNSBlurEffectStyleLight;
       case react::RNSScreenStackHeaderConfigBlurEffect::Dark:
-        return UIBlurEffectStyleDark;
+        return RNSBlurEffectStyleDark;
       case react::RNSScreenStackHeaderConfigBlurEffect::Regular:
-        return UIBlurEffectStyleRegular;
+        return RNSBlurEffectStyleRegular;
       case react::RNSScreenStackHeaderConfigBlurEffect::Prominent:
-        return UIBlurEffectStyleProminent;
+        return RNSBlurEffectStyleProminent;
       case react::RNSScreenStackHeaderConfigBlurEffect::SystemUltraThinMaterial:
-        return UIBlurEffectStyleSystemUltraThinMaterial;
+        return RNSBlurEffectStyleSystemUltraThinMaterial;
       case react::RNSScreenStackHeaderConfigBlurEffect::SystemThinMaterial:
-        return UIBlurEffectStyleSystemThinMaterial;
+        return RNSBlurEffectStyleSystemThinMaterial;
       case react::RNSScreenStackHeaderConfigBlurEffect::SystemMaterial:
-        return UIBlurEffectStyleSystemMaterial;
+        return RNSBlurEffectStyleSystemMaterial;
       case react::RNSScreenStackHeaderConfigBlurEffect::SystemThickMaterial:
-        return UIBlurEffectStyleSystemThickMaterial;
+        return RNSBlurEffectStyleSystemThickMaterial;
       case react::RNSScreenStackHeaderConfigBlurEffect::SystemChromeMaterial:
-        return UIBlurEffectStyleSystemChromeMaterial;
+        return RNSBlurEffectStyleSystemChromeMaterial;
       case react::RNSScreenStackHeaderConfigBlurEffect::SystemUltraThinMaterialLight:
-        return UIBlurEffectStyleSystemUltraThinMaterialLight;
+        return RNSBlurEffectStyleSystemUltraThinMaterialLight;
       case react::RNSScreenStackHeaderConfigBlurEffect::SystemThinMaterialLight:
-        return UIBlurEffectStyleSystemThinMaterialLight;
+        return RNSBlurEffectStyleSystemThinMaterialLight;
       case react::RNSScreenStackHeaderConfigBlurEffect::SystemMaterialLight:
-        return UIBlurEffectStyleSystemMaterialLight;
+        return RNSBlurEffectStyleSystemMaterialLight;
       case react::RNSScreenStackHeaderConfigBlurEffect::SystemThickMaterialLight:
-        return UIBlurEffectStyleSystemThickMaterialLight;
+        return RNSBlurEffectStyleSystemThickMaterialLight;
       case react::RNSScreenStackHeaderConfigBlurEffect::SystemChromeMaterialLight:
-        return UIBlurEffectStyleSystemChromeMaterialLight;
+        return RNSBlurEffectStyleSystemChromeMaterialLight;
       case react::RNSScreenStackHeaderConfigBlurEffect::SystemUltraThinMaterialDark:
-        return UIBlurEffectStyleSystemUltraThinMaterialDark;
+        return RNSBlurEffectStyleSystemUltraThinMaterialDark;
       case react::RNSScreenStackHeaderConfigBlurEffect::SystemThinMaterialDark:
-        return UIBlurEffectStyleSystemThinMaterialDark;
+        return RNSBlurEffectStyleSystemThinMaterialDark;
       case react::RNSScreenStackHeaderConfigBlurEffect::SystemMaterialDark:
-        return UIBlurEffectStyleSystemMaterialDark;
+        return RNSBlurEffectStyleSystemMaterialDark;
       case react::RNSScreenStackHeaderConfigBlurEffect::SystemThickMaterialDark:
-        return UIBlurEffectStyleSystemThickMaterialDark;
+        return RNSBlurEffectStyleSystemThickMaterialDark;
       case react::RNSScreenStackHeaderConfigBlurEffect::SystemChromeMaterialDark:
-        return UIBlurEffectStyleSystemChromeMaterialDark;
+        return RNSBlurEffectStyleSystemChromeMaterialDark;
     }
   }
 #endif
 
   switch (blurEffect) {
+    case react::RNSScreenStackHeaderConfigBlurEffect::None:
+      return RNSBlurEffectStyleNone;
     case react::RNSScreenStackHeaderConfigBlurEffect::Light:
-      return UIBlurEffectStyleLight;
+      return RNSBlurEffectStyleLight;
     case react::RNSScreenStackHeaderConfigBlurEffect::Dark:
-      return UIBlurEffectStyleDark;
+      return RNSBlurEffectStyleDark;
     case react::RNSScreenStackHeaderConfigBlurEffect::Regular:
-      return UIBlurEffectStyleRegular;
+      return RNSBlurEffectStyleRegular;
     case react::RNSScreenStackHeaderConfigBlurEffect::Prominent:
-      return UIBlurEffectStyleProminent;
+      return RNSBlurEffectStyleProminent;
     case react::RNSScreenStackHeaderConfigBlurEffect::ExtraLight:
     default:
-      return UIBlurEffectStyleExtraLight;
+      return RNSBlurEffectStyleNone;
   }
 }
 
-@end
+#endif // RCT_NEW_ARCH_ENABLED
 
++ (UIBlurEffectStyle)tryConvertRNSBlurEffectStyleToUIBlurEffectStyle:(RNSBlurEffectStyle)blurEffect
+{
+#ifdef RCT_NEW_ARCH_ENABLED
+  react_native_assert(blurEffect != RNSBlurEffectStyleNone);
+#else
+  RCTAssert(
+      blurEffect != RNSBlurEffectStyleNone, @"RNSBlurEffectStyleNone variant is not convertible to UIBlurEffectStyle");
 #endif // RCT_NEW_ARCH_ENABLED
+
+  // Cast safety: RNSBlurEffectStyle is defined in such way that its values map 1:1 with
+  // UIBlurEffectStyle, except RNSBlurEffectStyleNone which is excluded above.
+  return (UIBlurEffectStyle)blurEffect;
+}
+
+@end

package/ios/RNSEnums.h

@@ -30,6 +30,7 @@ typedef NS_ENUM(NSInteger, RNSScreenSwipeDirection) {
 };
 
 typedef NS_ENUM(NSInteger, RNSActivityState) {
+  RNSActivityStateUndefined = -1,
   RNSActivityStateInactive = 0,
   RNSActivityStateTransitioningOrBelowTop = 1,
   RNSActivityStateOnTop = 2
@@ -70,3 +71,49 @@ typedef NS_ENUM(NSInteger, RNSSearchBarPlacement) {
   RNSSearchBarPlacementInline,
   RNSSearchBarPlacementStacked,
 };
+
+// Redefinition of UIBlurEffectStyle. We need to represent additional case of `None`.
+typedef NS_ENUM(NSInteger, RNSBlurEffectStyle) {
+  /// No blur effect should be visible
+  RNSBlurEffectStyleNone = -1,
+  RNSBlurEffectStyleExtraLight = UIBlurEffectStyleExtraLight,
+  RNSBlurEffectStyleLight = UIBlurEffectStyleLight,
+  RNSBlurEffectStyleDark = UIBlurEffectStyleDark,
+  // TODO: Add support for this variant on tvOS
+  //  RNSBlurEffectStyleExtraDark = UIBlurEffectStyleExtraDark API_AVAILABLE(tvos(10.0)) API_UNAVAILABLE(ios)
+  //  API_UNAVAILABLE(watchos),
+  RNSBlurEffectStyleRegular API_AVAILABLE(ios(10.0)) API_UNAVAILABLE(watchos) = UIBlurEffectStyleRegular,
+  RNSBlurEffectStyleProminent API_AVAILABLE(ios(10.0)) API_UNAVAILABLE(watchos) = UIBlurEffectStyleProminent,
+  RNSBlurEffectStyleSystemUltraThinMaterial API_AVAILABLE(ios(13.0))
+      API_UNAVAILABLE(watchos, tvos) = UIBlurEffectStyleSystemUltraThinMaterial,
+  RNSBlurEffectStyleSystemThinMaterial API_AVAILABLE(ios(13.0))
+      API_UNAVAILABLE(watchos, tvos) = UIBlurEffectStyleSystemThinMaterial,
+  RNSBlurEffectStyleSystemMaterial API_AVAILABLE(ios(13.0))
+      API_UNAVAILABLE(watchos, tvos) = UIBlurEffectStyleSystemMaterial,
+  RNSBlurEffectStyleSystemThickMaterial API_AVAILABLE(ios(13.0))
+      API_UNAVAILABLE(watchos, tvos) = UIBlurEffectStyleSystemThickMaterial,
+  RNSBlurEffectStyleSystemChromeMaterial API_AVAILABLE(ios(13.0))
+      API_UNAVAILABLE(watchos, tvos) = UIBlurEffectStyleSystemChromeMaterial,
+  RNSBlurEffectStyleSystemUltraThinMaterialLight API_AVAILABLE(ios(13.0))
+      API_UNAVAILABLE(watchos, tvos) = UIBlurEffectStyleSystemUltraThinMaterialLight,
+  RNSBlurEffectStyleSystemThinMaterialLight API_AVAILABLE(ios(13.0))
+      API_UNAVAILABLE(watchos, tvos) = UIBlurEffectStyleSystemThinMaterialLight,
+  RNSBlurEffectStyleSystemMaterialLight API_AVAILABLE(ios(13.0))
+      API_UNAVAILABLE(watchos, tvos) = UIBlurEffectStyleSystemMaterialLight,
+  RNSBlurEffectStyleSystemThickMaterialLight API_AVAILABLE(ios(13.0))
+      API_UNAVAILABLE(watchos, tvos) = UIBlurEffectStyleSystemThickMaterialLight,
+  RNSBlurEffectStyleSystemChromeMaterialLight API_AVAILABLE(ios(13.0))
+      API_UNAVAILABLE(watchos, tvos) = UIBlurEffectStyleSystemChromeMaterialLight,
+
+  RNSBlurEffectStyleSystemUltraThinMaterialDark API_AVAILABLE(ios(13.0))
+      API_UNAVAILABLE(watchos, tvos) = UIBlurEffectStyleSystemUltraThinMaterialDark,
+  RNSBlurEffectStyleSystemThinMaterialDark API_AVAILABLE(ios(13.0))
+      API_UNAVAILABLE(watchos, tvos) = UIBlurEffectStyleSystemThinMaterialDark,
+  RNSBlurEffectStyleSystemMaterialDark API_AVAILABLE(ios(13.0))
+      API_UNAVAILABLE(watchos, tvos) = UIBlurEffectStyleSystemMaterialDark,
+  RNSBlurEffectStyleSystemThickMaterialDark API_AVAILABLE(ios(13.0))
+      API_UNAVAILABLE(watchos, tvos) = UIBlurEffectStyleSystemThickMaterialDark,
+  RNSBlurEffectStyleSystemChromeMaterialDark API_AVAILABLE(ios(13.0))
+      API_UNAVAILABLE(watchos, tvos) = UIBlurEffectStyleSystemChromeMaterialDark
+
+} API_AVAILABLE(ios(8.0)) API_UNAVAILABLE(watchos);

package/ios/RNSPercentDrivenInteractiveTransition.h

@@ -0,0 +1,12 @@
+#import <UIKit/UIKit.h>
+#import "RNSScreenStackAnimator.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface RNSPercentDrivenInteractiveTransition : UIPercentDrivenInteractiveTransition
+
+@property (nonatomic, nullable) RNSScreenStackAnimator *animationController;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/RNSPercentDrivenInteractiveTransition.mm

@@ -0,0 +1,69 @@
+#import "RNSPercentDrivenInteractiveTransition.h"
+
+@implementation RNSPercentDrivenInteractiveTransition {
+  RNSScreenStackAnimator *_animationController;
+}
+
+#pragma mark - UIViewControllerInteractiveTransitioning
+
+- (void)startInteractiveTransition:(id<UIViewControllerContextTransitioning>)transitionContext
+{
+  [super startInteractiveTransition:transitionContext];
+}
+
+#pragma mark - UIPercentDrivenInteractiveTransition
+
+// `updateInteractiveTransition`, `finishInteractiveTransition`,
+// `cancelInteractiveTransition` are forwared by superclass to
+// corresponding methods in transition context. In case
+// of "classical CA driven animations", such as UIView animation blocks
+// or direct utilization of CoreAnimation API, context drives the animation,
+// however in case of UIViewPropertyAnimator it does not. We need
+// to drive animation manually and this is exactly what happens below.
+
+- (void)updateInteractiveTransition:(CGFloat)percentComplete
+{
+  if (_animationController != nil) {
+    [_animationController.inFlightAnimator setFractionComplete:percentComplete];
+  }
+  [super updateInteractiveTransition:percentComplete];
+}
+
+- (void)finishInteractiveTransition
+{
+  [self finalizeInteractiveTransitionWithAnimationWasCancelled:NO];
+  [super finishInteractiveTransition];
+}
+
+- (void)cancelInteractiveTransition
+{
+  [self finalizeInteractiveTransitionWithAnimationWasCancelled:YES];
+  [super cancelInteractiveTransition];
+}
+
+#pragma mark - Helpers
+
+- (void)finalizeInteractiveTransitionWithAnimationWasCancelled:(BOOL)cancelled
+{
+  if (_animationController == nil) {
+    return;
+  }
+
+  UIViewPropertyAnimator *_Nullable animator = _animationController.inFlightAnimator;
+  if (animator == nil) {
+    return;
+  }
+
+  BOOL shouldReverseAnimation = cancelled;
+
+  id<UITimingCurveProvider> timingParams = [_animationController timingParamsForAnimationCompletion];
+
+  [animator pauseAnimation];
+  [animator setReversed:shouldReverseAnimation];
+  [animator continueAnimationWithTimingParameters:timingParams durationFactor:(1 - animator.fractionComplete)];
+
+  // System retains it & we don't need it anymore.
+  _animationController = nil;
+}
+
+@end

package/ios/RNSScreen.h

@@ -100,6 +100,8 @@ namespace react = facebook::react;
 @property (nonatomic) react::LayoutMetrics newLayoutMetrics;
 @property (weak, nonatomic) RNSScreenStackHeaderConfig *config;
 @property (nonatomic, readonly) BOOL hasHeaderConfig;
+@property (nonatomic, readonly, getter=isMarkedForUnmountInCurrentTransaction)
+    BOOL markedForUnmountInCurrentTransaction;
 #else
 @property (nonatomic, copy) RCTDirectEventBlock onAppear;
 @property (nonatomic, copy) RCTDirectEventBlock onDisappear;
@@ -124,6 +126,10 @@ namespace react = facebook::react;
 - (void)updateBounds;
 - (void)notifyDismissedWithCount:(int)dismissCount;
 - (instancetype)initWithFrame:(CGRect)frame;
+/// Tell `Screen` that it will be unmounted in next transaction.
+/// The component needs this so that we can later decide whether to
+/// replace it with snapshot or not.
+- (void)willBeUnmountedInUpcomingTransaction;
 #else
 - (instancetype)initWithBridge:(RCTBridge *)bridge;
 #endif // RCT_NEW_ARCH_ENABLED
@@ -133,6 +139,14 @@ namespace react = facebook::react;
 - (BOOL)isModal;
 - (BOOL)isPresentedAsNativeModal;
 
+/**
+ * Tell `Screen` component that it has been removed from react state and can safely cleanup
+ * any retained resources.
+ *
+ * Note, that on old architecture this method might be called by RN via `RCTInvalidating` protocol.
+ */
+- (void)invalidate;
+
 /// Looks for header configuration in instance's `reactSubviews` and returns it. If not present returns `nil`.
 - (RNSScreenStackHeaderConfig *_Nullable)findHeaderConfig;
 

package/ios/RNSScreen.mm

@@ -118,11 +118,16 @@ constexpr NSInteger SHEET_LARGEST_UNDIMMED_DETENT_NONE = -1;
   _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
@@ -304,15 +309,25 @@ constexpr NSInteger SHEET_LARGEST_UNDIMMED_DETENT_NONE = -1;
 {
   int activityState = [activityStateOrNil intValue];
   if (activityStateOrNil != nil && activityState != -1 && activityState != _activityState) {
-    if ([_controller.navigationController isKindOfClass:RNSNavigationController.class] &&
-        _activityState < activityState) {
-      RCTLogError(@"[RNScreens] activityState can only progress in NativeStack");
-    }
+    [self maybeAssertActivityStateProgressionOldValue:_activityState newValue:activityState];
     _activityState = activityState;
     [_reactSuperview markChildUpdated];
   }
 }
 
+- (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
 {
@@ -749,6 +764,12 @@ constexpr NSInteger SHEET_LARGEST_UNDIMMED_DETENT_NONE = -1;
       self.controller.modalPresentationStyle == UIModalPresentationOverCurrentContext;
 }
 
+- (void)invalidate
+{
+  _controller = nil;
+  [_sheetsScrollView removeObserver:self forKeyPath:@"bounds" context:nil];
+}
+
 #if !TARGET_OS_TV && !TARGET_OS_VISION
 
 - (void)setPropertyForSheet:(UISheetPresentationController *)sheet
@@ -1076,6 +1097,11 @@ constexpr NSInteger SHEET_LARGEST_UNDIMMED_DETENT_NONE = -1;
   return _config != nil;
 }
 
+- (void)willBeUnmountedInUpcomingTransaction
+{
+  _markedForUnmountInCurrentTransaction = YES;
+}
+
 + (react::ComponentDescriptorProvider)componentDescriptorProvider
 {
   return react::concreteComponentDescriptorProvider<react::RNSScreenComponentDescriptor>();
@@ -1265,11 +1291,6 @@ constexpr NSInteger SHEET_LARGEST_UNDIMMED_DETENT_NONE = -1;
   // subviews
 }
 
-- (void)invalidate
-{
-  _controller = nil;
-  [_sheetsScrollView removeObserver:self forKeyPath:@"bounds" context:nil];
-}
 #endif
 
 @end

package/ios/RNSScreenStack.mm

@@ -20,6 +20,7 @@
 #import "RCTTouchHandler+RNSUtility.h"
 #endif // RCT_NEW_ARCH_ENABLED
 
+#import "RNSPercentDrivenInteractiveTransition.h"
 #import "RNSScreen.h"
 #import "RNSScreenStack.h"
 #import "RNSScreenStackAnimator.h"
@@ -149,9 +150,16 @@ namespace react = facebook::react;
   NSMutableArray<RNSScreenView *> *_reactSubviews;
   BOOL _invalidated;
   BOOL _isFullWidthSwiping;
-  UIPercentDrivenInteractiveTransition *_interactionController;
+  RNSPercentDrivenInteractiveTransition *_interactionController;
   __weak RNSScreenStackManager *_manager;
   BOOL _updateScheduled;
+#ifdef RCT_NEW_ARCH_ENABLED
+  /// Screens that are subject of `ShadowViewMutation::Type::Delete` mutation
+  /// in current transaction. This vector should be populated when we receive notification via
+  /// `RCTMountingObserving` protocol, that a transaction will be performed, and should
+  /// be cleaned up when we're notified that the transaction has been completed.
+  std::vector<__strong RNSScreenView *> _toBeDeletedScreens;
+#endif // RCT_NEW_ARCH_ENABLED
 }
 
 #ifdef RCT_NEW_ARCH_ENABLED
@@ -862,7 +870,7 @@ namespace react = facebook::react;
 
   switch (gestureRecognizer.state) {
     case UIGestureRecognizerStateBegan: {
-      _interactionController = [UIPercentDrivenInteractiveTransition new];
+      _interactionController = [RNSPercentDrivenInteractiveTransition new];
       [_controller popViewControllerAnimated:YES];
       break;
     }
@@ -909,7 +917,7 @@ namespace react = facebook::react;
   if (_interactionController == nil && fromView.reactSuperview) {
     BOOL shouldCancelDismiss = [self shouldCancelDismissFromView:fromView toView:toView];
     if (shouldCancelDismiss) {
-      _interactionController = [UIPercentDrivenInteractiveTransition new];
+      _interactionController = [RNSPercentDrivenInteractiveTransition new];
       dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(0.01 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
         [self->_interactionController cancelInteractiveTransition];
         self->_interactionController = nil;
@@ -922,6 +930,10 @@ namespace react = facebook::react;
       });
     }
   }
+
+  if (_interactionController != nil) {
+    [_interactionController setAnimationController:animationController];
+  }
   return _interactionController;
 }
 
@@ -946,7 +958,7 @@ namespace react = facebook::react;
 
 - (void)markChildUpdated
 {
-  // do nothing
+  // In native stack this should be called only for `preload` purposes.
   [self updateContainer];
 }
 
@@ -1104,7 +1116,7 @@ namespace react = facebook::react;
 {
   if (_interactionController == nil) {
     _customAnimation = YES;
-    _interactionController = [UIPercentDrivenInteractiveTransition new];
+    _interactionController = [RNSPercentDrivenInteractiveTransition new];
     [_controller popViewControllerAnimated:YES];
   }
 }
@@ -1151,6 +1163,16 @@ namespace react = facebook::react;
   // `- [RNSScreenStackView mountingTransactionDidMount: withSurfaceTelemetry:]`
 }
 
+- (nullable RNSScreenView *)childScreenForTag:(react::Tag)tag
+{
+  for (RNSScreenView *child in _reactSubviews) {
+    if (child.tag == tag) {
+      return child;
+    }
+  }
+  return nil;
+}
+
 - (void)unmountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView index:(NSInteger)index
 {
   RNSScreenView *screenChildComponent = (RNSScreenView *)childComponentView;
@@ -1184,6 +1206,20 @@ namespace react = facebook::react;
   [screenChildComponent removeFromSuperview];
 }
 
+- (void)mountingTransactionWillMount:(const facebook::react::MountingTransaction &)transaction
+                withSurfaceTelemetry:(const facebook::react::SurfaceTelemetry &)surfaceTelemetry
+{
+  for (const auto &mutation : transaction.getMutations()) {
+    if (mutation.type == react::ShadowViewMutation::Delete) {
+      RNSScreenView *_Nullable toBeRemovedChild = [self childScreenForTag:mutation.oldChildShadowView.tag];
+      if (toBeRemovedChild != nil) {
+        [toBeRemovedChild willBeUnmountedInUpcomingTransaction];
+        _toBeDeletedScreens.push_back(toBeRemovedChild);
+      }
+    }
+  }
+}
+
 - (void)mountingTransactionDidMount:(const facebook::react::MountingTransaction &)transaction
                withSurfaceTelemetry:(const facebook::react::SurfaceTelemetry &)surfaceTelemetry
 {
@@ -1200,6 +1236,21 @@ namespace react = facebook::react;
       break;
     }
   }
+
+  if (!self->_toBeDeletedScreens.empty()) {
+    __weak RNSScreenStackView *weakSelf = self;
+    // We want to run after container updates are performed (transitions etc.)
+    dispatch_async(dispatch_get_main_queue(), ^{
+      RNSScreenStackView *_Nullable strongSelf = weakSelf;
+      if (strongSelf == nil) {
+        return;
+      }
+      for (RNSScreenView *screenRef : strongSelf->_toBeDeletedScreens) {
+        [screenRef invalidate];
+      }
+      strongSelf->_toBeDeletedScreens.clear();
+    });
+  }
 }
 
 - (void)prepareForRecycle
@@ -1227,12 +1278,25 @@ namespace react = facebook::react;
 - (void)invalidate
 {
   _invalidated = YES;
-  for (UIViewController *controller in _presentedModals) {
+  [self dismissAllRelatedModals];
+  [_controller willMoveToParentViewController:nil];
+  [_controller removeFromParentViewController];
+}
+
+// This method aims to dismiss all modals for which presentation process
+// has been initiated in this navigation controller, i. e. either a Screen
+// with modal presentation or foreign modal presented from inside a Screen.
+- (void)dismissAllRelatedModals
+{
+  [_controller dismissViewControllerAnimated:NO completion:nil];
+
+  // This loop seems to be excessive. Above message send to `_controller` should
+  // be enough, because system dismisses the controllers recursively,
+  // however better safe than sorry & introduce a regression, thus it is left here.
+  for (UIViewController *controller in [_presentedModals reverseObjectEnumerator]) {
     [controller dismissViewControllerAnimated:NO completion:nil];
   }
   [_presentedModals removeAllObjects];
-  [_controller willMoveToParentViewController:nil];
-  [_controller removeFromParentViewController];
 }
 
 #endif // RCT_NEW_ARCH_ENABLED

package/ios/RNSScreenStackAnimator.h

@@ -2,7 +2,19 @@
 
 @interface RNSScreenStackAnimator : NSObject <UIViewControllerAnimatedTransitioning>
 
-- (instancetype)initWithOperation:(UINavigationControllerOperation)operation;
+/// This property is filled whenever there is an ongoing animation and cleared on animation end.
+@property (nonatomic, strong, nullable, readonly) UIViewPropertyAnimator *inFlightAnimator;
+
+- (nonnull instancetype)initWithOperation:(UINavigationControllerOperation)operation;
+
+/// In case of interactive / interruptible transition (e.g. swipe back gesture) this method should return
+/// timing parameters expected by animator to be used for animation completion (e.g. when user's
+/// gesture had ended).
+///
+/// @return timing curve provider expected to be used for animation completion or nil,
+/// when there is no interactive transition running.
+- (nullable id<UITimingCurveProvider>)timingParamsForAnimationCompletion;
+
 + (BOOL)isCustomAnimation:(RNSScreenStackAnimation)animation;
 
 @end