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

package/ios/Layouts/Screen/ANNScreenReadiness.mm

@@ -0,0 +1,186 @@
+#import "ANNScreenReadiness.h"
+#import "ANNAssert.h"
+
+// What the safe area view of one id said.
+@interface ANNScreenReadinessEntry : NSObject
+@property(nonatomic) BOOL hasSafeAreaView;
+@property(nonatomic) BOOL laidOut;
+@property(nonatomic) BOOL rendered;
+@end
+
+@implementation ANNScreenReadinessEntry
+@end
+
+// Main queue.
+static NSMutableDictionary<NSString *, ANNScreenReadinessEntry *> *ANNReadinessEntries;
+static NSMapTable<NSString *, id<ANNScreenReadinessListener>> *ANNReadinessListeners;
+static NSMutableSet<NSString *> *ANNRendersAtOnce;
+// The live listeners of the ids that render at once, each id with its own weak list.
+static NSMutableDictionary<NSString *, NSHashTable<id<ANNScreenReadinessListener>> *>
+    *ANNSharedListeners;
+
+@implementation ANNScreenReadiness
+
++ (void)initialize {
+    if (self == ANNScreenReadiness.class) {
+        ANNReadinessEntries = [NSMutableDictionary new];
+        ANNReadinessListeners = [NSMapTable strongToWeakObjectsMapTable];
+        ANNRendersAtOnce = [NSMutableSet new];
+        ANNSharedListeners = [NSMutableDictionary new];
+    }
+}
+
+// Every live listener of the id: the shared ones of an id that renders at once, else the one.
++ (NSArray<id<ANNScreenReadinessListener>> *)listenersOf:(NSString *)screenId {
+    NSHashTable<id<ANNScreenReadinessListener>> *shared = ANNSharedListeners[screenId];
+    if (shared) {
+        return shared.allObjects;
+    }
+    id<ANNScreenReadinessListener> listener = [ANNReadinessListeners objectForKey:screenId];
+    return listener ? @[ listener ] : @[];
+}
+
++ (ANNScreenReadinessEntry *)entryOf:(NSString *)screenId {
+    ANNScreenReadinessEntry *entry = ANNReadinessEntries[screenId];
+    if (!entry) {
+        entry = [ANNScreenReadinessEntry new];
+        ANNReadinessEntries[screenId] = entry;
+    }
+    return entry;
+}
+
+#pragma mark - What the safe area view asks and says
+
++ (BOOL)screenWaitsForReadiness:(NSString *)screenId {
+    ANNAssertMainQueue();
+    return ![ANNRendersAtOnce containsObject:screenId];
+}
+
++ (void)screenHasSafeAreaView:(NSString *)screenId {
+    ANNAssertMainQueue();
+    [self entryOf:screenId].hasSafeAreaView = YES;
+}
+
++ (void)screenDidLayOut:(NSString *)screenId {
+    ANNAssertMainQueue();
+    ANNScreenReadinessEntry *entry = [self entryOf:screenId];
+    entry.hasSafeAreaView = YES;
+    if (entry.laidOut) {
+        return;
+    }
+    entry.laidOut = YES;
+    for (id<ANNScreenReadinessListener> listener in [self listenersOf:screenId]) {
+        if ([listener respondsToSelector:@selector(screenReadinessDidLayOut:)]) {
+            [listener screenReadinessDidLayOut:screenId];
+        }
+    }
+}
+
++ (void)screenContentDidRender:(NSString *)screenId {
+    ANNAssertMainQueue();
+    ANNScreenReadinessEntry *entry = [self entryOf:screenId];
+    entry.hasSafeAreaView = YES;
+    // Several roots of one bar component's id each render once: every signal reaches every root of the id.
+    BOOL shared = ANNSharedListeners[screenId] != nil;
+    if (entry.rendered && !shared) {
+        return;
+    }
+    entry.rendered = YES;
+    for (id<ANNScreenReadinessListener> listener in [self listenersOf:screenId]) {
+        if ([listener respondsToSelector:@selector(screenReadinessContentDidRender:)]) {
+            [listener screenReadinessContentDidRender:screenId];
+        }
+    }
+}
+
+#pragma mark - What the core asks and marks
+
++ (void)setRendersAtOnce:(BOOL)rendersAtOnce forScreenId:(NSString *)screenId {
+    ANNAssertMainQueue();
+    if (rendersAtOnce) {
+        [ANNRendersAtOnce addObject:screenId];
+    } else {
+        [ANNRendersAtOnce removeObject:screenId];
+    }
+}
+
++ (BOOL)isLaidOut:(NSString *)screenId {
+    ANNAssertMainQueue();
+    return ANNReadinessEntries[screenId].laidOut;
+}
+
++ (ANNContentRendered)contentRenderedOfScreen:(NSString *)screenId {
+    ANNAssertMainQueue();
+    ANNScreenReadinessEntry *entry = ANNReadinessEntries[screenId];
+    if (entry.rendered) {
+        return ANNContentRenderedYes;
+    }
+    return entry.hasSafeAreaView ? ANNContentRenderedNo : ANNContentRenderedUnknown;
+}
+
++ (void)setListener:(id<ANNScreenReadinessListener>)listener forScreenId:(NSString *)screenId {
+    ANNAssertMainQueue();
+    if ([ANNRendersAtOnce containsObject:screenId]) {
+        NSHashTable<id<ANNScreenReadinessListener>> *shared = ANNSharedListeners[screenId];
+        if (!shared) {
+            shared = [NSHashTable weakObjectsHashTable];
+            ANNSharedListeners[screenId] = shared;
+        }
+        BOOL alone = shared.allObjects.count == 0;
+        [shared addObject:listener];
+        // What was said belongs to another live root of the id: this one waits for its own render.
+        if (!alone) {
+            return;
+        }
+    } else {
+        [ANNReadinessListeners setObject:listener forKey:screenId];
+    }
+    // The signals are sticky: what was said before the listener came reaches it now, in order.
+    ANNScreenReadinessEntry *entry = ANNReadinessEntries[screenId];
+    if (entry.laidOut && [listener respondsToSelector:@selector(screenReadinessDidLayOut:)]) {
+        [listener screenReadinessDidLayOut:screenId];
+    }
+    if (entry.rendered && [listener respondsToSelector:@selector(screenReadinessContentDidRender:)]) {
+        [listener screenReadinessContentDidRender:screenId];
+    }
+}
+
++ (void)removeListener:(id<ANNScreenReadinessListener>)listener forScreenId:(NSString *)screenId {
+    ANNAssertMainQueue();
+    if ([ANNReadinessListeners objectForKey:screenId] == listener) {
+        [ANNReadinessListeners removeObjectForKey:screenId];
+    }
+    NSHashTable<id<ANNScreenReadinessListener>> *shared = ANNSharedListeners[screenId];
+    if (shared) {
+        [shared removeObject:listener];
+        if (shared.allObjects.count == 0) {
+            [ANNSharedListeners removeObjectForKey:screenId];
+        }
+    }
+}
+
++ (BOOL)isListener:(id<ANNScreenReadinessListener>)listener forScreenId:(NSString *)screenId {
+    ANNAssertMainQueue();
+    return [ANNReadinessListeners objectForKey:screenId] == listener ||
+           [ANNSharedListeners[screenId] containsObject:listener];
+}
+
++ (NSUInteger)listenerCountForScreenId:(NSString *)screenId {
+    ANNAssertMainQueue();
+    return [self listenersOf:screenId].count;
+}
+
++ (void)removeScreenId:(NSString *)screenId {
+    ANNAssertMainQueue();
+    [ANNReadinessEntries removeObjectForKey:screenId];
+}
+
++ (void)reset {
+    ANNAssertMainQueue();
+    [ANNReadinessEntries removeAllObjects];
+    [ANNReadinessListeners removeAllObjects];
+    [ANNRendersAtOnce removeAllObjects];
+    [ANNSharedListeners removeAllObjects];
+}
+
+@end

