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

package/ios/Layouts/Arrangement/ANNArrangementState.mm

@@ -1,16 +1,8 @@
 #import "ANNArrangementState.h"
 #import "ANNArrangementViewController.h"
 
-static NSMutableDictionary<NSString *, NSDictionary<NSString *, id> *> *ANNArrangementStateById;
-
 @implementation ANNArrangementState
 
-+ (void)initialize {
-    if (self == ANNArrangementState.class) {
-        ANNArrangementStateById = [NSMutableDictionary new];
-    }
-}
-
 + (BOOL)canShowArrangements {
 #if __IPHONE_OS_VERSION_MAX_ALLOWED >= 270100
     if (@available(iOS 27.1, *)) {
@@ -20,34 +12,4 @@ static NSMutableDictionary<NSString *, NSDictionary<NSString *, id> *> *ANNArran
     return NO;
 }
 
-+ (void)setState:(NSDictionary<NSString *, id> *)state
-     forScreenId:(NSString *)screenId
-    eventEmitter:(ANNEventEmitter *)eventEmitter {
-    @synchronized(ANNArrangementStateById) {
-        if ([ANNArrangementStateById[screenId] isEqualToDictionary:state]) {
-            return;
-        }
-        ANNArrangementStateById[screenId] = state;
-    }
-    [eventEmitter sendArrangementChanged:screenId state:state];
-}
-
-+ (NSDictionary<NSString *, id> *)stateForScreenId:(NSString *)screenId {
-    @synchronized(ANNArrangementStateById) {
-        return ANNArrangementStateById[screenId];
-    }
-}
-
-+ (void)removeScreenId:(NSString *)screenId {
-    @synchronized(ANNArrangementStateById) {
-        [ANNArrangementStateById removeObjectForKey:screenId];
-    }
-}
-
-+ (void)removeAll {
-    @synchronized(ANNArrangementStateById) {
-        [ANNArrangementStateById removeAllObjects];
-    }
-}
-
 @end

package/ios/Layouts/Arrangement/ANNArrangementViewController.mm

@@ -2,9 +2,10 @@
 
 #if __IPHONE_OS_VERSION_MAX_ALLOWED >= 270100
 
-#import "ANNArrangementState.h"
 #import "ANNComponentViewController.h"
+#import "ANNEventContract.h"
 #import "ANNExternalViewController.h"
+#import "ANNScreenEnvironment.h"
 #import "ANNShownScreens.h"
 #import "ANNUtils.h"
 
@@ -47,6 +48,14 @@ static NSDirectionalRectEdge ANNOppositeEdge(NSDirectionalRectEdge edge) {
     }
 }
 
+// `primaryEdge` of a split: whether the primary goes second, at the trailing side or at the bottom. A split has no edge
+// of its own: UIKit puts the view of its primary placement first along either axis (measured on iPhone Duo), so the
+// edge decides which screen goes into that placement.
+static BOOL ANNSecondaryFirst(NSDictionary *data) {
+    return ![@"overlay" isEqual:data[@"style"]] &&
+           ([@"trailing" isEqual:data[@"primaryEdge"]] || [@"bottom" isEqual:data[@"primaryEdge"]]);
+}
+
 // Overlay view properties with the edge a view takes when the pair goes side by side.
 static UIOverlayArrangementViewProperties *ANNOverlayProperties(UIOverlayArrangement *overlay,
                                                                NSDirectionalRectEdge edge)
@@ -94,8 +103,11 @@ static UIArrangement *ANNArrangementOfData(NSDictionary *data) API_AVAILABLE(ios
             height.preferred = dimension;
             primary.height = height;
         }
-        [split setViewProperties:primary
-                    forPlacement:UIArrangementViewControllerViewPlacementPrimary];
+        // The share is the primary screen's, in whichever placement it is.
+        UIArrangementViewControllerViewPlacement placement =
+            ANNSecondaryFirst(data) ? UIArrangementViewControllerViewPlacementSecondary
+                                    : UIArrangementViewControllerViewPlacementPrimary;
+        [split setViewProperties:primary forPlacement:placement];
     }
     return split;
 }
