@apexnative/navigation 0.0.0-stage → 1.0.0-alpha.0

package/ios/Core/ANNParking.mm

@@ -0,0 +1,117 @@
+#import "ANNParking.h"
+#import "ANNAppearanceDispatcher.h"
+#import "ANNAssert.h"
+#import "UIViewController+LayoutProtocol.h"
+
+// What a parked view had before it waited, and where it waits.
+@interface ANNParkedView : NSObject
+@property(nonatomic, weak, nullable) UIView *host;
+@property(nonatomic) BOOL userInteractionEnabled;
+@property(nonatomic) BOOL accessibilityElementsHidden;
+@property(nonatomic) UIViewAutoresizing autoresizingMask;
+@end
+
+@implementation ANNParkedView
+@end
+
+// Every node that waits in a parking now, whichever parking it is. Weak; main queue.
+static NSHashTable<UIViewController *> *ANNParkedNodes(void) {
+    static NSHashTable<UIViewController *> *nodes;
+    if (!nodes) {
+        nodes = [NSHashTable weakObjectsHashTable];
+    }
+    return nodes;
+}
+
+@implementation ANNParking {
+    // The parking holds its nodes: a node waits here until its waiter takes it out.
+    NSMapTable<UIViewController *, ANNParkedView *> *_parked;
+}
+
+- (instancetype)init {
+    if (self = [super init]) {
+        _parked = [NSMapTable strongToStrongObjectsMapTable];
+    }
+    return self;
+}
+
+- (BOOL)park:(UIViewController *)node inView:(UIView *)host {
+    ANNAssertMainQueue();
+    if ([_parked objectForKey:node]) {
+        return NO;
+    }
+    UIView *view = node.view;
+    ANNParkedView *parked = [ANNParkedView new];
+    parked.host = host;
+    parked.userInteractionEnabled = view.userInteractionEnabled;
+    parked.accessibilityElementsHidden = view.accessibilityElementsHidden;
+    parked.autoresizingMask = view.autoresizingMask;
+    [_parked setObject:parked forKey:node];
+    [ANNParkedNodes() addObject:node];
+    view.userInteractionEnabled = NO;
+    view.accessibilityElementsHidden = YES;
+    // It follows the host while it waits.
+    view.autoresizingMask = UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight;
+    view.frame = host.bounds;
+    [ANNAppearanceDispatcher driveAppearanceOf:@[ node ]];
+    [host insertSubview:view atIndex:0];
+    return YES;
+}
+
+// UIKit reports a view controller without a parent whose view leaves a window as disappearing at once, but its
+// `viewDidDisappear:` only after the next commit. A node that shows in the same turn (a root that becomes the window's
+// root) would get that late call after its own appearance, and UIKit would keep it disappeared for good: a stack UIKit
+// takes for disappeared gives the screens it pushes neither their appearance nor their safe area. The waiter that
+// shows the node at once ends the departure here.
+- (void)unpark:(UIViewController *)node endingDeparture:(BOOL)endingDeparture {
+    ANNAssertMainQueue();
+    ANNParkedView *parked = [_parked objectForKey:node];
+    if (!parked) {
+        return;
+    }
+    [_parked removeObjectForKey:node];
+    [ANNParkedNodes() removeObject:node];
+    UIView *view = node.viewIfLoaded;
+    view.userInteractionEnabled = parked.userInteractionEnabled;
+    view.accessibilityElementsHidden = parked.accessibilityElementsHidden;
+    view.autoresizingMask = parked.autoresizingMask;
+    if (endingDeparture) {
+        [node beginAppearanceTransition:NO animated:NO];
+    }
+    // UIKit places the view itself once it shows it: only the parking's own place is left.
+    if (view.superview == parked.host) {
+        [view removeFromSuperview];
+    }
+    if (endingDeparture) {
+        [node endAppearanceTransition];
+    }
+    [ANNAppearanceDispatcher stopDrivingAppearanceOf:@[ node ]];
+}
+
++ (BOOL)isUnseen:(UIViewController *)node {
+    ANNAssertMainQueue();
+    NSHashTable<UIViewController *> *parked = ANNParkedNodes();
+    if (parked.count == 0) {
+        return NO;
+    }
+    for (UIViewController *parent = node; parent; parent = parent.layoutParent) {
+        if ([parked containsObject:parent]) {
+            return YES;
+        }
+    }
+    return NO;
+}
+
+- (BOOL)isParked:(UIViewController *)node {
+    return [_parked objectForKey:node] != nil;
+}
+
+- (NSArray<UIViewController *> *)parkedNodes {
+    NSMutableArray<UIViewController *> *nodes = [NSMutableArray new];
+    for (UIViewController *node in _parked.keyEnumerator) {
+        [nodes addObject:node];
+    }
+    return nodes;
+}
+
+@end

