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

package/ios/Core/ANNSystemUIRules.mm

@@ -0,0 +1,139 @@
+#import "ANNSystemUIRules.h"
+#import <React/RCTLog.h>
+
+// The sides of one value of `layout.orientation`; `default` is the app's mask, which only the caller knows.
+static UIInterfaceOrientationMask ANNSidesOfOrientation(NSString *value) {
+    if ([value isEqualToString:@"all"] || [value isEqualToString:@"sensor"]) {
+        return UIInterfaceOrientationMaskAll;
+    }
+    if ([value isEqualToString:@"landscape"] || [value isEqualToString:@"sensorLandscape"]) {
+        return UIInterfaceOrientationMaskLandscape;
+    }
+    if ([value isEqualToString:@"portrait"]) {
+        return UIInterfaceOrientationMaskPortrait;
+    }
+    if ([value isEqualToString:@"sensorPortrait"]) {
+        return UIInterfaceOrientationMaskPortrait | UIInterfaceOrientationMaskPortraitUpsideDown;
+    }
+    if ([value isEqualToString:@"upsideDown"]) {
+        return UIInterfaceOrientationMaskPortraitUpsideDown;
+    }
+    return 0;
+}
+
+UIInterfaceOrientationMask ANNOrientationMaskOf(NSArray<NSString *> *values,
+                                                UIInterfaceOrientationMask appMask) {
+    UIInterfaceOrientationMask mask = 0;
+    for (id value in values) {
+        if (![value isKindOfClass:NSString.class]) {
+            continue;
+        }
+        mask |= [value isEqualToString:@"default"] ? appMask : ANNSidesOfOrientation(value);
+    }
+    mask &= appMask;
+    return mask != 0 ? mask : appMask;
+}
+
+UIStatusBarStyle ANNStatusBarStyleOf(NSString *style) {
+    if ([style isEqualToString:@"light"]) {
+        return UIStatusBarStyleLightContent;
+    }
+    if ([style isEqualToString:@"dark"]) {
+        return UIStatusBarStyleDarkContent;
+    }
+    return UIStatusBarStyleDefault;
+}
+
+BOOL ANNStatusBarHiddenOf(ANNStatusBarOptions *statusBar, BOOL navigationBarHidden) {
+    if (statusBar.visible.hasValue && !statusBar.visible.isNull) {
+        return ![statusBar.visible get];
+    }
+    return [statusBar.hideWithTopBar withDefault:NO] && navigationBarHidden;
+}
+
+UIRectEdge ANNDeferredEdgesOf(NSArray<NSString *> *values) {
+    UIRectEdge edges = UIRectEdgeNone;
+    for (id value in values) {
+        if ([value isEqual:@"top"]) {
+            edges |= UIRectEdgeTop;
+        } else if ([value isEqual:@"bottom"]) {
+            edges |= UIRectEdgeBottom;
+        } else if ([value isEqual:@"left"]) {
+            edges |= UIRectEdgeLeft;
+        } else if ([value isEqual:@"right"]) {
+            edges |= UIRectEdgeRight;
+        }
+    }
+    return edges;
+}
+
+#if DEBUG
+
+static void ANNExpectMask(const char *name, NSUInteger actual, NSUInteger expected) {
+    if (actual != expected) {
+        RCTLogError(@"[ApexNavigation] system UI rules self-check '%s': %lu, expected %lu", name,
+                    (unsigned long)actual, (unsigned long)expected);
+    }
+}
+
+void ANNSystemUIRulesSelfCheck(void) {
+    static dispatch_once_t once;
+    dispatch_once(&once, ^{
+      const UIInterfaceOrientationMask all = UIInterfaceOrientationMaskAll;
+      const UIInterfaceOrientationMask phone = UIInterfaceOrientationMaskAllButUpsideDown;
+      const UIInterfaceOrientationMask up = UIInterfaceOrientationMaskPortrait;
+      const UIInterfaceOrientationMask down = UIInterfaceOrientationMaskPortraitUpsideDown;
+      const UIInterfaceOrientationMask sides = UIInterfaceOrientationMaskLandscape;
+      auto mask = [](NSArray<NSString *> *values, UIInterfaceOrientationMask app) {
+          return ANNOrientationMaskOf(values, app);
+      };
+      // Each value alone, with an app that allows every side (the Android table's sides).
+      ANNExpectMask("all", mask(@[ @"all" ], all), all);
+      ANNExpectMask("sensor", mask(@[ @"sensor" ], all), all);
+      ANNExpectMask("landscape", mask(@[ @"landscape" ], all), sides);
+      ANNExpectMask("sensorLandscape", mask(@[ @"sensorLandscape" ], all), sides);
+      ANNExpectMask("portrait", mask(@[ @"portrait" ], all), up);
+      ANNExpectMask("sensorPortrait", mask(@[ @"sensorPortrait" ], all), up | down);
+      ANNExpectMask("upsideDown", mask(@[ @"upsideDown" ], all), down);
+      ANNExpectMask("default", mask(@[ @"default" ], phone), phone);
+      // Unions.
+      ANNExpectMask("portrait + landscape", mask(@[ @"portrait", @"landscape" ], all), phone);
+      ANNExpectMask("upsideDown + landscape", mask(@[ @"upsideDown", @"landscape" ], all),
+                    sides | down);
+      ANNExpectMask("upsideDown + portrait", mask(@[ @"upsideDown", @"portrait" ], all), up | down);
+      ANNExpectMask("default + landscape", mask(@[ @"default", @"landscape" ], up), up);
+      // The app's mask: the meet, and the app's mask for nothing in common, no values, no option, unknown values.
+      ANNExpectMask("sensorPortrait in a phone app", mask(@[ @"sensorPortrait" ], phone), up);
+      ANNExpectMask("upsideDown in a phone app", mask(@[ @"upsideDown" ], phone), phone);
+      ANNExpectMask("landscape in a portrait app", mask(@[ @"landscape" ], up), up);
+      ANNExpectMask("[]", mask(@[], phone), phone);
+      ANNExpectMask("no option", mask(nil, phone), phone);
+      ANNExpectMask("['bogus']", mask(@[ @"bogus" ], phone), phone);
+      // The edges.
+      ANNExpectMask("edges top + left", ANNDeferredEdgesOf(@[ @"top", @"left" ]),
+                    UIRectEdgeTop | UIRectEdgeLeft);
+      ANNExpectMask("edges all", ANNDeferredEdgesOf(@[ @"top", @"bottom", @"left", @"right" ]),
+                    UIRectEdgeAll);
+      ANNExpectMask("edges none", ANNDeferredEdgesOf(nil), UIRectEdgeNone);
+      ANNExpectMask("edges bogus", ANNDeferredEdgesOf(@[ @"bogus" ]), UIRectEdgeNone);
+      // The style.
+      ANNExpectMask("style light", ANNStatusBarStyleOf(@"light"), UIStatusBarStyleLightContent);
+      ANNExpectMask("style dark", ANNStatusBarStyleOf(@"dark"), UIStatusBarStyleDarkContent);
+      ANNExpectMask("style none", ANNStatusBarStyleOf(nil), UIStatusBarStyleDefault);
+      ANNExpectMask("style other", ANNStatusBarStyleOf(@"black"), UIStatusBarStyleDefault);
+      // The hidden rule: an explicit `visible` decides, else `hideWithTopBar` with the bar.
+      ANNStatusBarOptions *hides =
+          [[ANNStatusBarOptions alloc] initWithDict:@{@"hideWithTopBar" : @YES}];
+      ANNStatusBarOptions *shown =
+          [[ANNStatusBarOptions alloc] initWithDict:@{@"hideWithTopBar" : @YES, @"visible" : @YES}];
+      ANNStatusBarOptions *hidden = [[ANNStatusBarOptions alloc] initWithDict:@{@"visible" : @NO}];
+      ANNStatusBarOptions *none = [ANNStatusBarOptions new];
+      ANNExpectMask("hideWithTopBar, bar hidden", ANNStatusBarHiddenOf(hides, YES), YES);
+      ANNExpectMask("hideWithTopBar, bar shown", ANNStatusBarHiddenOf(hides, NO), NO);
+      ANNExpectMask("visible over hideWithTopBar", ANNStatusBarHiddenOf(shown, YES), NO);
+      ANNExpectMask("visible false", ANNStatusBarHiddenOf(hidden, NO), YES);
+      ANNExpectMask("no option", ANNStatusBarHiddenOf(none, YES), NO);
+    });
+}
+
+#endif

