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

package/ios/Core/ANNKeyCommands.mm

@@ -0,0 +1,74 @@
+#import "ANNKeyCommands.h"
+
+static NSString *ANNKeyInput(NSString *input) {
+    NSDictionary<NSString *, NSString *> *special = @{
+        @"escape" : UIKeyInputEscape,
+        @"enter" : @"\r",
+        @"tab" : @"\t",
+        @"delete" : @"\b",
+        @"up" : UIKeyInputUpArrow,
+        @"down" : UIKeyInputDownArrow,
+        @"left" : UIKeyInputLeftArrow,
+        @"right" : UIKeyInputRightArrow,
+    };
+    return special[input] ?: input;
+}
+
+NSArray<UIKeyCommand *> *ANNKeyCommandsFromOptions(NSArray<NSDictionary *> *options, SEL action) {
+    NSDictionary<NSString *, NSNumber *> *flags = @{
+        @"command" : @(UIKeyModifierCommand),
+        @"shift" : @(UIKeyModifierShift),
+        @"option" : @(UIKeyModifierAlternate),
+        @"alternate" : @(UIKeyModifierAlternate),
+        @"control" : @(UIKeyModifierControl),
+    };
+    NSMutableArray<UIKeyCommand *> *commands = [NSMutableArray new];
+    for (NSDictionary *option in options) {
+        if (![option isKindOfClass:NSDictionary.class] ||
+            ![option[@"id"] isKindOfClass:NSString.class] ||
+            ![option[@"input"] isKindOfClass:NSString.class]) {
+            continue;
+        }
+        UIKeyModifierFlags modifiers = 0;
+        NSArray *names = [option[@"modifiers"] isKindOfClass:NSArray.class] ? option[@"modifiers"] : @[];
+        for (id name in names) {
+            modifiers |= [name isKindOfClass:NSString.class] ? flags[name].integerValue : 0;
+        }
+        NSString *title = [option[@"title"] isKindOfClass:NSString.class] ? option[@"title"] : @"";
+        UIKeyCommand *command = [UIKeyCommand commandWithTitle:title
+                                                         image:nil
+                                                        action:action
+                                                         input:ANNKeyInput(option[@"input"])
+                                                 modifierFlags:modifiers
+                                                  propertyList:option[@"id"]];
+        // With a title the command shows in the list of shortcuts (holding ⌘ on iPad).
+        command.discoverabilityTitle = title.length > 0 ? title : nil;
+        [commands addObject:command];
+    }
+    return commands;
+}
+
+static __weak UIResponder *ANNFoundFirstResponder;
+
+@interface UIResponder (ANNFirstResponder)
+- (void)ann_reportFirstResponder:(id)sender;
+@end
+
+@implementation UIResponder (ANNFirstResponder)
+- (void)ann_reportFirstResponder:(id)sender {
+    ANNFoundFirstResponder = self;
+}
+@end
+
+// An action without a target goes to the first responder (UIKit's documented way to find it).
+BOOL ANNNoFirstResponder(void) {
+    ANNFoundFirstResponder = nil;
+    [UIApplication.sharedApplication sendAction:@selector(ann_reportFirstResponder:)
+                                             to:nil
+                                           from:nil
+                                       forEvent:nil];
+    UIResponder *responder = ANNFoundFirstResponder;
+    return !responder || [responder isKindOfClass:UIWindow.class] ||
+           [responder isKindOfClass:UIApplication.class] ||
+           [responder conformsToProtocol:@protocol(UIApplicationDelegate)];
+}

package/ios/Core/ANNLayoutInfo.h

@@ -0,0 +1,18 @@
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// What identifies a node of the layout: its id (`componentId`, the one JS gave it) and, for a screen, its name.
+@interface ANNLayoutInfo : NSObject
+
+- (instancetype)initWithComponentId:(NSString *)componentId name:(nullable NSString *)name;
+
+@property(nonatomic, copy, readonly) NSString *componentId;
+@property(nonatomic, copy, readonly, nullable) NSString *name;
+
+- (instancetype)init NS_UNAVAILABLE;
++ (instancetype)new NS_UNAVAILABLE;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/Core/ANNLayoutInfo.mm