package/ios/Core/ANNPendingLayers.h

@@ -0,0 +1,31 @@
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// The layers that wait to show: a root a `setRoot` puts up while it waits (for its render, then for its turn at the
+/// presentation gate); a modal or an overlay that waits. Such a layer sits in the window, unseen. A node inside it
+/// counts as off screen, and what changes what the layer shows tells the layer's wait, so that the wait follows a top a
+/// command changed. The layer's owner adds it when it starts to wait in the window and removes it when it shows or
+/// goes; nodes only ask. Main queue.
+@interface ANNPendingLayers : NSObject
+
+- (instancetype)init NS_UNAVAILABLE;
++ (instancetype)new NS_UNAVAILABLE;
+
+/// `layer` waits to show from now on. `onShownScreensChanged` runs each time what a node inside it shows changed
+/// (`shownScreensChangedIn:`); the layer keeps it until it is removed. Adding a layer again replaces its handler.
++ (void)add:(UIViewController *)layer onShownScreensChanged:(dispatch_block_t)onShownScreensChanged;
+
+/// `layer` waits to show no more; nothing when it doesn't.
++ (void)remove:(UIViewController *)layer;
+
+/// Whether `node`, or a layout parent of it, is a layer that waits to show.
++ (BOOL)isWaitingToShow:(UIViewController *)node;
+
+/// What `node` shows changed (a stack command ran in it): the nearest layer that waits to show and holds it hears it.
+/// Nothing when no such layer holds it.
++ (void)shownScreensChangedIn:(UIViewController *)node;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/Core/ANNPendingLayers.mm

@@ -0,0 +1,57 @@
+#import "ANNPendingLayers.h"
+#import "ANNAssert.h"
+#import "UIViewController+LayoutProtocol.h"
+
+// The layers that wait, kept weakly: a layer that goes without being removed waits no more. Main queue.
+static NSMapTable<UIViewController *, dispatch_block_t> *ANNLayers(void) {
+    static NSMapTable<UIViewController *, dispatch_block_t> *layers;
+    if (!layers) {
+        layers = [NSMapTable weakToStrongObjectsMapTable];
+    }
+    return layers;
+}
+
+@implementation ANNPendingLayers
+
++ (void)add:(UIViewController *)layer onShownScreensChanged:(dispatch_block_t)onShownScreensChanged {
+    ANNAssertMainQueue();
+    [ANNLayers() setObject:[onShownScreensChanged copy] forKey:layer];
+}
+
++ (void)remove:(UIViewController *)layer {
+    ANNAssertMainQueue();
+    [ANNLayers() removeObjectForKey:layer];
+}
+
+// The layer that waits to show and holds `node`, the nearest first.
++ (nullable UIViewController *)layerOf:(UIViewController *)node {
+    NSMapTable<UIViewController *, dispatch_block_t> *layers = ANNLayers();
+    if (layers.count == 0) {
+        return nil;
+    }
+    for (UIViewController *parent = node; parent; parent = parent.layoutParent) {
+        if ([layers objectForKey:parent]) {
+            return parent;
+        }
+    }
+    return nil;
+}
+
++ (BOOL)isWaitingToShow:(UIViewController *)node {
+    ANNAssertMainQueue();
+    return [self layerOf:node] != nil;
+}
+
++ (void)shownScreensChangedIn:(UIViewController *)node {
+    ANNAssertMainQueue();
+    UIViewController *layer = [self layerOf:node];
+    if (!layer) {
+        return;
+    }
+    dispatch_block_t handler = [ANNLayers() objectForKey:layer];
+    if (handler) {
+        handler();
+    }
+}
+
+@end

package/ios/Core/ANNReloadCoordinator.h

