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

package/ios/Core/ANNHinge.mm

@@ -1,5 +1,6 @@
 #import "ANNHinge.h"
 #import "ANNAssert.h"
+#import "ANNEventContract.h"
 #import "ANNUtils.h"
 
 NSNotificationName const ANNHingeDidChangeNotification = @"ANNHingeDidChange";
@@ -34,11 +35,12 @@ static NSDictionary<NSString *, id> *ANNHingeValue(UIHinge *hinge) API_AVAILABLE
     if (!hinge) {
         return @{};
     }
+    const auto &keys = ANNEventContract.HingeChanged;
     NSString *state = ANNHingeStateName(hinge.status);
     if (hinge.status == UIHingeStatusUnknown) {
-        return @{@"state" : state};
+        return @{keys.state : state};
     }
-    return @{@"state" : state, @"angle" : @(round(hinge.angle * 1800 / M_PI) / 10)};
+    return @{keys.state : state, keys.angle : @(round(hinge.angle * 1800 / M_PI) / 10)};
 }
 #endif
 
@@ -94,13 +96,13 @@ static NSDictionary<NSString *, id> *ANNHingeValue(UIHinge *hinge) API_AVAILABLE
         if ([ANNLastHinge isEqualToDictionary:value]) {
             return;
         }
-        previousState = ANNLastHinge[@"state"];
+        previousState = ANNLastHinge[ANNEventContract.HingeChanged.state];
         ANNLastHinge = value;
     }
     if (ANNHingeUpdatesEnabled) {
         [ANNHingeEventEmitter sendHingeChanged:value];
     }
