@apexnative/navigation 1.0.0-alpha.6 → 1.0.0-alpha.7

package/ios/Layouts/Stack/ANNSwipePopInteraction.mm

@@ -0,0 +1,185 @@
+#import "ANNSwipePopInteraction.h"
+#import "ANNAssert.h"
+#import "ANNTransitionAnimator.h"
+
+// A flick faster than this, in points a second, ends the swipe by its direction alone.
+static const CGFloat ANNSwipeFlickSpeed = 500;
+
+// The rest of the pop plays at most this many times as fast as its own animation.
+static const CGFloat ANNSwipeMostSpeedUp = 3;
+
+@implementation ANNSwipePopInteraction {
+    ANNTransitionAnimator *_strongAnimator;
+    __weak UIPanGestureRecognizer *_recognizer;
+    __weak UIView *_view;
+    id<UIViewControllerContextTransitioning> _context;
+    // The interaction keeps itself while it follows the gesture: UIKit may let it go before the finger does.
+    ANNSwipePopInteraction *_keep;
+    // The gesture ended before UIKit started the transition: the end is chosen at the start.
+    BOOL _endedEarly;
+    BOOL _gaveUpEarly;
+    CGFloat _completionSpeed;
+}
+
+- (instancetype)initWithAnimator:(ANNTransitionAnimator *)animator
+                      recognizer:(UIPanGestureRecognizer *)recognizer
+                            view:(UIView *)view {
+    if (self = [super init]) {
+        _animator = animator;
+        _strongAnimator = animator;
+        _recognizer = recognizer;
+        _view = view;
+        _completionSpeed = 1;
+        _keep = self;
+        [recognizer addTarget:self action:@selector(swipe:)];
+    }
+    return self;
+}
+
+#pragma mark - UIViewControllerInteractiveTransitioning
+
+- (void)startInteractiveTransition:(id<UIViewControllerContextTransitioning>)transitionContext {
+    ANNAssertMainQueue();
+    ANNTransitionAnimator *animator = _strongAnimator;
+    if (!animator || _context) {
+        return;
+    }
+    _context = transitionContext;
+    [animator animateFollowingGesture:transitionContext];
+    UIGestureRecognizerState state = _recognizer.state;
+    BOOL moving = state == UIGestureRecognizerStateBegan || state == UIGestureRecognizerStateChanged;
+    if (_gaveUpEarly) {
+        [self endFinishing:NO speed:1];
+        return;
+    }
+    if (_endedEarly || !moving) {
+        [self letGo];
+        return;
+    }
+    [self follow];
+}
+
+- (CGFloat)completionSpeed {
+    return _completionSpeed;
+}
+
+// The frames play at an even pace to their end, so UIKit's part (the bar) does too.
+- (UIViewAnimationCurve)completionCurve {
+    return UIViewAnimationCurveLinear;
+}
+
+- (BOOL)wantsInteractiveStart {
+    return YES;
+}
+
+#pragma mark - The gesture
+
+- (void)swipe:(UIPanGestureRecognizer *)recognizer {
+    switch (recognizer.state) {
+        case UIGestureRecognizerStateBegan:
+        case UIGestureRecognizerStateChanged:
+            [self follow];
+            break;
+        case UIGestureRecognizerStateEnded:
+            [self letGo];
+            break;
+        case UIGestureRecognizerStateCancelled:
+        case UIGestureRecognizerStateFailed:
+            [self giveUp];
+            break;
+        default:
+            break;
+    }
+}
+
+- (void)follow {
+    if (!_context) {
+        return;
+    }
+    if (_strongAnimator.isCompleted) {
+        [self stop];
+        return;
+    }
+    CGFloat progress = [self progress];
+    [_strongAnimator setProgress:progress];
+    [_context updateInteractiveTransition:progress];
+}
+
+// The finger left: a flick decides by its direction, a slow release by how far the swipe went.
+- (void)letGo {
+    if (!_context) {
+        [self endedEarlyGivingUp:NO];
+        return;
+    }
+    CGFloat velocity = [self alongBack:[_recognizer velocityInView:_view].x];
+    BOOL finish = velocity > ANNSwipeFlickSpeed ||
+                  (velocity >= -ANNSwipeFlickSpeed && [self progress] > 0.5);
+    // The rest takes the finger's pace when that is quicker than the animation's: the animation would cover the width
+    // in its length, the finger in width / velocity.
+    CGFloat width = MAX(_view.bounds.size.width, 1);
+    BOOL withFinger = finish ? velocity > 0 : velocity < 0;
+    CGFloat speed = withFinger ? fabs(velocity) * _strongAnimator.length / width : 1;
+    [self endFinishing:finish speed:MIN(MAX(speed, 1.0), ANNSwipeMostSpeedUp)];
+}
+
+// The system took the touch (a call, a second gesture): the screen goes back.
+- (void)giveUp {
+    if (!_context) {
+        [self endedEarlyGivingUp:YES];
+        return;
+    }
+    [self endFinishing:NO speed:1];
+}
+
+// UIKit holds an interaction it starts; one it never starts goes once the gesture ended.
+- (void)endedEarlyGivingUp:(BOOL)gaveUp {
+    _endedEarly = YES;
+    _gaveUpEarly = gaveUp;
+    [_recognizer removeTarget:self action:@selector(swipe:)];
+    _keep = nil;
+}
+
+- (void)endFinishing:(BOOL)finish speed:(CGFloat)speed {
+    id<UIViewControllerContextTransitioning> context = _context;
+    ANNTransitionAnimator *animator = _strongAnimator;
+    [self stop];
+    if (!context || !animator || animator.isCompleted) {
+        return;
+    }
+    // UIKit reads the speed as it ends its own part of the transition.
+    _completionSpeed = speed;
+    if (finish) {
+        [context finishInteractiveTransition];
+        [animator finishWithSpeed:speed];
+    } else {
+        [context cancelInteractiveTransition];
+        [animator rewindWithSpeed:speed];
+    }
+}
+
+// The part of the width the finger went in the direction of the swipe back.
+- (CGFloat)progress {
+    UIView *view = _view;
+    CGFloat width = view.bounds.size.width;
+    if (width <= 0) {
+        return 0;
+    }
+    CGFloat along = [self alongBack:[_recognizer translationInView:view].x];
+    return MIN(MAX(along / width, 0.0), 1.0);
+}
+
+// A move across the view, positive in the direction of the swipe back: rightward, leftward in a right-to-left layout.
+- (CGFloat)alongBack:(CGFloat)x {
+    BOOL rightToLeft =
+        _view.effectiveUserInterfaceLayoutDirection == UIUserInterfaceLayoutDirectionRightToLeft;
+    return rightToLeft ? -x : x;
+}
+
+- (void)stop {
+    [_recognizer removeTarget:self action:@selector(swipe:)];
+    _context = nil;
+    _strongAnimator = nil;
+    _keep = nil;
+}
+
+@end

