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

package/ios/Core/ANNRenderWait.mm

@@ -1,12 +1,26 @@
 #import "ANNRenderWait.h"
 #import "ANNAssert.h"
 #import "ANNComponentViewController.h"
+#import "ANNJavaScriptCalls.h"
 #import "ANNScreenReadiness.h"
 #import "UIViewController+LayoutProtocol.h"
+#import <QuartzCore/QuartzCore.h>
 
 // A screen whose rendered state stays unknown counts as ready after this, with `unknownContentRule`.
 static const NSTimeInterval ANNUnknownContentLimit = 1;
 
+// What a kind of the bar whose limit passed in the content phase still gets, with `barLimitsFromStart`: a limit of 0
+// would mean none of its own.
+static const NSTimeInterval ANNPassedBarLimit = 0.001;
+
+// What is left of a bar kind's `limit` after `spent`; no limit of its own stays none.
+static NSTimeInterval ANNBarLimitLeft(NSTimeInterval limit, NSTimeInterval spent) {
+    if (limit <= 0) {
+        return limit;
+    }
+    return MAX(limit - spent, ANNPassedBarLimit);
+}
+
 // The number of the last wait made: each wait listens under a key of its own.
 static NSUInteger ANNRenderWaitCount;
 
@@ -18,12 +32,18 @@ static NSUInteger ANNRenderWaitCount;
     ANNRenderWaitBar _bar;
     ANNBarWaitLimits _barLimits;
     NSString *_key;
+    // When the running wait started (`barLimitsFromStart`).
+    CFTimeInterval _startTime;
     // The token: each start, phase and end takes the next one, so that what an earlier one set up does nothing.
     NSUInteger _number;
     // Inside `start`: a step runs as it is, under the caller's protection.
     BOOL _starting;
     // Inside `setUp`: a ready handler leaves the node to the readiness test after it.
     BOOL _settingUp;
+    // The content is there and the phase waits for the calls JavaScript made by then (`settlesThroughJavaScript`); the
+    // number of that settle, so that one of an earlier take does nothing.
+    BOOL _settling;
+    NSUInteger _settleNumber;
     // The content nodes still waited, and every node the wait set its ready handler on.
     NSHashTable<UIViewController *> *_waited;
     NSHashTable<UIViewController *> *_listened;
@@ -70,6 +90,7 @@ static NSUInteger ANNRenderWaitCount;
     _isWaiting = YES;
     _isInBarPhase = NO;
     _mountLimitPassed = NO;
+    _startTime = CACurrentMediaTime();
     NSUInteger number = ++_number;
     _starting = YES;
     @try {
@@ -117,11 +138,9 @@ static NSUInteger ANNRenderWaitCount;
     if (![self runs:number]) {
         return;
     }
-    if (_content == ANNRenderWaitContentNode && _node && [self screensAreReady]) {
-        [_waited removeObject:_node];
-    }
+    [self testNode];
     if (_waited.count == 0 && !_barWait) {
-        [self phaseOfNumber:number endedMarkingReady:NO];
+        [self contentOfNumber:number];
     }
 }
 
@@ -206,7 +225,7 @@ static NSUInteger ANNRenderWaitCount;
     }
     [_waited removeObject:node];
     if (_waited.count == 0 && !_barWait) {
-        [self phaseOfNumber:number endedMarkingReady:NO];
+        [self contentOfNumber:number];
     }
 }
 
@@ -219,6 +238,36 @@ static NSUInteger ANNRenderWaitCount;
     if (_waited.count > 0) {
         return;
     }
+    [self contentOfNumber:number];
+}
+
+// What the running phase waited for came by its signals, or was there already. The content phase with
+// `settlesThroughJavaScript` ends once the calls JavaScript made by now are applied: the commit that mounted the content
+// ran its layout effects (`useScreenOptions`) in the same task of the JavaScript thread, so their `mergeOptions` are on
+// their way to the main queue ahead of the settle. Content that was there already (as the wait starts or takes its
+// screens again) may have mounted in a commit that ran just now: it settles too. The bar phase, and screens without
+// React content (a native screen), end at once.
+- (void)contentOfNumber:(NSUInteger)number {
+    if (!_settlesThroughJavaScript || _isInBarPhase || ![self hasReactScreen]) {
+        [self phaseOfNumber:number endedMarkingReady:NO];
+        return;
+    }
+    if (_settling) {
+        return;
+    }
+    _settling = YES;
+    NSUInteger settle = ++_settleNumber;
+    __weak ANNRenderWait *weakSelf = self;
+    [ANNJavaScriptCalls afterCallsMadeSoFar:^{
+      [weakSelf settleOfNumber:number settle:settle];
+    }];
+}
+
+- (void)settleOfNumber:(NSUInteger)number settle:(NSUInteger)settle {
+    if (![self runs:number] || !_settling || settle != _settleNumber) {
+        return;
+    }
+    _settling = NO;
     [self phaseOfNumber:number endedMarkingReady:NO];
 }
 
