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

package/ios/Core/ANNScreenAppearance.mm

@@ -0,0 +1,44 @@
+#import "ANNScreenAppearance.h"
+#import "ANNAppearanceDispatcher.h"
+#import "ANNScreenAppearance+Internal.h"
+#import "ANNReactView.h"
+#import "ApexNavigation+Internal.h"
+
+@implementation ANNScreenAppearance {
+    // Whether the record was made with content to wait for: a content that went away waits for nothing.
+    BOOL _waitsForContent;
+}
+
+- (instancetype)initWithComponentId:(NSString *)componentId
+                      componentName:(NSString *)componentName
+                      componentType:(ANNComponentType)componentType
+                            content:(id<ANNComponentProtocol>)content
+                       eventEmitter:(ANNEventEmitter *)eventEmitter {
+    if (self = [super init]) {
+        _componentId = [componentId copy] ?: @"";
+        _componentName = [componentName copy] ?: @"";
+        _componentType = componentType;
+        _content = content;
+        _waitsForContent = content != nil;
+        _eventEmitter = eventEmitter ?: ApexNavigation.eventEmitter;
+        _phase = ANNAppearancePhaseHidden;
+    }
+    return self;
+}
+
+- (BOOL)isReady {
+    if (_readyForGood) {
+        return YES;
+    }
+    id<ANNComponentProtocol> content = _content;
+    if (!_waitsForContent || !content || content.isReady) {
+        _readyForGood = YES;
+    }
+    return _readyForGood;
+}
+
+- (void)markReady {
+    [ANNAppearanceDispatcher appearanceBecameReady:self];
+}
+
+@end

package/ios/Core/ANNShownScreens.h

@@ -0,0 +1,27 @@
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// The one seam of "what a node shows changed": a stack operation ended, a tab was chosen, a side menu's menu showed or
+/// hid, a split view's columns collapsed, expanded or changed their display mode, a column took a new screen
+/// (`showInColumn`), a pair changed its arrangement. Every container that changes what it shows calls only this; the
+/// seam tells, in this order:
+///
+/// - the layer that waits to show and holds the node (`ANNPendingLayers`): its wait takes its screens again;
+/// - the modal that holds the node (`ANNModalCoordinator`): its hold follows the screen it shows now;
+/// - the system UI (`ANNSystemUI`): UIKit is asked again at the end of the turn.
+///
+/// Each of them does nothing when nothing changed for it, so a call that changes nothing costs nothing. The height of a
+/// sheet or a modal sized to its content is not part of it: it follows a stack's top, and stays the stack's own call
+/// (`+[ANNSheetPresenter stackDidShowScreenInModal:]`). Main queue.
+@interface ANNShownScreens : NSObject
+
+- (instancetype)init NS_UNAVAILABLE;
++ (instancetype)new NS_UNAVAILABLE;
+
+/// What `node` shows changed.
++ (void)changedIn:(UIViewController *)node;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/Core/ANNShownScreens.mm

@@ -0,0 +1,16 @@
+#import "ANNShownScreens.h"
+#import "ANNAssert.h"
+#import "ANNModalCoordinator.h"
+#import "ANNPendingLayers.h"
+#import "ANNSystemUI.h"
+
+@implementation ANNShownScreens
+
++ (void)changedIn:(UIViewController *)node {
+    ANNAssertMainQueue();
+    [ANNPendingLayers shownScreensChangedIn:node];
+    [ANNModalCoordinator visibleScreenChangedIn:node];
+    [ANNSystemUI setNeedsUpdate];
+}
+
+@end

package/ios/Core/ANNSystemUI.h