package/ios/Core/ANNUtils.h

@@ -0,0 +1,35 @@
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// Small answers about the app's window and screen that the core and the modules share: the navigation window and its
+/// scene take the place of the app-wide window APIs. Main queue.
+@interface ANNUtils : NSObject
+
+/// The window the navigation shows its root in; nil before the navigation started.
+@property(class, nonatomic, readonly, nullable) UIWindow *mainWindow;
+
+/// The screen of the navigation's window, or the device's main screen before the window has one.
+@property(class, nonatomic, readonly) UIScreen *mainScreen;
+
+/// The windows of the app: those of every connected window scene, and the navigation window when it isn't among them
+/// yet. The searches of screens go through these.
+@property(class, nonatomic, readonly) NSArray<UIWindow *> *windows;
+
+/// The key window: the one of the navigation window's scene, else of the first other connected scene that has one,
+/// else the navigation window.
+@property(class, nonatomic, readonly, nullable) UIWindow *keyWindow;
+
+/// The key window of `scene`; nil when none of its windows is key.
++ (nullable UIWindow *)keyWindowOfScene:(nullable UIWindowScene *)scene;
+
+/// The status bar's frame in the navigation window's scene (its status bar manager); `CGRectZero` without a scene.
+@property(class, nonatomic, readonly) CGRect statusBarFrame;
+
+/// The orientations of the app for the navigation window (F4): from iOS 27 its scene's delegate when it answers them,
+/// else the app delegate when it answers them, else the `Info.plist` of the app. Never empty.
+@property(class, nonatomic, readonly) UIInterfaceOrientationMask appOrientationMask;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/Core/ANNUtils.mm