@@ -0,0 +1,26 @@
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// The life of the JavaScript the navigation answers to.
+///
+/// The generation is a number that grows each time the JavaScript goes: when React Native's reload command is given,
+/// and again when the next bundle loaded (the only signal of every reload). Every command takes it when it arrives; its queued work and its answer do nothing once the number
+/// moved: the commands of the JavaScript that went get no answer, and its screens tell the new JavaScript nothing.
+///
+/// React Native tells when a bundle loaded, the first one of the process too. After a reload the navigation of the old
+/// JavaScript goes; after every bundle the navigation state is forgotten and `ANN.AppLaunched` goes to JavaScript.
+@interface ANNReloadCoordinator : NSObject
+
+/// The generation of the JavaScript that runs now. Any thread.
+@property(class, nonatomic, readonly) NSUInteger generation;
+
+/// How many bundles ran in the process so far, counted as each one's `AppLaunched` goes. Any thread.
+@property(class, nonatomic, readonly) NSUInteger bundleCount;
+
+/// Starts watching the bundles: once, when the navigation starts (`bootstrapWithHost:`). Main queue.
++ (void)start;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/Core/ANNReloadCoordinator.mm

@@ -0,0 +1,211 @@
+#import "ANNReloadCoordinator.h"
+#import "ANNArrangementState.h"
+#import "ANNAssert.h"
+#import "ANNErrorTexts.h"
+#import "ANNHinge.h"
+#import "ANNModalCoordinator.h"
+#import "ANNNativeScreenCalls.h"
+#import "ANNNavigationState.h"
+#import "ANNNodeRegistry.h"
+#import "ANNOverlayCoordinator.h"
+#import "ANNPresentationGate.h"
+#import "ANNPreviewInteraction.h"
+#import "ANNPreviewPush.h"
+#import "ANNRootCoordinator.h"
+#import "ANNScreenInsets.h"
+#import "ANNScreenReadiness.h"
+#import "ANNScreenRegions.h"
+#import "ANNSplashViewController.h"
+#import "ANNSplitViewCommands.h"
+#import "ANNTabsPreloadWindow.h"
+#import "ApexNavigation+Internal.h"
+#import "UIViewController+LayoutProtocol.h"
+#import <React/RCTConstants.h>
+#import <React/RCTLog.h>
+#import <React/RCTReloadCommand.h>
+#import <ReactCommon/RCTHost.h>
+#import <React/RCTUtils.h>
+#import <atomic>
+
+// How long the screens of the JavaScript that went stay before they are destroyed: React Native restarts the surfaces
+// of attached roots after a reload and holds them until they started; a surface released earlier is released while it
+// runs.
+static const NSTimeInterval ANNReleaseAfterReloadDelay = 2;
+
+// Any thread.
+static std::atomic<NSUInteger> ANNGeneration{0};
+// Main queue.
+// Any thread (read).
+static std::atomic<NSUInteger> ANNBundleCount{0};
+static BOOL ANNWatchingBundles;
+
+@implementation ANNReloadCoordinator
+
++ (NSUInteger)generation {
+    return ANNGeneration.load();
+}
+
++ (NSUInteger)bundleCount {
+    return ANNBundleCount.load();
+}
+
+// React Native's bridgeless instance (`RCTInstance`) posts `RCTJavaScriptDidLoadNotification` on the main queue once
+// a bundle ran, the first one of the process too, with itself as the object. The host doesn't give its instance, but
+// both answer the same surface presenter: a bundle of another host is not ours.
+//
+// A reload asked for through React Native's reload command (the dev menu, Command-R, `DevSettings.reload`) posts
+// `RCTTriggerReloadCommandNotification` before the old instance goes: the generation grows there at once, so the old
+// JavaScript's queued work and answers stop before the next bundle. A reload of the host from native code
+// (`[RCTHost reload]`) and one from the debugger post nothing first; for them the number grows at the next bundle.
++ (void)start {
+    ANNAssertMainQueue();
+    if (ANNWatchingBundles) {
+        return;
+    }
+    ANNWatchingBundles = YES;
+    [NSNotificationCenter.defaultCenter addObserver:self
+                                           selector:@selector(bundleDidLoad:)
+                                               name:RCTJavaScriptDidLoadNotification
+                                             object:nil];
+    [NSNotificationCenter.defaultCenter addObserver:self
+                                           selector:@selector(reloadWasAskedFor:)
+                                               name:RCTTriggerReloadCommandNotification
+                                             object:nil];
+}
+
+// Any thread: the reload command may come from the JavaScript's own queue.
++ (void)reloadWasAskedFor:(NSNotification *)notification {
+    ANNGeneration++;
+}
+
++ (void)bundleDidLoad:(NSNotification *)notification {
+    id instance = notification.object;
+    RCTExecuteOnMainQueue(^{
+      RCTSurfacePresenter *ours = [ApexNavigation getHost].surfacePresenter;
+      // The object is typed nowhere public: its getter is asked for by name.
+      if (ours && [instance respondsToSelector:@selector(surfacePresenter)] &&
+          [instance valueForKey:@"surfacePresenter"] != ours) {
+          return;
+      }
+      [self didLoadBundle];
+    });
+}
+
+// The order is the contract's: the old navigation goes, the state is forgotten, then the new JavaScript hears
+// `AppLaunched` and starts its navigation.
++ (void)didLoadBundle {
+    if (ANNBundleCount++ > 0) {
+        // The work of the old JavaScript still queued, and its answers, do nothing from now on (again, when the reload
+        // command grew the number already). The new JavaScript sends its first command after `AppLaunched` below.
+        ANNGeneration++;
+        [self resetAfterReload];
+    }
+    [ANNNavigationState reset];
+    [ApexNavigation.eventEmitter sendAppLaunched];
+}
+
++ (void)resetAfterReload {
+    // The calls waiting for the old JavaScript fail, each naming itself and its screen.
+    [ANNNativeScreenCalls failAllCalls:^NSString *(NSString *name, NSString *componentId) {
+      return [ANNErrorTexts nativeCallReloaded:name componentId:componentId];
+    }];
+    // The previews go without telling the old JavaScript; their screens still run their React views. Those still
+    // looking for their views stop and go the same way.
+    [self releaseAfterReload:[ANNPreviewInteraction removeAllPreviewsAfterReload]];
+    [self releaseAfterReload:[ANNPreviewPush takeSearchingForReload]];
+    // The new JavaScript asks for the hinge again with its own hooks.
+    [ANNHinge setUpdatesEnabled:NO eventEmitter:nil];
+    // Before the registry is cleared: the layouts to take away are found there too.
+    [self resetNavigationAfterReload];
+    [ANNNodeRegistry clear];
+}
+
+// The root of the window, the modals (their coordinator's records, never a walk of UIKit's chain), the overlays
+// and what the root coordinator holds (a pending root, the root a running transition replaces) are the old screens.
+// Nothing of them tells the new JavaScript anything: their emitters belong to the old one. They stay 2 s and are
+// destroyed then (`releaseAfterReload:`).
++ (void)resetNavigationAfterReload {
+    UIWindow *window = ApexNavigation.mainWindow;
+    UIViewController *root = window.rootViewController;
+    NSMutableArray<UIViewController *> *oldScreens = [NSMutableArray new];
+    // 1. The old screens.
+    if (![ANNRootCoordinator isSplash:root]) {
+        [oldScreens addObject:root];
+    }
+    // 2. The modals go without animation and without `ANN.ModalDismissed`: the new JavaScript never showed them. Their
+    // coordinator gives them, stops their waits, takes their waiting views out of the window (step 5: they leave the
+    // layers that wait to show) and forgets its list; UIKit's chain over the root is dismissed through the presentation
+    // gate, after a running transition.
+    [oldScreens addObjectsFromArray:[ANNModalCoordinator takeAllForReload]];
+    // The pending `setRoot` of the old JavaScript gets no answer.
+    [oldScreens addObjectsFromArray:[ANNRootCoordinator takeNodesForReload]];
+    [self dismissPresentedOver:root];
+    // 3. The overlays' windows hide at once; their screens join `oldScreens`; the main window is key and seen by
+    // VoiceOver again. The previews went already (`resetAfterReload`).
+    [oldScreens addObjectsFromArray:[ANNOverlayCoordinator takeAllForReload]];
+    // 4. The bar components and the tabs' cells and accessories have no store to empty: each screen and each tabs node
+    // keeps its own roots in its registry, so a new node never gets an old root by its id, and the old roots stop with
+    // their old nodes after the hold. The tabs' preload windows hide at once; their views go with their tabs. The loop
+    // updates are off already.
+    [ANNTabsPreloadWindow hideAllAfterReload];
+    // 5. The native screens of the old screens are silent by their emitter. The modals and overlays waiting to show
+    // left what waits for them in steps 2 and 3; the screens that wait to show in a split view's column leave it here,
+    // without an answer.
+    [oldScreens addObjectsFromArray:[ANNSplitViewCommands takeAllForReload]];
+    // The new JavaScript counts its ids anew: nothing the safe area views of the old screens said stays ready for a new
+    // screen with the same id. The old surfaces are stopped or silent. The same for what the old screens kept for
+    // JavaScript: their insets and padding, regions and arrangement states (an old screen still in a window writes no
+    // insets or regions again: its emitter is not current).
+    [ANNScreenReadiness reset];
+    [ANNScreenInsets removeAll];
+    [ANNScreenRegions removeAll];
+    [ANNArrangementState removeAll];
+    // 6. The window shows the blank screen, which counts as the splash: a reload is not a launch. The
+    // reset runs from the second bundle of the process on.
+    if (window) {
+        window.rootViewController = [ANNSplashViewController blankScreen];
+    }
+    // 7.
+    [self releaseAfterReload:oldScreens];
+}
+
+// UIKit drops a dismissal asked for while a presentation or dismissal runs: the old chain goes as a step of the
+// presentation gate, after what runs, from the old root (no longer the window's once the blank screen replaced it).
++ (void)dismissPresentedOver:(UIViewController *)root {
+    if (!root.presentedViewController) {
+        return;
+    }
+    ANNGateStep *step = [[ANNGateStep alloc] initWithRun:^(dispatch_block_t done) {
+      if (!root.presentedViewController) {
+          done();
+          return;
+      }
+      [root dismissViewControllerAnimated:NO completion:done];
+    }];
+    step.transitionRoot = ^UIViewController * {
+      return root;
+    };
+    [ANNPresentationGate enqueue:step];
+}
+
+// The screens stay until React Native restarted their surfaces in the new runtime, then each is destroyed on the main
+// queue: its surface stops, and its events go nowhere (its emitter is of the old JavaScript).
++ (void)releaseAfterReload:(NSArray<UIViewController *> *)screens {
+    if (screens.count == 0) {
+        return;
+    }
+    int64_t delay = (int64_t)(ANNReleaseAfterReloadDelay * NSEC_PER_SEC);
+    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, delay), dispatch_get_main_queue(), ^{
+      for (UIViewController *screen in screens) {
+          @try {
+              [screen destroy];
+          } @catch (NSException *exception) {
+              RCTLogWarn(@"[ApexNavigation] could not destroy a screen of the JavaScript that "
+                         @"reloaded: %@",
+                         exception.reason ?: exception.name);
+          }
+      }
+    });
+}
+
+@end

