@apexnative/navigation 1.0.0-alpha.1 → 1.0.0-alpha.11

package/ios/Layouts/Modal/ANNSheetPresenter.mm

@@ -1,6 +1,7 @@
 #import "ANNSheetPresenter.h"
 #import "ANNModalSizePresenter.h"
 #import "ANNReactView.h"
+#import "ANNUtils.h"
 #import "UIViewController+LayoutProtocol.h"
 #import <React/RCTLog.h>
 #import <objc/runtime.h>
@@ -53,7 +54,7 @@ static NSString *const ANNContentDetent = @"content";
 + (void)applyOptions:(ANNSheetOptions *)options toSheet:(UISheetPresentationController *)sheet {
     if (options.detents) {
         NSMutableArray<UISheetPresentationControllerDetent *> *detents = [NSMutableArray new];
-        for (id value in options.detents) {
+        for (id value in [self sortedDetents:options.detents ofSheet:sheet]) {
             UISheetPresentationControllerDetent *detent = [self detentFor:value ofSheet:sheet];
             if (detent) {
                 [detents addObject:detent];
@@ -81,6 +82,85 @@ static NSString *const ANNContentDetent = @"content";
     }
 }
 
+// UIKit wants the detents once each, from the lowest to the highest: it takes the last for the largest and closes the
+// sheet on a drag down from the first. The options may give them in any order and more than once; the first of a
+// repeat stays, and detents of the same height keep their order.
++ (NSArray *)sortedDetents:(NSArray *)values ofSheet:(UISheetPresentationController *)sheet {
+    NSMutableArray *detents = [NSMutableArray new];
+    NSMutableSet<NSString *> *identifiers = [NSMutableSet new];
+    for (id value in values) {
+        NSString *identifier = [self identifierFor:value];
+        if (identifier && ![identifiers containsObject:identifier]) {
+            [identifiers addObject:identifier];
+            [detents addObject:value];
+        }
+    }
+    CGFloat maximum = [self maximumDetentHeightOf:sheet];
+    return [detents sortedArrayWithOptions:NSSortStable
+                           usingComparator:^NSComparisonResult(id a, id b) {
+                             return [self compareHeightOf:a
+                                                     with:b
+                                                  maximum:maximum
+                                                  ofSheet:sheet];
+                           }];
+}
+
+// The content of a sheet sized to it changed its height, and with it maybe its place among the other detents.
++ (void)sortDetentsOfSheet:(UISheetPresentationController *)sheet API_AVAILABLE(ios(16.0)) {
+    CGFloat maximum = [self maximumDetentHeightOf:sheet];
+    NSArray<UISheetPresentationControllerDetent *> *detents = sheet.detents;
+    NSArray<UISheetPresentationControllerDetent *> *sorted = [detents
+        sortedArrayWithOptions:NSSortStable
+               usingComparator:^NSComparisonResult(UISheetPresentationControllerDetent *a,
+                                                   UISheetPresentationControllerDetent *b) {
+                 return [self compareHeightOf:[self detentForIdentifier:a.identifier]
+                                         with:[self detentForIdentifier:b.identifier]
+                                      maximum:maximum
+                                      ofSheet:sheet];
+               }];
+    if (![sorted isEqualToArray:detents]) {
+        sheet.detents = sorted;
+    }
+}
+
++ (NSComparisonResult)compareHeightOf:(id)a
+                                 with:(id)b
+                              maximum:(CGFloat)maximum
+                              ofSheet:(UISheetPresentationController *)sheet {
+    CGFloat heightA = [self heightOf:a maximum:maximum ofSheet:sheet];
+    CGFloat heightB = [self heightOf:b maximum:maximum ofSheet:sheet];
+    return heightA < heightB ? NSOrderedAscending
+                             : heightA > heightB ? NSOrderedDescending : NSOrderedSame;
+}
+
+// The height a detent of the options stands at, to sort them, as its resolver gives it: 'medium' half of the largest
+// height (UIKit's is about half), 'large' all of it, a height capped at it, 'content' the content's height now, all of
+// it while the content isn't measured.
++ (CGFloat)heightOf:(id)value
+            maximum:(CGFloat)maximum
+            ofSheet:(UISheetPresentationController *)sheet {
+    if ([value isEqual:@"medium"]) {
+        return maximum / 2;
+    }
+    if ([value isKindOfClass:NSNumber.class]) {
+        return MIN([value doubleValue], maximum);
+    }
+    if ([value isEqual:ANNContentDetent]) {
+        CGFloat height = [self contentHeightOf:sheet.presentedViewController];
+        return height > 0 ? MIN(height, maximum) : maximum;
+    }
+    return maximum;
+}
+
+// About the largest height of a sheet: its container, or the window before it is shown, below the top safe area.
++ (CGFloat)maximumDetentHeightOf:(UISheetPresentationController *)sheet {
+    UIView *view = sheet.containerView ?: ANNUtils.mainWindow;
+    if (!view) {
+        return ANNUtils.mainScreen.bounds.size.height;
+    }
+    return view.bounds.size.height - view.safeAreaInsets.top;
+}
+
 + (UISheetPresentationControllerDetent *)detentFor:(id)value
                                            ofSheet:(UISheetPresentationController *)sheet {
     if ([value isEqual:@"medium"]) {
@@ -180,6 +260,7 @@ static NSString *const ANNContentDetent = @"content";
               }
               height = newHeight;
               [strongSheet animateChanges:^{
+                [self sortDetentsOfSheet:strongSheet];
                 [strongSheet invalidateDetents];
               }];
             }
@@ -201,6 +282,7 @@ static NSString *const ANNContentDetent = @"content";
             // The new screen's content mounts may come later: its mounts resolve the detents again too.
             [self followContentOfSheet:sheet when:YES];
             [sheet animateChanges:^{
+              [self sortDetentsOfSheet:sheet];
               [sheet invalidateDetents];
             }];
         }

package/ios/Layouts/Overlay/ANNOverlayCoordinator.mm

@@ -179,7 +179,7 @@ static NSMutableArray<ANNOverlay *> *ANNOverlays;
                   limit:ANNOverlayRenderLimit
                     bar:ANNRenderWaitBarWithContent
               barLimits:withContent];
-    wait.mountLimit = ANNOverlayRenderLimit;
+    wait.unseenLimit = ANNOverlayRenderLimit;
     wait.protect = ^(dispatch_block_t step) {
       [ANNOverlayCoordinator protectWaitOf:weakOverlay step:step];
     };
@@ -238,13 +238,7 @@ static NSMutableArray<ANNOverlay *> *ANNOverlays;
                 [self dismiss:shown answer:nil];
             }
         }