@@ -0,0 +1,95 @@
+#import "ANNNavigationOptions.h"
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// The groups of the system UI a screen decides: what a trigger marks for UIKit to ask again.
+typedef NS_OPTIONS(NSUInteger, ANNSystemUIGroup) {
+    ANNSystemUIGroupNone = 0,
+    /// `statusBar.*`: the style and the visibility.
+    ANNSystemUIGroupStatusBar = 1 << 0,
+    /// `layout.orientation`.
+    ANNSystemUIGroupOrientation = 1 << 1,
+    /// `layout.autoHideHomeIndicator`.
+    ANNSystemUIGroupHomeIndicator = 1 << 2,
+    /// `layout.deferSystemGestures`.
+    ANNSystemUIGroupDeferredEdges = 1 << 3,
+    /// `layout.verticalBars` (iOS 27.1).
+    ANNSystemUIGroupVerticalBars = 1 << 4,
+    ANNSystemUIGroupAll = (1 << 5) - 1,
+};
+
+/// One question UIKit asks a view controller about the system UI; the status bar has two.
+typedef NS_ENUM(NSInteger, ANNSystemUIQuestion) {
+    ANNSystemUIQuestionStatusBarStyle,
+    ANNSystemUIQuestionStatusBarHidden,
+    ANNSystemUIQuestionOrientations,
+    ANNSystemUIQuestionHomeIndicator,
+    ANNSystemUIQuestionDeferredEdges,
+    ANNSystemUIQuestionVerticalBars,
+};
+
+/// The one owner of the system UI of the navigation's windows.
+///
+/// UIKit keeps the values: it asks the view controllers itself at its transitions, rotations and trait changes, and the
+/// screens answer from their resolved options (`ANNComponentViewController`, through the rules of `ANNNodePresenter`).
+/// The owner adds the asks UIKit doesn't make — a merge, a side menu at rest, an overlay, a root replaced, the bar of a
+/// stack shown or hidden, the orientation after an appearance — and makes them once per turn of the main queue: a
+/// trigger marks groups, the marks of a turn are coalesced, and at its end UIKit is asked again for each marked group
+/// in the main window and every overlay window. It keeps no values but the last status bar of each window, which only
+/// chooses whether a change of the style animates. Never a wait. Main queue.
+@interface ANNSystemUI : NSObject
+
+- (instancetype)init NS_UNAVAILABLE;
++ (instancetype)new NS_UNAVAILABLE;
+
+#pragma mark - Triggers
+
+/// Every group: a screen appeared or disappeared, a tab, a menu, a modal or an overlay changed, a root was replaced.
++ (void)setNeedsUpdate;
+
+/// The groups named.
++ (void)setNeedsUpdateOfGroups:(ANNSystemUIGroup)groups;
+
+/// `mergeOptions` merged `options`: the groups they name are asked again, always (a merge is never dropped).
++ (void)optionsMerged:(ANNNavigationOptions *)options;
+
+/// The groups `options` give a value to; for the status bar only the keys iOS reads (`visible`, `style`,
+/// `hideWithTopBar`) when `onlyRead`, every key of `statusBar` otherwise.
++ (ANNSystemUIGroup)groupsNamedBy:(ANNNavigationOptions *)options onlyRead:(BOOL)onlyRead;
+
+#pragma mark - Who decides
+
+/// The screen the system UI of `node` follows: down `systemUIChild`, else `getCurrentChild`, to a node without a child.
+/// A walk that meets a view controller that is no node of the layout stops there: nil.
++ (nullable UIViewController *)topScreenOf:(UIViewController *)node;
+
+/// The controller UIKit takes the answer to `question` from in `window`, along UIKit's own chain: down the presented
+/// controllers while UIKit hands the question to them (the status bar and the rest: a full-screen show as UIKit uses
+/// it, or one that captures the status bar; the orientations: a show that covers the screen, `fullScreen` or
+/// `overFullScreen`), then down the container's `childViewControllerFor…` to nil. Nil without a root.
++ (nullable UIViewController *)deciderInWindow:(nullable UIWindow *)window
+                                       question:(ANNSystemUIQuestion)question;
+
+/// The options `screen` answers the questions of `group` with: its resolved options; for a screen of an overlay, the
+/// own options of its overlay's nodes from the overlay's root down to it, without the app's defaults, when they name a
+/// key of the group; nil when they don't — the screen then answers what the main window's deciding controller answers
+/// (`deciderInWindow:question:`).
++ (nullable ANNNavigationOptions *)optionsOfScreen:(UIViewController *)screen
+                                          forGroup:(ANNSystemUIGroup)group;
+
+/// Whether the bar of `navigation` is hidden, by `navigationBarHidden` or by UIKit's own hide of the bar (F6): what
+/// `statusBar.hideWithTopBar` reads and what the stack watches. NO for nil.
++ (BOOL)barHiddenOf:(nullable UINavigationController *)navigation;
+
+/// Whether the bar of the navigation controller that shows `screen` (the stack, or UIKit's More navigation) is hidden;
+/// NO for a screen in no stack.
++ (BOOL)navigationBarHiddenOfScreen:(nullable UIViewController *)screen;
+
+/// The node's own options over its parents' over the defaults, without what its children show: the tabs' answer while
+/// UIKit's More list shows.
++ (ANNNavigationOptions *)ownOptionsWithDefaultOf:(UIViewController *)node;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/Core/ANNSystemUI.mm