package/ios/Layouts/Screen/ANNScreenRegions.h

@@ -0,0 +1,33 @@
+#import "ANNEventEmitter.h"
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// The reserved regions of each screen (`useReservedRegions`), iOS 27.1: `division`, where the screen divides (the fold
+/// of a partly folded device), and `occlusion`, where hardware covers it (a camera); each a list of
+/// `{ x, y, width, height }`. The native side keeps them on the main queue; JavaScript reads them from its own thread
+/// for a screen's first render, and gets every change as `ANN.ScreenRegionsChanged`.
+@interface ANNScreenRegions : NSObject
+
+/// The active regions UIKit reserves in `view`, without the margins it adds around them for interactive content, in
+/// the points of `coordinateView` and cut to its bounds (a region outside them is left out); nil before iOS 27.1.
+/// Main queue.
++ (nullable NSDictionary<NSString *, NSArray *> *)regionsOfView:(UIView *)view
+                                                inCoordinatesOf:(UIView *)coordinateView;
+
+/// Keeps the screen's regions and tells when they changed. Main queue.
++ (void)setRegions:(NSDictionary<NSString *, NSArray *> *)regions
+       forScreenId:(NSString *)screenId
+      eventEmitter:(ANNEventEmitter *)eventEmitter;
+
+/// `{ division, occlusion }`, or nil before the screen was laid out. Any thread.
++ (nullable NSDictionary<NSString *, NSArray *> *)regionsForScreenId:(NSString *)screenId;
+
++ (void)removeScreenId:(NSString *)screenId;
+
+/// Forgets every screen: after a reload the new JavaScript counts its ids anew. Main queue.
++ (void)removeAll;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/Layouts/Screen/ANNScreenRegions.mm

