@apexnative/navigation 1.0.0-alpha.8 → 1.0.0-alpha.9

package/ios/Core/ANNRenderWait.mm

@@ -47,10 +47,10 @@ static NSUInteger ANNRenderWaitCount;
     // The content nodes still waited, and every node the wait set its ready handler on.
     NSHashTable<UIViewController *> *_waited;
     NSHashTable<UIViewController *> *_listened;
-    // The waited screens of the "root mounted" kind (a subset of `_waited`), and whether their limit passed in this
-    // start (a retake waits for them no more then).
-    NSHashTable<UIViewController *> *_mountWaited;
-    BOOL _mountLimitPassed;
+    // The waited screens of the "unseen" kind (a subset of `_waited`), and whether their limit passed in this start (a
+    // retake waits for them no more then).
+    NSHashTable<UIViewController *> *_unseenWaited;
+    BOOL _unseenLimitPassed;
     ANNBarComponentsWait *_barWait;
     // What the last take of the running phase took: its screens (weakly) and, in the content phase, what the take read
     // of each to decide what it waits for (`takeStateOfScreens:`). A retake that would take the same does nothing.
@@ -75,7 +75,7 @@ static NSUInteger ANNRenderWaitCount;
             stringWithFormat:@"ApexNavigation.renderWait.%lu", (unsigned long)++ANNRenderWaitCount];
         _waited = [NSHashTable weakObjectsHashTable];
         _listened = [NSHashTable weakObjectsHashTable];
-        _mountWaited = [NSHashTable weakObjectsHashTable];
+        _unseenWaited = [NSHashTable weakObjectsHashTable];
     }
     return self;
 }
@@ -89,7 +89,7 @@ static NSUInteger ANNRenderWaitCount;
     }
     _isWaiting = YES;
     _isInBarPhase = NO;
-    _mountLimitPassed = NO;
+    _unseenLimitPassed = NO;
     _startTime = CACurrentMediaTime();
     NSUInteger number = ++_number;
     _starting = YES;
@@ -108,10 +108,10 @@ static NSUInteger ANNRenderWaitCount;
                          [weakSelf limitOfNumber:number];
                        });
     }