@@ -0,0 +1,111 @@
+#import "ANNUtils.h"
+#import "ApexNavigation+Internal.h"
+
+@implementation ANNUtils
+
++ (UIWindow *)mainWindow {
+    return ApexNavigation.mainWindow;
+}
+
++ (UIScreen *)mainScreen {
+    // The window knows its screen once it is in a scene; before that the device has one screen to show on.
+    return self.mainWindow.windowScene.screen ?: UIScreen.mainScreen;
+}
+
++ (NSArray<UIWindow *> *)windows {
+    NSMutableArray<UIWindow *> *windows = [NSMutableArray new];
+    for (UIScene *scene in UIApplication.sharedApplication.connectedScenes) {
+        if ([scene isKindOfClass:UIWindowScene.class]) {
+            [windows addObjectsFromArray:((UIWindowScene *)scene).windows];
+        }
+    }
+    UIWindow *mainWindow = self.mainWindow;
+    if (mainWindow && [windows indexOfObjectIdenticalTo:mainWindow] == NSNotFound) {
+        [windows addObject:mainWindow];
+    }
+    return windows;
+}
+
++ (UIWindow *)keyWindowOfScene:(UIWindowScene *)scene {
+    for (UIWindow *window in scene.windows) {
+        if (window.isKeyWindow) {
+            return window;
+        }
+    }
+    return nil;
+}
+
++ (UIWindow *)keyWindow {
+    UIWindow *mainWindow = self.mainWindow;
+    UIWindowScene *mainScene = mainWindow.windowScene;
+    UIWindow *key = [self keyWindowOfScene:mainScene];
+    if (key) {
+        return key;
+    }
+    for (UIScene *scene in UIApplication.sharedApplication.connectedScenes) {
+        if (scene != mainScene && [scene isKindOfClass:UIWindowScene.class]) {
+            key = [self keyWindowOfScene:(UIWindowScene *)scene];
+            if (key) {
+                return key;
+            }
+        }
+    }
+    return mainWindow;
+}
+
++ (CGRect)statusBarFrame {
+    UIStatusBarManager *manager = self.mainWindow.windowScene.statusBarManager;
+    return manager ? manager.statusBarFrame : CGRectZero;
+}
+
+// The core never answers these delegate methods itself; an app's delegate may answer with its root's orientations,
+// which ask this again: inside that question the `Info.plist` answers, which asks no controller (F4).
++ (UIInterfaceOrientationMask)appOrientationMask {
+    static BOOL asking = NO;
+    UIWindow *mainWindow = self.mainWindow;
+    UIApplication *application = UIApplication.sharedApplication;
+    UIInterfaceOrientationMask mask = 0;
+    if (asking) {
+        mask = [application supportedInterfaceOrientationsForWindow:mainWindow];
+        return mask != 0 ? mask : UIInterfaceOrientationMaskAllButUpsideDown;
+    }
+    asking = YES;
+    @try {
+        mask = [self appOrientationMaskOfWindow:mainWindow application:application];
+    } @finally {
+        asking = NO;
+    }
+    return mask != 0 ? mask : UIInterfaceOrientationMaskAllButUpsideDown;
+}
+
++ (UIInterfaceOrientationMask)appOrientationMaskOfWindow:(UIWindow *)mainWindow
+                                             application:(UIApplication *)application {
+    UIInterfaceOrientationMask mask = 0;
+    BOOL answered = NO;
+#if __IPHONE_OS_VERSION_MAX_ALLOWED >= 270000
+    if (@available(iOS 27.0, *)) {
+        UIWindowScene *scene = mainWindow.windowScene;
+        id<UIWindowSceneDelegate> sceneDelegate = (id<UIWindowSceneDelegate>)scene.delegate;
+        SEL selector = @selector(supportedInterfaceOrientationsForWindowScene:);
+        if (scene && [sceneDelegate respondsToSelector:selector]) {
+            mask = [sceneDelegate supportedInterfaceOrientationsForWindowScene:scene];
+            answered = YES;
+        }
+    }
+#endif
+    if (!answered) {
+        id<UIApplicationDelegate> delegate = application.delegate;
+        SEL selector = @selector(application:supportedInterfaceOrientationsForWindow:);
+        if ([delegate respondsToSelector:selector]) {
+            mask = [delegate application:application
+                supportedInterfaceOrientationsForWindow:mainWindow];
+            answered = YES;
+        }
+    }
+    if (!answered) {
+        mask = [application supportedInterfaceOrientationsForWindow:mainWindow];
+    }
+    return mask;
+}
+
+@end