@@ -0,0 +1,401 @@
+#import "ANNSystemUI.h"
+#import "ANNAssert.h"
+#import "ANNComponentViewController.h"
+#import "ANNDefaultOptions.h"
+#import "ANNOverlayCoordinator.h"
+#import "ANNRootCoordinator.h"
+#import "ANNSystemUIRules.h"
+#import "ANNUtils.h"
+#import "UIViewController+LayoutProtocol.h"
+
+// `statusBar.animate`: a change of the style fades over this.
+static const NSTimeInterval ANNStatusBarStyleDuration = 0.35;
+
+// How deep a walk of controllers goes at most: a chain that loops ends there.
+static const NSUInteger ANNWalkLimit = 64;
+
+// The status bar of a window after the owner's last ask: only to choose whether a change of the style animates.
+@interface ANNSystemUIStatusBarRecord : NSObject
+@property(nonatomic) UIStatusBarStyle style;
+@property(nonatomic) BOOL hidden;
+@end
+
+@implementation ANNSystemUIStatusBarRecord
+@end
+
+// Main queue.
+static ANNSystemUIGroup ANNMarkedGroups;
+static BOOL ANNUpdateScheduled;
+static NSMapTable<UIWindow *, ANNSystemUIStatusBarRecord *> *ANNStatusBarRecords;
+
+// The presentation style UIKit uses for `presented` now (F12): its presentation controller's (an automatic one is a
+// sheet there), and for a popover in a compact width the style UIKit adapts it to — full screen, unless its delegate
+// keeps it a popover (a kept popover answers none).
+static UIModalPresentationStyle ANNUsedPresentationStyle(UIViewController *presented) {
+    UIPresentationController *presentation = presented.presentationController;
+    if (!presentation || presentation.presentedViewController != presented) {
+        return presented.modalPresentationStyle;
+    }
+    UIModalPresentationStyle style = presentation.presentationStyle;
+    UITraitCollection *traits = presentation.traitCollection;
+    if (style == UIModalPresentationPopover &&
+        traits.horizontalSizeClass == UIUserInterfaceSizeClassCompact) {
+        UIModalPresentationStyle adapted =
+            [presentation adaptivePresentationStyleForTraitCollection:traits];
+        if (adapted != UIModalPresentationNone) {
+            style = adapted;
+        }
+    }
+    return style;
+}
+
+// UIKit hands the status bar, the home indicator, the deferred edges and the vertical bars to a presented controller
+// shown full screen, and the status bar also to one that captures it; the orientations to one that covers the screen
+// (F4).
+static BOOL ANNPresentedTakes(UIViewController *presented, ANNSystemUIQuestion question) {
+    UIModalPresentationStyle style = ANNUsedPresentationStyle(presented);
+    if (question == ANNSystemUIQuestionOrientations) {
+        return style == UIModalPresentationFullScreen ||
+               style == UIModalPresentationOverFullScreen;
+    }
+    BOOL statusBar = question == ANNSystemUIQuestionStatusBarStyle ||
+                     question == ANNSystemUIQuestionStatusBarHidden;
+    if (statusBar && presented.modalPresentationCapturesStatusBarAppearance) {
+        return YES;
+    }
+    return style == UIModalPresentationFullScreen;
+}
+
+// The child `controller` hands `question` to, as UIKit asks it.
+static UIViewController *ANNChildFor(UIViewController *controller, ANNSystemUIQuestion question) {
+    switch (question) {
+        case ANNSystemUIQuestionStatusBarStyle:
+            return controller.childViewControllerForStatusBarStyle;
+        case ANNSystemUIQuestionStatusBarHidden:
+            return controller.childViewControllerForStatusBarHidden;
+        case ANNSystemUIQuestionHomeIndicator:
+            return controller.childViewControllerForHomeIndicatorAutoHidden;
+        case ANNSystemUIQuestionDeferredEdges:
+            return controller.childViewControllerForScreenEdgesDeferringSystemGestures;
+        case ANNSystemUIQuestionVerticalBars:
+#if __IPHONE_OS_VERSION_MAX_ALLOWED >= 270100
+            if (@available(iOS 27.1, *)) {
+                return controller.childViewControllerForPreferredVerticalBarBehavior;
+            }
+#endif
+            return nil;
+        case ANNSystemUIQuestionOrientations:
+            return nil;
+    }
+    return nil;
+}
+
+// The window's root and its presented chain, to the first nil.
+static NSArray<UIViewController *> *ANNChainOf(UIWindow *window) {
+    UIViewController *root = window.rootViewController;
+    if (!root) {
+        return @[];
+    }
+    NSMutableArray<UIViewController *> *chain = [NSMutableArray arrayWithObject:root];
+    for (UIViewController *presented = root.presentedViewController;
+         presented && chain.count < ANNWalkLimit; presented = presented.presentedViewController) {
+        [chain addObject:presented];
+    }
+    return chain;
+}
+
+@implementation ANNSystemUI
+
+#pragma mark - Triggers
+
++ (void)setNeedsUpdate {
+    [self setNeedsUpdateOfGroups:ANNSystemUIGroupAll];
+}
+
++ (void)setNeedsUpdateOfGroups:(ANNSystemUIGroup)groups {
+    ANNAssertMainQueue();
+    if (groups == ANNSystemUIGroupNone) {
+        return;
+    }
+#if DEBUG
+    ANNSystemUIRulesSelfCheck();
+#endif
+    ANNMarkedGroups |= groups;
+    if (ANNUpdateScheduled) {
+        return;
+    }
+    // The end of this turn of the main queue: every trigger of the turn is in, nothing waits for it.
+    ANNUpdateScheduled = YES;
+    dispatch_async(dispatch_get_main_queue(), ^{
+      [ANNSystemUI update];
+    });
+}
+
++ (void)optionsMerged:(ANNNavigationOptions *)options {
+    [self setNeedsUpdateOfGroups:[self groupsNamedBy:options onlyRead:NO]];
+}
+
++ (ANNSystemUIGroup)groupsNamedBy:(ANNNavigationOptions *)options onlyRead:(BOOL)onlyRead {
+    ANNSystemUIGroup groups = ANNSystemUIGroupNone;
+    ANNStatusBarOptions *statusBar = options.statusBar;
+    BOOL namesStatusBar = onlyRead ? statusBar.visible.hasValue || statusBar.style.hasValue ||
+                                         statusBar.hideWithTopBar.hasValue
+                                   : statusBar.hasValue;
+    if (namesStatusBar) {
+        groups |= ANNSystemUIGroupStatusBar;
+    }
+    ANNLayoutOptions *layout = options.layout;
+    if (layout.orientation) {
+        groups |= ANNSystemUIGroupOrientation;
+    }
+    if (layout.autoHideHomeIndicator.hasValue) {
+        groups |= ANNSystemUIGroupHomeIndicator;
+    }
+    if (layout.deferSystemGestures) {
+        groups |= ANNSystemUIGroupDeferredEdges;
+    }
+    if (layout.verticalBars.hasValue) {
+        groups |= ANNSystemUIGroupVerticalBars;
+    }
+    return groups;
+}
+
+#pragma mark - The update
+
+// The marked groups of the turn, asked in the main window and in every overlay window: an overlay's screens may
+// answer what the main window's deciding controller answers, and UIKit may ask either window (F1). While the main
+// window's root plays its own animation, its transform is on the root's view: the orientation waits for its end, which
+// marks it again (the rest is asked now).
++ (void)update {
+    ANNUpdateScheduled = NO;
+    ANNSystemUIGroup groups = ANNMarkedGroups;
+    ANNMarkedGroups = ANNSystemUIGroupNone;
+    if ((groups & ANNSystemUIGroupOrientation) && [ANNRootCoordinator rootAnimationRuns]) {
+        groups &= ~ANNSystemUIGroupOrientation;
+        ANNMarkedGroups |= ANNSystemUIGroupOrientation;
+    }
+    if (groups == ANNSystemUIGroupNone) {
+        return;
+    }
+    NSMutableArray<UIWindow *> *windows = [NSMutableArray new];
+    UIWindow *mainWindow = ANNUtils.mainWindow;
+    if (mainWindow) {
+        [windows addObject:mainWindow];
+    }
+    [windows addObjectsFromArray:[ANNOverlayCoordinator overlayWindows]];
+    if (groups & ANNSystemUIGroupStatusBar) {
+        [self askStatusBarInWindows:windows];
+    }
+    for (UIWindow *window in windows) {
+        [self askGroups:groups inWindow:window];
+    }
+    // iOS 15 turns toward the device only when asked to, if the device's orientation is allowed now.
+    if (groups & ANNSystemUIGroupOrientation) {
+        if (@available(iOS 16.0, *)) {
+        } else {
+            [UIViewController attemptRotationToDeviceOrientation];
+        }
+    }
+}
+
+// UIKit compares the values itself: every controller of the window's chain is asked, the root first.
++ (void)askGroups:(ANNSystemUIGroup)groups inWindow:(UIWindow *)window {
+    NSArray<UIViewController *> *chain = ANNChainOf(window);
+    if (chain.count == 0) {
+        return;
+    }
+    if (groups & ANNSystemUIGroupOrientation) {
+        // UIKit turns the interface itself when its orientation is no longer allowed; animated.
+        if (@available(iOS 16.0, *)) {
+            [chain.firstObject setNeedsUpdateOfSupportedInterfaceOrientations];
+            if (chain.count > 1) {
+                [chain.lastObject setNeedsUpdateOfSupportedInterfaceOrientations];
+            }
+        }
+    }
+    for (UIViewController *controller in chain) {
+        if (groups & ANNSystemUIGroupHomeIndicator) {
+            [controller setNeedsUpdateOfHomeIndicatorAutoHidden];
+        }
+        if (groups & ANNSystemUIGroupDeferredEdges) {
+            [controller setNeedsUpdateOfScreenEdgesDeferringSystemGestures];
+        }
+#if __IPHONE_OS_VERSION_MAX_ALLOWED >= 270100
+        if (groups & ANNSystemUIGroupVerticalBars) {
+            if (@available(iOS 27.1, *)) {
+                [controller setNeedsUpdateOfVerticalBarConfiguration];
+            }
+        }
+#endif
+    }
+}
+
+// A change of the style alone fades over 0.35 s unless the deciding screen's `statusBar.animate` is `false`; a change
+// of the visibility never animates, with or without the style: the safe area changes with it, and the screens'
+// content would move along (`statusBar.animate`). UIKit shows one status bar for the scene, from whichever window it
+// takes (F1): when the visibility changed in any window, no window is asked inside an animation.
++ (void)askStatusBarInWindows:(NSArray<UIWindow *> *)windows {
+    if (!ANNStatusBarRecords) {
+        ANNStatusBarRecords = [NSMapTable weakToStrongObjectsMapTable];
+    }
+    NSMutableArray<NSArray<UIViewController *> *> *chains = [NSMutableArray new];
+    NSMutableArray<NSNumber *> *styleFades = [NSMutableArray new];
+    BOOL hiddenChanged = NO;
+    for (UIWindow *window in windows) {
+        NSArray<UIViewController *> *chain = ANNChainOf(window);
+        if (chain.count == 0) {
+            continue;
+        }
+        UIViewController *styleDecider =
+            [self deciderInWindow:window question:ANNSystemUIQuestionStatusBarStyle];
+        UIViewController *hiddenDecider =
+            [self deciderInWindow:window question:ANNSystemUIQuestionStatusBarHidden];
+        UIStatusBarStyle style =
+            styleDecider ? styleDecider.preferredStatusBarStyle : UIStatusBarStyleDefault;
+        BOOL hidden = hiddenDecider.prefersStatusBarHidden;
+        ANNSystemUIStatusBarRecord *record = [ANNStatusBarRecords objectForKey:window];
+        BOOL fades = record && record.style != style && [self statusBarAnimatesFor:styleDecider];
+        if (record && record.hidden != hidden) {
+            hiddenChanged = YES;
+        }
+        if (!record) {
+            record = [ANNSystemUIStatusBarRecord new];
+            [ANNStatusBarRecords setObject:record forKey:window];
+        }
+        record.style = style;
+        record.hidden = hidden;
+        [chains addObject:chain];
+        [styleFades addObject:@(fades)];
+    }
+    for (NSUInteger index = 0; index < chains.count; index++) {
+        NSArray<UIViewController *> *chain = chains[index];
+        void (^ask)(void) = ^{
+          for (UIViewController *controller in chain) {
+              [controller setNeedsStatusBarAppearanceUpdate];
+          }
+        };
+        if (!hiddenChanged && styleFades[index].boolValue) {
+            [UIView animateWithDuration:ANNStatusBarStyleDuration animations:ask];
+        } else {
+            ask();
+        }
+    }
+}
+
+// A controller that is no node of the layout (React Native's `<Modal>`, an alert, the splash) animates as UIKit's
+// default; a node by its options, as it answers.
++ (BOOL)statusBarAnimatesFor:(UIViewController *)decider {
+    if (!decider.isLayoutNode) {
+        return YES;
+    }
+    UIViewController *answering = decider;
+    ANNNavigationOptions *options = [self optionsOfScreen:decider
+                                                 forGroup:ANNSystemUIGroupStatusBar];
+    if (!options) {
+        UIViewController *main = [self deciderInWindow:ANNUtils.mainWindow
+                                              question:ANNSystemUIQuestionStatusBarStyle];
+        if (!main || main == decider || !main.isLayoutNode) {
+            return YES;
+        }
+        answering = main;
+        options = [self optionsOfScreen:main forGroup:ANNSystemUIGroupStatusBar];
+    }
+    ANNNodePresenter *presenter = answering.presenter;
+    return options && presenter ? [presenter statusBarAnimatesForOptions:options] : YES;
+}
+
+#pragma mark - Who decides
+
++ (UIViewController *)topScreenOf:(UIViewController *)node {
+    UIViewController *screen = node;
+    for (NSUInteger depth = 0; screen && depth < ANNWalkLimit; depth++) {
+        if (!screen.isLayoutNode) {
+            return nil;
+        }
+        UIViewController *child = [screen systemUIChild] ?: [screen getCurrentChild];
+        if (!child || child == screen) {
+            return screen;
+        }
+        screen = child;
+    }
+    return screen;
+}
+
++ (UIViewController *)deciderInWindow:(UIWindow *)window question:(ANNSystemUIQuestion)question {
+    UIViewController *root = window.rootViewController;
+    if (!root) {
+        return nil;
+    }
+    UIViewController *decider = root;
+    NSUInteger depth = 0;
+    UIViewController *presented = root.presentedViewController;
+    while (presented && depth < ANNWalkLimit) {
+        if (ANNPresentedTakes(presented, question)) {
+            decider = presented;
+        }
+        presented = presented.presentedViewController;
+        depth++;
+    }
+    for (depth = 0; depth < ANNWalkLimit; depth++) {
+        UIViewController *child = ANNChildFor(decider, question);
+        if (!child || child == decider) {
+            break;
+        }
+        decider = child;
+    }
+    return decider;
+}
+
++ (ANNNavigationOptions *)optionsOfScreen:(UIViewController *)screen
+                                 forGroup:(ANNSystemUIGroup)group {
+    if (![ANNOverlayCoordinator overlayRootIdOf:screen]) {
+        return [screen resolveOptionsWithDefault];
+    }
+    // The overlay's own options from its root down to the screen, merged on a copy: never the defaults.
+    NSMutableArray<UIViewController *> *nodes = [NSMutableArray new];
+    for (UIViewController *node = screen; node && nodes.count < ANNWalkLimit;
+         node = node.layoutParent) {
+        [nodes addObject:node];
+    }
+    ANNNavigationOptions *own = [ANNNavigationOptions new];
+    for (UIViewController *node in nodes.reverseObjectEnumerator) {
+        ANNNavigationOptions *options = node.options;
+        if (options) {
+            [own mergeOptions:options];
+        }
+    }
+    return ([self groupsNamedBy:own onlyRead:YES] & group) ? own : nil;
+}
+
++ (BOOL)navigationBarHiddenOfScreen:(UIViewController *)screen {
+    if (![screen isKindOfClass:ANNComponentViewController.class]) {
+        return NO;
+    }
+    return [self barHiddenOf:[(ANNComponentViewController *)screen shownNavigation]];
+}
+
++ (BOOL)barHiddenOf:(UINavigationController *)navigation {
+    return navigation != nil && (navigation.navigationBarHidden || navigation.navigationBar.hidden);
+}
+
++ (ANNNavigationOptions *)ownOptionsWithDefaultOf:(UIViewController *)node {
+    ANNNavigationOptions *result = [ANNDefaultOptions.current copy];
+    NSMutableArray<UIViewController *> *parents = [NSMutableArray new];
+    for (UIViewController *parent = node.layoutParent; parent && parents.count < ANNWalkLimit;
+         parent = parent.layoutParent) {
+        [parents addObject:parent];
+    }
+    for (UIViewController *parent in parents.reverseObjectEnumerator) {
+        ANNNavigationOptions *own = parent.options;
+        if (own) {
+            [result mergeOptions:own];
+        }
+    }
+    ANNNavigationOptions *own = node.options;
+    if (own) {
+        [result mergeOptions:own];
+    }
+    return result;
+}
+
+@end