-    id state = value[@"state"];
+    id state = value[ANNEventContract.HingeChanged.state];
     if (previousState != state && ![previousState isEqual:state]) {
         [NSNotificationCenter.defaultCenter postNotificationName:ANNHingeDidChangeNotification
                                                           object:nil];

package/ios/Core/ANNSceneDelegate.mm

@@ -1,9 +1,10 @@
 #import "ANNSceneDelegate.h"
+#import "ANNDeepLinkQueue.h"
 #import "ApexNavigation.h"
-#import <React/RCTLinkingManager.h>
 
 // On the scene life cycle UIKit stops calling the app delegate's URL, user activity and foreground/background
-// methods. The scene forwards them, so AppDelegate overrides (and the deep links of ANNDeepLinkQueue) keep working.
+// methods. The scene forwards them, so AppDelegate overrides (and the deep links of ANNDeepLinkQueue) keep working; the
+// links keep their scene, through which React Native 0.88 and newer take them.
 @implementation ANNSceneDelegate
 
 - (void)scene:(UIScene *)scene
@@ -15,21 +16,21 @@
     self.window = [ApexNavigation attachToWindowScene:(UIWindowScene *)scene];
 
     for (UIOpenURLContext *context in connectionOptions.URLContexts) {
-        [self ann_openURLContext:context];
+        [self ann_openURLContext:context ofScene:scene];
     }
     for (NSUserActivity *activity in connectionOptions.userActivities) {
-        [self ann_continueUserActivity:activity];
+        [self ann_continueUserActivity:activity ofScene:scene];
     }
 }
 
 - (void)scene:(UIScene *)scene openURLContexts:(NSSet<UIOpenURLContext *> *)URLContexts {
     for (UIOpenURLContext *context in URLContexts) {
-        [self ann_openURLContext:context];
+        [self ann_openURLContext:context ofScene:scene];
     }
 }
 
 - (void)scene:(UIScene *)scene continueUserActivity:(NSUserActivity *)userActivity {
-    [self ann_continueUserActivity:userActivity];
+    [self ann_continueUserActivity:userActivity ofScene:scene];
 }
 
 - (void)sceneDidBecomeActive:(UIScene *)scene {
@@ -62,7 +63,7 @@
 
 #pragma mark - private
 
-- (void)ann_openURLContext:(UIOpenURLContext *)context {
+- (void)ann_openURLContext:(UIOpenURLContext *)context ofScene:(UIScene *)scene {
     UIApplication *application = UIApplication.sharedApplication;
     id<UIApplicationDelegate> appDelegate = application.delegate;
     if ([appDelegate respondsToSelector:@selector(application:openURL:options:)]) {
@@ -70,22 +71,31 @@
         options[UIApplicationOpenURLOptionsSourceApplicationKey] = context.options.sourceApplication;
         options[UIApplicationOpenURLOptionsAnnotationKey] = context.options.annotation;
         options[UIApplicationOpenURLOptionsOpenInPlaceKey] = @(context.options.openInPlace);
-        [appDelegate application:application openURL:context.URL options:options];
+        [ANNDeepLinkQueue forwardURLContext:context
+                                    ofScene:scene
+                                    through:^{
+                                      [appDelegate application:application openURL:context.URL options:options];
+                                    }];
     } else {
-        [RCTLinkingManager application:application openURL:context.URL options:@{}];
+        [ANNDeepLinkQueue openURLContext:context ofScene:scene];
     }
 }
 
-- (void)ann_continueUserActivity:(NSUserActivity *)activity {
+- (void)ann_continueUserActivity:(NSUserActivity *)activity ofScene:(UIScene *)scene {
     UIApplication *application = UIApplication.sharedApplication;
     id<UIApplicationDelegate> appDelegate = application.delegate;
     if ([appDelegate respondsToSelector:@selector(application:continueUserActivity:restorationHandler:)]) {
-        [appDelegate application:application
-             continueUserActivity:activity
-               restorationHandler:^(NSArray<id<UIUserActivityRestoring>> *restorableObjects){
-               }];
+        [ANNDeepLinkQueue forwardUserActivity:activity
+                                      ofScene:scene
+                                      through:^{
+                                        [appDelegate application:application
+                                             continueUserActivity:activity
+                                               restorationHandler:^(
+                                                   NSArray<id<UIUserActivityRestoring>> *restorableObjects){
+                                               }];
+                                      }];
     } else if ([activity.activityType isEqualToString:NSUserActivityTypeBrowsingWeb]) {
-        [RCTLinkingManager application:application openURL:activity.webpageURL options:@{}];
+        [ANNDeepLinkQueue openUserActivity:activity ofScene:scene];
     }
 }
 

package/ios/Core/ANNSystemUI.h

@@ -36,8 +36,9 @@ typedef NS_ENUM(NSInteger, ANNSystemUIQuestion) {
 /// The owner adds the asks UIKit doesn't make — a merge, a side menu at rest, an overlay, a root replaced, the bar of a
 /// stack shown or hidden, the orientation after an appearance — and makes them once per turn of the main queue: a
 /// trigger marks groups, the marks of a turn are coalesced, and at its end UIKit is asked again for each marked group
-/// in the main window and every overlay window. It keeps no values but the last status bar of each window, which only
-/// chooses whether a change of the style animates. Never a wait. Main queue.
+/// in the main window and every overlay window. Each ask of the status bar also lays out the screens' blurs under it
+/// (`statusBar.blur`), then and on the next turn. It keeps no values but the last status bar of each window, which
+/// only chooses whether a change of the style animates. Never a wait. Main queue.
 @interface ANNSystemUI : NSObject
 
 - (instancetype)init NS_UNAVAILABLE;

package/ios/Core/ANNSystemUI.mm

@@ -1,5 +1,6 @@
 #import "ANNSystemUI.h"
 #import "ANNAssert.h"
+#import "ANNComponentPresenter.h"
 #import "ANNComponentViewController.h"
 #import "ANNDefaultOptions.h"
 #import "ANNOverlayCoordinator.h"
@@ -280,6 +281,12 @@ static NSArray<UIViewController *> *ANNChainOf(UIWindow *window) {
             ask();
         }
     }
+    // The status bar hidden or shown moves no view where the safe area stays (a device with a notch): the blurs under
+    // it take its frame now, and once more on the next turn of the main queue, in case UIKit settles it after the ask.
+    [ANNComponentPresenter statusBarDidChange];
+    dispatch_async(dispatch_get_main_queue(), ^{
+      [ANNComponentPresenter statusBarDidChange];
+    });
 }
 
 // A controller that is no node of the layout (React Native's `<Modal>`, an alert, the splash) animates as UIKit's

package/ios/Layouts/Arrangement/ANNArrangementViewController.mm

@@ -4,6 +4,7 @@
 
 #import "ANNArrangementState.h"
 #import "ANNComponentViewController.h"
+#import "ANNEventContract.h"
 #import "ANNExternalViewController.h"
 #import "ANNShownScreens.h"
 #import "ANNUtils.h"
@@ -130,11 +131,12 @@ static BOOL ANNKeepsState(UIViewController *screen) {
 
 static NSDictionary<NSString *, id> *ANNStateOf(NSString *placement, NSString *layout, BOOL front,
                                                 BOOL hidden) {
+    const auto &keys = ANNEventContract.ArrangementChanged;
     return @{
-        @"placement" : placement,
-        @"layout" : layout,
-        @"front" : @(front),
-        @"hidden" : @(hidden),
+        keys.placement : placement,
+        keys.layout : layout,
+        keys.front : @(front),
+        keys.hidden : @(hidden),
     };
 }
 

package/ios/Layouts/Modal/ANNModalCoordinator.mm

@@ -407,7 +407,7 @@ static void ANNCollectIds(UIViewController *node, NSMutableSet<NSString *> *ids)
         ANNNavigationOptions *resolved = [root resolveOptionsWithDefault];
         ANNModalPresentation *presentation =
             [[ANNModalPresentation alloc] initWithOptions:resolved animated:modal.animatedOverride];
-        NSString *problem = [presentation problemPresentingFrom:presenting windowRoot:windowRoot];
+        NSString *problem = [presentation fitToPresenting:presenting windowRoot:windowRoot];
         if (problem) {
             [self failShowOf:modal reason:problem];
             done();

package/ios/Layouts/Modal/ANNModalPresentation.h

@@ -20,7 +20,8 @@ NS_ASSUME_NONNULL_BEGIN
 
 /// `modalPresentationStyle`: one to one; unset is UIKit's automatic style; an unknown string full screen.
 @property(nonatomic, readonly) UIModalPresentationStyle style;
-/// `modalTransitionStyle`: `coverVertical` unless one of the others is given.
+/// `modalTransitionStyle`: `coverVertical` unless one of the others is given; `partialCurl` only where UIKit curls
+/// (`fitToPresenting:windowRoot:`).
 @property(nonatomic, readonly) UIModalTransitionStyle transitionStyle;
 /// The present is animated: `enter.enabled` is not `false`.
 @property(nonatomic, readonly) BOOL animated;
@@ -47,10 +48,12 @@ NS_ASSUME_NONNULL_BEGIN
                                     animation:(nullable ANNModalAnimationOptions *)animation
                                         under:(nullable UIViewController *)under;
 
-/// Why UIKit can't make this show from `presenting` (`partialCurl` only full screen, to and from), as the reason of the
-/// rejection; nil when it can. `windowRoot` is the main window's root.
-- (nullable NSString *)problemPresentingFrom:(UIViewController *)presenting
-                                  windowRoot:(nullable UIViewController *)windowRoot;
+/// Fits the show to `presenting`, before `prepare:…`: `partialCurl` stays only for a full-screen modal over a
+/// controller that fills the screen (`presenting` is `windowRoot`, the main window's root, or a full-screen modal);
+/// otherwise `transitionStyle` becomes `coverVertical`. Returns why UIKit can't make the show (`presenting` was shown
+/// with `partialCurl`), as the reason of the rejection; nil when it can.
+- (nullable NSString *)fitToPresenting:(UIViewController *)presenting
+                            windowRoot:(nullable UIViewController *)windowRoot;
 
 /// Before `presentViewController:`: the style and the transition, the presentation's delegate, the popover kept a
 /// popover (`adaptive: false`), the sheet, the size, the popover's source on `presentingLayout`, the hold, the

package/ios/Layouts/Modal/ANNModalPresentation.mm

@@ -118,21 +118,21 @@ static NSDictionary<NSString *, NSNumber *> *ANNTransitionStyles(void) {
     return nil;
 }
 
-// UIKit takes `partialCurl` only for a full-screen modal over a controller that fills the screen, and a controller
-// shown with `partialCurl` presents nothing more: the command rejects before it asks UIKit.
-- (NSString *)problemPresentingFrom:(UIViewController *)presenting
-                         windowRoot:(UIViewController *)windowRoot {
+// UIKit curls only a full-screen modal over a controller that fills the screen: elsewhere `partialCurl` is
+// `coverVertical`, so the modal still shows. A controller shown with `partialCurl` presents nothing more: the command
+// rejects before it asks UIKit.
+- (NSString *)fitToPresenting:(UIViewController *)presenting
+                   windowRoot:(UIViewController *)windowRoot {
     if (presenting.presentingViewController &&
         presenting.modalTransitionStyle == UIModalTransitionStylePartialCurl) {
-        return @"partialCurl needs a full screen modal";
+        return @"a modal shown with partialCurl can't show another modal";
     }
-    if (_transitionStyle != UIModalTransitionStylePartialCurl) {
-        return nil;
-    }
-    BOOL presentingFills = presenting == windowRoot ||
-                           presenting.modalPresentationStyle == UIModalPresentationFullScreen;
-    if (_style != UIModalPresentationFullScreen || !presentingFills) {
-        return @"partialCurl needs a full screen modal";
+    if (_transitionStyle == UIModalTransitionStylePartialCurl) {
+        BOOL presentingFills = presenting == windowRoot ||
+                               presenting.modalPresentationStyle == UIModalPresentationFullScreen;
+        if (_style != UIModalPresentationFullScreen || !presentingFills) {
+            _transitionStyle = UIModalTransitionStyleCoverVertical;
+        }
     }
     return nil;
 }

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/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:`).
@@ -415,9 +418,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 +488,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;
     }

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.mm

@@ -3,6 +3,7 @@
 #import "ANNArrangementState.h"
 #import "ANNBottomTabsController.h"
 #import "ANNComponentPresenter.h"
+#import "ANNEventContract.h"
 #import "ANNHinge.h"
 #import "ANNKeyCommands.h"
 #import "ANNNodeRegistry.h"
@@ -66,6 +67,12 @@
 
 #pragma mark - The view
 
+- (nullable ANNComponentPresenter *)componentPresenter {
+    ANNNodePresenter *presenter = self.presenter;
+    return [presenter isKindOfClass:ANNComponentPresenter.class] ? (ANNComponentPresenter *)presenter
+                                                                  : nil;
+}
+
 // The size of the screen of the navigation window's scene, not the deprecated main screen: a surface made before the
 // screen is in a window starts with the width it will have.
 - (void)loadView {
@@ -94,6 +101,22 @@
     }
     // The pair the screen is in may lie otherwise now.
     [self.arrangement screenDidChangeLayout:self];
+    [self.componentPresenter layOutStatusBarBlur];
+}
+
+// UIKit names the size transition as the moment the status bar's frame changes (a rotation, a new window size): the
+// blur follows it along the animation and takes the final frame at its end.
+- (void)viewWillTransitionToSize:(CGSize)size
+       withTransitionCoordinator:(id<UIViewControllerTransitionCoordinator>)coordinator {
+    [super viewWillTransitionToSize:size withTransitionCoordinator:coordinator];
+    __weak ANNComponentViewController *weakSelf = self;
+    [coordinator
+        animateAlongsideTransition:^(id<UIViewControllerTransitionCoordinatorContext> context) {
+          [weakSelf.componentPresenter layOutStatusBarBlur];
+        }
+        completion:^(id<UIViewControllerTransitionCoordinatorContext> context) {
+          [weakSelf.componentPresenter layOutStatusBarBlur];
+        }];
 }
 
 - (void)viewSafeAreaInsetsDidChange {
@@ -110,6 +133,7 @@
     __weak ANNComponentViewController *weakSelf = self;
     dispatch_async(dispatch_get_main_queue(), ^{
       [weakSelf updateRootLayout];
+      [weakSelf.componentPresenter layOutStatusBarBlur];
     });
 }
 
@@ -200,9 +224,7 @@
 #pragma mark - The root frame and the safe area
 
 - (void)applyBackground {
-    if ([self.presenter isKindOfClass:ANNComponentPresenter.class]) {
-        [(ANNComponentPresenter *)self.presenter applyBackground:[self resolveOptionsWithDefault]];
-    }
+    [self.componentPresenter applyBackground:[self resolveOptionsWithDefault]];
 }
 
 // The navigation controller that shows the screen's stack: the stack, or UIKit's More navigation while a tab of More
@@ -434,7 +456,8 @@
     if (!regions) {
         return;
     }
-    BOOL empty = [regions[@"division"] count] == 0 && [regions[@"occlusion"] count] == 0;
+    const auto &keys = ANNEventContract.ScreenRegionsChanged;
+    BOOL empty = [regions[keys.division] count] == 0 && [regions[keys.occlusion] count] == 0;
     if (empty && ![ANNScreenRegions regionsForScreenId:componentId]) {
         return;
     }
@@ -606,9 +629,7 @@
     content.autoresizingMask = UIViewAutoresizingNone;
     content.frame = [self rootFrameForOptions:[self resolveOptionsWithDefault]];
     [view addSubview:content];
-    if ([self.presenter isKindOfClass:ANNComponentPresenter.class]) {
-        [(ANNComponentPresenter *)self.presenter keepStatusBarBlurOnTop];
-    }
+    [self.componentPresenter keepStatusBarBlurOnTop];
     [self applyBackground];
     [self updateRootLayout];
 }

package/ios/Layouts/Screen/ANNNativeScreenContext.mm

@@ -1,5 +1,6 @@
 #import "ANNNativeScreenContext+Internal.h"
 #import "ANNErrorTexts.h"
+#import "ANNEventContract.h"
 #import "ANNEventEmitter.h"
 #import "ANNNativeScreenCalls.h"
 #import <React/RCTUtils.h>
@@ -71,12 +72,13 @@
                                                                  componentId:self->_componentId]];
           return;
       }
+      const auto &keys = ANNEventContract.NativeScreenCall;
       [eventEmitter sendNativeScreenCall:@{
-          @"componentId" : self->_componentId,
-          @"callId" : callId,
-          @"kind" : kind,
-          @"name" : name,
-          @"args" : arguments ?: @[],
+          keys.componentId : self->_componentId,
+          keys.callId : callId,
+          keys.kind : kind,
+          keys.name : name,
+          keys.args : arguments ?: @[],
       }];
     });
 }

package/ios/Layouts/Screen/ANNScreenInsets.mm

@@ -1,4 +1,5 @@
 #import "ANNScreenInsets.h"
+#import "ANNEventContract.h"
 
 NSNotificationName const ANNScreenSafeAreaPaddingDidChangeNotification = @"ANNScreenSafeAreaPaddingDidChange";
 
@@ -26,11 +27,12 @@ static NSMutableDictionary<NSString *, NSValue *> *ANNScreenPaddingById;
                                                           object:screenId];
     }
     // JavaScript gets what still covers the content: the edges the safe area view keeps it off are 0.
+    const auto &keys = ANNEventContract.ScreenInsetsChanged;
     NSDictionary<NSString *, NSNumber *> *value = @{
-        @"top" : @(MAX(insets.top - padding.top, 0)),
-        @"right" : @(MAX(insets.right - padding.right, 0)),
-        @"bottom" : @(MAX(insets.bottom - padding.bottom, 0)),
-        @"left" : @(MAX(insets.left - padding.left, 0)),
+        keys.top : @(MAX(insets.top - padding.top, 0)),
+        keys.right : @(MAX(insets.right - padding.right, 0)),
+        keys.bottom : @(MAX(insets.bottom - padding.bottom, 0)),
+        keys.left : @(MAX(insets.left - padding.left, 0)),
     };
     @synchronized(ANNScreenInsetsById) {
         if ([ANNScreenInsetsById[screenId] isEqualToDictionary:value]) {