-    if (_mountLimit > 0) {
-        int64_t delay = (int64_t)(_mountLimit * NSEC_PER_SEC);
+    if (_unseenLimit > 0) {
+        int64_t delay = (int64_t)(_unseenLimit * NSEC_PER_SEC);
         dispatch_after(dispatch_time(DISPATCH_TIME_NOW, delay), dispatch_get_main_queue(), ^{
-          [weakSelf mountLimitOfNumber:number];
+          [weakSelf unseenLimitOfNumber:number];
         });
     }
     if (_unknownContentRule) {
@@ -162,8 +162,8 @@ static NSUInteger ANNRenderWaitCount;
         case ANNRenderWaitContentNone:
             break;
         case ANNRenderWaitContentEachScreen:
-            // Each screen by the readiness it needs: its content, or the first mount of its root (an unselected
-            // tab's screen). A screen with no content to wait for (a native screen) is ready.
+            // Each screen by its content; an unselected tab's to the unseen limit. A screen with no content to wait
+            // for (a native screen) is ready.
             for (UIViewController *node in screens) {
                 if (![node isKindOfClass:ANNComponentViewController.class]) {
                     continue;
@@ -177,25 +177,11 @@ static NSUInteger ANNRenderWaitCount;
                     [self listenTo:screen number:number];
                     continue;
                 }
-                if (_mountLimitPassed) {
+                if (_unseenLimitPassed) {
                     continue;
                 }
-                [_mountWaited addObject:screen];
-                // A slot screen's readiness is its mount: its ready handler serves.
-                if (![content respondsToSelector:@selector(whenMounted:)]) {
-                    [self listenTo:screen number:number];
-                    continue;
-                }
-                if (content.hasMounted) {
-                    [_mountWaited removeObject:screen];
-                    continue;
-                }
-                [_waited addObject:screen];
-                __weak ANNRenderWait *weakSelf = self;
-                __weak UIViewController *weakScreen = screen;
-                [content whenMounted:^{
-                  [weakSelf node:weakScreen readyOfNumber:number];
-                }];
+                [_unseenWaited addObject:screen];
+                [self listenTo:screen number:number];
             }
             break;
         case ANNRenderWaitContentNode:
@@ -271,19 +257,19 @@ static NSUInteger ANNRenderWaitCount;
     [self phaseOfNumber:number endedMarkingReady:NO];
 }
 
-// The screens of the "root mounted" kind are waited no longer: nobody sees them, nothing of theirs is held.
-- (void)mountLimitOfNumber:(NSUInteger)number {
+// The screens of the "unseen" kind are waited no longer: nobody sees them, nothing of theirs is held.
+- (void)unseenLimitOfNumber:(NSUInteger)number {
     if (![self runs:number]) {
         return;
     }
-    _mountLimitPassed = YES;
-    if (_mountWaited.count == 0) {
+    _unseenLimitPassed = YES;
+    if (_unseenWaited.count == 0) {
         return;
     }
-    for (UIViewController *node in _mountWaited.allObjects) {
+    for (UIViewController *node in _unseenWaited.allObjects) {
         [_waited removeObject:node];
     }
-    [_mountWaited removeAllObjects];
+    [_unseenWaited removeAllObjects];
     if (_waited.count == 0 && !_barWait) {
         [self phaseOfNumber:number endedMarkingReady:NO];
     }
@@ -464,7 +450,7 @@ static NSUInteger ANNRenderWaitCount;
     }
     [_listened removeAllObjects];
     [_waited removeAllObjects];
-    [_mountWaited removeAllObjects];
+    [_unseenWaited removeAllObjects];
 }
 
 #pragma mark - Helpers
@@ -476,15 +462,14 @@ static NSUInteger ANNRenderWaitCount;
 }
 
 // What the content phase's take reads of each screen to decide what it waits for: the readiness it needs, whether it
-// has its content yet, whether that content is ready, and whether its root mounted.
+// has its content yet, and whether that content is ready.
 - (NSArray<NSNumber *> *)takeStateOfScreens:(NSArray<UIViewController *> *)screens {
     NSMutableArray<NSNumber *> *states = [NSMutableArray arrayWithCapacity:screens.count];
     for (UIViewController *node in screens) {
-        NSUInteger state = (NSUInteger)ANNWaitedReadinessOf(node) << 3;
+        NSUInteger state = (NSUInteger)ANNWaitedReadinessOf(node) << 2;
         if ([node isKindOfClass:ANNComponentViewController.class]) {
             UIView<ANNComponentProtocol> *content = ((ANNComponentViewController *)node).reactView;
-            BOOL mounted = [content respondsToSelector:@selector(hasMounted)] && content.hasMounted;
-            state |= (content ? 1 : 0) | (content.isReady ? 2 : 0) | (mounted ? 4 : 0);
+            state |= (content ? 1 : 0) | (content.isReady ? 2 : 0);
         }
         [states addObject:@(state)];
     }

package/ios/Core/ApexNavigation.mm

@@ -9,7 +9,6 @@
 #import "ANNReloadCoordinator.h"
 #import "ANNSlotHost.h"
 #import "ANNSplashViewController.h"
-#import "ANNTabsPreloadWindow.h"
 #import "ANNUtils.h"
 #import <React/RCTLog.h>
 #import <ReactCommon/RCTHost.h>
@@ -149,9 +148,7 @@ static UIWindowScene *ANNConnectedWindowScene(void) {
     ANNMainWindow.windowScene = windowScene;
     ANNMainWindow.frame = windowScene.coordinateSpace.bounds;
     [ANNMainWindow makeKeyAndVisible];
-    // The tabs' preload windows, the overlay windows and the slot host's window made before the scene go where the
-    // main window is.
-    [ANNTabsPreloadWindow mainWindowSceneDidConnect:windowScene];
+    // The overlay windows and the slot host's window made before the scene go where the main window is.
     [ANNOverlayCoordinator mainWindowSceneDidConnect:windowScene];
     [ANNSlotHost mainWindowSceneDidConnect:windowScene];
     // A direction the app set before the window had a scene takes the scene now.

package/ios/Layouts/Modal/ANNModalCoordinator.mm

@@ -233,7 +233,7 @@ static void ANNCollectIds(UIViewController *node, NSMutableSet<NSString *> *ids)
                   limit:contentFirst ? 0 : ANNModalRenderLimit
                     bar:contentFirst ? ANNRenderWaitBarAfterContent : ANNRenderWaitBarWithContent
               barLimits:contentFirst ? ownPhase : withContent];
-    wait.mountLimit = ANNModalRenderLimit;
+    wait.unseenLimit = ANNModalRenderLimit;
     wait.protect = ^(dispatch_block_t step) {
       [ANNModalCoordinator protect:weakModal step:step];
     };

package/ios/Layouts/Overlay/ANNOverlayCoordinator.mm

@@ -179,7 +179,7 @@ static NSMutableArray<ANNOverlay *> *ANNOverlays;
                   limit:ANNOverlayRenderLimit
                     bar:ANNRenderWaitBarWithContent
               barLimits:withContent];
-    wait.mountLimit = ANNOverlayRenderLimit;
+    wait.unseenLimit = ANNOverlayRenderLimit;
     wait.protect = ^(dispatch_block_t step) {
       [ANNOverlayCoordinator protectWaitOf:weakOverlay step:step];
     };

package/ios/Layouts/Root/ANNRootCoordinator.mm

@@ -300,7 +300,7 @@ static __weak ANNRootShow *ANNAnimatingShow;
               barLimits:contentFirst ? ownPhase : withContent];
     // A screen the user won't see at once (an unselected tab's) never holds the root longer than the limit, also with
     // `waitForRender: true`.
-    wait.mountLimit = ANNRootRenderLimit;
+    wait.unseenLimit = ANNRootRenderLimit;
     wait.protect = ^(dispatch_block_t step) {
       [ANNRootCoordinator protect:weakShow step:step];
     };

package/ios/Layouts/Screen/ANNComponentViewController.h

@@ -44,27 +44,21 @@ NS_ASSUME_NONNULL_BEGIN
 - (void)render;
 
 /// Where the screen will show while it waits for its content out of it (parked by a stack's or `showInColumn`'s wait,
-/// `ANNParking`): it lays out with that place's safe area and bars (`ANNScreenPlace`), as it will once it shows there.
-/// Asked at each layout, and kept past the parking until UIKit gives the screen a safe area of its own in a parent
-/// (the push lays it out once before that, with none), or as it appears. Nil: its view's own. Set by the one that
-/// parks the screen.
+/// or in a tab rendered before it shows, `ANNParking`): it lays out with that place's safe area and bars
+/// (`ANNScreenPlace`), as it will once it shows there. Asked at each layout, and kept past the parking until UIKit
+/// gives the screen a safe area of its own in a parent (the push lays it out once before that, with none), or as it
+/// appears. Nil: its view's own. Set by the one that parks the screen.
 @property(nonatomic, copy, nullable) ANNScreenPlace *_Nullable (^placeWhileParked)(void);
 
+/// The place is kept until the screen appears, not only until UIKit gives it a safe area: a tab's screen rendered
+/// before the tab shows gets a part of it first (the bar without the status bar) as UIKit lays the tab out. Set with
+/// `placeWhileParked`, and goes with it.
+@property(nonatomic) BOOL placeKeptUntilAppearance;
+
 /// Applies the "under bars" rule to the root frame again, then gives the modules the insets, the padding and the
 /// regions of the screen. Nothing before the view loaded; the safe area only in a window.
 - (void)updateRootLayout;
 
-/// The content view (only the core's React view, never the screen's own view) mounts unseen in `host` (the tabs'
-/// preload window) at the frame it has, while the screen's tab isn't shown. NO when there is nothing to lend: no React
-/// view of its own, in a window already, lent already, or the screen went.
-- (BOOL)lendContentTo:(UIView *)host;
-
-/// The lent content comes back into the screen's view at its root frame; also as the screen first appears.
-- (void)takeContentBack;
-
-/// The content is lent (`lendContentTo:`): `updateRootLayout` leaves its frame alone meanwhile.
-@property(nonatomic, readonly) BOOL contentIsLent;
-
 /// The transition that removes the screen starts (before its destroy): with `blurOnUnmount` in its resolved options,
 /// the editing inside its view ends and the keyboard goes (`blurOnUnmount`).
 - (void)screenWillLeave;

package/ios/Layouts/Screen/ANNComponentViewController.mm

@@ -19,10 +19,7 @@
 #import "ANNTopBarPresenter.h"
 #import "ANNUtils.h"
 
-@implementation ANNComponentViewController {
-    // Where the content is lent while it mounts unseen (the tabs' preload window).
-    __weak UIView *_contentLentTo;
-}
+@implementation ANNComponentViewController
 
 - (instancetype)initWithLayoutInfo:(ANNLayoutInfo *)layoutInfo
                            creator:(id<ANNComponentViewCreator>)creator
@@ -146,8 +143,6 @@
 // command's order: the command reports instead.
 - (void)viewWillAppear:(BOOL)animated {
     [super viewWillAppear:animated];
-    // A tab shows for the first time while its content still mounts in the preload window.
-    [self takeContentBack];
     // A preview screen that UIKit's menu takes leaves its unseen place first, so that the menu reports it.
     [ANNPreviewPush screenWillAppear:self];
     if (![ANNAppearanceDispatcher isAppearanceDriven:self]) {
@@ -166,6 +161,7 @@
     // A parked screen whose place gave it no safe area at all lays out with its view's own from now on.
     if (self.placeWhileParked && ![ANNParking isUnseen:self]) {
         self.placeWhileParked = nil;
+        self.placeKeptUntilAppearance = NO;
         [self updateRootLayout];
     }
     // Once JavaScript heard the appearance (a driven one ends later, with its command).
@@ -377,7 +373,8 @@
     if (!place) {
         return nil;
     }
-    if (![ANNParking isUnseen:self] && self.parentViewController &&
+    if (!self.placeKeptUntilAppearance && ![ANNParking isUnseen:self] &&
+        self.parentViewController &&
         !UIEdgeInsetsEqualToEdgeInsets(self.view.safeAreaInsets, UIEdgeInsetsZero)) {
         self.placeWhileParked = nil;
         return nil;
@@ -402,7 +399,7 @@
     }
     ANNNavigationOptions *options = [self resolveOptionsWithDefault];
     UIView<ANNComponentProtocol> *content = _reactView;
-    if (content && !self.contentIsLent) {
+    if (content) {
         CGRect frame = [self rootFrameForOptions:options];
         if (!CGRectEqualToRect(content.frame, frame)) {
             content.frame = frame;
@@ -553,37 +550,6 @@
     });
 }
 
-#pragma mark - The preload window
-
-- (BOOL)contentIsLent {
-    return _contentLentTo != nil;
-}
-
-- (BOOL)lendContentTo:(UIView *)host {
-    UIView<ANNComponentProtocol> *content = _reactView;
-    if (!content || _contentLentTo || content.window || self.nodeHelper.destroyed ||
-        ![content isKindOfClass:ANNReactView.class]) {
-        return NO;
-    }
-    _contentLentTo = host;
-    [host addSubview:content];
-    return YES;
-}
-
-- (void)takeContentBack {
-    if (!_contentLentTo) {
-        return;
-    }
-    _contentLentTo = nil;
-    UIView<ANNComponentProtocol> *content = _reactView;
-    if (!content || self.nodeHelper.destroyed) {
-        [content removeFromSuperview];
-        return;
-    }
-    [self.view insertSubview:content atIndex:0];
-    [self updateRootLayout];
-}
-
 #pragma mark - Leaving
 
 - (void)screenWillLeave {
@@ -674,9 +640,7 @@
     [topBar releaseLists];
     [topBar stopComponents];
     [self destroyReactView];
-    // The stop holds the hosting view until the surface stopped: the screen lets go of its content view now, wherever
-    // it is (a preload window too).
-    _contentLentTo = nil;
+    // The stop holds the hosting view until the surface stopped: the screen lets go of its content view now.
     [_reactView removeFromSuperview];
     // The data is kept by id: a node that holds the id now (a new JavaScript reused it while this screen waited for
     // its destroy, as at a reload) keeps it.

package/ios/Layouts/Screen/ANNScreenPlace.h

@@ -27,6 +27,18 @@ NS_ASSUME_NONNULL_BEGIN
                                   inStack:(UINavigationController *)stack
                                   options:(ANNNavigationOptions *)options;
 
+/// The same, measured in `host` instead of the stack's view: for a stack UIKit gives no safe area yet (a tab not shown,
+/// parked in the tabs' view), `host` is a view with the safe area the stack gets as it shows (the shown tab's). Nil
+/// when `host` isn't in a window.
++ (nullable ANNScreenPlace *)placeOfEntry:(UIViewController *)entry
+                                  inStack:(UINavigationController *)stack
+                               measuredIn:(UIView *)host
+                                  options:(ANNNavigationOptions *)options;
+
+/// The place of a screen that is a tab of its own, with no stack: the safe area of `host` (the shown tab's view), no
+/// top bar. Nil when `host` isn't in a window.
++ (nullable ANNScreenPlace *)placeOfScreen:(UIViewController *)screen measuredIn:(UIView *)host;
+
 /// The safe area of the entry's view in the place.
 @property(nonatomic, readonly) UIEdgeInsets safeArea;
 

package/ios/Layouts/Screen/ANNScreenPlace.mm

@@ -49,17 +49,16 @@ static void ANNCopyBarItem(UINavigationItem *from, UINavigationItem *to) {
 }
 
 // Everything the measure reads: the same answer while none of it changed.
-static NSString *ANNPlaceSignature(UINavigationItem *item, UINavigationController *stack, BOOL showsTopBar,
-                                   BOOL showsToolbar) {
-    UIView *stackView = stack.view;
+static NSString *ANNPlaceSignature(UINavigationItem *item, UINavigationController *stack,
+                                   UIView *host, BOOL showsTopBar, BOOL showsToolbar) {
     NSMutableString *signature = [NSMutableString
         stringWithFormat:@"%@|%@|%ld|%p|%p|%p|%p|%p|%d|%d|%d|%d|%@|%@", item.title, item.prompt,
                          (long)item.largeTitleDisplayMode, item.standardAppearance,
                          item.scrollEdgeAppearance, item.compactAppearance,
                          item.compactScrollEdgeAppearance, item.searchController,
                          item.hidesSearchBarWhenScrolling, stack.navigationBar.prefersLargeTitles,
-                         showsTopBar, showsToolbar, NSStringFromCGSize(stackView.bounds.size),
-                         NSStringFromUIEdgeInsets(stackView.safeAreaInsets)];
+                         showsTopBar, showsToolbar, NSStringFromCGSize(host.bounds.size),
+                         NSStringFromUIEdgeInsets(host.safeAreaInsets)];
     [signature appendFormat:@"|%p|%ld", stack,
                             (long)stack.topViewController.navigationItem.largeTitleDisplayMode];
     if (@available(iOS 16.0, *)) {
@@ -91,9 +90,19 @@ static NSString *ANNPlaceSignature(UINavigationItem *item, UINavigationControlle
 + (ANNScreenPlace *)placeOfEntry:(UIViewController *)entry
                          inStack:(UINavigationController *)stack
                          options:(ANNNavigationOptions *)options {
-    ANNAssertMainQueue();
     UIView *stackView = stack.viewIfLoaded;
-    UIWindow *window = stackView.window;
+    if (!stackView) {
+        return nil;
+    }
+    return [self placeOfEntry:entry inStack:stack measuredIn:stackView options:options];
+}
+
++ (ANNScreenPlace *)placeOfEntry:(UIViewController *)entry
+                         inStack:(UINavigationController *)stack
+                      measuredIn:(UIView *)host
+                         options:(ANNNavigationOptions *)options {
+    ANNAssertMainQueue();
+    UIWindow *window = host.window;
     if (!window) {
         return nil;
     }
@@ -102,19 +111,20 @@ static NSString *ANNPlaceSignature(UINavigationItem *item, UINavigationControlle
     BOOL showsTabBar = !entry.hidesBottomBarWhenPushed &&
                        [[ANNBottomTabsController tabsOf:entry] showsTabBarForScreen:entry];
     NSString *signature =
-        ANNPlaceSignature(entry.navigationItem, stack, showsTopBar, showsToolbar);
+        ANNPlaceSignature(entry.navigationItem, stack, host, showsTopBar, showsToolbar);
     ANNScreenPlace *kept = objc_getAssociatedObject(entry, ANNScreenPlaceKey);
     if (kept && kept.showsTabBar == showsTabBar && [kept->_signature isEqualToString:signature]) {
         return kept;
     }
     UIEdgeInsets safeArea = [self measureEntry:entry
                                        inStack:stack
+                                          host:host
                                    showsTopBar:showsTopBar
                                   showsToolbar:showsToolbar];
-    // The measure stands in the stack's view, whose safe area has the tab bar shown now: an entry that hides it gets
-    // the window's bottom there.
+    // The measure stands in the host, whose safe area has the tab bar shown now: an entry that hides it gets the
+    // window's bottom there.
     if (!showsTabBar) {
-        CGFloat tabBar = stackView.safeAreaInsets.bottom - window.safeAreaInsets.bottom;
+        CGFloat tabBar = host.safeAreaInsets.bottom - window.safeAreaInsets.bottom;
         if (tabBar > 0) {
             safeArea.bottom = MAX(safeArea.bottom - tabBar, 0);
         }
@@ -127,10 +137,31 @@ static NSString *ANNPlaceSignature(UINavigationItem *item, UINavigationControlle
     return place;
 }
 
-// The probe lays out at the stack's size in the stack's view, unseen and for this moment only, and leaves no search
-// field behind.
++ (ANNScreenPlace *)placeOfScreen:(UIViewController *)screen measuredIn:(UIView *)host {
+    ANNAssertMainQueue();
+    UIWindow *window = host.window;
+    if (!window) {
+        return nil;
+    }
+    BOOL showsTabBar = [[ANNBottomTabsController tabsOf:screen] showsTabBarForScreen:screen];
+    UIEdgeInsets safeArea = host.safeAreaInsets;
+    if (!showsTabBar) {
+        CGFloat tabBar = safeArea.bottom - window.safeAreaInsets.bottom;
+        if (tabBar > 0) {
+            safeArea.bottom = MAX(safeArea.bottom - tabBar, 0);
+        }
+    }
+    return [[ANNScreenPlace alloc] initWithSafeArea:safeArea
+                                        showsTopBar:NO
+                                        showsTabBar:showsTabBar
+                                          signature:@""];
+}
+
+// The probe lays out at the host's size in the host, unseen and for this moment only, and leaves no search field
+// behind.
 + (UIEdgeInsets)measureEntry:(UIViewController *)entry
                      inStack:(UINavigationController *)stack
+                        host:(UIView *)host
                  showsTopBar:(BOOL)showsTopBar
                 showsToolbar:(BOOL)showsToolbar {
     UINavigationController *probe = ANNPlaceProbeOf(stack);
@@ -152,7 +183,6 @@ static NSString *ANNPlaceSignature(UINavigationItem *item, UINavigationControlle
                                                           action:nil] ]
                      : nil;
     __block UIEdgeInsets safeArea = UIEdgeInsetsZero;
-    UIView *stackView = stack.view;
     UIView *probeView = probe.view;
     [UIView performWithoutAnimation:^{
       [probe setNavigationBarHidden:!showsTopBar animated:NO];
@@ -160,8 +190,8 @@ static NSString *ANNPlaceSignature(UINavigationItem *item, UINavigationControlle
       probeView.alpha = 0;
       probeView.userInteractionEnabled = NO;
       probeView.accessibilityElementsHidden = YES;
-      probeView.frame = stackView.bounds;
-      [stackView insertSubview:probeView atIndex:0];
+      probeView.frame = host.bounds;
+      [host insertSubview:probeView atIndex:0];
       [probeView layoutIfNeeded];
       [top.view layoutIfNeeded];
       safeArea = top.view.safeAreaInsets;

package/ios/Layouts/SideMenu/ANNSideMenuTypes.h

@@ -12,6 +12,14 @@ typedef NS_ENUM(NSInteger, ANNSideMenuOpenMode) {
     ANNSideMenuOpenModeAboveContent,
 };
 
+/** `sideMenu.menusAttachMode`: when the screens of the menus are made, with the side menu, after its first
+ * appearance, or each as it first starts to open. */
+typedef NS_ENUM(NSInteger, ANNSideMenuAttachMode) {
+    ANNSideMenuAttachModeTogether,
+    ANNSideMenuAttachModeAfterCenter,
+    ANNSideMenuAttachModeOnOpen,
+};
+
 /** `sideMenu.openGestureMode`: a pan from anywhere on the center, or from its edges only. */
 typedef NS_ENUM(NSInteger, ANNSideMenuOpenGestureMode) {
     ANNSideMenuOpenGestureModeEntireScreen,

package/ios/Layouts/SideMenu/ANNSideMenuViewController.mm

@@ -12,6 +12,24 @@ static const CGFloat ANNSideMenuDimAlpha = 0.5;
 static const CGFloat ANNSideMenuMaxStretch = 1.1;
 static const NSTimeInterval ANNSideMenuMinimumDuration = 0.1;
 
+// `sideMenu.menusAttachMode` of the side menu's own options, else of the defaults; any other value, and none, is
+// `together`.
+static ANNSideMenuAttachMode ANNSideMenuAttachModeOf(ANNNavigationOptions *options,
+                                                     ANNNavigationOptions *defaultOptions) {
+    Text *value = options.sideMenu.menusAttachMode;
+    if (!value.hasValue) {
+        value = defaultOptions.sideMenu.menusAttachMode;
+    }
+    NSString *mode = [value withDefault:nil];
+    if ([mode isEqualToString:@"afterCenter"]) {
+        return ANNSideMenuAttachModeAfterCenter;
+    }
+    if ([mode isEqualToString:@"onOpen"]) {
+        return ANNSideMenuAttachModeOnOpen;
+    }
+    return ANNSideMenuAttachModeTogether;
+}
+
 static UINavigationController *ANNStackOfResponder(UIResponder *responder) {
     for (; responder; responder = responder.nextResponder) {
         if ([responder isKindOfClass:UINavigationController.class]) {
@@ -65,6 +83,8 @@ typedef NS_ENUM(NSInteger, ANNSideMenuAppearance) {
 @property(nonatomic) BOOL glass;
 @property(nonatomic) ANNSideMenuAppearance appearance;
 @property(nonatomic, copy) NSString *scrimTestID;
+// The menu's part is in its container and renders (`menusAttachMode`).
+@property(nonatomic) BOOL attached;
 @end
 
 @implementation ANNSideMenuSideState
@@ -95,6 +115,8 @@ typedef NS_ENUM(NSInteger, ANNSideMenuAppearance) {
     ANNSideMenuSideState *_leftState;
     ANNSideMenuSideState *_rightState;
     ANNSideMenuOpenGestureMode _openGestureMode;
+    ANNSideMenuAttachMode _attachMode;
+    BOOL _firstAppeared;
     NSString *_animationType;
     UIView *_centerContainer;
     UIView *_leftContainer;
@@ -132,6 +154,7 @@ typedef NS_ENUM(NSInteger, ANNSideMenuAppearance) {
     _leftState = [ANNSideMenuSideState new];
     _rightState = [ANNSideMenuSideState new];
     _openGestureMode = ANNSideMenuOpenGestureModeBezel;
+    _attachMode = ANNSideMenuAttachModeOf(options, defaultOptions);
     [self setSideMenuChildren:childViewControllers];
 
     self.presenter = presenter;
@@ -181,10 +204,15 @@ typedef NS_ENUM(NSInteger, ANNSideMenuAppearance) {
 
 - (void)viewDidLoad {
     [super viewDidLoad];
-    _leftContainer = [self containerForChild:self.left];
-    _rightContainer = [self containerForChild:self.right];
-    _centerContainer = [self containerForChild:self.center];
+    _leftContainer = [self makeContainer];
+    _rightContainer = [self makeContainer];
+    _centerContainer = [self makeContainer];
+    [self putChild:self.center into:_centerContainer];
     _centerContainer.hidden = NO;
+    if (_attachMode == ANNSideMenuAttachModeTogether) {
+        [self attachMenu:ANNSideMenuSideLeft];
+        [self attachMenu:ANNSideMenuSideRight];
+    }
     [self applyGlassOf:ANNSideMenuSideLeft];
     [self applyGlassOf:ANNSideMenuSideRight];
 
@@ -200,32 +228,65 @@ typedef NS_ENUM(NSInteger, ANNSideMenuAppearance) {
     [self.view addGestureRecognizer:_pan];
 }
 
-// A child in a view of its own, which the menu moves; a menu's container is hidden while closed.
-- (UIView *)containerForChild:(UIViewController *)child {
+// The view of a part, which the menu moves; a menu's container is hidden while closed.
+- (UIView *)makeContainer {
     UIView *container = [[UIView alloc] initWithFrame:self.view.bounds];
     container.hidden = YES;
     [self.view addSubview:container];
-    if (child) {
-        [self addChildViewController:child];
-        child.view.frame = container.bounds;
-        child.view.autoresizingMask =
-            UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight;
-        [container addSubview:child.view];
-        [child didMoveToParentViewController:self];
-    }
     return container;
 }
 
+// A part in its container, over the container's glass. Loading the part's view loads its node's, which renders.
+- (void)putChild:(UIViewController *)child into:(UIView *)container {
+    if (!child) {
+        return;
+    }
+    [self addChildViewController:child];
+    child.view.frame = container.bounds;
+    child.view.autoresizingMask = UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight;
+    [container addSubview:child.view];
+    [child didMoveToParentViewController:self];
+}
+
+// The menu's part goes into its container and renders, once: with the side menu's view (`together`), after its first
+// appearance (`afterCenter`), or as the menu first starts to open (`onOpen`, and any mode for a menu that opens
+// earlier). A menu not attached yet keeps its node and options; only its view and content wait.
+- (void)attachMenu:(ANNSideMenuSide)side {
+    ANNSideMenuChildViewController *menu = [self menuOf:side];
+    if (!menu || [self stateOf:side].attached || self.nodeHelper.destroyed) {
+        return;
+    }
+    [self loadViewIfNeeded];
+    ANNSideMenuSideState *state = [self stateOf:side];
+    if (state.attached) {
+        return;
+    }
+    state.attached = YES;
+    [self putChild:menu into:[self containerOf:side]];
+    [menu render];
+}
+
+// The current part renders, and every other part that is attached or will be with the side menu's view.
 - (void)render {
     [self.nodeHelper render];
     UIViewController *currentChild = self.getCurrentChild;
     for (UIViewController *vc in _sideMenuChildren) {
-        if (vc != currentChild) {
+        if (vc != currentChild && [self rendersPart:vc]) {
             [vc render];
         }
     }
 }
 
+- (BOOL)rendersPart:(UIViewController *)part {
+    if (part == self.left) {
+        return _attachMode == ANNSideMenuAttachModeTogether || _leftState.attached;
+    }
+    if (part == self.right) {
+        return _attachMode == ANNSideMenuAttachModeTogether || _rightState.attached;
+    }
+    return YES;
+}
+
 #pragma mark - Options
 
 - (ANNSideMenuSideState *)stateOf:(ANNSideMenuSide)side {
@@ -380,6 +441,7 @@ typedef NS_ENUM(NSInteger, ANNSideMenuAppearance) {
 
 // The menu on screen in its place under or over the center, its screens about to appear.
 - (void)show:(ANNSideMenuSide)side {
+    [self attachMenu:side];
     _side = side;
     [self orderSide:side];
     [self containerOf:side].hidden = NO;
@@ -586,6 +648,13 @@ typedef NS_ENUM(NSInteger, ANNSideMenuAppearance) {
     if (_side != ANNSideMenuSideNone) {
         [self side:_side transitionEnded:YES];
     }
+    if (!_firstAppeared) {
+        _firstAppeared = YES;
+        if (_attachMode == ANNSideMenuAttachModeAfterCenter) {
+            [self attachMenu:ANNSideMenuSideLeft];
+            [self attachMenu:ANNSideMenuSideRight];
+        }
+    }
 }
 
 - (void)viewWillDisappear:(BOOL)animated {