-        UIWindow *mainWindow = ApexNavigation.mainWindow;
-        UIWindowScene *scene = mainWindow.windowScene;
-        // `initWithFrame:` is deprecated from iOS 26 on and warns only with a deployment target from 26: a window
-        // without a scene is made so, and joins the scene as the main window gets it.
-        ANNOverlayWindow *window =
-            scene ? [[ANNOverlayWindow alloc] initWithWindowScene:scene]
-                  : [[ANNOverlayWindow alloc] initWithFrame:ANNUtils.mainScreen.bounds];
+        ANNOverlayWindow *window = [ANNUtils makeWindowOfClass:ANNOverlayWindow.class];
         window.windowLevel = UIWindowLevelNormal;
         window.backgroundColor = UIColor.clearColor;
         window.previousWindow = [self keyWindow];

package/ios/Layouts/Root/ANNRootCoordinator.mm

@@ -69,7 +69,10 @@ typedef NS_ENUM(NSInteger, ANNRootShowState) {
 // The nodes whose appearance the transition reports itself (`driveAppearanceOf:`), while `driving`.
 @property(nonatomic, copy) NSArray<UIViewController *> *driven;
 @property(nonatomic) BOOL driving;
+// The snapshot of the window as it was: it dissolves over the new root (`dissolves`), plays its `exit` (`custom`), or
+// only covers the old root's modals while they go, and leaves as the new root is the window's.
 @property(nonatomic, strong, nullable) UIView *snapshot;
+@property(nonatomic) BOOL dissolves;
 // The root is the window's root: the old root's modals went before it (`startTransitionOf:done:`).
 @property(nonatomic) BOOL installed;
 // The root's view waits in the window under the current root (`park:`).
@@ -80,6 +83,10 @@ typedef NS_ENUM(NSInteger, ANNRootShowState) {
 @property(nonatomic, strong, nullable) ANNFrameDriver *driver;
 @property(nonatomic, copy, nullable) NSArray<ANNViewTracks *> *tracks;
 @property(nonatomic) BOOL animating;
+// The new root's view takes no touches while it animates, and whether it took them before: Core Animation draws it
+// elsewhere than where it is (the view itself stays in place), so a tap on the old screen would reach it.
+@property(nonatomic, weak, nullable) UIView *untouchableRoot;
+@property(nonatomic) BOOL rootTouchesBefore;
 @property(nonatomic) BOOL layersShown;
 @end
 
@@ -293,7 +300,7 @@ static __weak ANNRootShow *ANNAnimatingShow;
               barLimits:contentFirst ? ownPhase : withContent];
     // A screen the user won't see at once (an unselected tab's) never holds the root longer than the limit, also with
     // `waitForRender: true`.
-    wait.mountLimit = ANNRootRenderLimit;
+    wait.unseenLimit = ANNRootRenderLimit;
     wait.protect = ^(dispatch_block_t step) {
       [ANNRootCoordinator protect:weakShow step:step];
     };
@@ -415,9 +422,14 @@ static __weak ANNRootShow *ANNAnimatingShow;
     BOOL seen = !window.hidden && scene != nil &&
                 scene.activationState != UISceneActivationStateBackground;
     BOOL dissolves = !overSplash && !enterDisabled && !custom && seen;
+    show.dissolves = dissolves;
     show.custom = custom && seen;
-    UIView *snapshot =
-        dissolves || show.custom ? [window snapshotViewAfterScreenUpdates:NO] : nil;
+    // UIKit draws the dismissal of the old root's modals, without animation too (a sheet's dim goes a frame before
+    // its card): with nothing to dissolve, the snapshot covers them until the new root is in place.
+    BOOL covers = seen && old.presentedViewController != nil;
+    UIView *snapshot = dissolves || show.custom || covers
+                           ? [window snapshotViewAfterScreenUpdates:NO]
+                           : nil;
 
     show.state = ANNRootShowStateTransition;
     // It shows from here: a stack in it counts as on screen.
@@ -480,7 +492,8 @@ static __weak ANNRootShow *ANNAnimatingShow;
         [self endTransitionOf:show];
         return;
     }