@@ -0,0 +1,13 @@
+#import "ANNLayoutInfo.h"
+
+@implementation ANNLayoutInfo
+
+- (instancetype)initWithComponentId:(NSString *)componentId name:(NSString *)name {
+    if (self = [super init]) {
+        _componentId = [componentId copy];
+        _name = [name copy];
+    }
+    return self;
+}
+
+@end

package/ios/Core/ANNLayoutProtocol.h

@@ -0,0 +1,155 @@
+#import "ANNComponentViewCreator.h"
+#import "ANNEventEmitter.h"
+#import "ANNLayoutInfo.h"
+#import "ANNNavigationOptions.h"
+#import "ANNNodePresenter.h"
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// What a wait for a node's render waits for on one of its waited screens (`waitedComponentViewControllers`).
+typedef NS_ENUM(NSInteger, ANNWaitedReadiness) {
+    /// The screen's content rendered: what the user sees.
+    ANNWaitedReadinessContent,
+    /// The screen's root mounted once: a screen the user doesn't see yet (an unselected tab of `together`), which
+    /// renders its content only where it shows. Its part of a wait ends at the command's 0.5 s at the latest, and its
+    /// bar components are not waited for.
+    ANNWaitedReadinessRootMounted,
+};
+
+/// A transition of the navigation is done: what it moved is in place.
+typedef void (^ANNTransitionCompletionBlock)(void);
+
+/// A transition of the navigation could not be made: the sentence JavaScript gets ( no code), and the error behind it
+/// when there is one.
+typedef void (^ANNTransitionRejectionBlock)(NSString *message, NSError *_Nullable error);
+
+/// What every node of the layout answers the core (the container contract). The core's containers (screen, stack, tabs)
+/// and the container modules (split view, pair, side menu) adopt it. A node gets its data and its helper
+/// (`ANNNodeHelper`) through `UIViewController+LayoutProtocol`, which also gives defaults safe for any view controller
+/// (its view controller children, what its current child shows, destroying its children); a container answers the
+/// methods that differ for it and does the common part with its helper, never through `super`.
+@protocol ANNLayoutProtocol <NSObject>
+
+@optional
+
+/// The initializer of a container whose children come as a list.
+- (instancetype)initWithLayoutInfo:(ANNLayoutInfo *)layoutInfo
+                           creator:(id<ANNComponentViewCreator>)creator
+                           options:(ANNNavigationOptions *)options
+                    defaultOptions:(ANNNavigationOptions *)defaultOptions
+                         presenter:(ANNNodePresenter *)presenter
+                      eventEmitter:(ANNEventEmitter *)eventEmitter
+              childViewControllers:(nullable NSArray<UIViewController *> *)childViewControllers;
+
+@required
+
+/// The child the node shows now: the core resolves the node's options and finds its visible screen through it.
+- (nullable UIViewController *)getCurrentChild;
+
+/// Every child of the node, also those UIKit doesn't show now (a collapsed column, a screen of a pair out of the
+/// window).
+- (NSArray<UIViewController *> *)layoutChildren;
+
+/// The screens of the node on screen now (the source of a popover, of a `zoom` modal).
+- (NSArray<UIViewController *> *)shownComponentViewControllers;
+
+/// Prepares the children for presentation; the node is ready once they are (`readyForPresentation`).
+- (void)render;
+
+/// The node, or a child of it, is ready: a node that waits for nothing else tells its helper.
+- (void)readyForPresentation;
+
+/// The node shows only once its content rendered (`waitForRender`).
+- (BOOL)waitForRender;
+- (void)setWaitForRender:(BOOL)waitForRender;
+
+/// The node's options over those of its current child.
+- (ANNNavigationOptions *)resolveOptions;
+
+/// `mergeOptions` with the node's id: where the options go.
+- (void)mergeOptions:(ANNNavigationOptions *)options;
+
+/// A child merged `options`: what the node takes of them, and what goes on to its own parent.
+- (void)mergeChildOptions:(ANNNavigationOptions *)options child:(UIViewController *)child;
+
+/// The node goes: the React views of its screens stop.
+- (void)destroyReactView;
+
+/// The node goes, with everything in it.
+- (void)destroy;
+
+/// The node left its stack: its own cleanup. It sends no event: the core sends `ANN.ScreenPopped` itself, for the
+/// screens of `screensLeavingWithNode`, or for the node alone without that capability.
+- (void)screenPopped;
+
+/// The child the system UI follows: the home indicator, the deferred system gestures, the vertical bars.
+- (nullable UIViewController *)systemUIChild;
+
+@optional
+
+#pragma mark - The waits
+
+/// The screens a wait for the node's render waits for (a root's `setRoot`, a modal's, an overlay's): by default the
+/// shown screens (`shownComponentViewControllers`), and a container whose shown screens are all inside its current
+/// child answers what that child answers (`UIViewController+LayoutProtocol`). A node whose waited screens differ from
+/// what it shows answers itself (the tabs, with the readiness each screen needs: `waitedReadinessOfScreen:`).
+- (NSArray<UIViewController *> *)waitedComponentViewControllers;
+
+/// The readiness a wait needs of `screen`, a waited screen inside this node; a node without an answer leaves it to its
+/// parents (`ANNWaitedReadinessOf`). The tabs answer "root mounted" for the screens of their unselected tabs.
+- (ANNWaitedReadiness)waitedReadinessOfScreen:(UIViewController *)screen;
+
+#pragma mark - The children
+
+/// A child of the node disappeared (UIKit's `viewDidDisappear:` of a stack): the tabs check `popToRootOnBlur` of its
+/// tab there.
+- (void)childDidDisappear:(UIViewController *)child;
+
+/// A screen inside the node appeared in UIKit while a command drove its appearance (`ANNAppearanceDispatcher`). The
+/// screen tells every layout parent up its chain; a node that drives a switch of its own ends it here when the screen
+/// is the one it waited for (the tabs), and ends no other node's switch.
+- (void)drivenDescendantDidAppear:(UIViewController *)screen;
+
+/// A screen inside the node appeared in UIKit by itself, no command driving its appearance (a pop of UIKit's own: the
+/// back button, the edge swipe). The screen tells every layout parent up its chain. A split view whose columns UIKit
+/// shows as one stack announces what it shows then: UIKit took a column off that stack by itself.
+- (void)descendantDidAppear:(UIViewController *)screen;
+
+#pragma mark - Capabilities: a node without one answers "no"
+
+/// `returnsScreenFromColumn`: `pop` of the only screen of a column goes back to the column before it (split view). YES
+/// when the node did it; `completion` runs once that is on screen.
+- (BOOL)goBackFromColumnOf:(UIViewController *)screen completion:(dispatch_block_t)completion;
+
+/// `screensLeavingWithNode`: the screens that leave their stack with the node (a pair: both); the core sends
+/// `ANN.ScreenPopped` for each of them.
+- (NSArray<UIViewController *> *)screensLeavingWithNode;
+
+/// `childOffsetFromRest`: how far the child is moved from where it rests (a sliding pane), for its safe area.
+- (CGPoint)childOffsetFromRest:(UIViewController *)child;
+
+/// `optionsScreen`: the screen whose options are the node's (a pair: the primary): its bars, search, status bar.
+- (nullable UIViewController *)optionsScreen;
+
+/// `keepsStatusBarRoom`: the node keeps the room of the status bar for its screens (a pair).
+- (BOOL)keepsStatusBarRoom;
+
+#pragma mark - The columns of a split view
+
+/// The view controller of the column: 'primary', 'supplementary', 'secondary', 'compact' or 'inspector'.
+- (nullable UIViewController *)viewControllerOfColumn:(NSString *)column;
+
+/// Collapsed into the compact layout: no column shows.
+@property(nonatomic, readonly) BOOL isCollapsedIntoCompact;
+
+/// `showInColumn`: `screen` in place of what the column shows.
+- (void)showScreen:(UIViewController *)screen
+              inColumn:(NSString *)column
+    fromViewController:(UIViewController *)fromViewController
+            completion:(ANNTransitionCompletionBlock)completion
+             rejection:(ANNTransitionRejectionBlock)rejection;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/Core/ANNNavigationState.h