@@ -240,9 +289,18 @@ static NSUInteger ANNRenderWaitCount;
     }
 }
 
-// The limit: what is still waited counts as rendered from now on, its held events go at once.
+// The limit: what is still waited counts as rendered from now on, its held events go at once. A phase that only waits
+// for the calls of JavaScript (its content is there) ends without marking anything.
 - (void)limitOfNumber:(NSUInteger)number {
-    if (![self runs:number] || (_waited.count == 0 && !_barWait)) {
+    if (![self runs:number]) {
+        return;
+    }
+    if (_settling) {
+        [self stopSettling];
+        [self phaseOfNumber:number endedMarkingReady:NO];
+        return;
+    }
+    if (_waited.count == 0 && !_barWait) {
         return;
     }
     [self phaseOfNumber:number endedMarkingReady:YES];
@@ -288,7 +346,7 @@ static NSUInteger ANNRenderWaitCount;
           [self markContentReady];
       }
       if (self->_bar == ANNRenderWaitBarAfterContent && !self->_isInBarPhase) {
-          [self startBarPhase];
+          [self startBarPhaseWithLimits:[self barLimitsAfterContent]];
           return;
       }
       [self finish];
@@ -309,9 +367,10 @@ static NSUInteger ANNRenderWaitCount;
 
 #pragma mark - The bar phase
 
-// The content is there: the bar components of the screens now, each kind to its own limit from now. Nothing to wait
-// for ends the wait at once.
-- (void)startBarPhase {
+// The content is there: the bar components of the screens now, each kind to its limit in `limits` from now. Nothing to
+// wait for ends the wait at once.
+- (void)startBarPhaseWithLimits:(ANNBarWaitLimits)limits {
+    [self stopSettling];
     [_barWait cancel];
     _barWait = nil;
     [self releaseContent];
@@ -321,7 +380,7 @@ static NSUInteger ANNRenderWaitCount;
     NSArray<UIViewController *> *barScreens = [self barScreens];
     [self rememberTakenScreens:barScreens states:nil];
     ANNBarComponentsWait *barWait = [ANNBarComponentsWait waitForScreens:barScreens
-                                                                  limits:_barLimits
+                                                                  limits:limits
                                                                     done:^{
                                                                       [weakSelf barOfNumber:number];
                                                                     }];
@@ -344,23 +403,28 @@ static NSUInteger ANNRenderWaitCount;
     }
     if (_isInBarPhase) {
         [self runStep:^{
-          [self startBarPhase];
+          [self startBarPhaseWithLimits:self->_barLimits];
         }];
         return;
     }
     // The same token: the limit set at the start stays.
     NSUInteger number = _number;
+    [self stopSettling];
     [self releaseContent];
     [_barWait cancel];
     _barWait = nil;
-    if (take) {
-        [self takeScreensOfNumber:number];
-    } else {
+    if (!take) {
         _takenScreens = nil;
         _takenStates = nil;
+        [self phaseOfNumber:number endedMarkingReady:NO];
+        return;
     }
+    // As at the start: a node ready already counts at once (its ready handler waits for the next time), and content
+    // that is there settles again, the settle of the last take having stopped.
+    [self takeScreensOfNumber:number];
+    [self testNode];
     if (_waited.count == 0 && !_barWait) {
-        [self phaseOfNumber:number endedMarkingReady:NO];
+        [self contentOfNumber:number];
     }
 }
 
@@ -382,6 +446,7 @@ static NSUInteger ANNRenderWaitCount;
 
 // The wait lets go of everything: its handlers, its bar wait; its limits find another token.
 - (void)stop {
+    [self stopSettling];
     _isWaiting = NO;
     _isInBarPhase = NO;
     _takenScreens = nil;
@@ -404,6 +469,12 @@ static NSUInteger ANNRenderWaitCount;
 
 #pragma mark - Helpers
 
+// A settle on its way does nothing from now on.
+- (void)stopSettling {
+    _settling = NO;
+    _settleNumber++;
+}
+
 // What the content phase's take reads of each screen to decide what it waits for: the readiness it needs, whether it
 // has its content yet, whether that content is ready, and whether its root mounted.
 - (NSArray<NSNumber *> *)takeStateOfScreens:(NSArray<UIViewController *> *)screens {
@@ -470,6 +541,37 @@ static NSUInteger ANNRenderWaitCount;
     return screens;
 }
 
+// With `ANNRenderWaitContentNode`, the node counts as ready when every screen of it is.
+- (void)testNode {
+    if (_content == ANNRenderWaitContentNode && _node && [self screensAreReady]) {
+        [_waited removeObject:_node];
+    }
+}
+
+// The limits of the bar phase that follows the content phase: with `barLimitsFromStart`, what is left of each since the
+// wait started.
+- (ANNBarWaitLimits)barLimitsAfterContent {
+    ANNBarWaitLimits limits = _barLimits;
+    if (!_barLimitsFromStart) {
+        return limits;
+    }
+    NSTimeInterval spent = CACurrentMediaTime() - _startTime;
+    limits.titleAndBackground = ANNBarLimitLeft(limits.titleAndBackground, spent);
+    limits.buttons = ANNBarLimitLeft(limits.buttons, spent);
+    return limits;
+}
+
+// A screen with React content is among the screens: a commit of React mounted it.
+- (BOOL)hasReactScreen {
+    for (UIViewController *node in [self screens]) {
+        if ([node isKindOfClass:ANNComponentViewController.class] &&
+            ((ANNComponentViewController *)node).reactView) {
+            return YES;
+        }
+    }
+    return NO;
+}
+
 // Every screen has no content to wait for (a native screen) or its content is ready.
 - (BOOL)screensAreReady {
     for (UIViewController *node in [self screens]) {

package/ios/Core/UIViewController+LayoutProtocol.h

@@ -64,10 +64,17 @@ FOUNDATION_EXPORT ANNWaitedReadiness ANNWaitedReadinessOf(UIViewController *scre
 /// The own options merged with `options` (`ANNNodeHelper mergeOwnOptions:`).
 - (void)mergeOwnOptions:(ANNNavigationOptions *)options;
 
-/// A change of the own options on a copy (`ANNNodeHelper changeOwnOptions:`): the way a presenter or a module keeps a
-/// choice of the user (a scope, tokens, a checked menu item, a toggled button).
+/// A change of the own options on a copy (`ANNNodeHelper changeOwnOptions:`): what the core keeps of the app's merges.
 - (void)changeOwnOptions:(void (^)(ANNNavigationOptions *options))change;
 
+/// A choice of the user in the node's user layer (`ANNNodeHelper setUserChoice:forKey:`): the way a presenter or a
+/// module keeps what the user did (a scope, tokens, a checked menu item, a toggled button, a renamed title). Nil
+/// removes it.
+- (void)setUserChoice:(nullable ANNUserChoice *)choice forKey:(NSString *)key;
+
+/// The choice of the user layer under `key`, or nil (`ANNNodeHelper userChoiceForKey:`).
+- (nullable ANNUserChoice *)userChoiceForKey:(NSString *)key;
+
 #pragma mark - Readiness
 
 /// A ready handler of the node under the waiter's own key (`ANNNodeHelper setReadyHandler:forKey:`): it runs once, the

package/ios/Core/UIViewController+LayoutProtocol.mm

@@ -125,6 +125,14 @@ ANNWaitedReadiness ANNWaitedReadinessOf(UIViewController *screen) {
     [self.nodeHelper changeOwnOptions:change];
 }
 
+- (void)setUserChoice:(ANNUserChoice *)choice forKey:(NSString *)key {
+    [self.nodeHelper setUserChoice:choice forKey:key];
+}
+
+- (ANNUserChoice *)userChoiceForKey:(NSString *)key {
+    return [self.nodeHelper userChoiceForKey:key];
+}
+
 #pragma mark - Readiness
 
 - (void)setReadyHandler:(dispatch_block_t)handler forKey:(NSString *)key {

package/ios/Layouts/Modal/ANNModalCoordinator.h

@@ -25,7 +25,7 @@ NS_ASSUME_NONNULL_BEGIN
 
 /// `dismissModal`: the record of `componentId` (its root's id or any id inside, also of a modal closed below or by the
 /// user), the options merged into its visible screen, the animation from the command's screen, then its state decides.
-/// Answers with the root's id.
+/// Answers with the root's id. The last modal over no root rejects `[ANNErrorTexts modalWithoutRoot:]`, as on Android.
 + (void)dismissModal:(NSString *)componentId
              options:(nullable NSDictionary *)options
               answer:(ANNCommandAnswer *)answer;

package/ios/Layouts/Modal/ANNModalCoordinator.mm

@@ -277,8 +277,8 @@ static void ANNCollectIds(UIViewController *node, NSMutableSet<NSString *> *ids)
 
 // The end steps of a record (its show presented, its dismissal ended, closed by the user) run inside UIKit's
 // completions and delegate calls, outside the runner's protection, in any state: a failure there is logged in one line,
-// rejects what of the record still waits for an answer (its show, a chain step, its dismissals), and its drive stops.
-// The gate's `done` ran before the step, as without a failure.
+// answers what of the record still waits for an answer (its show, a chain step, its dismissals:
+// `endFailedOf:showing:exception:`), and its drive stops. The gate's `done` ran before the step, as without a failure.
 + (void)protectEndOf:(ANNModal *)modal showing:(BOOL)showing step:(dispatch_block_t)step {
     @try {
         step();
@@ -288,24 +288,43 @@ static void ANNCollectIds(UIViewController *node, NSMutableSet<NSString *> *ids)
                                : (showing ? @"show a modal" : @"dismiss a modal");
         NSString *reason = exception.reason.length > 0 ? exception.reason : exception.name;
         RCTLogWarn(@"[ApexNavigation] %@", [ANNErrorTexts couldNot:what reason:reason]);
-        [self endFailedOf:modal exception:exception];
+        [self endFailedOf:modal showing:showing exception:exception];
     }
 }
 
-+ (void)endFailedOf:(ANNModal *)modal exception:(NSException *)exception {
+// A failed end step of `modal`: its show rejects. After a failed show the dismissals that wait for it don't fail with
+// it, as on Android: on a modal that shows they run now and resolve once it went (one still `Presenting` shows: UIKit's
+// completion ran); on one that goes another way (a `dismissAllModals`, with the old root) or went already they resolve
+// with its root's id; on one in another transition (a drag, its own dismissal) they wait for that transition's end.
+// A failed dismissal rejects itself and the dismissals behind it.
++ (void)endFailedOf:(ANNModal *)modal showing:(BOOL)showing exception:(NSException *)exception {
     if (!modal) {
         return;
     }
     [self stopDriving:modal];
     NSString *show = [NSString stringWithFormat:@"show the screen '%@'", modal.rootId];
-    NSString *dismiss = [NSString stringWithFormat:@"dismiss the modal '%@'", modal.rootId];
     [modal.showAnswer reject:[ANNCommandRunner rejectionOf:exception what:show]];
-    NSString *dismissText = [ANNCommandRunner rejectionOf:exception what:dismiss];
-    [modal.dismissal.answer reject:dismissText];
-    NSArray<ANNModalDismissal *> *pending = modal.pending.copy;
-    [modal.pending removeAllObjects];
-    for (ANNModalDismissal *waiting in pending) {
-        [waiting.answer reject:dismissText];
+    ANNModalState state = modal.state;
+    BOOL goesAnotherWay = (state == ANNModalStateDismissing && modal.batch) ||
+                          state == ANNModalStateWithOldRoot ||
+                          state == ANNModalStateClosedBelow || state == ANNModalStateGone;
+    if (showing && state == ANNModalStatePresenting) {
+        modal.state = ANNModalStateShown;
+    }
+    if (showing && modal.state == ANNModalStateShown) {
+        [self runPendingOf:modal];
+    } else if (showing && goesAnotherWay) {
+        [modal.dismissal.answer resolve:modal.rootId];
+        [self resolvePendingOf:modal];
+    } else if (!showing) {
+        NSString *dismiss = [NSString stringWithFormat:@"dismiss the modal '%@'", modal.rootId];
+        NSString *dismissText = [ANNCommandRunner rejectionOf:exception what:dismiss];
+        [modal.dismissal.answer reject:dismissText];
+        NSArray<ANNModalDismissal *> *pending = modal.pending.copy;
+        [modal.pending removeAllObjects];
+        for (ANNModalDismissal *waiting in pending) {
+            [waiting.answer reject:dismissText];
+        }
     }
     // A `setRoot` chain goes on (its own steps are guarded by the root coordinator).
     void (^chainStep)(BOOL) = modal.chainStep;
@@ -333,7 +352,7 @@ static void ANNCollectIds(UIViewController *node, NSMutableSet<NSString *> *ids)
             [waiter reject:text];
         }
         for (ANNModal *modal in batch.records.copy) {
-            [self endFailedOf:modal exception:exception];
+            [self endFailedOf:modal showing:NO exception:exception];
         }
     }
 }
@@ -537,7 +556,8 @@ static void ANNCollectIds(UIViewController *node, NSMutableSet<NSString *> *ids)
     modal.coversUnder = under != nil && under.viewIfLoaded.window == nil;
     NSArray<UIViewController *> *hidden = modal.coversUnder ? @[ under ] : @[];
     @try {
-        // The chain step stays on the record until its events went: a failure there tells the chain (`endFailedOf:`).
+        // The chain step stays on the record until its events went: a failure there tells the chain
+        // (`endFailedOf:showing:exception:`).
         void (^chainStep)(BOOL) = modal.chainStep;
         if (chainStep) {
             [ANNAppearanceDispatcher endSwitchHiding:hidden showing:@[ root ] events:nil];
@@ -778,6 +798,11 @@ static void ANNCollectIds(UIViewController *node, NSMutableSet<NSString *> *ids)
         [answer reject:[ANNErrorTexts screenNotShown:componentId]];
         return;
     }
+    // The last modal over no root (shown before any `setRoot`) stays: nothing would be left to show, as on Android.
+    if ([self isLastWithoutRoot:modal]) {
+        [answer reject:[ANNErrorTexts modalWithoutRoot:componentId]];
+        return;
+    }
     // Step 1: the options, read on the main queue; one that can't be read rejects before anything changes. They merge
     // into the modal's visible screen as `mergeOptions` would.
     if (options.count > 0) {
@@ -815,6 +840,22 @@ static void ANNCollectIds(UIViewController *node, NSMutableSet<NSString *> *ids)
     [self dismiss:modal with:dismissal];
 }
 
+// No root in the window (the splash, or nothing yet) and no other modal that shows or comes: `modal` is all a dismissal
+// would take away. One closed below, going with the old root or gone takes nothing away, so it doesn't count.
++ (BOOL)isLastWithoutRoot:(ANNModal *)modal {
+    if (modal.state == ANNModalStateClosedBelow || modal.state == ANNModalStateGone ||
+        ApexNavigation.mainWindow.rootViewController.isLayoutNode) {
+        return NO;
+    }
+    for (ANNModal *other in ANNModals) {
+        if (other != modal && other.state != ANNModalStateClosedBelow &&
+            other.state != ANNModalStateWithOldRoot && other.state != ANNModalStateGone) {
+            return NO;
+        }
+    }
+    return YES;
+}
+
 // The modal of `node`: the record whose root is the top of `node`'s layout.
 + (ANNModal *)modalOf:(UIViewController *)node {
     UIViewController *top = node;
@@ -897,7 +938,7 @@ static void ANNCollectIds(UIViewController *node, NSMutableSet<NSString *> *ids)
                    [ANNErrorTexts couldNot:what reason:exception.reason ?: exception.name]);
         // The dismissal still open answers, and so do the dismissals waiting behind it (an answer given already
         // stays as it was).
-        [self endFailedOf:modal exception:exception];
+        [self endFailedOf:modal showing:NO exception:exception];
         done();
     }
 }

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>
 
@@ -42,6 +43,13 @@ 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,
+/// `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);
+
 /// 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;

package/ios/Layouts/Screen/ANNComponentViewController.mm

@@ -162,6 +162,11 @@
     [ANNSystemUI setNeedsUpdate];
     [self.arrangement screenDidChangeLayout:self];
     [ANNHinge watchForScreens];
+    // A parked screen whose place gave it no safe area at all lays out with its view's own from now on.
+    if (self.placeWhileParked && ![ANNParking isUnseen:self]) {
+        self.placeWhileParked = nil;
+        [self updateRootLayout];
+    }
     // Once JavaScript heard the appearance (a driven one ends later, with its command).
     __weak ANNComponentViewController *weakSelf = self;
     [ANNAppearanceDispatcher afterDidAppearOf:self.appearance
@@ -363,11 +368,31 @@
 }
 #endif
 
+// The place the screen waits to show in, while it is parked out of it and until UIKit gives it a safe area of its
+// own there: the push lays the screen out once before that, with none, and a list laid out then at the screen's top
+// would stay the list the bar follows. A place that shows with no safe area at all hands over as the screen appears.
+- (nullable ANNScreenPlace *)parkedPlace {
+    ANNScreenPlace * (^place)(void) = self.placeWhileParked;
+    if (!place) {
+        return nil;
+    }
+    if (![ANNParking isUnseen:self] && self.parentViewController &&
+        !UIEdgeInsetsEqualToEdgeInsets(self.view.safeAreaInsets, UIEdgeInsetsZero)) {
+        self.placeWhileParked = nil;
+        return nil;
+    }
+    return place();
+}
+
 - (CGRect)rootFrameForOptions:(ANNNavigationOptions *)options {
     UIView *view = self.view;
-    BOOL fromTop = ANNScreenIsUnderTopBar(options) || ![self hasShownTopBar];
-    BOOL toBottom = ANNScreenIsUnderTabBar(options) || ![self hasShownTabBar];
-    return ANNScreenRootFrame(view.bounds, view.safeAreaInsets, fromTop, toBottom);
+    ANNScreenPlace *place = [self parkedPlace];
+    BOOL topBarShown = place ? place.showsTopBar : [self hasShownTopBar];
+    BOOL tabBarShown = place ? place.showsTabBar : [self hasShownTabBar];
+    BOOL fromTop = ANNScreenIsUnderTopBar(options) || !topBarShown;
+    BOOL toBottom = ANNScreenIsUnderTabBar(options) || !tabBarShown;
+    UIEdgeInsets safeArea = place ? place.safeArea : view.safeAreaInsets;
+    return ANNScreenRootFrame(view.bounds, safeArea, fromTop, toBottom);
 }
 
 - (void)updateRootLayout {
@@ -421,8 +446,10 @@
         self.nodeHelper.destroyed) {
         return;
     }
-    UIEdgeInsets insets =
-        ANNScreenInsetsOverRoot(content.frame, view.bounds.size, view.safeAreaInsets);
+    // A parked screen has no safe area of its own: it takes its place's.
+    ANNScreenPlace *place = [self parkedPlace];
+    UIEdgeInsets safeArea = place ? place.safeArea : view.safeAreaInsets;
+    UIEdgeInsets insets = ANNScreenInsetsOverRoot(content.frame, view.bounds.size, safeArea);
     UINavigationController *stack = [self shownNavigation];
     ANNScreenPaddingContext context = {
         .inStack = stack != nil,

package/ios/Layouts/Screen/ANNScreenPlace.h

@@ -0,0 +1,41 @@
+#import "ANNNavigationOptions.h"
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// Where an entry will show on top of a stack, as UIKit lays it out there: the safe area its screens get, and whether
+/// the stack's bar and the tab bar show for it. A screen that waits for its content out of its stack (parked,
+/// `ANNParking`) has no parent view controller, and UIKit gives its view no safe area at all: it lays out with its
+/// place's instead (`placeWhileParked` of `ANNComponentViewController`), so that its root frame, its padding, the
+/// insets JavaScript reads in its first render and its main list are those it has after the push. Nothing of it moves
+/// as the push starts: a list that moved then would lose the large title, which UIKit draws in the list the bar
+/// follows.
+///
+/// The bar's height is UIKit's own: a navigation controller of the core's, unseen in the stack's view for the moment of
+/// the measure, shows an item made like the entry's (title, display mode of the large title, looks, subtitles, prompt,
+/// style, search field) over one like the stack's top, with the stack's bar settings and the entry's toolbar. Main
+/// queue.
+@interface ANNScreenPlace : NSObject
+
+- (instancetype)init NS_UNAVAILABLE;
++ (instancetype)new NS_UNAVAILABLE;
+
+/// The place of `entry` (a screen, or a pair whose screens show under its bar) on top of `stack`, with `options` the
+/// resolved options the stack shows its bar and toolbar by; nil when the stack isn't in a window. Measured again only
+/// when something the measure reads changed since the last one for `entry`.
++ (nullable ANNScreenPlace *)placeOfEntry:(UIViewController *)entry
+                                  inStack:(UINavigationController *)stack
+                                  options:(ANNNavigationOptions *)options;
+
+/// The safe area of the entry's view in the place.
+@property(nonatomic, readonly) UIEdgeInsets safeArea;
+
+/// The stack's bar shows for the entry (`topBar.visible`).
+@property(nonatomic, readonly) BOOL showsTopBar;
+
+/// A tab bar shows at the bottom for the entry: one shows now and the entry doesn't hide it.
+@property(nonatomic, readonly) BOOL showsTabBar;
+
+@end
+
+NS_ASSUME_NONNULL_END