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

package/ios/Core/ANNHinge.h

@@ -5,6 +5,9 @@ NS_ASSUME_NONNULL_BEGIN
 
 /// Posted on the main queue when the state of the hinge changes (closed, partly open, open), once a screen showed.
 extern NSNotificationName const ANNHingeDidChangeNotification;
+/// Posted on the main queue for each new value of the hinge (the first one, a move, a new state, the hinge's coming or
+/// going), once a screen showed.
+extern NSNotificationName const ANNHingeDidMoveNotification;
 
 /// The device's hinge (`useHinge`), iOS 27.1: one UIHingeInteraction on the app's window, which runs once a screen
 /// showed (the regions of the screens follow the hinge's state) and while JavaScript asks for updates (it counts its
@@ -21,6 +24,9 @@ extern NSNotificationName const ANNHingeDidChangeNotification;
 /// The last value, `{}` before the first update and without a hinge. Any thread.
 + (NSDictionary<NSString *, id> *)lastValue;
 
+/// Whether the device has a hinge, as the last update tells: NO before the first one. Any thread.
++ (BOOL)isPresent;
+
 @end
 
 NS_ASSUME_NONNULL_END

package/ios/Core/ANNHinge.mm

@@ -1,8 +1,10 @@
 #import "ANNHinge.h"
 #import "ANNAssert.h"
+#import "ANNEventContract.h"
 #import "ANNUtils.h"
 
 NSNotificationName const ANNHingeDidChangeNotification = @"ANNHingeDidChange";
+NSNotificationName const ANNHingeDidMoveNotification = @"ANNHingeDidMove";
 
 // Main queue.
 static ANNEventEmitter *ANNHingeEventEmitter;
@@ -34,11 +36,12 @@ static NSDictionary<NSString *, id> *ANNHingeValue(UIHinge *hinge) API_AVAILABLE
     if (!hinge) {
         return @{};
     }
+    const auto &keys = ANNEventContract.HingeChanged;
     NSString *state = ANNHingeStateName(hinge.status);
     if (hinge.status == UIHingeStatusUnknown) {
-        return @{@"state" : state};
+        return @{keys.state : state};
     }
-    return @{@"state" : state, @"angle" : @(round(hinge.angle * 1800 / M_PI) / 10)};
+    return @{keys.state : state, keys.angle : @(round(hinge.angle * 1800 / M_PI) / 10)};
 }
 #endif
 
@@ -94,13 +97,15 @@ static NSDictionary<NSString *, id> *ANNHingeValue(UIHinge *hinge) API_AVAILABLE
         if ([ANNLastHinge isEqualToDictionary:value]) {
             return;
         }
-        previousState = ANNLastHinge[@"state"];
+        previousState = ANNLastHinge[ANNEventContract.HingeChanged.state];
         ANNLastHinge = value;
     }
     if (ANNHingeUpdatesEnabled) {
         [ANNHingeEventEmitter sendHingeChanged:value];
     }
-    id state = value[@"state"];
+    NSNotificationCenter *center = NSNotificationCenter.defaultCenter;
+    [center postNotificationName:ANNHingeDidMoveNotification object:nil];
+    id state = value[ANNEventContract.HingeChanged.state];
     if (previousState != state && ![previousState isEqual:state]) {
         [NSNotificationCenter.defaultCenter postNotificationName:ANNHingeDidChangeNotification
                                                           object:nil];
@@ -113,4 +118,10 @@ static NSDictionary<NSString *, id> *ANNHingeValue(UIHinge *hinge) API_AVAILABLE
     }
 }
 
++ (BOOL)isPresent {
+    @synchronized(ANNHinge.class) {
+        return ANNLastHinge[ANNEventContract.HingeChanged.state] != nil;
+    }
+}
+
 @end

package/ios/Core/ANNJavaScriptCalls.h