@@ -108,6 +120,38 @@ static UIArrangement *ANNPrimaryAloneArrangement(void) API_AVAILABLE(ios(27.1))
     return split;
 }
 
+// A size range from `minimum` to `maximum`, preferring `preferred`.
+static UISplitArrangementDimensionRange *ANNDimensionRange(UISplitArrangementDimension *minimum,
+                                                           UISplitArrangementDimension *preferred,
+                                                           UISplitArrangementDimension *maximum)
+    API_AVAILABLE(ios(27.1)) {
+    UISplitArrangementDimensionRange *range = [UISplitArrangementDimensionRange new];
+    range.minimum = minimum;
+    range.preferred = preferred;
+    range.maximum = maximum;
+    return range;
+}
+
+// The primary alone in the secondary placement, with the primary placement empty. UIKit keeps the empty placement's
+// share of a split (measured on iPhone Duo folded: the primary in the lower half, the upper one blank), so the empty
+// placement gets no room and the primary all of it, along either axis, which no shape of the window leaves out.
+static UIArrangement *ANNSecondPlacementAloneArrangement(void) API_AVAILABLE(ios(27.1)) {
+    UISplitArrangement *split = [UISplitArrangement splitArrangement];
+    split.axes = UIAxisHorizontal | UIAxisVertical;
+    UISplitArrangementDimension *none = [UISplitArrangementDimension absoluteDimension:0];
+    UISplitArrangementDimension *all = [UISplitArrangementDimension fractionalDimension:1];
+    UISplitArrangementViewProperties *empty = [split.defaultViewProperties copy];
+    empty.width = ANNDimensionRange(none, none, none);
+    empty.height = ANNDimensionRange(none, none, none);
+    [split setViewProperties:empty forPlacement:UIArrangementViewControllerViewPlacementPrimary];
+    UISplitArrangementViewProperties *primary = [split.defaultViewProperties copy];
+    primary.width = ANNDimensionRange(all, all, all);
+    primary.height = ANNDimensionRange(all, all, all);
+    [split setViewProperties:primary
+                forPlacement:UIArrangementViewControllerViewPlacementSecondary];
+    return split;
+}
+
 // Room for a pair: both size classes regular (iPad, iPhone Duo unfolded). Nil without a size class yet: the view
 // controller is not in a window.
 static NSNumber *ANNIsLargeWindow(UITraitCollection *traits) {
@@ -130,11 +174,12 @@ static BOOL ANNKeepsState(UIViewController *screen) {
 
 static NSDictionary<NSString *, id> *ANNStateOf(NSString *placement, NSString *layout, BOOL front,
                                                 BOOL hidden) {
+    const auto &keys = ANNEventContract.ArrangementChanged;
     return @{
-        @"placement" : placement,
-        @"layout" : layout,
-        @"front" : @(front),
-        @"hidden" : @(hidden),
+        keys.placement : placement,
+        keys.layout : layout,
+        keys.front : @(front),
+        keys.hidden : @(hidden),
     };
 }
 
@@ -181,9 +226,20 @@ static BOOL ANNIsShown(UIViewController *screen, UIArrangementViewState *state,
     // (`compact: 'primary'`).
     UIArrangement *_arrangement;
     BOOL _primaryAloneWhenSmall;
+    // `primaryEdge` of a split at the trailing side or the bottom: the secondary is in UIKit's primary placement, the
+    // primary in its secondary one. The primary alone keeps its placement and the secondary leaves its own, so the
+    // primary never changes its container at a fold. The axes the pair may use, for the primary alone then.
+    BOOL _secondaryFirst;
+    UIAxis _axes;
+    // The size a running size transition leads to, zero without one: the shape the pair decides its axes by.
+    CGSize _transitionSize;
     // What UIKit has now, once an arrangement went to it.
     BOOL _arranged;
     BOOL _primaryAlone;
+    // The scene's size classes the pair takes for a size transition, and which transition set them last: only that
+    // one's end takes them away.
+    BOOL _sceneSizeClasses;
+    NSUInteger _sceneSizeClassesTransition;
 }
 
 - (instancetype)initWithLayoutInfo:(ANNLayoutInfo *)layoutInfo
@@ -216,14 +272,16 @@ static BOOL ANNIsShown(UIViewController *screen, UIArrangementViewState *state,
             ((ANNComponentViewController *)screen).arrangement = self;
         }
     }
-    [self setViewController:primary
+    _secondaryFirst = ANNSecondaryFirst(data);
+    _axes = ANNArrangementAxes(data[@"axes"]);
+    [self setViewController:_secondaryFirst ? secondary : primary
                forPlacement:UIArrangementViewControllerViewPlacementPrimary];
-    [self setViewController:secondary
+    [self setViewController:_secondaryFirst ? primary : secondary
                forPlacement:UIArrangementViewControllerViewPlacementSecondary];
     _arrangement = ANNArrangementOfData(data);
     _primaryAloneWhenSmall = ![@"pair" isEqual:data[@"compact"]];
     // Before it is in a window: the window's size classes, which it will most likely have.
-    [self arrangeForTraits:ANNUtils.mainWindow.traitCollection animated:NO];
+    [self arrangeForTraits:ANNUtils.mainWindow.traitCollection];
     if (!_arranged) {
         [self updateArrangement:_arrangement animated:NO];
     }
@@ -237,19 +295,33 @@ static BOOL ANNIsShown(UIViewController *screen, UIArrangementViewState *state,
 // `compact: 'primary'`: the pair shows only in a large window; in any other (an iPhone, iPhone Duo folded) the primary
 // shows alone, and the secondary waits out of the window until the window is large (iPhone Duo unfolded). With
 // `compact: 'pair'` UIKit lays the pair out everywhere.
-- (void)arrangeForTraits:(UITraitCollection *)traits animated:(BOOL)animated {
+- (void)arrangeForTraits:(UITraitCollection *)traits {
     NSNumber *large = ANNIsLargeWindow(traits);
     if (!large) {
         return;
     }
-    BOOL alone = _primaryAloneWhenSmall && !large.boolValue;
+    BOOL alone = (_primaryAloneWhenSmall && !large.boolValue) ||
+                 (_secondaryFirst && ![self axesAllowSize:[self pairSize]]);
     if (_arranged && alone == _primaryAlone) {
         return;
     }
     BOOL changed = _arranged;
     _arranged = YES;
     _primaryAlone = alone;
-    [self updateArrangement:alone ? ANNPrimaryAloneArrangement() : _arrangement animated:animated];
+    if (_secondaryFirst) {
+        // The secondary leaves the window with its placement, as a split with no axis takes it out otherwise.
+        UIViewController *first = alone ? nil : _secondary;
+        if ([self viewControllerForPlacement:UIArrangementViewControllerViewPlacementPrimary] !=
+            first) {
+            [self setViewController:first
+                       forPlacement:UIArrangementViewControllerViewPlacementPrimary
+                           animated:NO];
+        }
+        [self updateArrangement:alone ? ANNSecondPlacementAloneArrangement() : _arrangement
+                       animated:NO];
+    } else {
+        [self updateArrangement:alone ? ANNPrimaryAloneArrangement() : _arrangement animated:NO];
+    }
     // A secondary that leaves the window renders no content: the pair waits for it no more.
     if (alone && _secondaryCounted) {
         _secondaryCounted = NO;
@@ -262,8 +334,103 @@ static BOOL ANNIsShown(UIViewController *screen, UIArrangementViewState *state,
     }
 }
 
+// Where the axes leave the pair no room, UIKit shows its primary placement alone: with the secondary first that would
+// be the secondary, so the pair takes it out itself, by the shape UIKit goes by (side by side in a wide window, one
+// above the other in a tall one, measured on iPhone Duo).
+- (BOOL)axesAllowSize:(CGSize)size {
+    if ((_axes & UIAxisHorizontal) && (_axes & UIAxisVertical)) {
+        return YES;
+    }
+    BOOL wide = size.width > size.height;
+    return (_axes & (wide ? UIAxisHorizontal : UIAxisVertical)) != 0;
+}
+
+// The pair's size: where a size transition leads, its own once laid out, the window's before.
+- (CGSize)pairSize {
+    if (!CGSizeEqualToSize(_transitionSize, CGSizeZero)) {
+        return _transitionSize;
+    }
+    CGSize size = self.viewIfLoaded.bounds.size;
+    return size.width > 0 && size.height > 0 ? size : ANNUtils.mainWindow.bounds.size;
+}
+
+// New size classes come with a new window size, which leads the pair to its new place. UIKit's own animation of the
+// arrangement would aim at a layout it gives only in between (on iPhone Duo, one above the other while the window
+// still has its old size classes) and play on after the pair took its real one: the screens lagged by half a second.
 - (void)sizeClassesDidChange {
-    [self arrangeForTraits:self.traitCollection animated:self.viewIfLoaded.window != nil];
+    [self arrangeForTraits:self.traitCollection];
+}
+
+// On iPhone Duo the scene has its new size classes as the size transition starts, and the pair gets them only after
+// UIKit laid it out in the new size: the primary first filled the whole open window, then gave half of it to the
+// secondary. For the transition the pair takes the scene's size classes, so it lies as it will from its first layout.
+// Only where the pair has the window's size classes: a sheet or a split view's column has its own.
+- (void)viewWillTransitionToSize:(CGSize)size
+       withTransitionCoordinator:(id<UIViewControllerTransitionCoordinator>)coordinator {
+    [super viewWillTransitionToSize:size withTransitionCoordinator:coordinator];
+    // A new shape may leave the axes no room, or give it back: the pair takes it before its first layout in the size.
+    if (_secondaryFirst) {
+        _transitionSize = size;
+        [self arrangeForTraits:self.traitCollection];
+        __weak ANNArrangementViewController *weakPair = self;
+        void (^sized)(id<UIViewControllerTransitionCoordinatorContext>) =
+            ^(id<UIViewControllerTransitionCoordinatorContext> context) {
+              ANNArrangementViewController *pair = weakPair;
+              if (pair && CGSizeEqualToSize(pair->_transitionSize, size)) {
+                  pair->_transitionSize = CGSizeZero;
+              }
+            };
+        [coordinator animateAlongsideTransition:nil completion:sized];
+    }
+    UITraitCollection *scene = self.viewIfLoaded.window.windowScene.traitCollection;
+    NSNumber *large = ANNIsLargeWindow(self.traitCollection);
+    NSNumber *largeScene = scene ? ANNIsLargeWindow(scene) : nil;
+    if (!large || !largeScene || ![self hasWindowSizeClasses]) {
+        return;
+    }
+    // The size classes the pair has now are the scene's of an earlier transition, still running: this one keeps them
+    // until its own end.
+    if ([large isEqual:largeScene] && !_sceneSizeClasses) {
+        return;
+    }
+    _sceneSizeClasses = YES;
+    NSUInteger transition = ++_sceneSizeClassesTransition;
+    self.traitOverrides.horizontalSizeClass = scene.horizontalSizeClass;
+    self.traitOverrides.verticalSizeClass = scene.verticalSizeClass;
+    [self updateTraitsIfNeeded];
+    __weak ANNArrangementViewController *weakSelf = self;
+    void (^ended)(id<UIViewControllerTransitionCoordinatorContext>) =
+        ^(id<UIViewControllerTransitionCoordinatorContext> context) {
+          [weakSelf dropSceneSizeClassesOfTransition:transition];
+        };
+    [coordinator animateAlongsideTransition:nil completion:ended];
+}
+
+- (void)dropSceneSizeClassesOfTransition:(NSUInteger)transition {
+    if (!_sceneSizeClasses || transition != _sceneSizeClassesTransition) {
+        return;
+    }
+    _sceneSizeClasses = NO;
+    [self.traitOverrides removeTrait:UITraitHorizontalSizeClass.class];
+    [self.traitOverrides removeTrait:UITraitVerticalSizeClass.class];
+}
+
+// The pair's size classes are the window's: it stands in the window's root, not in a presented layer, and no split
+// view's column is between them.
+- (BOOL)hasWindowSizeClasses {
+    UIWindow *window = self.viewIfLoaded.window;
+    if (!window) {
+        return NO;
+    }
+    UIViewController *top = self;
+    for (UIViewController *parent = self.parentViewController; parent;
+         parent = parent.parentViewController) {
+        if ([parent isKindOfClass:UISplitViewController.class]) {
+            return NO;
+        }
+        top = parent;
+    }
+    return top == window.rootViewController;
 }
 
 // The first state, before the pair is laid out: as UIKit lays it out in the window's shape (measured on iPhone Duo),
@@ -296,9 +463,9 @@ static BOOL ANNIsShown(UIViewController *screen, UIArrangementViewState *state,
          ofScreen:(UIViewController *)screen
      eventEmitter:(ANNEventEmitter *)eventEmitter {
     if (ANNKeepsState(screen)) {
-        [ANNArrangementState setState:state
-                          forScreenId:screen.layoutInfo.componentId
-                         eventEmitter:eventEmitter];
+        [ANNScreenEnvironment setArrangement:state
+                                 forScreenId:screen.layoutInfo.componentId
+                                eventEmitter:eventEmitter];
     }
 }
 
@@ -431,13 +598,17 @@ static BOOL ANNIsShown(UIViewController *screen, UIArrangementViewState *state,
 
 - (void)viewDidLayoutSubviews {
     [super viewDidLayoutSubviews];
+    // A size of its own without a transition (a column of a split view): the axes may allow another shape now.
+    if (_secondaryFirst) {
+        [self arrangeForTraits:self.traitCollection];
+    }
     [self setNeedsStateUpdate];
 }
 
 // In the window now: its own size classes, which the window's stood in for.
 - (void)viewWillAppear:(BOOL)animated {
     [super viewWillAppear:animated];
-    [self arrangeForTraits:self.traitCollection animated:NO];
+    [self arrangeForTraits:self.traitCollection];
 }
 
 - (void)viewDidAppear:(BOOL)animated {
@@ -477,10 +648,12 @@ static BOOL ANNIsShown(UIViewController *screen, UIArrangementViewState *state,
     if (!self.viewIfLoaded.window || _screensDestroyed) {
         return;
     }
+    // By the screens' placements: with `primaryEdge` at the trailing side or the bottom they are the other way round,
+    // and a secondary out of its placement has none.
     UIArrangementViewState *primaryState =
-        [self stateForPlacement:UIArrangementViewControllerViewPlacementPrimary];
+        [self stateForPlacement:[self placementForViewController:_primary]];
     UIArrangementViewState *secondaryState =
-        [self stateForPlacement:UIArrangementViewControllerViewPlacementSecondary];
+        [self stateForPlacement:[self placementForViewController:_secondary]];
     CGRect primaryFrame = ANNShownFrame(_primary.viewIfLoaded, self.view);
     CGRect secondaryFrame = ANNShownFrame(_secondary.viewIfLoaded, self.view);
     BOOL primaryShown = ANNIsShown(_primary, primaryState, primaryFrame);
@@ -496,7 +669,8 @@ static BOOL ANNIsShown(UIViewController *screen, UIArrangementViewState *state,
         CGRect overlap = CGRectIntersection(primaryFrame, secondaryFrame);
         if (!CGRectIsNull(overlap) && overlap.size.width > 1 && overlap.size.height > 1) {
             layout = @"overlay";
-            // UIKit puts the primary over the secondary (zIndex 1 and 0).
+            // UIKit puts the primary over the secondary (zIndex 1 and 0); an overlay keeps the screens in their own
+            // placements.
             primaryFront = primaryState.zIndex >= secondaryState.zIndex;
             secondaryFront = !primaryFront;
         } else {

package/ios/Layouts/Modal/ANNModalCoordinator.h

@@ -25,7 +25,7 @@ NS_ASSUME_NONNULL_BEGIN
 
 /// `dismissModal`: the record of `componentId` (its root's id or any id inside, also of a modal closed below or by the
 /// user), the options merged into its visible screen, the animation from the command's screen, then its state decides.
-/// Answers with the root's id.
+/// Answers with the root's id. The last modal over no root rejects `[ANNErrorTexts modalWithoutRoot:]`, as on Android.
 + (void)dismissModal:(NSString *)componentId
              options:(nullable NSDictionary *)options
               answer:(ANNCommandAnswer *)answer;

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];
     };
@@ -277,8 +277,8 @@ static void ANNCollectIds(UIViewController *node, NSMutableSet<NSString *> *ids)
 
 // The end steps of a record (its show presented, its dismissal ended, closed by the user) run inside UIKit's
 // completions and delegate calls, outside the runner's protection, in any state: a failure there is logged in one line,
-// rejects what of the record still waits for an answer (its show, a chain step, its dismissals), and its drive stops.
-// The gate's `done` ran before the step, as without a failure.
+// answers what of the record still waits for an answer (its show, a chain step, its dismissals:
+// `endFailedOf:showing:exception:`), and its drive stops. The gate's `done` ran before the step, as without a failure.
 + (void)protectEndOf:(ANNModal *)modal showing:(BOOL)showing step:(dispatch_block_t)step {
     @try {
         step();
@@ -288,24 +288,43 @@ static void ANNCollectIds(UIViewController *node, NSMutableSet<NSString *> *ids)
                                : (showing ? @"show a modal" : @"dismiss a modal");
         NSString *reason = exception.reason.length > 0 ? exception.reason : exception.name;
         RCTLogWarn(@"[ApexNavigation] %@", [ANNErrorTexts couldNot:what reason:reason]);
-        [self endFailedOf:modal exception:exception];
+        [self endFailedOf:modal showing:showing exception:exception];
     }
 }
 
-+ (void)endFailedOf:(ANNModal *)modal exception:(NSException *)exception {
+// A failed end step of `modal`: its show rejects. After a failed show the dismissals that wait for it don't fail with
+// it, as on Android: on a modal that shows they run now and resolve once it went (one still `Presenting` shows: UIKit's
+// completion ran); on one that goes another way (a `dismissAllModals`, with the old root) or went already they resolve
+// with its root's id; on one in another transition (a drag, its own dismissal) they wait for that transition's end.
+// A failed dismissal rejects itself and the dismissals behind it.
++ (void)endFailedOf:(ANNModal *)modal showing:(BOOL)showing exception:(NSException *)exception {
     if (!modal) {
         return;
     }
     [self stopDriving:modal];
     NSString *show = [NSString stringWithFormat:@"show the screen '%@'", modal.rootId];
-    NSString *dismiss = [NSString stringWithFormat:@"dismiss the modal '%@'", modal.rootId];
     [modal.showAnswer reject:[ANNCommandRunner rejectionOf:exception what:show]];
-    NSString *dismissText = [ANNCommandRunner rejectionOf:exception what:dismiss];
-    [modal.dismissal.answer reject:dismissText];
-    NSArray<ANNModalDismissal *> *pending = modal.pending.copy;
-    [modal.pending removeAllObjects];
-    for (ANNModalDismissal *waiting in pending) {
-        [waiting.answer reject:dismissText];
+    ANNModalState state = modal.state;
+    BOOL goesAnotherWay = (state == ANNModalStateDismissing && modal.batch) ||
+                          state == ANNModalStateWithOldRoot ||
+                          state == ANNModalStateClosedBelow || state == ANNModalStateGone;
+    if (showing && state == ANNModalStatePresenting) {
+        modal.state = ANNModalStateShown;
+    }
+    if (showing && modal.state == ANNModalStateShown) {
+        [self runPendingOf:modal];
+    } else if (showing && goesAnotherWay) {
+        [modal.dismissal.answer resolve:modal.rootId];
+        [self resolvePendingOf:modal];
+    } else if (!showing) {
+        NSString *dismiss = [NSString stringWithFormat:@"dismiss the modal '%@'", modal.rootId];
+        NSString *dismissText = [ANNCommandRunner rejectionOf:exception what:dismiss];
+        [modal.dismissal.answer reject:dismissText];
+        NSArray<ANNModalDismissal *> *pending = modal.pending.copy;
+        [modal.pending removeAllObjects];
+        for (ANNModalDismissal *waiting in pending) {
+            [waiting.answer reject:dismissText];
+        }
     }
     // A `setRoot` chain goes on (its own steps are guarded by the root coordinator).
     void (^chainStep)(BOOL) = modal.chainStep;
@@ -333,7 +352,7 @@ static void ANNCollectIds(UIViewController *node, NSMutableSet<NSString *> *ids)
             [waiter reject:text];
         }
         for (ANNModal *modal in batch.records.copy) {
-            [self endFailedOf:modal exception:exception];
+            [self endFailedOf:modal showing:NO exception:exception];
         }
     }
 }
@@ -407,7 +426,7 @@ static void ANNCollectIds(UIViewController *node, NSMutableSet<NSString *> *ids)
         ANNNavigationOptions *resolved = [root resolveOptionsWithDefault];
         ANNModalPresentation *presentation =
             [[ANNModalPresentation alloc] initWithOptions:resolved animated:modal.animatedOverride];
-        NSString *problem = [presentation problemPresentingFrom:presenting windowRoot:windowRoot];
+        NSString *problem = [presentation fitToPresenting:presenting windowRoot:windowRoot];
         if (problem) {
             [self failShowOf:modal reason:problem];
             done();
@@ -537,7 +556,8 @@ static void ANNCollectIds(UIViewController *node, NSMutableSet<NSString *> *ids)
     modal.coversUnder = under != nil && under.viewIfLoaded.window == nil;
     NSArray<UIViewController *> *hidden = modal.coversUnder ? @[ under ] : @[];
     @try {
-        // The chain step stays on the record until its events went: a failure there tells the chain (`endFailedOf:`).
+        // The chain step stays on the record until its events went: a failure there tells the chain
+        // (`endFailedOf:showing:exception:`).
         void (^chainStep)(BOOL) = modal.chainStep;
         if (chainStep) {
             [ANNAppearanceDispatcher endSwitchHiding:hidden showing:@[ root ] events:nil];
@@ -778,6 +798,11 @@ static void ANNCollectIds(UIViewController *node, NSMutableSet<NSString *> *ids)
         [answer reject:[ANNErrorTexts screenNotShown:componentId]];
         return;
     }
+    // The last modal over no root (shown before any `setRoot`) stays: nothing would be left to show, as on Android.
+    if ([self isLastWithoutRoot:modal]) {
+        [answer reject:[ANNErrorTexts modalWithoutRoot:componentId]];
+        return;
+    }
     // Step 1: the options, read on the main queue; one that can't be read rejects before anything changes. They merge
     // into the modal's visible screen as `mergeOptions` would.
     if (options.count > 0) {
@@ -815,6 +840,22 @@ static void ANNCollectIds(UIViewController *node, NSMutableSet<NSString *> *ids)
     [self dismiss:modal with:dismissal];
 }
 
+// No root in the window (the splash, or nothing yet) and no other modal that shows or comes: `modal` is all a dismissal
+// would take away. One closed below, going with the old root or gone takes nothing away, so it doesn't count.
++ (BOOL)isLastWithoutRoot:(ANNModal *)modal {
+    if (modal.state == ANNModalStateClosedBelow || modal.state == ANNModalStateGone ||
+        ApexNavigation.mainWindow.rootViewController.isLayoutNode) {
+        return NO;
+    }
+    for (ANNModal *other in ANNModals) {
+        if (other != modal && other.state != ANNModalStateClosedBelow &&
+            other.state != ANNModalStateWithOldRoot && other.state != ANNModalStateGone) {
+            return NO;
+        }
+    }
+    return YES;
+}
+
 // The modal of `node`: the record whose root is the top of `node`'s layout.
 + (ANNModal *)modalOf:(UIViewController *)node {
     UIViewController *top = node;
@@ -897,7 +938,7 @@ static void ANNCollectIds(UIViewController *node, NSMutableSet<NSString *> *ids)
                    [ANNErrorTexts couldNot:what reason:exception.reason ?: exception.name]);
         // The dismissal still open answers, and so do the dismissals waiting behind it (an answer given already
         // stays as it was).
-        [self endFailedOf:modal exception:exception];
+        [self endFailedOf:modal showing:NO exception:exception];
         done();
     }
 }

package/ios/Layouts/Modal/ANNModalPresentation.h

@@ -20,7 +20,8 @@ NS_ASSUME_NONNULL_BEGIN
 
 /// `modalPresentationStyle`: one to one; unset is UIKit's automatic style; an unknown string full screen.
 @property(nonatomic, readonly) UIModalPresentationStyle style;
-/// `modalTransitionStyle`: `coverVertical` unless one of the others is given.
+/// `modalTransitionStyle`: `coverVertical` unless one of the others is given; `partialCurl` only where UIKit curls
+/// (`fitToPresenting:windowRoot:`).
 @property(nonatomic, readonly) UIModalTransitionStyle transitionStyle;
 /// The present is animated: `enter.enabled` is not `false`.
 @property(nonatomic, readonly) BOOL animated;
@@ -47,10 +48,12 @@ NS_ASSUME_NONNULL_BEGIN
                                     animation:(nullable ANNModalAnimationOptions *)animation
                                         under:(nullable UIViewController *)under;
 
-/// Why UIKit can't make this show from `presenting` (`partialCurl` only full screen, to and from), as the reason of the
-/// rejection; nil when it can. `windowRoot` is the main window's root.
-- (nullable NSString *)problemPresentingFrom:(UIViewController *)presenting
-                                  windowRoot:(nullable UIViewController *)windowRoot;
+/// Fits the show to `presenting`, before `prepare:…`: `partialCurl` stays only for a full-screen modal over a
+/// controller that fills the screen (`presenting` is `windowRoot`, the main window's root, or a full-screen modal);
+/// otherwise `transitionStyle` becomes `coverVertical`. Returns why UIKit can't make the show (`presenting` was shown
+/// with `partialCurl`), as the reason of the rejection; nil when it can.
+- (nullable NSString *)fitToPresenting:(UIViewController *)presenting
+                            windowRoot:(nullable UIViewController *)windowRoot;
 
 /// Before `presentViewController:`: the style and the transition, the presentation's delegate, the popover kept a
 /// popover (`adaptive: false`), the sheet, the size, the popover's source on `presentingLayout`, the hold, the

package/ios/Layouts/Modal/ANNModalPresentation.mm

@@ -118,21 +118,21 @@ static NSDictionary<NSString *, NSNumber *> *ANNTransitionStyles(void) {
     return nil;
 }
 
-// UIKit takes `partialCurl` only for a full-screen modal over a controller that fills the screen, and a controller
-// shown with `partialCurl` presents nothing more: the command rejects before it asks UIKit.
-- (NSString *)problemPresentingFrom:(UIViewController *)presenting
-                         windowRoot:(UIViewController *)windowRoot {
+// UIKit curls only a full-screen modal over a controller that fills the screen: elsewhere `partialCurl` is
+// `coverVertical`, so the modal still shows. A controller shown with `partialCurl` presents nothing more: the command
+// rejects before it asks UIKit.
+- (NSString *)fitToPresenting:(UIViewController *)presenting
+                   windowRoot:(UIViewController *)windowRoot {
     if (presenting.presentingViewController &&
         presenting.modalTransitionStyle == UIModalTransitionStylePartialCurl) {
-        return @"partialCurl needs a full screen modal";
+        return @"a modal shown with partialCurl can't show another modal";
     }
-    if (_transitionStyle != UIModalTransitionStylePartialCurl) {
-        return nil;
-    }
-    BOOL presentingFills = presenting == windowRoot ||
-                           presenting.modalPresentationStyle == UIModalPresentationFullScreen;
-    if (_style != UIModalPresentationFullScreen || !presentingFills) {
-        return @"partialCurl needs a full screen modal";
+    if (_transitionStyle == UIModalTransitionStylePartialCurl) {
+        BOOL presentingFills = presenting == windowRoot ||
+                               presenting.modalPresentationStyle == UIModalPresentationFullScreen;
+        if (_style != UIModalPresentationFullScreen || !presentingFills) {
+            _transitionStyle = UIModalTransitionStyleCoverVertical;
+        }
     }
     return nil;
 }