@@ -0,0 +1,38 @@
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// The navigation state JavaScript reads with `navigation.getState()`: `ANN.NavigationStateChanged { screen, tab }`
+/// (EVT-NavigationStateChanged).
+///
+/// What: the visible layout of the navigation's window — the top modal of the library, else the root; overlays and
+/// presentations that are not layout (alerts, the share sheet, a search controller, React Native's `<Modal>`) don't
+/// count — then down the current children to the end. `screen` is that node when it is a screen, its name without the
+/// `slot:` prefix (a native screen: its registration name); `tab` is the selected index of the nearest tabs the
+/// screen is in (with tabs inside tabs the inner ones), `null` out of tabs. When: only when it differs from the last
+/// one sent. Main queue.
+@interface ANNNavigationState : NSObject
+
+/// One update in the next pass of the main loop, however many are asked in this one: after a `DidAppear` or a
+/// `DidDisappear` that went, after `ANN.BottomTabSelected`.
++ (void)setNeedsUpdate;
+
+/// The coalesced updates (`setNeedsUpdate`) wait while a command holds them: a `setRoot` that shows its layout's
+/// modals and overlays (one state, before its answer), a user's close whose end waits for UIKit. Each hold is released
+/// once; the last release asks for the update that waited. `updateNow` is never held.
++ (void)holdUpdates;
++ (void)releaseUpdates;
+
+/// The state now, sent when it changed: at the end of a transition, at once after a tab chosen from code. A walk that
+/// throws logs one line and sends nothing, so its caller always goes on.
++ (void)updateNow;
+
+/// A command is about to answer: when what shows changed, the new state goes now, before the promise.
++ (void)reportBeforeAnswer;
+
+/// Forgets the last state sent: the next one goes even if it is the same (a new bundle, `AppLaunched`).
++ (void)reset;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/Core/ANNNavigationState.mm