@@ -0,0 +1,105 @@
+#import "ANNScreenRegions.h"
+
+static NSMutableDictionary<NSString *, NSDictionary<NSString *, NSArray *> *> *ANNScreenRegionsById;
+
+#if __IPHONE_OS_VERSION_MAX_ALLOWED >= 270100
+// The part of a region inside the screen, CGRectNull for a region outside it (the fold beside a screen of a pair, the
+// camera above a screen under the bar). A fold is 0 wide or 0 high: it is inside where its line crosses the screen,
+// its edges included; a region with an area that only touches the screen's edge is not.
+static CGRect ANNRegionInside(CGRect region, CGRect bounds) {
+    CGFloat minX = MAX(CGRectGetMinX(region), CGRectGetMinX(bounds));
+    CGFloat maxX = MIN(CGRectGetMaxX(region), CGRectGetMaxX(bounds));
+    CGFloat minY = MAX(CGRectGetMinY(region), CGRectGetMinY(bounds));
+    CGFloat maxY = MIN(CGRectGetMaxY(region), CGRectGetMaxY(bounds));
+    if (maxX < minX || maxY < minY || (maxX == minX && region.size.width > 0) ||
+        (maxY == minY && region.size.height > 0)) {
+        return CGRectNull;
+    }
+    return CGRectMake(minX, minY, maxX - minX, maxY - minY);
+}
+
+// The region itself: UIKit's frame includes the margins it keeps around it for interactive content (20 pt on each side
+// of the fold of iPhone Duo, which is 0 wide without them). UIKit gives the active regions without the option to
+// include the others; a region that is not active (the fold of a flat device, a camera that does not run) is left out
+// all the same. Only the part inside `coordinateView` counts, as on Android.
+static NSArray<NSDictionary<NSString *, NSNumber *> *> *
+ANNRegionRects(NSArray<UIViewReservedRegion *> *regions, UIView *view, UIView *coordinateView)
+    API_AVAILABLE(ios(27.1)) {
+    NSMutableArray<NSDictionary<NSString *, NSNumber *> *> *rects = [NSMutableArray new];
+    for (UIViewReservedRegion *region in regions) {
+        if (!region.isActive) {
+            continue;
+        }
+        CGRect inView = [view convertRect:UIEdgeInsetsInsetRect(region.frame, region.margins)
+                                   toView:coordinateView];
+        CGRect frame = ANNRegionInside(inView, coordinateView.bounds);
+        if (CGRectIsNull(frame)) {
+            continue;
+        }
+        [rects addObject:@{
+            @"x" : @(frame.origin.x),
+            @"y" : @(frame.origin.y),
+            @"width" : @(frame.size.width),
+            @"height" : @(frame.size.height),
+        }];
+    }
+    return rects;
+}
+#endif
+
+@implementation ANNScreenRegions
+
++ (void)initialize {
+    if (self == ANNScreenRegions.class) {
+        ANNScreenRegionsById = [NSMutableDictionary new];
+    }
+}
+
++ (NSDictionary<NSString *, NSArray *> *)regionsOfView:(UIView *)view
+                                       inCoordinatesOf:(UIView *)coordinateView {
+#if __IPHONE_OS_VERSION_MAX_ALLOWED >= 270100
+    if (@available(iOS 27.1, *)) {
+        NSArray<UIViewReservedRegion *> *division =
+            [view reservedRegionsOfKind:[UIViewReservedRegionKind divisionRegionKind]];
+        NSArray<UIViewReservedRegion *> *occlusion =
+            [view reservedRegionsOfKind:[UIViewReservedRegionKind occlusionRegionKind]];
+        return @{
+            @"division" : ANNRegionRects(division, view, coordinateView),
+            @"occlusion" : ANNRegionRects(occlusion, view, coordinateView),
+        };
+    }
+#endif
+    return nil;
+}
+
++ (void)setRegions:(NSDictionary<NSString *, NSArray *> *)regions
+       forScreenId:(NSString *)screenId
+      eventEmitter:(ANNEventEmitter *)eventEmitter {
+    @synchronized(ANNScreenRegionsById) {
+        if ([ANNScreenRegionsById[screenId] isEqualToDictionary:regions]) {
+            return;
+        }
+        ANNScreenRegionsById[screenId] = regions;
+    }
+    [eventEmitter sendScreenRegionsChanged:screenId regions:regions];
+}
+
++ (NSDictionary<NSString *, NSArray *> *)regionsForScreenId:(NSString *)screenId {
+    @synchronized(ANNScreenRegionsById) {
+        return ANNScreenRegionsById[screenId];
+    }
+}
+
++ (void)removeScreenId:(NSString *)screenId {
+    @synchronized(ANNScreenRegionsById) {
+        [ANNScreenRegionsById removeObjectForKey:screenId];
+    }
+}
+
++ (void)removeAll {
+    @synchronized(ANNScreenRegionsById) {
+        [ANNScreenRegionsById removeAllObjects];
+    }
+}
+
+@end