@@ -0,0 +1,33 @@
+#import <Foundation/Foundation.h>
+
+@class RCTCallInvoker;
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// The way of the calls JavaScript makes to `ANNTurboModule`, for a step that must come after them. A call without an
+/// answer (`mergeOptions`) leaves the JavaScript thread as it is made, as a task on the main queue, the module's queue
+/// (React Native's `ModuleNativeMethodCallInvoker`, a `dispatch_async` to it), and runs whole in that task
+/// (`ANNCommandRunner`). A step sent from the JavaScript thread to the main queue after them comes after them: the
+/// JavaScript thread runs its tasks in order, and the main queue runs what it is given in the order it was given. The
+/// module tells its call invoker when React Native made it, and that it went when React Native invalidates it (a
+/// reload). Any thread, except `afterCallsMadeSoFar:`.
+@interface ANNJavaScriptCalls : NSObject
+
+- (instancetype)init NS_UNAVAILABLE;
++ (instancetype)new NS_UNAVAILABLE;
+
+/// The module of the JavaScript that runs now and its call invoker (the JavaScript thread).
++ (void)setCallInvoker:(nullable RCTCallInvoker *)callInvoker ofModule:(id)module;
+
+/// The module went: with no newer module told since, no JavaScript runs to wait for.
++ (void)moduleWent:(id)module;
+
+/// `block` runs on the main queue once every call JavaScript made to the module before the next task of its thread is
+/// applied: a task on the JavaScript thread, from there one on the main queue. With no JavaScript to ask (none yet, a
+/// reload), at once. Main queue. A JavaScript thread that never runs the task again (its runtime went) never runs
+/// `block`: a caller that can't wait for long has a limit of its own.
++ (void)afterCallsMadeSoFar:(dispatch_block_t)block;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/Core/ANNJavaScriptCalls.mm

@@ -0,0 +1,52 @@
+#import "ANNJavaScriptCalls.h"
+#import "ANNAssert.h"
+#import <React/RCTCallInvoker.h>
+#import <ReactCommon/CallInvoker.h>
+
+// The module told last, weakly: a module that went takes its invoker with it.
+static __weak id ANNCallsModule;
+static RCTCallInvoker *ANNCallsInvoker;
+
+@implementation ANNJavaScriptCalls
+
++ (void)setCallInvoker:(RCTCallInvoker *)callInvoker ofModule:(id)module {
+    @synchronized(self) {
+        ANNCallsModule = module;
+        ANNCallsInvoker = callInvoker;
+    }
+}
+
++ (void)moduleWent:(id)module {
+    @synchronized(self) {
+        if (ANNCallsModule != module) {
+            return;
+        }
+        ANNCallsModule = nil;
+        ANNCallsInvoker = nil;
+    }
+}
+
++ (void)afterCallsMadeSoFar:(dispatch_block_t)block {
+    ANNAssertMainQueue();
+    RCTCallInvoker *callInvoker = nil;
+    @synchronized(self) {
+        if (ANNCallsModule) {
+            callInvoker = ANNCallsInvoker;
+        }
+    }
+    std::shared_ptr<facebook::react::CallInvoker> invoker =
+        callInvoker ? callInvoker.callInvoker : nullptr;
+    if (!invoker) {
+        block();
+        return;
+    }
+    dispatch_block_t done = [block copy];
+    // The JavaScript thread runs the task after the one it runs now, which made the calls of this moment (a commit of
+    // React and its layout effects). Each of those calls went to the main queue as it was made, so this hop, sent from
+    // the same thread later, reaches the main queue behind them (a serial queue, in the order it was given).
+    invoker->invokeAsync([done](facebook::jsi::Runtime &) {
+        dispatch_async(dispatch_get_main_queue(), done);
+    });
+}
+
+@end

package/ios/Core/ANNLayoutProtocol.h

@@ -11,10 +11,10 @@ NS_ASSUME_NONNULL_BEGIN
 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,
+    /// The screen's content rendered, on a screen the user doesn't see yet (an unselected tab of `together`, which
+    /// renders unseen in the tabs' view). Its part of a wait ends at the command's 0.5 s at the latest, and its bar
+    /// components are not waited for.
+    ANNWaitedReadinessUnseen,
 };
 
 /// A transition of the navigation is done: what it moved is in place.