@@ -0,0 +1,127 @@
+#import "ANNNavigationState.h"
+#import "ANNAssert.h"
+#import "ANNBottomTabsController.h"
+#import "ANNComponentViewController.h"
+#import "ANNErrorTexts.h"
+#import "ANNModalCoordinator.h"
+#import "ANNSlotContainers.h"
+#import "ApexNavigation+Internal.h"
+#import "UIViewController+LayoutProtocol.h"
+#import <React/RCTLog.h>
+
+// Main queue.
+static BOOL ANNUpdateScheduled;
+static BOOL ANNHasLastState;
+static NSString *ANNLastScreenId;
+static NSString *ANNLastScreenName;
+static NSNumber *ANNLastTab;
+static NSUInteger ANNUpdateHolds;
+static BOOL ANNUpdateWaitsForRelease;
+
+static BOOL ANNSameValue(id a, id b) {
+    return a == b || [a isEqual:b];
+}
+
+@implementation ANNNavigationState
+
++ (void)setNeedsUpdate {
+    ANNAssertMainQueue();
+    if (ANNUpdateScheduled) {
+        return;
+    }
+    ANNUpdateScheduled = YES;
+    dispatch_async(dispatch_get_main_queue(), ^{
+      ANNUpdateScheduled = NO;
+      if (ANNUpdateHolds > 0) {
+          ANNUpdateWaitsForRelease = YES;
+          return;
+      }
+      [ANNNavigationState updateNow];
+    });
+}
+
++ (void)holdUpdates {
+    ANNAssertMainQueue();
+    ANNUpdateHolds++;
+}
+
++ (void)releaseUpdates {
+    ANNAssertMainQueue();
+    if (ANNUpdateHolds == 0) {
+        return;
+    }
+    ANNUpdateHolds--;
+    if (ANNUpdateHolds == 0 && ANNUpdateWaitsForRelease) {
+        ANNUpdateWaitsForRelease = NO;
+        [self setNeedsUpdate];
+    }
+}
+
++ (void)updateNow {
+    ANNAssertMainQueue();
+    NSString *screenId = nil;
+    NSString *name = nil;
+    NSNumber *tab = nil;
+    // The one guard of the state step: a walk that fails costs only this state, never the events and the answer of
+    // the transition that asked for it.
+    @try {
+        ANNBottomTabsController *tabs = nil;
+        UIViewController *screen = [self visibleScreenWithTabs:&tabs];
+        screenId = screen.layoutInfo.componentId;
+        if (screenId) {
+            name = ANNComponentNameWithoutSlotPrefix(screen.layoutInfo.name ?: @"");
+            tab = tabs ? @(tabs.selectedTabIndex) : nil;
+        }
+    } @catch (NSException *exception) {
+        NSString *reason = exception.reason.length > 0 ? exception.reason : exception.name;
+        RCTLogWarn(@"[ApexNavigation] %@",
+                   [ANNErrorTexts couldNot:@"report the navigation state" reason:reason]);
+        return;
+    }
+    if (ANNHasLastState && ANNSameValue(screenId, ANNLastScreenId) &&
+        ANNSameValue(name, ANNLastScreenName) && ANNSameValue(tab, ANNLastTab)) {
+        return;
+    }
+    ANNHasLastState = YES;
+    ANNLastScreenId = screenId;
+    ANNLastScreenName = name;
+    ANNLastTab = tab;
+    [ApexNavigation.eventEmitter sendNavigationStateChanged:screenId name:name tab:tab];
+}
+
++ (void)reportBeforeAnswer {
+    [self updateNow];
+}
+
++ (void)reset {
+    ANNAssertMainQueue();
+    ANNHasLastState = NO;
+    // A new bundle: nothing of the old JavaScript holds the state any more.
+    ANNUpdateHolds = 0;
+    ANNUpdateWaitsForRelease = NO;
+    ANNLastScreenId = nil;
+    ANNLastScreenName = nil;
+    ANNLastTab = nil;
+}
+
+#pragma mark - What shows
+
+// The layout the user sees: the top modal on screen, from the modals' own records (a modal being dismissed counts until
+// its end, one closed below doesn't, foreign controllers and overlays never), else the window's root; then down the
+// current children. `tabs` gets the nearest tabs the visible screen is in, the last met on the way down: in a modal
+// those of the modal, never those under it; with tabs inside tabs the inner ones. Their own selected index is in layout
+// order, More's tabs included, never UIKit's.
++ (UIViewController *)visibleScreenWithTabs:(ANNBottomTabsController **)tabs {
+    UIViewController *visible = [ANNModalCoordinator visibleLayout];
+    ANNBottomTabsController *nearestTabs = nil;
+    for (UIViewController *node = visible; node; node = [node getCurrentChild]) {
+        visible = node;
+        if ([node isKindOfClass:ANNBottomTabsController.class]) {
+            nearestTabs = (ANNBottomTabsController *)node;
+        }
+    }
+    *tabs = nearestTabs;
+    return [visible isKindOfClass:ANNComponentViewController.class] ? visible : nil;
+}
+
+@end