package/ios/Core/ANNSystemUIRules.h

@@ -0,0 +1,35 @@
+#import "ANNNavigationOptions.h"
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// The values of the system UI a screen answers UIKit with, from its options alone: no view, no window.
+/// `ANNNodePresenter` answers through these rules, so the screens, the side menu and the split view answer the same.
+
+/// The sides of the values of `layout.orientation`: `all` and `sensor` all four, `landscape` and `sensorLandscape` both
+/// landscapes, `portrait` the portrait, `sensorPortrait` both portraits, `upsideDown` the portrait upside down,
+/// `default` the app's; unknown values count for nothing. The union meets the app's mask; no values, no option, or
+/// nothing in common with the app give the app's mask (an empty mask would crash UIKit).
+FOUNDATION_EXPORT UIInterfaceOrientationMask
+ANNOrientationMaskOf(NSArray<NSString *> *_Nullable values, UIInterfaceOrientationMask appMask);
+
+/// `statusBar.style`: `'light'` the light content, `'dark'` the dark content, none or another value UIKit's default,
+/// which follows the interface style.
+FOUNDATION_EXPORT UIStatusBarStyle ANNStatusBarStyleOf(NSString *_Nullable style);
+
+/// `statusBar.visible` decides when set; without it `statusBar.hideWithTopBar` hides the status bar while the bar of
+/// the deciding screen's navigation controller is hidden (`navigationBarHidden`; a screen without one passes NO).
+FOUNDATION_EXPORT BOOL ANNStatusBarHiddenOf(ANNStatusBarOptions *statusBar,
+                                           BOOL navigationBarHidden);
+
+/// `layout.deferSystemGestures`: the union of the physical edges named (right to left doesn't swap them); none, or only
+/// unknown values, defer nothing.
+FOUNDATION_EXPORT UIRectEdge ANNDeferredEdgesOf(NSArray<NSString *> *_Nullable values);
+
+#if DEBUG
+/// Development only (there is no iOS test target): checks the rules against the vectors the Android tests share for the
+/// sides of the orientation values, once; a mismatch is logged.
+FOUNDATION_EXPORT void ANNSystemUIRulesSelfCheck(void);
+#endif
+
+NS_ASSUME_NONNULL_END