package/ios/Core/ApexNavigation+Internal.h

@@ -0,0 +1,26 @@
+#import "ANNEventEmitter.h"
+#import "ApexNavigation.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// What the core keeps from the start of the navigation (`bootstrapWithHost:`), for its own parts. Main queue.
+@interface ApexNavigation ()
+
+/// The navigation's window: made at the start, before any scene, and moved into the app's scene when it connects.
+@property(class, nonatomic, readonly, nullable) UIWindow *mainWindow;
+
+/// The sender of the events of the JavaScript that runs now: a new one each time the JavaScript changed. Keep the one
+/// you were made with; ask again only for the events of the navigation as a whole (the state, `AppLaunched`). Any
+/// thread.
+@property(class, nonatomic, readonly) ANNEventEmitter *eventEmitter;
+
+/// The creator registered for a native screen, or nil. Any thread.
++ (nullable ANNNativeScreenCreator)nativeScreenCreatorForName:(NSString *)name;
+
+/// Whether a native screen is registered under the name by `registerNativeScreen:creator:` (the registration of 8.x is
+/// gone). Any thread: the layout of a command is checked on the module's queue.
++ (BOOL)hasNativeScreenNamed:(NSString *)name;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/Core/ApexNavigation.mm

@@ -0,0 +1,177 @@
+#import "ApexNavigation+Internal.h"
+#import "ANNAppDirection.h"
+#import "ANNAssert.h"
+#import "ANNDeepLinkQueue.h"
+#import "ANNModalHostViewComponentView.h"
+#import "ANNNodeRegistry.h"
+#import "ANNOverlayCoordinator.h"
+#import "ANNPresentationGate.h"
+#import "ANNReloadCoordinator.h"
+#import "ANNSlotHost.h"
+#import "ANNSplashViewController.h"
+#import "ANNTabsPreloadWindow.h"
+#import "ANNUtils.h"
+#import <React/RCTLog.h>
+#import <ReactCommon/RCTHost.h>
+
+// Main queue, but the registrations of native screens: an app may register from any thread, before the start.
+static RCTHost *ANNHost;
+static UIWindow *ANNMainWindow;
+static BOOL ANNBootstrapped;
+// The emitter of the JavaScript that runs now; a new one once the generation grew. Any thread.
+static ANNEventEmitter *ANNCurrentEventEmitter;
+static NSMutableDictionary<NSString *, ANNNativeScreenCreator> *ANNNativeScreenCreators;
+
+// The scene of the app's main window, when one is connected already: the active one first.
+static UIWindowScene *ANNConnectedWindowScene(void) {
+    UIWindowScene *found = nil;
+    for (UIScene *scene in UIApplication.sharedApplication.connectedScenes) {
+        if (![scene isKindOfClass:UIWindowScene.class] ||
+            ![scene.session.role isEqualToString:UIWindowSceneSessionRoleApplication]) {
+            continue;
+        }
+        if (!found || scene.activationState == UISceneActivationStateForegroundActive) {
+            found = (UIWindowScene *)scene;
+        }
+    }
+    return found;
+}
+
+@implementation ApexNavigation
+
++ (void)initialize {
+    if (self == ApexNavigation.class) {
+        ANNNativeScreenCreators = [NSMutableDictionary new];
+    }
+}
+
+// Once, on the main queue: the generated native screens before any other part, then the core's parts, the `<Modal>`
+// replacement before any React content, the window with the copy of the launch screen, and the watch of the bundles.
++ (void)bootstrapWithHost:(RCTHost *)host {
+    ANNAssertMainQueue();
+    if (ANNBootstrapped) {
+        return;
+    }
+    ANNBootstrapped = YES;
+    [self registerGeneratedScreens];
+    ANNHost = host;
+    // React Native lets a class with the descriptor of `ModalHostView` stand in for its own.
+    [ANNModalHostViewComponentView registerForModalHostView];
+    [self makeMainWindowInScene:nil];
+    // Every bundle of the host, the first one too, starts the navigation of its JavaScript.
+    [ANNReloadCoordinator start];
+}
+
+// The class `codegen` writes, found by its runtime name; an app without it has none.
++ (void)registerGeneratedScreens {
+    Class generated = NSClassFromString(@"ApexNavigationGeneratedScreens");
+    SEL registerScreens = NSSelectorFromString(@"registerScreens");
+    if (![generated respondsToSelector:registerScreens]) {
+        return;
+    }
+    IMP implementation = [generated methodForSelector:registerScreens];
+    ((void (*)(id, SEL))implementation)(generated, registerScreens);
+}
+
+// The app delegate's window when it has one; else a new one, in the main scene when one is connected, else at the size
+// of the device's screen (`ANNUtils.mainScreen`: `UIScreen.mainScreen` only while the window has no scene). The
+// delegate keeps it when it takes a window. Its root is the copy of the launch screen. `scene` is the scene the window
+// is made for (`attachToWindowScene:` before the start); nil looks for one.
++ (void)makeMainWindowInScene:(UIWindowScene *)scene {
+    if (ANNMainWindow) {
+        return;
+    }
+    id<UIApplicationDelegate> delegate = UIApplication.sharedApplication.delegate;
+    UIWindow *window = [delegate respondsToSelector:@selector(window)] ? delegate.window : nil;
+    if (!window) {
+        scene = scene ?: ANNConnectedWindowScene();
+        // `initWithFrame:` is deprecated from iOS 26 on and warns only with a deployment target from 26: without a
+        // scene there is no other way to make a window before the scene connects.
+        window = scene ? [[UIWindow alloc] initWithWindowScene:scene]
+                       : [[UIWindow alloc] initWithFrame:ANNUtils.mainScreen.bounds];
+        if ([delegate respondsToSelector:@selector(setWindow:)]) {
+            delegate.window = window;
+        }
+    }
+    ANNMainWindow = window;
+    UIViewController *launchScreenCopy =
+        [ANNSplashViewController launchScreenCopyWithBounds:window.bounds];
+    if (launchScreenCopy) {
+        window.rootViewController = launchScreenCopy;
+    }
+}
+
++ (void)registerNativeScreen:(NSString *)name creator:(ANNNativeScreenCreator)creator {
+    @synchronized(ApexNavigation.class) {
+#if DEBUG
+        if (ANNNativeScreenCreators[name]) {
+            RCTLogWarn(@"[ApexNavigation] registerNativeScreen: '%@' is registered again; "
+                       @"the last one counts.",
+                       name);
+        }
+#endif
+        ANNNativeScreenCreators[name] = [creator copy];
+    }
+}
+
++ (ANNNativeScreenCreator)nativeScreenCreatorForName:(NSString *)name {
+    @synchronized(ApexNavigation.class) {
+        return ANNNativeScreenCreators[name];
+    }
+}
+
++ (BOOL)hasNativeScreenNamed:(NSString *)name {
+    @synchronized(ApexNavigation.class) {
+        return ANNNativeScreenCreators[name] != nil;
+    }
+}
+
++ (RCTHost *)getHost {
+    return ANNHost;
+}
+
+// The node by its id: shown, or made and waiting to show.
++ (UIViewController *)findViewController:(NSString *)componentId {
+    ANNAssertMainQueue();
+    return [ANNNodeRegistry nodeForComponentId:componentId];
+}
+
+// The window keeps what it shows and moves into the scene at the scene's size; the links module knows the launch links
+// after this turn of the main queue.
++ (UIWindow *)attachToWindowScene:(UIWindowScene *)windowScene {
+    ANNAssertMainQueue();
+    // A scene that connects before the start (an app on its own delegate) gets the window the start would make.
+    [self makeMainWindowInScene:windowScene];
+    ANNMainWindow.windowScene = windowScene;
+    ANNMainWindow.frame = windowScene.coordinateSpace.bounds;
+    [ANNMainWindow makeKeyAndVisible];
+    // The tabs' preload windows, the overlay windows and the slot host's window made before the scene go where the
+    // main window is.
+    [ANNTabsPreloadWindow mainWindowSceneDidConnect:windowScene];
+    [ANNOverlayCoordinator mainWindowSceneDidConnect:windowScene];
+    [ANNSlotHost mainWindowSceneDidConnect:windowScene];
+    // A direction the app set before the window had a scene takes the scene now.
+    [ANNAppDirection windowSceneDidConnect];
+    // A modal asked for before the window showed presents now (N2).
+    [ANNPresentationGate pump];
+    [ANNDeepLinkQueue windowSceneDidConnect];
+    return ANNMainWindow;
+}
+
+#pragma mark - Internal
+
++ (UIWindow *)mainWindow {
+    return ANNMainWindow;
+}
+
+// A node or a content made from now on keeps this emitter: once the JavaScript goes, it stays silent.
++ (ANNEventEmitter *)eventEmitter {
+    @synchronized(ApexNavigation.class) {
+        if (!ANNCurrentEventEmitter.isCurrent) {
+            ANNCurrentEventEmitter = [ANNEventEmitter new];
+        }
+        return ANNCurrentEventEmitter;
+    }
+}
+
+@end