package/ios/Core/ANNNodeHelper.h

@@ -0,0 +1,114 @@
+#import "ANNComponentViewCreator.h"
+#import "ANNEventEmitter.h"
+#import "ANNLayoutInfo.h"
+#import "ANNNavigationOptions.h"
+#import "ANNNodePresenter.h"
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// The key of a container's ready handler on each of its children (a pair waits for both of its screens).
+FOUNDATION_EXPORT NSString *const ANNContainerReadyHandlerKey;
+
+/// The core's part of a layout node: the data the node got at creation and the work every node shares. The core makes
+/// one for each view controller as it is first asked (`UIViewController+LayoutProtocol`), and the view controller keeps
+/// it. A container calls it for the common part of its answers.
+@interface ANNNodeHelper : NSObject
+
+- (instancetype)initWithNode:(UIViewController *)node;
+
+- (instancetype)init NS_UNAVAILABLE;
++ (instancetype)new NS_UNAVAILABLE;
+
+/// The view controller of the node.
+@property(nonatomic, weak, readonly, nullable) UIViewController *node;
+
+@property(nonatomic, strong, nullable) ANNLayoutInfo *layoutInfo;
+/// The node's own options: its layout options with every `mergeOptions` into it and the choices of the user the modules
+/// keep. The setter stores them without the one-shot options and makes every resolved options miss its cache; it is the
+/// only way to change them. Never change them in place: `mergeOwnOptions:` or `changeOwnOptions:`.
+@property(nonatomic, strong, nullable) ANNNavigationOptions *options;
+/// The default options of the app (`ANNDefaultOptions.current`); setting it does nothing, the defaults are the app's.
+@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;
+@property(nonatomic) BOOL waitForRender;
+
+/// The parent by the layout when UIKit took the node out of its parent (a screen of a pair out of the window, a tab of
+/// More) or put it into one that is no node (UIKit's More navigation).
+@property(nonatomic, weak, nullable) UIViewController *layoutParentFallback;
+
+/// The parent by the layout whatever UIKit's parent is: a column of a split view, which UIKit moves into the primary
+/// column's stack while the columns show as one stack, or wraps in a navigation controller of its own. It wins over
+/// UIKit's parent and the fallback while it is set.
+@property(nonatomic, weak, nullable) UIViewController *explicitLayoutParent;
+
+/// The common setup of a node: keeps its data, binds the presenter to the node and applies the initial options. A nil
+/// `eventEmitter` keeps the emitter of the JavaScript that runs now (`ApexNavigation.eventEmitter`).
+- (void)setUpWithLayoutInfo:(ANNLayoutInfo *)layoutInfo
+                    creator:(nullable id<ANNComponentViewCreator>)creator
+                    options:(nullable ANNNavigationOptions *)options
+             defaultOptions:(nullable ANNNavigationOptions *)defaultOptions
+                  presenter:(nullable ANNNodePresenter *)presenter
+               eventEmitter:(nullable ANNEventEmitter *)eventEmitter;
+
+/// The node's parent by the layout: the explicit one when set; else its parent view controller when that is a node of
+/// the layout, else the fallback (when there is none, the parent view controller).
+- (nullable UIViewController *)layoutParent;
+
+/// `options` merged with `options` given and stored through the setter.
+- (void)mergeOwnOptions:(ANNNavigationOptions *)options;
+
+/// A change of the own options by the core or a module: `change` gets a copy of them, and the copy is stored through
+/// the setter. A presenter or module that keeps a choice of the user in the node's options (a scope, tokens, a
+/// checked menu item, a toggled button) writes it this way, never into the options in place.
+- (void)changeOwnOptions:(void (^)(ANNNavigationOptions *options))change;
+
+/// The common resolve: a copy of the node's own options with the resolved options of its current child over them, down
+/// the visible chain. A new object each call: a container's override may change it in place.
+- (ANNNavigationOptions *)resolveOptions;
+
+/// What the node shows with: the default options, then the own options of its parents from the farthest to the nearest,
+/// then the node's `resolveOptions`. Cached until any options change (`ANNOptionsCache`), the node has another parent,
+/// or a node of its visible chain has another current child. Read-only: copy it before changing anything.
+- (ANNNavigationOptions *)resolveOptionsWithDefault;
+
+/// `resolveOptionsWithDefault` built now, without the cache: for a reader whose node resolves through more than its
+/// visible chain (the side menu reads its center while a menu is open), which the cache's key doesn't follow. A new
+/// object each call.
+- (ANNNavigationOptions *)resolveOptionsWithDefaultUncached;
+
+/// The common render: the current child renders. A node that waits for its children to say "ready" (a pair) does it
+/// itself.
+- (void)render;
+
+/// Sends "ready": every ready handler set now runs, once, in the order they were first set, and is dropped.
+- (void)readyForPresentation;
+
+/// `handler` runs the next time the node is ready for presentation (`readyForPresentation`), once. One handler per
+/// key: each waiter (a command's render wait, the stack's lower screens, a container on its children) sets and removes
+/// only its own, so that waiters never take each other's place. Setting a key again replaces its handler. Destroying the
+/// node (`markDestroyed`) drops every handler.
+- (void)setReadyHandler:(dispatch_block_t)handler forKey:(NSString *)key;
+
+/// The handler of `key` goes without running; nothing when there is none.
+- (void)removeReadyHandlerForKey:(NSString *)key;
+
+/// The node is known by its id from now on (`ANNNodeRegistry`): the layout factory calls it for every node it makes,
+/// right after making it, but for the sides of side menus.
+- (void)registerNode;
+
+/// Whether the node was destroyed.
+@property(nonatomic, readonly) BOOL destroyed;
+
+/// The node is being destroyed: YES the first time, NO after, so that a destroy runs once. Its ready handlers go.
+- (BOOL)markDestroyed;
+
+/// The node is known by its id no more; a later node with the same id stays. The default `destroy` calls it; a node
+/// that destroys itself otherwise calls it too.
+- (void)unregisterNode;
+
+@end
+
+NS_ASSUME_NONNULL_END