package/ios/Layouts/Screen/ANNScreenSafeArea.h

@@ -0,0 +1,38 @@
+#import "ANNNavigationOptions.h"
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// What the screen's containers answer for its padding.
+typedef struct {
+    /// The screen is in a stack.
+    BOOL inStack;
+    /// The screen's stack shows its toolbar.
+    BOOL stackShowsToolbar;
+    /// The bottom of the window's safe area: the home indicator.
+    CGFloat windowBottomSafeArea;
+    /// The physical side of the iPhone Duo vertical bar (iOS 27.1): `UIRectEdgeLeft`, `UIRectEdgeRight`, or
+    /// `UIRectEdgeNone` without one.
+    UIRectEdge verticalBarSide;
+} ANNScreenPaddingContext;
+
+/// The frame of the React root inside the screen's view: the whole width; from the top of the view when the screen is
+/// under the top bar or no top bar shows, else from the top of the safe area; to the bottom of the view when it is
+/// under the tab bar or no tab bar shows, else to the bottom of the safe area.
+FOUNDATION_EXPORT CGRect ANNScreenRootFrame(CGRect bounds, UIEdgeInsets safeArea, BOOL fromTop,
+                                            BOOL toBottom);
+
+/// The insets of the root: the view's safe area over the root frame, each side at least 0.
+FOUNDATION_EXPORT UIEdgeInsets ANNScreenInsetsOverRoot(CGRect rootFrame, CGSize viewSize,
+                                                      UIEdgeInsets safeArea);
+
+/// The padding the screen's safe area view keeps (`layout.safeAreaEdges`): the insets on the padded edges, 0 on the
+/// others. With `layout.safeAreaEdges` exactly those edges (an explicit `'top'` keeps the top under a large title too);
+/// without it every edge but: the top under a shown top bar (in a stack, under the top bar, `topBar.visible` not
+/// `false`) or with a large title that can show; the bottom when the bottom inset covers more than the window's home
+/// indicator (by over 0.5 pt), or in a stack with a toolbar and `topBar.hideOnScroll`; the side of the vertical bar
+/// unless `layout.drawBehindVerticalBar` or `layout.verticalBars` is `false`.
+FOUNDATION_EXPORT UIEdgeInsets ANNScreenPadding(UIEdgeInsets insets, ANNNavigationOptions *options,
+                                                ANNScreenPaddingContext context);
+
+NS_ASSUME_NONNULL_END