package/ios/Core/ANNRenderWait.h

@@ -0,0 +1,105 @@
+#import "ANNBarComponentsWait.h"
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// What content a render wait waits for.
+typedef NS_ENUM(NSInteger, ANNRenderWaitContent) {
+    /// No content: the bar components alone (a push without `waitForRender`).
+    ANNRenderWaitContentNone,
+    /// Each screen of `screens` whose React content isn't ready, by its own ready handler (a root's screens). The limit
+    /// marks ready the screens still waited.
+    ANNRenderWaitContentEachScreen,
+    /// `node` as a whole, by its ready handler (a screen, or a pair once both of its screens are), and after `setUp` by
+    /// the test that every screen of `screens` has no content to wait for or its content is ready (a stack's entry).
+    /// The limit marks ready every screen of `screens`.
+    ANNRenderWaitContentNode,
+};
+
+/// How a render wait waits for the bar components of `screens` (title, background, component buttons).
+typedef NS_ENUM(NSInteger, ANNRenderWaitBar) {
+    /// Not at all.
+    ANNRenderWaitBarNone,
+    /// Together with the content, within the wait's limit, and each kind within `barLimits` (0: the wait's limit only).
+    ANNRenderWaitBarWithContent,
+    /// A phase of their own once the content is there, each kind within `barLimits` from the phase's start.
+    ANNRenderWaitBarAfterContent,
+};
+
+/// The one wait for the render of what a command shows: the content of some screens within a limit or none, `markReady`
+/// at the limit (their held events go at once); the bar components within the limit or as a phase after the content;
+/// the rule for content of unknown readiness. A token makes every ready handler, limit and bar callback of an earlier
+/// wait or phase do nothing. The owner says what it waits for and what runs at the end; a root's `setRoot`, a stack's
+/// push and `setStackRoot`, and the show of a modal and of an overlay use it. Each wait listens under a ready handler
+/// key of its own (`ANNNodeHelper setReadyHandler:forKey:`). Main queue.
+@interface ANNRenderWait : NSObject
+
+/// `screens` gives the screens the wait is about: their bar components, the screens the limit marks ready, the screens
+/// of the unknown-content rule, and with `ANNRenderWaitContentEachScreen` the screens whose content it waits for, each
+/// by the readiness it needs (`ANNWaitedReadinessOf`: content, or "root mounted" without its bar components). It is
+/// asked as the wait starts, as it takes its screens again (`retakeScreens:`) and as its bar phase starts. `node` is
+/// the node of `ANNRenderWaitContentNode`; nil otherwise. `limit` 0: no limit.
+- (instancetype)initWithContent:(ANNRenderWaitContent)content
+                           node:(nullable UIViewController *)node
+                        screens:(NSArray<UIViewController *> * (^)(void))screens
+                          limit:(NSTimeInterval)limit
+                            bar:(ANNRenderWaitBar)bar
+                      barLimits:(ANNBarWaitLimits)barLimits NS_DESIGNATED_INITIALIZER;
+
+- (instancetype)init NS_UNAVAILABLE;
++ (instancetype)new NS_UNAVAILABLE;
+
+/// The longest a waited screen of the "root mounted" kind (`ANNWaitedReadinessOf`, an unselected tab's screen) is
+/// waited for, from the start, also when the wait has no limit: a screen the user doesn't see never holds a command for
+/// long. 0: only the wait's own limit.
+@property(nonatomic) NSTimeInterval mountLimit;
+
+/// The rule for content of unknown readiness: 1 s after the start, a screen whose rendered state stays unknown (no safe
+/// area view says it) counts as ready; a screen whose safe area view spoke waits for its signal. Off by default (a root
+/// has none).
+@property(nonatomic) BOOL unknownContentRule;
+
+/// Runs inside `start`, after the ready handlers are set and before the readiness test (the stack parks and renders
+/// its entry there). A ready handler that runs inside it is left to the test after it.
+@property(nonatomic, copy, nullable) dispatch_block_t setUp;
+
+/// Asked each time the wait would end or go on to its bar phase: NO leaves it waiting as it is (a stack's operation
+/// that ended or belongs to an old JavaScript). Nil: always YES.
+@property(nonatomic, copy, nullable) BOOL (^canEnd)(void);
+
+/// The owner's protection of the steps that come later (a ready handler, a limit, the bar components, `endPhase`,
+/// `retakeScreens:`): it gets each step that ends the wait or starts its bar phase, and runs it. Steps inside `start`
+/// run as they are, under the caller's own protection. Nil: steps run as they are.
+@property(nonatomic, copy, nullable) void (^protect)(dispatch_block_t step);
+
+/// Runs once, when the wait ends by itself (never after `cancel`), after it let go of everything.
+@property(nonatomic, copy, nullable) dispatch_block_t ended;
+
+/// The wait starts: the bar components that go with the content, the ready handlers, `setUp`, the readiness test, and
+/// the limits. It may end inside (nothing to wait for).
+- (void)start;
+
+/// The wait runs (also in its bar phase).
+@property(nonatomic, readonly) BOOL isWaiting;
+
+/// The wait runs its bar phase (`ANNRenderWaitBarAfterContent`, the content being there).
+@property(nonatomic, readonly) BOOL isInBarPhase;
+
+/// What the waited place shows changed (a stack command inside a waiting root): in the content phase the wait lets go
+/// of what it waited for and, when `take`, takes `screens` again (with the bar components that go with them) with the
+/// same token, so that its limit stays; it ends when nothing is left. In the bar phase the phase starts again, with its
+/// limits from now. `take` NO: the place went (destroyed); the content phase takes nothing. Nothing when it doesn't
+/// run, and nothing when `take` would take the same screens as the phase's last take, in the content phase each with
+/// the same readiness, content, readiness of its content and first mount.
+- (void)retakeScreens:(BOOL)take;
+
+/// The running phase ends now, as if what it waits for were there, without `markReady` (a stack that left the screen):
+/// the content phase goes on to the bar phase, the bar phase ends the wait. Through `canEnd` and `protect`.
+- (void)endPhase;
+
+/// The wait ends without `ended`: its handlers, its bar wait and its limits do nothing from now on.
+- (void)cancel;
+
+@end
+
+NS_ASSUME_NONNULL_END