package/ios/Layouts/Stack/InteractivePopGestureDelegate.mm

@@ -86,10 +86,11 @@ static BOOL ANNIsOwnQuestionOfUIKit(SEL selector) {
 
 #pragma mark - UIGestureRecognizerDelegate
 
-// The order: `popGesture` first (with `false` there is neither a swipe nor the hold's event), then one screen or a
-// stack not at rest, then the hold (its event instead of the swipe), then the edge swipe under a hidden bar begins
-// without UIKit's delegate, and otherwise UIKit's delegate decides (its direction, a vertical scroll of the content). A
-// top that isn't the stack's own (a column UIKit's split view moved in) is UIKit's.
+// The order: which of the stack's swipes plays first (`swipeBackTakes:`: the stack's own while the top's pop follows
+// the finger, UIKit's otherwise), then `popGesture` (with `false` there is neither a swipe nor the hold's event), then
+// one screen or a stack not at rest, then the hold (its event instead of the swipe), then the edge swipe under a hidden
+// bar begins without UIKit's delegate, and otherwise UIKit's delegate decides (its direction, a vertical scroll of the
+// content). A top that isn't the stack's own (a column UIKit's split view moved in) is UIKit's.
 //
 // Every pan in the content is offered to the content swipe, so it is first sorted: a pan that isn't a swipe back
 // (vertical, the other way) is no attempt, and neither is one on a list that scrolls sideways, which takes the pan
@@ -97,6 +98,10 @@ static BOOL ANNIsOwnQuestionOfUIKit(SEL selector) {
 // hidden bar it refuses them all, and the swipe sorts them itself, as the edge swipe begins there without it.
 - (BOOL)gestureRecognizerShouldBegin:(UIGestureRecognizer *)gestureRecognizer {
     ANNStackController *stack = _stack;
+    // One swipe plays the pop: the stack's own while the top's pop follows the finger, UIKit's otherwise.
+    if (stack && ![stack swipeBackTakes:gestureRecognizer]) {
+        return NO;
+    }
     if (stack && ![stack swipeBackIsUIKits:gestureRecognizer]) {
         if (!_enabled || ![stack swipeBackMayBegin]) {
             return NO;
@@ -191,6 +196,25 @@ static BOOL ANNIsOwnQuestionOfUIKit(SEL selector) {
     return YES;
 }
 
+// A list under the stack's own swipe waits for it, as for UIKit's edge swipe: a swipe from the edge goes back, also on
+// a list that scrolls sideways. UIKit's swipes keep UIKit's answer.
+- (BOOL)gestureRecognizer:(UIGestureRecognizer *)gestureRecognizer
+    shouldBeRequiredToFailByGestureRecognizer:(UIGestureRecognizer *)otherGestureRecognizer {
+    ANNStackController *stack = _stack;
+    if (stack && [stack swipeBackIsStacks:gestureRecognizer]) {
+        UIView *view = otherGestureRecognizer.view;
+        return [view isKindOfClass:UIScrollView.class] &&
+               otherGestureRecognizer == ((UIScrollView *)view).panGestureRecognizer;
+    }
+    id<UIGestureRecognizerDelegate> systemDelegate = _systemDelegate;
+    SEL question = @selector(gestureRecognizer:shouldBeRequiredToFailByGestureRecognizer:);
+    if ([systemDelegate respondsToSelector:question]) {
+        return [systemDelegate gestureRecognizer:gestureRecognizer
+            shouldBeRequiredToFailByGestureRecognizer:otherGestureRecognizer];
+    }
+    return NO;
+}
+
 #pragma mark - The rest goes to UIKit's delegate
 
 - (void)setBarHidden:(BOOL)barHidden {

package/ios/Options/ANNAnimationOptions.h

@@ -3,6 +3,7 @@
 #import "ANNOptions.h"
 #import "ANNSetStackRootAnimationOptions.h"
 #import "ANNStackAnimationOptions.h"
+#import "ANNStackPopAnimationOptions.h"
 #import "ANNStackPushAnimationOptions.h"
 
 NS_ASSUME_NONNULL_BEGIN
@@ -11,7 +12,7 @@ NS_ASSUME_NONNULL_BEGIN
 @interface ANNAnimationOptions : ANNOptions
 
 @property(nonatomic, strong) ANNStackPushAnimationOptions *push;
-@property(nonatomic, strong) ANNStackAnimationOptions *pop;
+@property(nonatomic, strong) ANNStackPopAnimationOptions *pop;
 @property(nonatomic, strong) ANNSetStackRootAnimationOptions *setStackRoot;
 @property(nonatomic, strong) ANNEnterExitScreenAnimationOptions *setRoot;
 @property(nonatomic, strong) ANNModalAnimationOptions *showModal;

package/ios/Options/ANNAnimationOptions.mm

@@ -5,7 +5,7 @@
 + (NSArray<ANNOptionField *> *)optionFields {
     return @[
         [ANNOptionField groupField:@"push" class:ANNStackPushAnimationOptions.class],
-        [ANNOptionField groupField:@"pop" class:ANNStackAnimationOptions.class],
+        [ANNOptionField groupField:@"pop" class:ANNStackPopAnimationOptions.class],
         [ANNOptionField groupField:@"setStackRoot" class:ANNSetStackRootAnimationOptions.class],
         [ANNOptionField groupField:@"setRoot" class:ANNEnterExitScreenAnimationOptions.class],
         [ANNOptionField groupField:@"showModal" class:ANNModalAnimationOptions.class],

package/ios/Options/ANNOptions.h

@@ -58,6 +58,13 @@ void ANNCheckOptionClassesFrom(Class root);
 /// The group has any value.
 - (BOOL)hasValue;
 
+/// Takes the value at `path` out, in place: the JSON keys from this group, the last one a value, an array or a whole
+/// group, which gets what a freshly made group has there (unset). A key of a text's font goes through the text. A
+/// module's group (an empty field table) is walked by its properties named as the keys. NO, and nothing changes, when
+/// a key of the path is none of the group's or a key before the last is no group. Only on a copy of own options
+/// (`changeOwnOptions:`), never on options in use.
+- (BOOL)clearValueAtPath:(NSArray<NSString *> *)path;
+
 /// A deep copy: a new group of the same class with these merged into it. The copy shares values, never groups.
 - (instancetype)copy;
 

package/ios/Options/ANNOptions.mm

@@ -398,6 +398,51 @@ static NSArray *ANNCopyItems(NSArray *items) {
     return NO;
 }
 
+// Generic over the whole tree, so that any option an edit takes out (`clearOptions`) goes without a list of options:
+// the field table names each key's property; a module's group, which reads its JSON itself, names its properties as
+// the keys.
+- (BOOL)clearValueAtPath:(NSArray<NSString *> *)path {
+    NSString *key = path.firstObject;
+    if (key.length == 0) {
+        return NO;
+    }
+    NSArray<ANNOptionField *> *fields = ANNFieldsOf(self.class);
+    NSString *property = nil;
+    if (fields.count) {
+        for (ANNOptionField *field in fields) {
+            if ([field.key isEqualToString:key]) {
+                property = field.property;
+                break;
+            }
+        }
+        if (!property) {
+            // A group without a key (the font of a text) holds keys of its parent's object.
+            for (ANNOptionField *field in fields) {
+                if (field.kind == ANNOptionFieldKindGroup && !field.key &&
+                    [[self valueForKey:field.property] clearValueAtPath:path]) {
+                    return YES;
+                }
+            }
+            return NO;
+        }
+    } else if ([ANNValuePropertiesOf(self.class) containsObject:key]) {
+        property = key;
+    } else {
+        return NO;
+    }
+    if (path.count == 1) {
+        ANNOptions *fresh = [[self.class alloc] initWithDict:nil];
+        [self setValue:[fresh valueForKey:property] forKey:property];
+        return YES;
+    }
+    id value = [self valueForKey:property];
+    if (![value isKindOfClass:ANNOptions.class]) {
+        return NO;
+    }
+    NSArray<NSString *> *rest = [path subarrayWithRange:NSMakeRange(1, path.count - 1)];
+    return [(ANNOptions *)value clearValueAtPath:rest];
+}
+
 - (id)copyWithZone:(NSZone *)zone {
     ANNOptions *copy = [[self.class alloc] initWithDict:nil];
     [copy mergeOptions:self];

package/ios/Options/ANNOptionsReader.mm

@@ -52,8 +52,7 @@ static void ANNCheckSameValues(void) {
     NSDictionary *json = @{
         @"topBar" : @{
             @"title" : @{@"text" : @"Home", @"color" : @(0xFF112233)},
-            @"rightButtonColor" :
-                @{@"dynamic" : @{@"light" : @(0xFF000000), @"dark" : @(0xFFFFFFFF)}},
+            @"rightButtonColor" : @{@"light" : @(0xFF000000), @"dark" : @(0xFFFFFFFF)},
             @"leftButtonColor" : NSNull.null,
             @"rightButtons" : @[ button ],
             @"leftButtons" : @[],
@@ -75,8 +74,7 @@ static void ANNCheckSameValues(void) {
     NSDictionary<NSString *, NSArray *> *changes = @{
         @"a text" : @[ @[ @"topBar", @"title", @"text" ], @"Profile" ],
         @"a color" : @[ @[ @"topBar", @"title", @"color" ], @(0xFF112234) ],
-        @"a side of a color pair" :
-            @[ @[ @"topBar", @"rightButtonColor", @"dynamic", @"dark" ], @(0xFFEEEEEE) ],
+        @"a side of a color pair" : @[ @[ @"topBar", @"rightButtonColor", @"dark" ], @(0xFFEEEEEE) ],
         @"a number" : @[ @[ @"topBar", @"height" ], @45 ],
         @"an image" : @[ @[ @"topBar", @"rightButtons", @0, @"icon", @"system" ], @"heart" ],
         @"a boolean" : @[ @[ @"topBar", @"rightButtons", @0, @"enabled" ], @NO ],

package/ios/Options/ANNStackPopAnimationOptions.h

@@ -0,0 +1,13 @@
+#import "ANNStackAnimationOptions.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// `animations.pop` (`StackPopAnimationOptions`).
+@interface ANNStackPopAnimationOptions : ANNStackAnimationOptions
+
+/// The swipe back plays the screen's own pop under the finger.
+@property(nonatomic, strong) Bool *interactive;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/Options/ANNStackPopAnimationOptions.mm

@@ -0,0 +1,11 @@
+#import "ANNStackPopAnimationOptions.h"
+
+@implementation ANNStackPopAnimationOptions
+
++ (NSArray<ANNOptionField *> *)optionFields {
+    return [[super optionFields] arrayByAddingObjectsFromArray:@[
+        [ANNOptionField boolField:@"interactive"],
+    ]];
+}
+
+@end

package/ios/Options/Params/ColorParser.h

@@ -2,9 +2,10 @@
 
 NS_ASSUME_NONNULL_BEGIN
 
-/// Reads `key` of the options' JSON as a color, in the forms JS sends on iOS: an ARGB number, `{ dynamic: { light, dark
-/// } }` with a number or a platform color on each side, `{ semantic: [...] }`, and `'NoColor'` (or `null`) for "no
-/// color". A value it can't read is no value and a warning in development.
+/// Reads `key` of the options' JSON as a color, in the forms JS sends on iOS: an ARGB number, `{ light, dark }` (or an
+/// app's `DynamicColorIOS`, `{ dynamic: { light, dark } }`) with a number or a platform color on each side,
+/// `{ semantic: [...] }`, and `'NoColor'` (or `null`) for "no color". A value it can't read is no value and a warning
+/// in development.
 @interface ColorParser : NSObject
 
 + (Color *)parse:(nullable NSDictionary *)json key:(NSString *)key;

package/ios/Options/Params/ColorParser.mm

@@ -49,6 +49,24 @@ static UIColor *ANNOneColor(id value) {
     return nil;
 }
 
+// A pair comes as `{ light, dark }`, either side may be left out; an app's own `DynamicColorIOS` as
+// `{ dynamic: { light, dark } }`. Anything else is not a pair.
+static NSDictionary *ANNColorPair(id value) {
+    if (![value isKindOfClass:NSDictionary.class]) {
+        return nil;
+    }
+    id dynamic = value[@"dynamic"];
+    if (dynamic) {
+        return [dynamic isKindOfClass:NSDictionary.class] ? dynamic : nil;
+    }
+    for (id side in value) {
+        if (![side isEqual:@"light"] && ![side isEqual:@"dark"]) {
+            return nil;
+        }
+    }
+    return value;
+}
+
 @implementation ColorParser
 
 + (Color *)parse:(NSDictionary *)json key:(NSString *)key {
@@ -64,8 +82,8 @@ static UIColor *ANNOneColor(id value) {
         return [[Color alloc] initWithColor:color];
     }
     NSString *path = [ANNOptionsReader pathOfKey:key];
-    NSDictionary *pair = [value isKindOfClass:NSDictionary.class] ? value[@"dynamic"] : nil;
-    if ([pair isKindOfClass:NSDictionary.class]) {
+    NSDictionary *pair = ANNColorPair(value);
+    if (pair) {
         UIColor *light = [self side:pair[@"light"] name:@"light" path:path];
         UIColor *dark = [self side:pair[@"dark"] name:@"dark" path:path];
         if (light || dark) {
@@ -77,8 +95,8 @@ static UIColor *ANNOneColor(id value) {
     return [[Color alloc] initWithValue:nil];
 }
 
-// A side of `{ dynamic: { light, dark } }`. A side that is not there is a partial pair and is silent (the sides are
-// optional); a side that is there but can't be read is missing too, with a warning.
+// A side of `{ light, dark }`. A side that is not there is a partial pair and is silent (the sides are optional); a
+// side that is there but can't be read is missing too, with a warning.
 + (UIColor *)side:(id)value name:(NSString *)name path:(NSString *)path {
     if (!value || value == NSNull.null) {
         return nil;

package/ios/React/ANNSurfaceHostingView.h

@@ -8,6 +8,14 @@ NS_ASSUME_NONNULL_BEGIN
 /// every change on.
 @interface ANNSurfaceHostingView : RCTSurfaceHostingView
 
+/// A size transition of the window (a rotation, a new window size) runs until its coordinator completes. Meanwhile React
+/// content takes its new size without animation (`layOutContent:`). Each call ends with its own transition; main queue.
++ (void)followSizeTransition:(id<UIViewControllerTransitionCoordinator>)coordinator;
+
+/// Runs a layout that gives React content a new size: without animation while a size transition runs, as it is
+/// otherwise. Main queue.
++ (void)layOutContent:(void (^)(void))layout;
+
 /// Called at each mount of the hosted surface: after a change of the surface's size, the first one lays the surface
 /// out again, so a render that was on its way during the change doesn't keep the old size's layout.
 - (void)surfaceDidMount;

package/ios/React/ANNSurfaceHostingView.mm

@@ -11,6 +11,9 @@ static const void *ANNSurfaceStopperKey = &ANNSurfaceStopperKey;
 // The hosting views whose surface stops at its start; each keeps its surface. Main queue.
 static NSMutableSet<ANNSurfaceHostingView *> *ANNHostingViewsStoppingAtStart;
 
+// The size transitions of the window that run now. Main queue.
+static NSInteger ANNSizeTransitionCount;
+
 // The delegate of a surface its hosting view let go at the limit: the surface keeps it, and it keeps nothing, so
 // neither holds the other alive. A surface that something else still starts (a start already on its way holds its
 // surface; React Native restarts every surface it knows after a reload, holding it) stops at once, instead of running
@@ -60,6 +63,28 @@ static NSMutableSet<ANNSurfaceHostingView *> *ANNHostingViewsStoppingAtStart;
 
 #pragma mark - The surface's size
 
+// UIKit lays the screens out inside the animation of a rotation or a new window size, and React Native commits and
+// mounts the new layout synchronously inside the layout that gives it the size: every frame of its views animated
+// from the old size to the new one, and what a view draws itself (an SVG, a glass view, text) was drawn once at the new
+// size and stretched along that animation. During such a transition the content takes its new layout at once; the
+// hosting view itself still follows the animation. Other animated size changes (a sheet's detent, a split view's
+// column) keep the content's frames animated, so content pinned to the moving edge rides along with it.
++ (void)followSizeTransition:(id<UIViewControllerTransitionCoordinator>)coordinator {
+    ANNSizeTransitionCount++;
+    [coordinator animateAlongsideTransition:nil
+                                 completion:^(id<UIViewControllerTransitionCoordinatorContext> context) {
+                                   ANNSizeTransitionCount--;
+                                 }];
+}
+
++ (void)layOutContent:(void (^)(void))layout {
+    if (ANNSizeTransitionCount > 0) {
+        [UIView performWithoutAnimation:layout];
+    } else {
+        layout();
+    }
+}
+
 // React Native gives the surface its size here. A size change is noted for the next mount (see below). The note is
 // put aside during the call: the change's own commit mounts inside it and must not take an earlier note, or a size
 // that changes every frame (a sheet dragged between detents, a window resized) would lay out three times a frame. A
@@ -70,7 +95,9 @@ static NSMutableSet<ANNSurfaceHostingView *> *ANNHostingViewsStoppingAtStart;
     CGSize maximumSize = surface.maximumSize;
     BOOL sizeChangedBefore = _surfaceSizeChanged;
     _surfaceSizeChanged = NO;
-    [super layoutSubviews];
+    [ANNSurfaceHostingView layOutContent:^{
+      [super layoutSubviews];
+    }];
     BOOL sizeChanged = surface && (!CGSizeEqualToSize(minimumSize, surface.minimumSize) ||
                                    !CGSizeEqualToSize(maximumSize, surface.maximumSize));
     _surfaceSizeChanged = sizeChanged || sizeChangedBefore;

package/ios/React/Slots/ANNSlotScreenView.mm

@@ -3,6 +3,7 @@
 #import "ANNScreenAppearance.h"
 #import "ANNScreenReadiness.h"
 #import "ANNSlotHost.h"
+#import "ANNSurfaceHostingView.h"
 #import "../../cpp/react/renderer/components/ApexNavigationSpec/ANNSlotState.h"
 #import <React/RCTConstants.h>
 #import <React/RCTSurfacePresenter.h>
@@ -62,12 +63,17 @@
     return nil;
 }
 
-// The slot lays its content out at this size: every change goes to it (rotation, a sheet detent, the bars).
+// The slot lays its content out at this size: every change goes to it (rotation, a sheet detent, the bars). Its state
+// update mounts synchronously, here: during a rotation the content takes its new layout at once, as a screen's surface
+// does (`+[ANNSurfaceHostingView layOutContent:]`).
 - (void)layoutSubviews {
     [super layoutSubviews];
     if (!CGSizeEqualToSize(self.bounds.size, _lastSize)) {
         _lastSize = self.bounds.size;
-        [ANNSlotContainers containerDidChange:_componentId];
+        NSString *componentId = _componentId;
+        [ANNSurfaceHostingView layOutContent:^{
+          [ANNSlotContainers containerDidChange:componentId];
+        }];
     }
 }
 

package/ios/TurboModules/ANNTurboModule.mm

@@ -1,6 +1,7 @@
 #import "ANNTurboModule.h"
 #import "ANNAppDirection.h"
 #import "ANNArrangementState.h"
+#import "ANNArrangementViewController.h"
 #import "ANNCommandRunner.h"
 #import "ANNComponentViewController.h"
 #import "ANNDeepLinkQueue.h"
@@ -245,6 +246,51 @@ RCT_EXPORT_MODULE(ANNTurboModule)
                          }];
 }
 
+// `clearOptions` (development: Fast Refresh took options out of a screen that shows): the values at the paths leave
+// the node's own options, so it resolves to what its parents and the defaults give there, and what shows applies the
+// new resolution as after `setDefaultOptions`. The window and the node are found as for `mergeOptions`; an unknown
+// id, or no path that names an option, does nothing, without a log. The user layer stays.
+- (void)clearOptions:(NSString *)componentId paths:(NSArray *)paths {
+    NSString *what = ANNWhat(@"clear the options of the screen '%@'", componentId);
+    [ANNCommandRunner runVoid:@"clearOptions"
+                         what:what
+                         body:^{
+                           if (!ApexNavigation.mainWindow) {
+                               [ANNCommandRunner logFailure:@"clearOptions"
+                                                       text:ANNErrorTexts.nowhereToShow];
+                               return;
+                           }
+                           UIViewController *node = ANNCommandNode(componentId);
+#if __IPHONE_OS_VERSION_MAX_ALLOWED >= 270100
+                           // The options set with a pair's id are its primary's, as for `mergeOptions`.
+                           if (@available(iOS 27.1, *)) {
+                               if ([node isKindOfClass:ANNArrangementViewController.class]) {
+                                   node = ((ANNArrangementViewController *)node).primary;
+                               }
+                           }
+#endif
+                           NSMutableArray<NSArray<NSString *> *> *keyPaths = [NSMutableArray new];
+                           for (id path in [paths isKindOfClass:NSArray.class] ? paths : @[]) {
+                               if ([path isKindOfClass:NSString.class] && [path length] > 0) {
+                                   [keyPaths addObject:[path componentsSeparatedByString:@"."]];
+                               }
+                           }
+                           if (!node || keyPaths.count == 0) {
+                               return;
+                           }
+                           __block BOOL cleared = NO;
+                           [node changeOwnOptions:^(ANNNavigationOptions *options) {
+                             for (NSArray<NSString *> *keyPath in keyPaths) {
+                                 cleared = [options clearValueAtPath:keyPath] || cleared;
+                             }
+                           }];
+                           // Paths that name no option change nothing that shows.
+                           if (cleared) {
+                               [ANNOptionsRepaint applyNewDefaultOptions:ANNDefaultOptions.current];
+                           }
+                         }];
+}
+
 #pragma mark - Stack
 
 - (void)push:(NSString *)commandId

package/ios/cpp/react/renderer/components/ApexNavigationSpec/ANNSlotState.cpp

@@ -0,0 +1,20 @@
+#include "ANNSlotState.h"
+
+namespace facebook::react {
+
+std::mutex &ANNSlotContentHeights::mutex() {
+    static std::mutex value;
+    return value;
+}
+
+std::unordered_map<std::string, Float> &ANNSlotContentHeights::heights() {
+    static std::unordered_map<std::string, Float> value;
+    return value;
+}
+
+std::atomic<int> &ANNSlotContentHeights::requested() {
+    static std::atomic<int> value{0};
+    return value;
+}
+
+} // namespace facebook::react

package/ios/cpp/react/renderer/components/ApexNavigationSpec/ANNSlotState.h

@@ -82,20 +82,11 @@ class ANNSlotContentHeights final {
     }
 
   private:
-    static std::mutex &mutex() {
-        static std::mutex value;
-        return value;
-    }
-
-    static std::unordered_map<std::string, Float> &heights() {
-        static std::unordered_map<std::string, Float> value;
-        return value;
-    }
-
-    static std::atomic<int> &requested() {
-        static std::atomic<int> value{0};
-        return value;
-    }
+    // One store for the whole app, in ANNSlotState.cpp: on Android the slot's layout runs in the app's library and the
+    // native side reads the heights from the library's own, and an inline static would give each its own copy.
+    static std::mutex &mutex();
+    static std::unordered_map<std::string, Float> &heights();
+    static std::atomic<int> &requested();
 };
 
 } // namespace facebook::react