package/ios/Layouts/Screen/ANNScreenSafeArea.mm

@@ -0,0 +1,58 @@
+#import "ANNScreenSafeArea.h"
+#import "ANNScreenBars.h"
+
+// A bar at the bottom covers more than the home indicator when the bottom inset passes it by more than this.
+static const CGFloat ANNBottomBarThreshold = 0.5;
+
+CGRect ANNScreenRootFrame(CGRect bounds, UIEdgeInsets safeArea, BOOL fromTop, BOOL toBottom) {
+    CGFloat top = fromTop ? 0 : safeArea.top;
+    CGFloat bottom = toBottom ? CGRectGetHeight(bounds) : CGRectGetHeight(bounds) - safeArea.bottom;
+    return CGRectMake(0, top, CGRectGetWidth(bounds), MAX(0, bottom - top));
+}
+
+UIEdgeInsets ANNScreenInsetsOverRoot(CGRect rootFrame, CGSize viewSize, UIEdgeInsets safeArea) {
+    return UIEdgeInsetsMake(
+        MAX(0, safeArea.top - CGRectGetMinY(rootFrame)),
+        MAX(0, safeArea.left - CGRectGetMinX(rootFrame)),
+        MAX(0, CGRectGetMaxY(rootFrame) - (viewSize.height - safeArea.bottom)),
+        MAX(0, CGRectGetMaxX(rootFrame) - (viewSize.width - safeArea.right)));
+}
+
+UIEdgeInsets ANNScreenPadding(UIEdgeInsets insets, ANNNavigationOptions *options,
+                              ANNScreenPaddingContext context) {
+    NSArray<NSString *> *edges = options.layout.safeAreaEdges;
+    if (edges) {
+        // Exactly the edges given; unknown names count for nothing (`layout.safeAreaEdges`).
+        return UIEdgeInsetsMake([edges containsObject:@"top"] ? insets.top : 0,
+                                [edges containsObject:@"left"] ? insets.left : 0,
+                                [edges containsObject:@"bottom"] ? insets.bottom : 0,
+                                [edges containsObject:@"right"] ? insets.right : 0);
+    }
+    UIEdgeInsets padding = insets;
+    ANNTopBarOptions *topBar = options.topBar;
+    BOOL topBarShown = [topBar.visible withDefault:YES];
+    // A bar hidden for a while (`hideOnScroll`, `hideOnTap`, `hideOnKeyboard`) still counts as shown: only
+    // `topBar.visible: false` gives the content its top back. A large title that can show takes the top too: the list
+    // goes under the bar that collapses it.
+    if (topBarShown && context.inStack &&
+        (ANNScreenIsUnderTopBar(options) || ANNLargeTitleCanShow(options))) {
+        padding.top = 0;
+    }
+    // A bar at the bottom over the home indicator (a tab bar, a toolbar, the bottom search field of iOS 26): the list
+    // goes under it. A tab bar at the top on iPad adds nothing to the bottom. A toolbar that hides on scroll counts as
+    // there.
+    if (insets.bottom > context.windowBottomSafeArea + ANNBottomBarThreshold ||
+        (context.inStack && context.stackShowsToolbar && [topBar.hideOnScroll withDefault:NO])) {
+        padding.bottom = 0;
+    }
+    BOOL behindVerticalBar = [options.layout.drawBehindVerticalBar withDefault:YES] &&
+                             [options.layout.verticalBars withDefault:YES];
+    if (behindVerticalBar) {
+        if (context.verticalBarSide == UIRectEdgeLeft) {
+            padding.left = 0;
+        } else if (context.verticalBarSide == UIRectEdgeRight) {
+            padding.right = 0;
+        }
+    }
+    return padding;
+}