-    if (!snapshot) {
+    // A snapshot that only covered the old root's modals leaves in this turn, with the new root in place under it.
+    if (!snapshot || !show.dissolves) {
         [self endTransitionOf:show];
         return;
     }
@@ -524,20 +537,43 @@ static __weak ANNRootShow *ANNAnimatingShow;
     NSMutableArray<ANNViewTracks *> *tracks = [NSMutableArray new];
     ANNViewAnimationOptions *enter = [ANNAnimationRules playingSide:animation.enter];
     ANNViewAnimationOptions *exit = [ANNAnimationRules playingSide:animation.exit];
-    if (enter && rootView) {
-        [tracks addObject:[[ANNViewTracks alloc] initWithView:rootView
-                                                         side:enter
-                                                  alphaBefore:rootView.alpha]];
-    }
-    if (exit && snapshot) {
-        [tracks addObject:[[ANNViewTracks alloc] initWithView:snapshot
-                                                         side:exit
-                                                  alphaBefore:snapshot.alpha]];
-    }
     NSTimeInterval length =
         MAX([ANNAnimationRules lengthOfSide:enter], [ANNAnimationRules lengthOfSide:exit]);
+    if (UIAccessibilityIsReduceMotionEnabled() && length > 0) {
+        // With the system's Reduce Motion on, nothing moves: the new root fades in over the snapshot in the same
+        // length, or the snapshot fades out without a new root's view.
+        if (rootView) {
+            [tracks addObject:[[ANNViewTracks alloc] initWithView:rootView
+                                                         fadeFrom:0
+                                                               to:rootView.alpha
+                                                         duration:length
+                                                      alphaBefore:rootView.alpha]];
+        } else if (snapshot) {
+            [tracks addObject:[[ANNViewTracks alloc] initWithView:snapshot
+                                                         fadeFrom:snapshot.alpha
+                                                               to:0
+                                                         duration:length
+                                                      alphaBefore:snapshot.alpha]];
+        }
+    } else {
+        if (enter && rootView) {
+            [tracks addObject:[[ANNViewTracks alloc] initWithView:rootView
+                                                             side:enter
+                                                      alphaBefore:rootView.alpha]];
+        }
+        if (exit && snapshot) {
+            [tracks addObject:[[ANNViewTracks alloc] initWithView:snapshot
+                                                             side:exit
+                                                      alphaBefore:snapshot.alpha]];
+        }
+    }
     show.tracks = tracks;
     show.animating = YES;
+    if (rootView) {
+        show.untouchableRoot = rootView;
+        show.rootTouchesBefore = rootView.userInteractionEnabled;
+        rootView.userInteractionEnabled = NO;
+    }
     ANNAnimatingShow = show;
     show.driver = [[ANNFrameDriver alloc] initWithClients:tracks length:length];
     // The layers' state from here on: the chain may start and a newer `setRoot` stops it.
@@ -574,8 +610,8 @@ static __weak ANNRootShow *ANNAnimatingShow;
     [self finishLayersOf:show];
 }
 