@@ -97,7 +97,7 @@ typedef void (^ANNTransitionRejectionBlock)(NSString *message, NSError *_Nullabl
 - (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.
+/// parents (`ANNWaitedReadinessOf`). The tabs answer "unseen" for the screens of their unselected tabs.
 - (ANNWaitedReadiness)waitedReadinessOfScreen:(UIViewController *)screen;
 
 #pragma mark - The children

package/ios/Core/ANNNavigationState.h

@@ -23,12 +23,14 @@ NS_ASSUME_NONNULL_BEGIN
 + (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;
+/// The state now, sent when it changed. A command's answer asks for it once (`-[ANNCommandAnswer reportStateNow]`, at
+/// the end of its transition or before its promise); the end of a user's transition and a tab chosen from code ask
+/// `updateNow`. A walk that throws logs one line, `[ApexNavigation] <commandName>: could not report the navigation
+/// state: <reason>` (as on Android; `transition` without a command), and sends nothing, so its caller always goes on.
++ (void)updateNowFor:(nullable NSString *)commandName;
 
-/// A command is about to answer: when what shows changed, the new state goes now, before the promise.
-+ (void)reportBeforeAnswer;
+/// `updateNowFor:` without a command.
++ (void)updateNow;
 
 /// Forgets the last state sent: the next one goes even if it is the same (a new bundle, `AppLaunched`).
 + (void)reset;

package/ios/Core/ANNNavigationState.mm

@@ -2,12 +2,12 @@
 #import "ANNAssert.h"
 #import "ANNBottomTabsController.h"
 #import "ANNComponentViewController.h"
+#import "ANNErrorHandler.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;
@@ -58,6 +58,10 @@ static BOOL ANNSameValue(id a, id b) {
 }
 
 + (void)updateNow {
+    [self updateNowFor:nil];
+}
+
++ (void)updateNowFor:(NSString *)commandName {
     ANNAssertMainQueue();
     NSString *screenId = nil;
     NSString *name = nil;
@@ -74,8 +78,9 @@ static BOOL ANNSameValue(id a, id b) {
         }
     } @catch (NSException *exception) {
         NSString *reason = exception.reason.length > 0 ? exception.reason : exception.name;
-        RCTLogWarn(@"[ApexNavigation] %@",
-                   [ANNErrorTexts couldNot:@"report the navigation state" reason:reason]);
+        [ANNErrorHandler logFailureOf:commandName ?: @"transition"
+                                 text:[ANNErrorTexts couldNot:@"report the navigation state"
+                                                        reason:reason]];
         return;
     }
     if (ANNHasLastState && ANNSameValue(screenId, ANNLastScreenId) &&
@@ -89,10 +94,6 @@ static BOOL ANNSameValue(id a, id b) {
     [ApexNavigation.eventEmitter sendNavigationStateChanged:screenId name:name tab:tab];
 }
 
-+ (void)reportBeforeAnswer {
-    [self updateNow];
-}
-
 + (void)reset {
     ANNAssertMainQueue();
     ANNHasLastState = NO;

package/ios/Core/ANNNodeHelper.h

@@ -3,6 +3,7 @@
 #import "ANNLayoutInfo.h"
 #import "ANNNavigationOptions.h"
 #import "ANNNodePresenter.h"
+#import "ANNUserChoice.h"
 #import <UIKit/UIKit.h>
 
 NS_ASSUME_NONNULL_BEGIN
@@ -24,9 +25,11 @@ FOUNDATION_EXPORT NSString *const ANNContainerReadyHandlerKey;
 @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:`.
+/// The node's own options: its layout options with every `mergeOptions` into it and what the core keeps of a merge (the
+/// title component a merged text drops, side colors). The user's choices are not here but in the user layer
+/// (`setUserChoice:forKey:`). 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;
@@ -57,21 +60,38 @@ FOUNDATION_EXPORT NSString *const ANNContainerReadyHandlerKey;
 /// 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.
+/// The app's `mergeOptions` into the node: `options` merged with `options` given and stored through the setter. A
+/// choice of the user layer that the merge changes leaves the layer, by Android's rules
+/// (`ANNUserChoice choiceAfterMerge:own:before:after:`): a field given a value other than the app had there (the own
+/// options', else the node's resolution before the merge), or the button, item or scope of the choice gone from the
+/// node's resolution after it; the same value sent again keeps it.
 - (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.
+/// A change of the own options by the core: `change` gets a copy of them, and the copy is stored through the setter.
+/// For what the core keeps of the app's merges (the title component a merged text drops, side colors), never for a
+/// choice of the user, which goes into the user layer.
 - (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.
+/// The user layer: the choices the user made in native UI (a toggled button, the check of a single-selection menu, the
+/// search scope, the tokens and suggestions UIKit removed, a renamed title), one per key, apart from the own options.
+/// The resolution writes them over the own options, by identity (`ANNUserChoice applyTo:`): defaults < parents < own <
+/// user. Setting one (nil removes it) makes every resolved options miss its cache, as a change of own options does.
+/// `setDefaultOptions` never touches the layer; it goes with the node.
+- (void)setUserChoice:(nullable ANNUserChoice *)choice forKey:(NSString *)key;
+
+/// The choice under `key`, or nil.
+- (nullable ANNUserChoice *)userChoiceForKey:(NSString *)key;
+
+/// The common resolve: a copy of the node's own options with its user layer written over them, then the resolved
+/// options of its current child over that, 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.
+/// What the node shows with: the default options, then the own options of its parents (each with its user layer) from
+/// the farthest to the nearest, then the node's `resolveOptions`; a node without a current child (a screen) writes its
+/// user layer once more at the end, so a choice also reaches a list the screen takes from its stack or the defaults.
+/// Cached until any options or user layer 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

package/ios/Core/ANNNodeHelper.mm

@@ -29,8 +29,14 @@ static NSPointerArray *ANNWeakNodes(NSArray<UIViewController *> *nodes) {
 
 NSString *const ANNContainerReadyHandlerKey = @"ApexNavigation.container";
 
+// Set while a node works out the app's resolution (`appResolution`): no user layer is written. Main queue.
+static BOOL ANNUserLayersLeftOut = NO;
+
 @implementation ANNNodeHelper {
     ANNNavigationOptions *_options;
+    // The user layer: the choices by key, and their keys in the order they were set, the order they are written in.
+    NSMutableDictionary<NSString *, ANNUserChoice *> *_userChoices;
+    NSMutableArray<NSString *> *_userChoiceKeys;
     // The ready handlers by key, and their keys in the order they were first set.
     NSMutableDictionary<NSString *, dispatch_block_t> *_readyHandlers;
     NSMutableArray<NSString *> *_readyKeys;
@@ -108,10 +114,27 @@ NSString *const ANNContainerReadyHandlerKey = @"ApexNavigation.container";
 - (void)setDefaultOptions:(ANNNavigationOptions *)defaultOptions {
 }
 
+// With a user layer, the choices meet the merge as on Android: they see the app's resolution before it and after it
+// (the merge in place for that, uncached), and those the merge changes leave; the setter then moves the cache once for
+// both, also when a choice's rule throws: the new own options never stay with a cache of the old ones.
 - (void)mergeOwnOptions:(ANNNavigationOptions *)options {
-    ANNNavigationOptions *merged = _options ? [_options copy] : [ANNNavigationOptions new];
+    ANNAssertMainQueue();
+    ANNNavigationOptions *own = _options ?: [ANNNavigationOptions new];
+    ANNNavigationOptions *merged = [own copy];
     [merged mergeOptions:options];
-    self.options = merged;
+    if (_userChoiceKeys.count == 0) {
+        self.options = merged;
+        return;
+    }
+    ANNNavigationOptions *before = [self appResolution];
+    ANNNavigationOptions *stored = [merged withoutOneShotOptions];
+    _options = stored;
+    @try {
+        ANNNavigationOptions *after = [self appResolution];
+        [self userChoicesMeetMerge:options own:own before:before after:after];
+    } @finally {
+        self.options = stored;
+    }
 }
 
 - (void)changeOwnOptions:(void (^)(ANNNavigationOptions *options))change {
@@ -120,10 +143,78 @@ NSString *const ANNContainerReadyHandlerKey = @"ApexNavigation.container";
     self.options = changed;
 }
 
+#pragma mark - The user layer
+
+- (void)setUserChoice:(ANNUserChoice *)choice forKey:(NSString *)key {
+    ANNAssertMainQueue();
+    if (!choice && !_userChoices[key]) {
+        return;
+    }
+    if (!_userChoices) {
+        _userChoices = [NSMutableDictionary new];
+        _userChoiceKeys = [NSMutableArray new];
+    }
+    // A choice set again goes last: it is the newest.
+    [_userChoiceKeys removeObject:key];
+    if (choice) {
+        _userChoices[key] = choice;
+        [_userChoiceKeys addObject:key];
+    } else {
+        [_userChoices removeObjectForKey:key];
+    }
+    [ANNOptionsCache optionsChanged];
+}
+
+- (ANNUserChoice *)userChoiceForKey:(NSString *)key {
+    return _userChoices[key];
+}
+
+// Each choice answers the merge itself: it stays, keeps a part, or goes. The order of the rest stays.
+- (void)userChoicesMeetMerge:(ANNNavigationOptions *)merge
+                         own:(ANNNavigationOptions *)own
+                      before:(ANNNavigationOptions *)before
+                       after:(ANNNavigationOptions *)after {
+    for (NSString *key in [_userChoiceKeys copy]) {
+        ANNUserChoice *choice = _userChoices[key];
+        ANNUserChoice *kept = [choice choiceAfterMerge:merge own:own before:before after:after];
+        if (kept == choice) {
+            continue;
+        }
+        if (kept) {
+            _userChoices[key] = kept;
+        } else {
+            [_userChoices removeObjectForKey:key];
+            [_userChoiceKeys removeObject:key];
+        }
+    }
+}
+
+// The node's resolution with the defaults and without any user layer: what the app's options alone give (Android's
+// `resolveCurrentOptions().withDefaultOptions`). Built now, never cached: the resolution reads no cache on the way.
+- (ANNNavigationOptions *)appResolution {
+    BOOL leftOut = ANNUserLayersLeftOut;
+    ANNUserLayersLeftOut = YES;
+    @try {
+        return [self resolveOptionsWithDefaultUncached];
+    } @finally {
+        ANNUserLayersLeftOut = leftOut;
+    }
+}
+
+- (void)applyUserLayerTo:(ANNNavigationOptions *)options {
+    if (ANNUserLayersLeftOut) {
+        return;
+    }
+    for (NSString *key in _userChoiceKeys) {
+        [_userChoices[key] applyTo:options];
+    }
+}
+
 #pragma mark - Resolving
 
 - (ANNNavigationOptions *)resolveOptions {
     ANNNavigationOptions *result = _options ? [_options copy] : [ANNNavigationOptions new];
+    [self applyUserLayerTo:result];
     UIViewController *child = [_node getCurrentChild];
     if (child) {
         [result mergeOptions:[child resolveOptions]];
@@ -168,7 +259,9 @@ NSString *const ANNContainerReadyHandlerKey = @"ApexNavigation.container";
     return [self resolveOfNode:node parents:parents];
 }
 
-// Built on copies: the defaults never go into a node's own options.
+// Built on copies: the defaults never go into a node's own options. Each parent's user layer goes over its own
+// options; a node without a current child writes its own layer once more at the end, for the lists it takes from its
+// parents or the defaults (a toggle of a button of the stack's). Writing a choice twice gives the same result.
 - (ANNNavigationOptions *)resolveOfNode:(UIViewController *)node
                                 parents:(NSArray<UIViewController *> *)parents {
     ANNNavigationOptions *result = [ANNDefaultOptions.current copy];
@@ -177,8 +270,12 @@ NSString *const ANNContainerReadyHandlerKey = @"ApexNavigation.container";
         if (own) {
             [result mergeOptions:own];
         }
+        [parent.nodeHelper applyUserLayerTo:result];
     }
     [result mergeOptions:[node resolveOptions]];
+    if (![node getCurrentChild]) {
+        [self applyUserLayerTo:result];
+    }
     return result;
 }
 

package/ios/Core/ANNParking.h

@@ -4,10 +4,11 @@ NS_ASSUME_NONNULL_BEGIN
 
 /// A place where the views of nodes wait for their content unseen (their safe area views lay out only in a window): the
 /// window under the current root while a root waits, a stack's view under UIKit's container while a screen of the stack
-/// waits or renders. A parked view sits at the back of its host, at the host's size and following it (a rotation, a
-/// resize), gets no touches and is hidden from accessibility; it isn't a child of anything there, and its node's
-/// appearance is driven meanwhile (`ANNAppearanceDispatcher driveAppearanceOf:`), so UIKit's appearance callbacks
-/// report nothing for it. Each node leaves it as it was. Main queue.
+/// waits or renders, the tabs' view while a tab rendered before it shows renders its content. A parked view sits at the
+/// back of its host, at the host's size and following it (a rotation, a resize), gets no touches and is hidden from
+/// accessibility; it isn't a child of anything there (a tab stays the tabs' child), and its node's appearance is driven
+/// meanwhile (`ANNAppearanceDispatcher driveAppearanceOf:`), so UIKit's appearance callbacks report nothing for it.
+/// Each node leaves it as it was. Main queue.
 @interface ANNParking : NSObject
 
 /// `node`'s view waits in `host` from now on, with what it had kept. NO when it waits here already.

package/ios/Core/ANNReloadCoordinator.mm

@@ -1,5 +1,4 @@
 #import "ANNReloadCoordinator.h"
-#import "ANNArrangementState.h"
 #import "ANNAssert.h"
 #import "ANNErrorTexts.h"
 #import "ANNHinge.h"
@@ -12,12 +11,10 @@
 #import "ANNPreviewInteraction.h"
 #import "ANNPreviewPush.h"
 #import "ANNRootCoordinator.h"
-#import "ANNScreenInsets.h"
+#import "ANNScreenEnvironment.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>
@@ -145,21 +142,17 @@ static BOOL ANNWatchingBundles;
     [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];
+    // their old nodes after the hold. The loop updates are off already.
     // 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).
+    // JavaScript, their environment: insets and padding, regions and arrangements (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];
+    [ANNScreenEnvironment 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) {

package/ios/Core/ANNRenderWait.h

@@ -5,7 +5,7 @@ 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`).
+    /// No content: the bar components alone.
     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.
@@ -36,7 +36,7 @@ typedef NS_ENUM(NSInteger, ANNRenderWaitBar) {
 
 /// `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
+/// by the readiness it needs (`ANNWaitedReadinessOf`: content, or "unseen" content 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
@@ -49,16 +49,30 @@ typedef NS_ENUM(NSInteger, ANNRenderWaitBar) {
 - (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 longest a waited screen of the "unseen" 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 unseenLimit;
 
 /// 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;
 
+/// The content phase ends only once every call JavaScript made by then is applied on the main queue
+/// (`ANNJavaScriptCalls`): the options a screen merges in the commit that mounted it are there before the owner's next
+/// step. Also when the content is there already as the wait starts or takes its screens again (the commit that mounted
+/// it may have run just now): such a phase ends after `start`, through `protect`, while JavaScript has a call invoker;
+/// without one (no JavaScript running) the calls are applied already and the phase ends inside `start`, as without
+/// this. Screens without React content (a native screen) end the phase at once. The limit still ends the phase
+/// meanwhile. Off by default.
+@property(nonatomic) BOOL settlesThroughJavaScript;
+
+/// With `ANNRenderWaitBarAfterContent`, the bar phase that follows the content phase counts its limits from the wait's
+/// start, not from its own: the time the content took comes off each kind's limit, and a kind past it by then waits no
+/// more. A bar phase that starts again (`retakeScreens:`) counts from then, as without it. Off by default.
+@property(nonatomic) BOOL barLimitsFromStart;
+
 /// 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;