package/ios/Layouts/SideMenu/ANNSideMenuChildViewController.h

@@ -0,0 +1,41 @@
+#import "ANNLayoutProtocol.h"
+#import "UIViewController+LayoutProtocol.h"
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// Which part of a side menu a child is: `SideMenuCenter`, `SideMenuLeft`, `SideMenuRight` in the layout.
+typedef NS_ENUM(NSInteger, ANNSideMenuChildType) {
+    ANNSideMenuChildTypeCenter,
+    ANNSideMenuChildTypeLeft,
+    ANNSideMenuChildTypeRight,
+};
+
+/// A part of a side menu: the wrapper of the center or of a menu, with the layout it holds. The sides are places, not
+/// layouts: nothing finds a side by its id, so the wrapper is never in the registry. Its child is its UIKit child from
+/// the start and fills its view; the side menu drives the wrapper's appearance, which UIKit forwards to the child. Its
+/// system UI and its merges follow its child: the home indicator, the deferred edges and the vertical bars are the
+/// child's, a merge inside goes to the side menu.
+@interface ANNSideMenuChildViewController : UIViewController <ANNLayoutProtocol>
+
+- (instancetype)initWithLayoutInfo:(ANNLayoutInfo *)layoutInfo
+                           creator:(id<ANNComponentViewCreator>)creator
+                           options:(ANNNavigationOptions *)options
+                    defaultOptions:(ANNNavigationOptions *)defaultOptions
+                         presenter:(ANNNodePresenter *)presenter
+                      eventEmitter:(ANNEventEmitter *)eventEmitter
+                             child:(UIViewController *)child
+                              type:(ANNSideMenuChildType)type;
+
+@property(nonatomic, readonly) ANNSideMenuChildType type;
+
+/// The layout of the part.
+@property(nonatomic, strong, readonly) UIViewController *child;
+
+/// The id of the part's view for e2e tests: `<sideMenu.testID>.center`, a menu's own `sideMenu.<side>.testID` or
+/// `<sideMenu.testID>.<side>`; nil: no id. Kept until the view loads.
+@property(nonatomic, copy, nullable) NSString *testID;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/Layouts/SideMenu/ANNSideMenuChildViewController.mm