-// The animation stops at its end state (its end, a newer `setRoot`, a reload, a failure): the views get back what they
-// had and the snapshot goes.
+// The animation stops (its end, a newer `setRoot`, a reload, a failure): its animations go, the views get back what
+// they had and the snapshot goes.
 + (void)stopAnimationOf:(ANNRootShow *)show {
     if (!show.animating) {
         return;
@@ -583,13 +619,16 @@ static __weak ANNRootShow *ANNAnimatingShow;
     show.animating = NO;
     [show.driver cancel];
     show.driver = nil;
+    show.untouchableRoot.userInteractionEnabled = show.rootTouchesBefore;
+    show.untouchableRoot = nil;
     for (ANNViewTracks *tracks in show.tracks) {
         [tracks restore];
     }
     show.tracks = nil;
-    // UIKit works out the safe area of the window's root view from where the view is drawn: moved away from the top
-    // edge by `enter` (from the bottom, scaled down) it has no top inset, and putting the transform back doesn't make
-    // UIKit work it out again. A layout now gives the root, its bars and its screens the window's safe area back.
+    // UIKit works out the safe area of the window's root view from where the view is: moved away from the top edge by
+    // a transform it has no top inset, and putting the transform back doesn't make UIKit work it out again. `enter`
+    // moves only what Core Animation draws now; the layout stays, so the root, its bars and its screens end with the
+    // window's safe area whatever moved them.
     UIView *rootView = show.root.viewIfLoaded;
     [rootView setNeedsLayout];
     [rootView layoutIfNeeded];

package/ios/Layouts/Root/ANNSplashViewController.h

@@ -7,9 +7,11 @@ NS_ASSUME_NONNULL_BEGIN
 /// either at once. The status bar follows the Info.plist keys `UIStatusBarStyle` and `UIStatusBarHidden`. Main queue.
 @interface ANNSplashViewController : UIViewController
 
-/// The copy of the launch screen: the initial view controller of `UILaunchStoryboardName` as a child (a storyboard
-/// that doesn't load: the first view of the nib of that name), else the legacy launch images, full screen. Nil when the
-/// app has none of these: the window then has no root view controller until the first root.
+/// The copy of the launch screen. When iOS builds it from the Info.plist (`UILaunchScreen`, or the default of
+/// `UILaunchScreens`), the same color, image and bars as plain views; else the initial view controller of
+/// `UILaunchStoryboardName` as a child (a storyboard that doesn't load: the first view of the nib of that name), else
+/// the legacy launch images, full screen. Nil when the app has none of these: the window then has no root view
+/// controller until the first root.
 + (nullable instancetype)launchScreenCopyWithBounds:(CGRect)bounds;
 
 /// The blank screen after a reload: clear when the default options give the window a color (`window.backgroundColor`),

package/ios/Layouts/Root/ANNSplashViewController.mm

@@ -34,9 +34,63 @@ static NSArray<NSString *> *ANNLegacyLaunchImageNames(CGFloat height) {
     return names;
 }
 
+static NSDictionary *ANNDictionaryOrNil(id value) {
+    return [value isKindOfClass:NSDictionary.class] ? value : nil;
+}
+
+static NSString *ANNStringOrNil(id value) {
+    return [value isKindOfClass:NSString.class] && [value length] > 0 ? value : nil;
+}
+
+// The definition that a plural key (`UILaunchScreens`, `UILaunchStoryboards`) marks as its default.
+static NSDictionary *ANNDefaultDefinition(id plural, NSString *definitionsKey,
+                                          NSString *identifierKey, NSString *defaultKey) {
+    NSDictionary *dictionary = ANNDictionaryOrNil(plural);
+    NSArray *definitions = dictionary[definitionsKey];
+    NSString *defaultIdentifier = ANNStringOrNil(dictionary[defaultKey]);
+    if (![definitions isKindOfClass:NSArray.class] || !defaultIdentifier) {
+        return nil;
+    }
+    for (id definition in definitions) {
+        NSDictionary *entry = ANNDictionaryOrNil(definition);
+        if ([entry[identifierKey] isEqual:defaultIdentifier]) {
+            return entry;
+        }
+    }
+    return nil;
+}
+
+// The launch screen that iOS builds from the Info.plist without a storyboard, or nil when it shows a storyboard. Of
+// `UILaunchStoryboardName`, `UILaunchScreen`, the default of `UILaunchStoryboards` and the default of
+// `UILaunchScreens`, the last one present wins (SplashBoard's `XBApplicationLaunchCompatibilityInfo`). A launch by a
+// link that `UILaunchScreens` maps to a screen of its own still gets the default here.
+static NSDictionary *ANNLaunchScreenConfiguration(NSBundle *bundle) {
+    NSDictionary *screen =
+        ANNDefaultDefinition([bundle objectForInfoDictionaryKey:@"UILaunchScreens"],
+                             @"UILaunchScreenDefinitions", @"UILaunchScreenIdentifier",
+                             @"UIDefaultLaunchScreen");
+    if (screen) {
+        return screen;
+    }
+    if (ANNDefaultDefinition([bundle objectForInfoDictionaryKey:@"UILaunchStoryboards"],
+                             @"UILaunchStoryboardDefinitions", @"UILaunchStoryboardIdentifier",
+                             @"UIDefaultLaunchStoryboard")) {
+        return nil;
+    }
+    return ANNDictionaryOrNil([bundle objectForInfoDictionaryKey:@"UILaunchScreen"]);
+}
+
 @implementation ANNSplashViewController {
     UIViewController *_content;
     UIView *_contentView;
+    NSDictionary *_launchScreen;
+    // The parts of a launch screen built from `UILaunchScreen`, laid out once the safe area is known.
+    UIImageView *_imageView;
+    BOOL _imageRespectsSafeArea;
+    UINavigationBar *_navigationBar;
+    UIImageView *_navigationBarImageView;
+    UIView *_bottomBar;
+    UIImageView *_bottomBarImageView;
 }
 
 - (instancetype)initWithContent:(UIViewController *)content
@@ -52,6 +106,12 @@ static NSArray<NSString *> *ANNLegacyLaunchImageNames(CGFloat height) {
 
 + (instancetype)launchScreenCopyWithBounds:(CGRect)bounds {
     NSBundle *bundle = NSBundle.mainBundle;
+    NSDictionary *launchScreen = ANNLaunchScreenConfiguration(bundle);
+    if (launchScreen) {
+        ANNSplashViewController *copy = [[self alloc] initWithContent:nil contentView:nil blank:NO];
+        copy->_launchScreen = launchScreen;
+        return copy;
+    }
     NSString *storyboardName = [bundle objectForInfoDictionaryKey:@"UILaunchStoryboardName"];
     if ([storyboardName isKindOfClass:NSString.class] && storyboardName.length > 0) {
         UIViewController *initial = nil;
@@ -97,6 +157,10 @@ static NSArray<NSString *> *ANNLegacyLaunchImageNames(CGFloat height) {
         view.backgroundColor = windowHasColor ? UIColor.clearColor : UIColor.systemBackgroundColor;
         return;
     }
+    if (_launchScreen) {
+        [self buildLaunchScreen];
+        return;
+    }
     UIView *contentView = _contentView;
     if (_content) {
         [self addChildViewController:_content];
@@ -109,6 +173,89 @@ static NSArray<NSString *> *ANNLegacyLaunchImageNames(CGFloat height) {
     [_content didMoveToParentViewController:self];
 }
 
+#pragma mark - The launch screen of `UILaunchScreen`
+
+// Built as SplashBoard builds it: the named color over the whole screen, else the system background; the named image
+// at its own size in the middle of the screen or of its safe area, stretched instead when the asset has slicing; a tab
+// bar or a toolbar at the bottom and a navigation bar at the top, the system's own bars, or the bar's named image
+// stretched over the bar's place. A name the asset catalog doesn't have leaves its part out, as iOS does.
+- (void)buildLaunchScreen {
+    UIView *view = self.view;
+    NSString *colorName = ANNStringOrNil(_launchScreen[@"UIColorName"]);
+    UIColor *color = colorName ? [UIColor colorNamed:colorName] : nil;
+    view.backgroundColor = color ?: UIColor.systemBackgroundColor;
+
+    NSString *imageName = ANNStringOrNil(_launchScreen[@"UIImageName"]);
+    UIImage *image = imageName ? [UIImage imageNamed:imageName] : nil;
+    if (image) {
+        _imageView = [[UIImageView alloc] initWithImage:image];
+        _imageView.contentMode = UIEdgeInsetsEqualToEdgeInsets(image.capInsets, UIEdgeInsetsZero)
+                                     ? UIViewContentModeCenter
+                                     : UIViewContentModeScaleToFill;
+        id respects = _launchScreen[@"UIImageRespectsSafeAreaInsets"];
+        _imageRespectsSafeArea = [respects respondsToSelector:@selector(boolValue)] &&
+                                 [respects boolValue];
+        [view addSubview:_imageView];
+    }
+
+    // A toolbar takes the bottom before a tab bar; a navigation bar comes on top of either.
+    id toolbar = _launchScreen[@"UIToolbar"];
+    id tabBar = _launchScreen[@"UITabBar"];
+    if (toolbar || tabBar) {
+        _bottomBar = toolbar ? [UIToolbar new] : [UITabBar new];
+        _bottomBarImageView = [self addBar:_bottomBar configuration:toolbar ?: tabBar];
+    }
+    id navigationBar = _launchScreen[@"UINavigationBar"];
+    if (navigationBar) {
+        _navigationBar = [UINavigationBar new];
+        _navigationBarImageView = [self addBar:_navigationBar configuration:navigationBar];
+    }
+}
+
+// Adds the bar, or its image in its place when its configuration names one that loads.
+- (UIImageView *)addBar:(UIView *)bar configuration:(id)configuration {
+    NSString *name = ANNStringOrNil(ANNDictionaryOrNil(configuration)[@"UIImageName"]);
+    UIImage *image = name ? [UIImage imageNamed:name] : nil;
+    UIImageView *imageView = image ? [[UIImageView alloc] initWithImage:image] : nil;
+    bar.hidden = imageView != nil;
+    [self.view addSubview:bar];
+    if (imageView) {
+        [self.view addSubview:imageView];
+    }
+    return imageView;
+}
+
+// The safe area is known only in the window, so the parts are laid out here, after every change of it.
+- (void)viewDidLayoutSubviews {
+    [super viewDidLayoutSubviews];
+    if (!_launchScreen) {
+        return;
+    }
+    CGRect bounds = self.view.bounds;
+    UIEdgeInsets safeArea = self.view.safeAreaInsets;
+    _imageView.frame =
+        _imageRespectsSafeArea ? UIEdgeInsetsInsetRect(bounds, safeArea) : bounds;
+    [self layOutBar:_bottomBar imageView:_bottomBarImageView atBottom:YES];
+    [self layOutBar:_navigationBar imageView:_navigationBarImageView atBottom:NO];
+}
+
+// A bar is as tall as UIKit makes it, plus the safe area on its edge of the screen, and as wide as the screen.
+- (void)layOutBar:(UIView *)bar
+        imageView:(UIImageView *)imageView
+         atBottom:(BOOL)atBottom {
+    if (!bar) {
+        return;
+    }
+    CGRect bounds = self.view.bounds;
+    UIEdgeInsets safeArea = self.view.safeAreaInsets;
+    CGFloat height = [bar sizeThatFits:bounds.size].height +
+                     (atBottom ? safeArea.bottom : safeArea.top);
+    CGFloat y = atBottom ? CGRectGetMaxY(bounds) - height : CGRectGetMinY(bounds);
+    CGRect frame = CGRectMake(CGRectGetMinX(bounds), y, CGRectGetWidth(bounds), height);
+    bar.frame = frame;
+    imageView.frame = frame;
+}
+
 #pragma mark - The status bar, as the launch screen had it
 
 - (UIStatusBarStyle)preferredStatusBarStyle {

package/ios/Layouts/Screen/ANNComponentPresenter.h

@@ -19,11 +19,19 @@ NS_ASSUME_NONNULL_BEGIN
 /// it. Nothing before the screen's view is loaded.
 - (void)applyBackground:(ANNNavigationOptions *)resolvedOptions;
 
-/// `statusBar.blur` (iOS): UIKit's regular blur over the screen's own view in the frame of the scene's status bar at
-/// this moment (x 0, the view's width; it doesn't follow a rotation); `false` or none removes it. At each appearance
-/// and at a merge that names it; nothing before the screen's view is loaded.
+/// `statusBar.blur` (iOS): UIKit's regular blur over the screen's own view in the frame of the scene's status bar (x 0,
+/// the view's width), laid out at once; `false` or none removes it. At each appearance and at a merge that names it;
+/// nothing before the screen's view is loaded.
 - (void)applyStatusBarBlur:(ANNNavigationOptions *)resolvedOptions;
 
+/// The blur takes the status bar's frame as it is now; nothing without a blur. The single place of its frame: the blur
+/// as it is applied, the screen's view laid out (a rotation, a new window size, a new safe area), a size transition
+/// along its animation and at its end, the turn after new traits, and `statusBarDidChange`.
+- (void)layOutStatusBarBlur;
+
+/// The status bar was asked again (hidden or shown, a new style): every blur takes its frame.
++ (void)statusBarDidChange;
+
 /// The blur stays the last subview of the screen's view: the content added after it goes under it.
 - (void)keepStatusBarBlurOnTop;
 

package/ios/Layouts/Screen/ANNComponentPresenter.mm

@@ -5,6 +5,10 @@
 #import "ANNTopBarPresenter.h"
 #import "ANNUtils.h"
 
+// The presenters whose screen shows `statusBar.blur`: the status bar hidden or shown lays out no view, so they hear of
+// it from the system UI (`statusBarDidChange`).
+static NSHashTable<ANNComponentPresenter *> *ANNBlurringPresenters;
+
 @implementation ANNComponentPresenter {
     // `statusBar.blur` while it is on.
     UIVisualEffectView *_statusBarBlur;
@@ -95,9 +99,7 @@
 
 #pragma mark - The status bar's blur (`statusBar.blur`)
 
-// Over the screen's own view, never over a React view; no touches, nothing for VoiceOver. The frame is the scene's
-// status bar's as it is now, in the view's own coordinates without a conversion: a pushed screen's view may still be
-// out of place while it appears.
+// Over the screen's own view, never over a React view; no touches, nothing for VoiceOver.
 - (void)applyStatusBarBlur:(ANNNavigationOptions *)resolvedOptions {
     ANNComponentViewController *screen = self.screen;
     if (!screen.isViewLoaded) {
@@ -106,6 +108,7 @@
     if (![resolvedOptions.statusBar.blur withDefault:NO]) {
         [_statusBarBlur removeFromSuperview];
         _statusBarBlur = nil;
+        [ANNBlurringPresenters removeObject:self];
         return;
     }
     UIView *view = screen.view;
@@ -115,15 +118,40 @@
         _statusBarBlur.userInteractionEnabled = NO;
         _statusBarBlur.isAccessibilityElement = NO;
         _statusBarBlur.accessibilityElementsHidden = YES;
+        if (!ANNBlurringPresenters) {
+            ANNBlurringPresenters = [NSHashTable weakObjectsHashTable];
+        }
+        [ANNBlurringPresenters addObject:self];
     }
-    CGRect statusBar = ANNUtils.statusBarFrame;
-    _statusBarBlur.frame = CGRectMake(0, CGRectGetMinY(statusBar), CGRectGetWidth(view.bounds),
-                                      CGRectGetHeight(statusBar));
     if (_statusBarBlur.superview != view) {
         [view addSubview:_statusBarBlur];
     } else {
         [view bringSubviewToFront:_statusBarBlur];
     }
+    [self layOutStatusBarBlur];
+}
+
+// The status bar's frame in the scene of the screen's window (the main window's before the screen is in one), in the
+// view's own coordinates without a conversion: a pushed screen's view may still be out of place while it appears. A
+// hidden status bar has no frame, and the blur no height.
+- (void)layOutStatusBarBlur {
+    UIView *view = _statusBarBlur.superview;
+    if (!view) {
+        return;
+    }
+    UIWindowScene *scene = view.window.windowScene;
+    CGRect statusBar = scene ? scene.statusBarManager.statusBarFrame : ANNUtils.statusBarFrame;
+    CGRect frame = CGRectMake(0, CGRectGetMinY(statusBar), CGRectGetWidth(view.bounds),
+                              CGRectGetHeight(statusBar));
+    if (!CGRectEqualToRect(_statusBarBlur.frame, frame)) {
+        _statusBarBlur.frame = frame;
+    }
+}
+
++ (void)statusBarDidChange {
+    for (ANNComponentPresenter *presenter in ANNBlurringPresenters.allObjects) {
+        [presenter layOutStatusBarBlur];
+    }
 }
 
 - (void)keepStatusBarBlurOnTop {

package/ios/Layouts/Screen/ANNComponentViewController.h

@@ -1,6 +1,7 @@
 #import "ANNArrangementScreenDelegate.h"
 #import "ANNLayoutProtocol.h"
 #import "ANNScreenAppearance.h"
+#import "ANNScreenPlace.h"
 #import "UIViewController+LayoutProtocol.h"
 #import <UIKit/UIKit.h>
 
@@ -10,8 +11,8 @@ NS_ASSUME_NONNULL_BEGIN
 ///
 /// Its view has the size of the screen of the navigation window's scene; the content sits in the root frame, by the one
 /// "under bars" rule (`ANNScreenBars`). Every recompute of the frame (a layout, a change of the safe area or the
-/// traits, `mergeOptions`, an appearance) gives the modules the screen's insets, padding and regions
-/// (`ANNScreenInsets`, `ANNScreenRegions`). Its presenter is an `ANNComponentPresenter`.
+/// traits, `mergeOptions`, an appearance) gives the store the screen's insets, padding and regions
+/// (`ANNScreenEnvironment`). Its presenter is an `ANNComponentPresenter`.
 ///
 /// The screen answers UIKit's questions about the system UI (native screens too): the status bar's style and visibility
 /// (never animated), the orientations, the home indicator, the deferred edges and the vertical bars, from its resolved
@@ -42,21 +43,22 @@ NS_ASSUME_NONNULL_BEGIN
 /// nobody rendered gets its content when UIKit first loads its view.
 - (void)render;
 
+/// Where the screen will show while it waits for its content out of it (parked by a stack's or `showInColumn`'s wait,
+/// or in a tab rendered before it shows, `ANNParking`): it lays out with that place's safe area and bars
+/// (`ANNScreenPlace`), as it will once it shows there. Asked at each layout, and kept past the parking until UIKit
+/// gives the screen a safe area of its own in a parent (the push lays it out once before that, with none), or as it
+/// appears. Nil: its view's own. Set by the one that parks the screen.
+@property(nonatomic, copy, nullable) ANNScreenPlace *_Nullable (^placeWhileParked)(void);
+
+/// The place is kept until the screen appears, not only until UIKit gives it a safe area: a tab's screen rendered
+/// before the tab shows gets a part of it first (the bar without the status bar) as UIKit lays the tab out. Set with
+/// `placeWhileParked`, and goes with it.
+@property(nonatomic) BOOL placeKeptUntilAppearance;
+
 /// Applies the "under bars" rule to the root frame again, then gives the modules the insets, the padding and the
 /// regions of the screen. Nothing before the view loaded; the safe area only in a window.
 - (void)updateRootLayout;
 
-/// The content view (only the core's React view, never the screen's own view) mounts unseen in `host` (the tabs'
-/// preload window) at the frame it has, while the screen's tab isn't shown. NO when there is nothing to lend: no React
-/// view of its own, in a window already, lent already, or the screen went.
-- (BOOL)lendContentTo:(UIView *)host;
-
-/// The lent content comes back into the screen's view at its root frame; also as the screen first appears.
-- (void)takeContentBack;
-
-/// The content is lent (`lendContentTo:`): `updateRootLayout` leaves its frame alone meanwhile.
-@property(nonatomic, readonly) BOOL contentIsLent;
-
 /// The transition that removes the screen starts (before its destroy): with `blurOnUnmount` in its resolved options,
 /// the editing inside its view ends and the keyboard goes (`blurOnUnmount`).
 - (void)screenWillLeave;