package/ios/Core/UIViewController+LayoutProtocol.h

@@ -0,0 +1,102 @@
+#import "ANNLayoutProtocol.h"
+#import "ANNNodeHelper.h"
+#import "ANNReactView.h"
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// The readiness a wait needs of `screen`: the answer of its nearest layout parent that has one
+/// (`waitedReadinessOfScreen:`), else its content.
+FOUNDATION_EXPORT ANNWaitedReadiness ANNWaitedReadinessOf(UIViewController *screen);
+
+/// Every view controller as a node of the layout: the data the core gave it (kept by its helper) and the answers of
+/// `ANNLayoutProtocol` that are safe for any view controller: its view controller children are its children by the
+/// layout, it shows what its current child shows, and it destroys its children. A container answers the protocol
+/// methods that differ for it itself and does the common part with `nodeHelper`.
+@interface UIViewController (LayoutProtocol)
+
+/// The core's part of this node, made as it is first asked.
+@property(nonatomic, strong, readonly) ANNNodeHelper *nodeHelper;
+
+/// Whether the view controller is a node of the layout: it has the core's helper with its layout data. Asking makes
+/// no helper, so it is safe on any view controller (an alert, the share sheet, a search controller).
+@property(nonatomic, readonly) BOOL isLayoutNode;
+
+#pragma mark - The node's data
+
+@property(nonatomic, strong, nullable) ANNLayoutInfo *layoutInfo;
+/// The node's own options (`ANNNodeHelper.options`): set them whole, or change them with `mergeOwnOptions:` /
+/// `changeOwnOptions:`; never in place.
+@property(nonatomic, strong, nullable) ANNNavigationOptions *options;
+/// The default options of the app (`ANNDefaultOptions.current`); setting it does nothing.
+@property(nonatomic, strong, nullable) ANNNavigationOptions *defaultOptions;
+@property(nonatomic, strong, nullable) ANNEventEmitter *eventEmitter;
+@property(nonatomic, strong, nullable) id<ANNComponentViewCreator> creator;
+@property(nonatomic, strong, nullable) ANNNodePresenter *presenter;
+
+#pragma mark - Places
+
+/// The parent by the layout: the parent view controller, or the fallback a container gave.
+@property(nonatomic, readonly, nullable) UIViewController *layoutParent;
+
+/// The parent by the layout while UIKit has the view controller out of its parent.
+- (void)setLayoutParentFallback:(nullable UIViewController *)layoutParent;
+
+/// The parent by the layout whatever UIKit's parent is (`ANNNodeHelper explicitLayoutParent`): the split view of its
+/// columns.
+- (void)setExplicitLayoutParent:(nullable UIViewController *)layoutParent;
+
+/// The stack the node is in, through its parents by the layout.
+@property(nonatomic, readonly, nullable) UINavigationController *stack;
+
+/// The screen this node shows now (for a screen: itself).
+@property(nonatomic, readonly, nullable) UIViewController *presentedComponentViewController;
+
+/// What the screen shows: its React view, or its slot screen view; nil for a node that is no React screen.
+@property(nonatomic, readonly, nullable) UIView<ANNComponentProtocol> *reactView;
+
+#pragma mark - Options
+
+/// The resolved options over those of the parents and the default options: what the node shows with. Cached and
+/// read-only (`ANNNodeHelper resolveOptionsWithDefault`).
+- (ANNNavigationOptions *)resolveOptionsWithDefault;
+
+/// 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).
+- (void)changeOwnOptions:(void (^)(ANNNavigationOptions *options))change;
+
+#pragma mark - Readiness
+
+/// A ready handler of the node under the waiter's own key (`ANNNodeHelper setReadyHandler:forKey:`): it runs once, the
+/// next time the node is ready for presentation.
+- (void)setReadyHandler:(dispatch_block_t)handler forKey:(NSString *)key;
+
+/// The waiter's handler goes without running (`ANNNodeHelper removeReadyHandlerForKey:`).
+- (void)removeReadyHandlerForKey:(NSString *)key;
+
+#pragma mark - ANNLayoutProtocol, the defaults
+
+- (nullable UIViewController *)getCurrentChild;
+- (NSArray<UIViewController *> *)layoutChildren;
+- (NSArray<UIViewController *> *)shownComponentViewControllers;
+/// The screens a wait for the node's render waits for (`ANNLayoutProtocol`): the node's shown screens; a container
+/// whose shown screens are all inside its current child answers what that child answers.
+- (NSArray<UIViewController *> *)waitedComponentViewControllers;
+- (void)render;
+- (void)readyForPresentation;
+@property(nonatomic) BOOL waitForRender;
+- (ANNNavigationOptions *)resolveOptions;
+- (void)mergeOptions:(ANNNavigationOptions *)options;
+- (void)mergeChildOptions:(ANNNavigationOptions *)options child:(UIViewController *)child;
+- (void)destroyReactView;
+/// Once: the node leaves the registry and destroys its children; a second call does nothing.
+- (void)destroy;
+- (void)screenPopped;
+- (nullable UIViewController *)systemUIChild;
+
+@end
+
+NS_ASSUME_NONNULL_END