@@ -0,0 +1,113 @@
+#import "ANNSideMenuChildViewController.h"
+#import "ANNShownScreens.h"
+
+@implementation ANNSideMenuChildViewController
+
+// The child is the wrapper's UIKit child from the start, so that it finds the side menu through the wrapper before
+// any view loads; its view comes in with the wrapper's.
+- (instancetype)initWithLayoutInfo:(ANNLayoutInfo *)layoutInfo
+                           creator:(id<ANNComponentViewCreator>)creator
+                           options:(ANNNavigationOptions *)options
+                    defaultOptions:(ANNNavigationOptions *)defaultOptions
+                         presenter:(ANNNodePresenter *)presenter
+                      eventEmitter:(ANNEventEmitter *)eventEmitter
+                             child:(UIViewController *)child
+                              type:(ANNSideMenuChildType)type {
+    self = [super initWithNibName:nil bundle:nil];
+    _child = child;
+    _type = type;
+    [self.nodeHelper setUpWithLayoutInfo:layoutInfo
+                                 creator:creator
+                                 options:options
+                          defaultOptions:defaultOptions
+                               presenter:presenter
+                            eventEmitter:eventEmitter];
+    [self addChildViewController:child];
+    return self;
+}
+
+- (void)viewDidLoad {
+    [super viewDidLoad];
+    UIView *view = _child.view;
+    view.frame = self.view.bounds;
+    view.autoresizingMask = UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight;
+    [self.view addSubview:view];
+    [_child didMoveToParentViewController:self];
+    self.view.accessibilityIdentifier = _testID;
+}
+
+- (void)setTestID:(NSString *)testID {
+    _testID = [testID copy];
+    self.viewIfLoaded.accessibilityIdentifier = _testID;
+}
+
+#pragma mark - Appearance
+
+// A menu shows or hides at the end of its motion, also with the side menu: a modal's hold follows the screen the
+// modal shows now, and the system UI follows the open menu or the center. Asking again changes nothing when nothing
+// changed. The side menu asks UIKit for its own controller itself; the owner adds the orientation it doesn't ask, and
+// the overlays.
+- (void)viewDidAppear:(BOOL)animated {
+    [super viewDidAppear:animated];
+    if (_type != ANNSideMenuChildTypeCenter) {
+        [ANNShownScreens changedIn:self];
+    }
+}
+
+- (void)viewDidDisappear:(BOOL)animated {
+    [super viewDidDisappear:animated];
+    if (_type != ANNSideMenuChildTypeCenter) {
+        [ANNShownScreens changedIn:self];
+    }
+}
+
+#pragma mark - ANNLayoutProtocol
+
+- (UIViewController *)getCurrentChild {
+    return _child;
+}
+
+- (NSArray<UIViewController *> *)layoutChildren {
+    return @[ _child ];
+}
+
+// The center through the common render of its side menu, a menu through the side menu's own.
+- (void)render {
+    [_child render];
+}
+
+// A merge inside the part: the side menu takes its part, then the merge goes on to the side menu's parent without
+// `sideMenu`, so that only the nearest side menu acts on it.
+- (void)mergeChildOptions:(ANNNavigationOptions *)options child:(UIViewController *)child {
+    UIViewController *sideMenu = self.layoutParent;
+    if (!sideMenu) {
+        return;
+    }
+    ANNNodePresenter *presenter = sideMenu.presenter;
+    [presenter mergeChildOptions:options];
+    [sideMenu.layoutParent mergeChildOptions:presenter ? [presenter optionsForParent:options] : options
+                                       child:sideMenu];
+}
+
+- (UIViewController *)systemUIChild {
+    return _child;
+}
+
+#pragma mark - UIViewController
+
+// The side menu answers the status bar itself from its resolved options; the rest is the screen's.
+- (UIViewController *)childViewControllerForHomeIndicatorAutoHidden {
+    return _child;
+}
+
+- (UIViewController *)childViewControllerForScreenEdgesDeferringSystemGestures {
+    return _child;
+}
+
+#if __IPHONE_OS_VERSION_MAX_ALLOWED >= 270100
+- (UIViewController *)childViewControllerForPreferredVerticalBarBehavior API_AVAILABLE(ios(27.1)) {
+    return _child;
+}
+#endif
+
+@end

package/ios/Layouts/SideMenu/ANNSideMenuPresenter.h

@@ -0,0 +1,28 @@
+#import "ANNNodePresenter.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// The presenter of a side menu: it turns `sideMenu.*` into the calls of the side menu module
+/// (`ANNSideMenuViewController`), with the module's background and the `testID`s of its parts.
+///
+/// When: at creation, and at every appearance of a screen inside (`descendantWillAppear:`), every field with its
+/// default (`enabled` true, `width` 280, `openMode` `aboveContent`, `shouldStretchDrawer` true, `animationVelocity`
+/// 840, `glass` false, `openGestureMode` `bezel`, no `animationType`); at a merge into the side menu or into a node
+/// inside it, the fields the merge names. The values always come from the side menu's resolution at that moment (its
+/// own options under the current part's chain, the center's `sideMenu` over an open menu, the defaults under), read
+/// without the cache, so that a merge off the visible chain changes nothing until its screen appears. `visible` with
+/// `animate` acts only from a merge, last, and from the layout at the first show: resolved options never open or close
+/// a menu.
+@interface ANNSideMenuPresenter : ANNNodePresenter
+
+/// The layout's `sideMenu.left.visible` / `sideMenu.right.visible`, read before the node's own options drop them: a
+/// menu with `true` opens without animation at the first appearance of a screen inside.
+- (void)setVisibilityAtFirstShow:(ANNSideMenuOptions *)sideMenu;
+
+/// A node inside the side menu merged `mergeOptions` (the override of `ANNNodePresenter`'s hook): the fields the merge
+/// names, then its `visible`.
+- (void)mergeChildOptions:(ANNNavigationOptions *)mergeOptions;
+
+@end
+
+NS_ASSUME_NONNULL_END