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

package/ios/Options/ANNOptionsReader.mm

@@ -1,12 +1,121 @@
 #import "ANNOptionsReader.h"
 #import "ANNAssert.h"
 #import "ANNNavigationOptions.h"
+#if DEBUG
+#import <React/RCTLog.h>
+#endif
 
 // The parse runs on the main queue, one tree at a time: the path and the first failure are its state. A group read
 // outside a parse (a module that reads its own JSON) finds an empty path and keeps no failure.
 static NSMutableArray<NSString *> *ANNPathComponents;
 static NSString *ANNFirstFailure;
 
+#if DEBUG
+// A deep mutable copy of `json` with `value` at `path` (keys, and indexes of arrays); nil `value` removes the key.
+static id ANNJSONWith(id json, NSArray *path, id value) {
+    if (path.count == 0) {
+        return value;
+    }
+    NSArray *rest = [path subarrayWithRange:NSMakeRange(1, path.count - 1)];
+    if ([json isKindOfClass:NSArray.class]) {
+        NSMutableArray *items = [json mutableCopy];
+        NSUInteger index = [path[0] unsignedIntegerValue];
+        items[index] = ANNJSONWith(items[index], rest, value);
+        return items;
+    }
+    NSMutableDictionary *fields = [json mutableCopy];
+    id inner = ANNJSONWith(fields[path[0]], rest, value);
+    if (inner) {
+        fields[path[0]] = inner;
+    } else {
+        [fields removeObjectForKey:path[0]];
+    }
+    return fields;
+}
+
+// There is no iOS test target: in development the value equality of the options (`isSameValueAs:`) checks itself
+// once on a tree with a value of each kind: two reads, a copy and a merge give the same options and the same hash, and
+// a change of one value at any depth gives other options. A module's group (the menu) compares by its properties.
+static void ANNCheckSameValues(void) {
+    NSDictionary *button = @{
+        @"id" : @"save",
+        @"text" : @"Save",
+        @"icon" : @{@"system" : @"star"},
+        @"enabled" : @YES,
+        @"badge" : @1,
+        @"fontSize" : @15,
+        @"menu" : @{
+            @"title" : @"More",
+            @"items" : @[ @{@"id" : @"details", @"title" : @"Details", @"checked" : @YES} ],
+        },
+    };
+    NSDictionary *json = @{
+        @"topBar" : @{
+            @"title" : @{@"text" : @"Home", @"color" : @(0xFF112233)},
+            @"rightButtonColor" :
+                @{@"dynamic" : @{@"light" : @(0xFF000000), @"dark" : @(0xFFFFFFFF)}},
+            @"leftButtonColor" : NSNull.null,
+            @"rightButtons" : @[ button ],
+            @"leftButtons" : @[],
+            @"height" : @44,
+        },
+        @"keyCommands" : @[ @{@"input" : @"k", @"modifiers" : @[ @"command" ]} ],
+    };
+    ANNNavigationOptions *options = [[ANNNavigationOptions alloc] initWithDict:json];
+    ANNNavigationOptions *again = [[ANNNavigationOptions alloc] initWithDict:json];
+    ANNNavigationOptions *copy = [options copy];
+    ANNNavigationOptions *overEmpty = [options withDefault:[ANNNavigationOptions new]];
+    for (ANNNavigationOptions *same in @[ again, copy, overEmpty ]) {
+        if (![options isSameValueAs:same] || options.valueHash != same.valueHash) {
+            RCTLogError(@"[ApexNavigation] options read, copied or resolved from the same JSON are "
+                        @"not the same value");
+        }
+    }
+    // Each change: the path of one value and its new value; an unset key is not the same as `null` or `[]`.
+    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 number" : @[ @[ @"topBar", @"height" ], @45 ],
+        @"an image" : @[ @[ @"topBar", @"rightButtons", @0, @"icon", @"system" ], @"heart" ],
+        @"a boolean" : @[ @[ @"topBar", @"rightButtons", @0, @"enabled" ], @NO ],
+        @"a boolean for a number" : @[ @[ @"topBar", @"rightButtons", @0, @"badge" ], @YES ],
+        @"a font" : @[ @[ @"topBar", @"rightButtons", @0, @"fontSize" ], @16 ],
+        @"a module's group" :
+            @[ @[ @"topBar", @"rightButtons", @0, @"menu", @"items", @0, @"checked" ], @NO ],
+        @"an object of an array" : @[ @[ @"keyCommands", @0, @"modifiers", @0 ], @"shift" ],
+    };
+    NSDictionary<NSString *, NSArray *> *removals = @{
+        @"a color of `null` and no color" : @[ @"topBar", @"leftButtonColor" ],
+        @"an empty array and no array" : @[ @"topBar", @"leftButtons" ],
+    };
+    NSMutableDictionary<NSString *, id> *variants = [NSMutableDictionary new];
+    [changes enumerateKeysAndObjectsUsingBlock:^(NSString *what, NSArray *change, BOOL *stop) {
+      variants[what] = ANNJSONWith(json, change[0], change[1]);
+    }];
+    [removals enumerateKeysAndObjectsUsingBlock:^(NSString *what, NSArray *path, BOOL *stop) {
+      variants[what] = ANNJSONWith(json, path, nil);
+    }];
+    [variants enumerateKeysAndObjectsUsingBlock:^(NSString *what, NSDictionary *variant,
+                                                  BOOL *stop) {
+      ANNNavigationOptions *changed = [[ANNNavigationOptions alloc] initWithDict:variant];
+      if ([options isSameValueAs:changed] || [changed isSameValueAs:options]) {
+          RCTLogError(@"[ApexNavigation] options that differ in %@ are the same value", what);
+      }
+    }];
+    ANNNavigationOptions *merged = [options copy];
+    [merged mergeOptions:[[ANNNavigationOptions alloc]
+                             initWithDict:@{@"topBar" : @{@"title" : @{@"text" : @"Profile"}}}]];
+    ANNNavigationOptions *read = [[ANNNavigationOptions alloc]
+        initWithDict:ANNJSONWith(json, @[ @"topBar", @"title", @"text" ], @"Profile")];
+    if (![merged isSameValueAs:read] || merged.valueHash != read.valueHash) {
+        RCTLogError(@"[ApexNavigation] merged options are not the same value as the same options "
+                    @"read at once");
+    }
+}
+#endif
+
 @implementation ANNOptionsReader
 
 + (ANNNavigationOptions *)optionsFrom:(NSDictionary *)json unreadablePath:(NSString **)unreadablePath {
@@ -15,6 +124,7 @@ static NSString *ANNFirstFailure;
     static dispatch_once_t checkOnce;
     dispatch_once(&checkOnce, ^{
       ANNCheckOptionClassesFrom(ANNNavigationOptions.class);
+      ANNCheckSameValues();
     });
 #endif
     NSMutableArray<NSString *> *outerPath = ANNPathComponents;

package/ios/Options/Params/ANNParam.h

@@ -8,6 +8,14 @@ BOOL ANNJSONIsBoolean(id _Nullable value);
 /// A JSON number that is finite: never a boolean, `NaN` or an infinity.
 BOOL ANNJSONIsNumber(id _Nullable value);
 
+/// Two values as the options keep them are the same: a boolean is never the same as a number, arrays and objects
+/// compare item by item, anything else (a string, a number, `null`, a color) by `isEqual:`. nil is the same only as
+/// nil.
+BOOL ANNJSONValuesSame(id _Nullable a, id _Nullable b);
+
+/// A hash of a value `ANNJSONValuesSame` compares: values that are the same have the same hash.
+NSUInteger ANNJSONValueHash(id _Nullable value);
+
 /// One value of the options as the JSON gave it. Immutable: trees of options may share it. `null` is a value too where
 /// the kind has an explicit "none" (a text, a color): it takes the place of what the layers under it gave.
 @interface ANNParam : NSObject
@@ -23,6 +31,13 @@ BOOL ANNJSONIsNumber(id _Nullable value);
 /// The options gave `null`.
 - (BOOL)isNull;
 
+/// A param of the same class with the same value: two reads of the same JSON are the same, two params without a value
+/// are the same. `==` and `isEqual:` stay identity.
+- (BOOL)isSameValueAs:(nullable ANNParam *)other;
+
+/// A hash consistent with `isSameValueAs:`.
+- (NSUInteger)valueHash;
+
 @end
 
 NS_ASSUME_NONNULL_END

package/ios/Options/Params/ANNParam.mm

@@ -9,6 +9,56 @@ BOOL ANNJSONIsNumber(id value) {
     return [value isKindOfClass:NSNumber.class] && !ANNJSONIsBoolean(value) && isfinite([value doubleValue]);
 }
 
+BOOL ANNJSONValuesSame(id a, id b) {
+    if (a == b) {
+        return YES;
+    }
+    if (!a || !b) {
+        return NO;
+    }
+    if ([a isKindOfClass:NSArray.class]) {
+        if (![b isKindOfClass:NSArray.class] || [a count] != [b count]) {
+            return NO;
+        }
+        NSArray *items = b;
+        __block BOOL same = YES;
+        [(NSArray *)a enumerateObjectsUsingBlock:^(id item, NSUInteger index, BOOL *stop) {
+          same = ANNJSONValuesSame(item, items[index]);
+          *stop = !same;
+        }];
+        return same;
+    }
+    if ([a isKindOfClass:NSDictionary.class]) {
+        if (![b isKindOfClass:NSDictionary.class] || [a count] != [b count]) {
+            return NO;
+        }
+        NSDictionary *fields = b;
+        __block BOOL same = YES;
+        [(NSDictionary *)a enumerateKeysAndObjectsUsingBlock:^(id key, id value, BOOL *stop) {
+          same = ANNJSONValuesSame(value, fields[key]);
+          *stop = !same;
+        }];
+        return same;
+    }
+    // `isEqual:` of NSNumber takes `true` for 1: a badge of `true` (a dot) and of `1` (a number) are not the same.
+    if (ANNJSONIsBoolean(a) != ANNJSONIsBoolean(b)) {
+        return NO;
+    }
+    return [a isEqual:b];
+}
+
+// An object's hash is its count only (Foundation's); an array mixes its items in, so lists of other values differ.
+NSUInteger ANNJSONValueHash(id value) {
+    if ([value isKindOfClass:NSArray.class]) {
+        NSUInteger hash = [value count];
+        for (id item in value) {
+            hash = hash * 31 + ANNJSONValueHash(item);
+        }
+        return hash;
+    }
+    return [value hash];
+}
+
 @implementation ANNParam
 
 - (instancetype)initWithValue:(id)value {
@@ -26,4 +76,15 @@ BOOL ANNJSONIsNumber(id value) {
     return _value == NSNull.null;
 }
 
+- (BOOL)isSameValueAs:(ANNParam *)other {
+    if (other == self) {
+        return YES;
+    }
+    return other.class == self.class && ANNJSONValuesSame(_value, other.value);
+}
+
+- (NSUInteger)valueHash {
+    return ANNJSONValueHash(_value);
+}
+
 @end

package/ios/Options/Params/Color.h

@@ -38,6 +38,9 @@ NS_ASSUME_NONNULL_BEGIN
 /// A pair that has only one of its sides.
 - (BOOL)isPartial;
 
+/// The same color: a pair by its sides (its dynamic color is made anew at each read), anything else by its value.
+- (BOOL)isSameValueAs:(nullable ANNParam *)other;
+
 @end
 
 NS_ASSUME_NONNULL_END

package/ios/Options/Params/Color.mm

@@ -40,6 +40,27 @@
     return [super get];
 }
 
+- (BOOL)isSameValueAs:(ANNParam *)other {
+    if (other == self) {
+        return YES;
+    }
+    if (other.class != self.class) {
+        return NO;
+    }
+    Color *color = (Color *)other;
+    if (_light || _dark || color.light || color.dark) {
+        return ANNJSONValuesSame(_light, color.light) && ANNJSONValuesSame(_dark, color.dark);
+    }
+    return [super isSameValueAs:other];
+}
+
+- (NSUInteger)valueHash {
+    if (_light || _dark) {
+        return _light.hash * 31 + _dark.hash;
+    }
+    return [super valueHash];
+}
+
 - (UIColor *)withDefault:(UIColor *)defaultValue {
     if (!self.isPartial) {
         return self.hasValue ? self.get : defaultValue;

package/ios/Options/Params/Image.h

@@ -19,6 +19,10 @@ NS_ASSUME_NONNULL_BEGIN
 /// What the options name; nil without a value.
 @property(nonatomic, strong, readonly, nullable) ANNImageSource *source;
 
+/// The same image the options name: a source by its `sourceKey` (what a file holds now isn't compared, so a file the
+/// app writes again at the same path is the same value), an image that came already by identity.
+- (BOOL)isSameValueAs:(nullable ANNParam *)other;
+
 @end
 
 NS_ASSUME_NONNULL_END

package/ios/Options/Params/Image.mm

@@ -17,6 +17,26 @@
     return source ? [ANNOptionImages imageOf:source] : nil;
 }
 
+- (BOOL)isSameValueAs:(ANNParam *)other {
+    if (other == self) {
+        return YES;
+    }
+    if (other.class != self.class) {
+        return NO;
+    }
+    ANNImageSource *source = self.source;
+    ANNImageSource *otherSource = ((Image *)other).source;
+    if (source || otherSource) {
+        return [source.sourceKey isEqualToString:otherSource.sourceKey];
+    }
+    return self.value == other.value;
+}
+
+- (NSUInteger)valueHash {
+    ANNImageSource *source = self.source;
+    return source ? source.sourceKey.hash : (NSUInteger)(__bridge void *)self.value;
+}
+
 // A source that doesn't load is no image: the default then, as without a value.
 - (UIImage *)withDefault:(UIImage *)defaultValue {
     UIImage *image = self.hasValue ? self.get : nil;

package/ios/React/ANNReactView.mm

@@ -8,29 +8,9 @@
 #import "ANNSurfaceHostingView.h"
 #import <React/RCTFabricSurface.h>
 #import <React/RCTSurfacePresenter.h>
-#import <React/RCTSurfaceStage.h>
 #import <React/RCTSurfaceView.h>
 #import <ReactCommon/RCTHost.h>
 
-// A surface that still starts can't be stopped yet: it is checked this often, at most this many times (5 s), and then
-// stopped anyway.
-static const NSTimeInterval ANNSurfaceStopCheckInterval = 0.05;
-static const NSUInteger ANNSurfaceStopCheckLimit = 100;
-
-// Stops `surface` once it runs. The block holds the surface and the view that hosts it until then: a hosting view
-// released earlier would stop the surface in its `dealloc`, maybe off the main queue.
-static void ANNStopSurfaceWhenRunning(RCTFabricSurface *surface, UIView *hostingView,
-                                      NSUInteger checksLeft) {
-    if (RCTSurfaceStageIsRunning(surface.stage) || checksLeft == 0) {
-        [surface stop];
-        return;
-    }
-    int64_t delay = (int64_t)(ANNSurfaceStopCheckInterval * NSEC_PER_SEC);
-    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, delay), dispatch_get_main_queue(), ^{
-      ANNStopSurfaceWhenRunning(surface, hostingView, checksLeft - 1);
-    });
-}
-
 @interface ANNReactView () <RCTSurfacePresenterObserver, ANNScreenReadinessListener>
 @end
 
@@ -359,14 +339,15 @@ static void ANNStopSurfaceWhenRunning(RCTFabricSurface *surface, UIView *hosting
     _reactViewReadyBlock = nil;
     _mountHandlers = nil;
     [_contentDidMountHandlers removeAllObjects];
-    RCTFabricSurface *surface = _surface;
-    if (surface) {
+    ANNSurfaceHostingView *hostingView = _hostingView;
+    if (_surface && hostingView) {
         // On the next turn of the main queue: a destroy that runs inside React Native's mounting (a wait that ends in
         // a mount, a root that replaces at once) would stop the surface there, React Native would drop its last
-        // transaction and recycle its root view with the old content still in it, to show in a later screen.
-        UIView *hostingView = _hostingView;
+        // transaction and recycle its root view with the old content still in it, to show in a later screen. The
+        // hosting view stops the surface then, or at its start when it doesn't run yet; the block keeps the hosting
+        // view, and with it the surface, until it asks.
         dispatch_async(dispatch_get_main_queue(), ^{
-          ANNStopSurfaceWhenRunning(surface, hostingView, ANNSurfaceStopCheckLimit);
+          [hostingView stopSurfaceWhenRunning];
         });
     }
 }

package/ios/React/ANNSafeAreaViewComponentView.mm

@@ -1,11 +1,14 @@
 #import "ANNSafeAreaViewComponentView.h"
-#import "ANNScreenInsets.h"
+#import "ANNScreenEnvironment.h"
 #import "ANNScreenReadiness.h"
 #import "../cpp/react/renderer/components/ApexNavigationSpec/ANNSafeAreaViewComponentDescriptor.h"
 #import <React/RCTConversions.h>
 
 using namespace facebook::react;
 
+@interface ANNSafeAreaViewComponentView () <ANNScreenPaddingListener>
+@end
+
 @implementation ANNSafeAreaViewComponentView {
     ANNSafeAreaViewShadowNode::ConcreteState::Shared _state;
     NSString *_screenId;
@@ -22,21 +25,13 @@ using namespace facebook::react;
     if (self = [super initWithFrame:frame]) {
         static const auto defaultProps = std::make_shared<const ANNSafeAreaViewProps>();
         _props = defaultProps;
-        [NSNotificationCenter.defaultCenter addObserver:self
-                                               selector:@selector(paddingDidChange:)
-                                                   name:ANNScreenSafeAreaPaddingDidChangeNotification
-                                                 object:nil];
     }
     return self;
 }
 
-- (void)dealloc {
-    [NSNotificationCenter.defaultCenter removeObserver:self];
-}
-
 - (void)updateProps:(const Props::Shared &)props oldProps:(const Props::Shared &)oldProps {
     const auto &newProps = static_cast<const ANNSafeAreaViewProps &>(*props);
-    _screenId = RCTNSStringFromStringNilIfEmpty(newProps.screenId);
+    [self listenToScreenId:RCTNSStringFromStringNilIfEmpty(newProps.screenId)];
     // The screen's readiness comes from this view, never from its root's children.
     if (_screenId != nil) {
         [ANNScreenReadiness screenHasSafeAreaView:_screenId];
@@ -70,18 +65,33 @@ using namespace facebook::react;
     [self applyPadding];
 }
 
-- (void)paddingDidChange:(NSNotification *)notification {
-    if ([notification.object isEqual:_screenId]) {
-        [self applyPadding];
+// The view hears the padding changes of its screen only. It listens before it applies the padding it has, at each
+// props, so a change between the two can't be missed.
+- (void)listenToScreenId:(nullable NSString *)screenId {
+    if ((screenId == nil && _screenId == nil) || [screenId isEqualToString:_screenId]) {
+        return;
+    }
+    if (_screenId != nil) {
+        [ANNScreenEnvironment removePaddingListener:self forScreenId:_screenId];
+    }
+    _screenId = screenId;
+    if (screenId != nil) {
+        [ANNScreenEnvironment addPaddingListener:self forScreenId:screenId];
     }
 }
 
+#pragma mark - ANNScreenPaddingListener
+
+- (void)screenPaddingDidChange {
+    [self applyPadding];
+}
+
 // The padding of the screen goes to the state, which lays the view out with it.
 - (void)applyPadding {
     if (_state == nullptr || _screenId == nil) {
         return;
     }
-    UIEdgeInsets padding = [ANNScreenInsets paddingForScreenId:_screenId];
+    UIEdgeInsets padding = [ANNScreenEnvironment paddingForScreenId:_screenId];
     EdgeInsets insets{.left = (Float)padding.left,
                       .top = (Float)padding.top,
                       .right = (Float)padding.right,
@@ -144,7 +154,8 @@ using namespace facebook::react;
 - (void)prepareForRecycle {
     [super prepareForRecycle];
     _state.reset();
-    _screenId = nil;
+    // A recycled view gets its next screen's id with its next props.
+    [self listenToScreenId:nil];
     _readySent = NO;
     _contentRenderedSent = NO;
     _contentRendered = NO;

package/ios/React/ANNSurfaceHostingView.h

@@ -12,6 +12,12 @@ NS_ASSUME_NONNULL_BEGIN
 /// out again, so a render that was on its way during the change doesn't keep the old size's layout.
 - (void)surfaceDidMount;
 
+/// The screen went: the hosted surface stops as soon as it runs, on the main queue. A surface that runs already stops
+/// at once; one that doesn't run yet stops at its change to running (`surface:didChangeStage:`). Until then this view
+/// and its surface are kept, so the core gives them up on the main queue. A surface that hasn't started after 5 s is
+/// let go, and stops if it ever starts later. Once; main queue.
+- (void)stopSurfaceWhenRunning;
+
 @end
 
 NS_ASSUME_NONNULL_END

package/ios/React/ANNSurfaceHostingView.mm

@@ -1,9 +1,49 @@
 #import "ANNSurfaceHostingView.h"
+#import "ANNAssert.h"
 #import <React/RCTFabricSurface.h>
+#import <objc/runtime.h>
+
+// How long a gone screen's surface that doesn't run yet is kept for its stop. The host starts a surface through a weak
+// reference once its JavaScript ran, so a surface let go before that, which nothing else holds, goes away unstarted.
+static const NSTimeInterval ANNSurfaceStartWaitLimit = 5.0;
+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 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
+// with no screen and going away running, which leaves its React tree registered.
+@interface ANNSurfaceStopper : NSObject <RCTSurfaceDelegate>
+@end
+
+@implementation ANNSurfaceStopper
+
+// React Native's delegate method names the deprecated `RCTSurface`; the surface is an `RCTFabricSurface`.
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated"
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+- (void)surface:(RCTSurface *)surface didChangeStage:(RCTSurfaceStage)stage {
+    if (!RCTSurfaceStageIsRunning(stage)) {
+        return;
+    }
+    // The start tells this off the main queue, before it ends: the stop goes on the main queue, the block keeping the
+    // surface until then.
+    id<RCTSurfaceProtocol> startedSurface = (id<RCTSurfaceProtocol>)surface;
+    dispatch_async(dispatch_get_main_queue(), ^{
+      [startedSurface stop];
+    });
+}
+#pragma clang diagnostic pop
+
+@end
 
 @implementation ANNSurfaceHostingView {
     // The surface was given a new size since its last mount.
     BOOL _surfaceSizeChanged;
+    // The screen went: the surface stops each time it runs. Main queue.
+    BOOL _stopsWhenRunning;
 }
 
 // React Native 0.87 posts the hosting view's traits as the app's scheme from here (`RCTSurfaceHostingView.mm`). On
@@ -60,6 +100,82 @@
     [surface setMinimumSize:minimumSize maximumSize:maximumSize];
 }
 
+#pragma mark - The stop
+
+// `RCTFabricSurface stop` does nothing while the surface doesn't run, and the host starts a surface later, off the main
+// queue: a screen can go before that. Its surface then stops at its change to running. This view is kept until then,
+// with its surface: released earlier, it would stop the surface in its `dealloc`, maybe off the main queue.
+- (void)stopSurfaceWhenRunning {
+    ANNAssertMainQueue();
+    if (_stopsWhenRunning) {
+        return;
+    }
+    _stopsWhenRunning = YES;
+    RCTFabricSurface *surface = [self fabricSurface];
+    if (!surface) {
+        return;
+    }
+    if (RCTSurfaceStageIsRunning(surface.stage)) {
+        [surface stop];
+        return;
+    }
+    if (!ANNHostingViewsStoppingAtStart) {
+        ANNHostingViewsStoppingAtStart = [NSMutableSet new];
+    }
+    [ANNHostingViewsStoppingAtStart addObject:self];
+    __weak ANNSurfaceHostingView *weakSelf = self;
+    int64_t delay = (int64_t)(ANNSurfaceStartWaitLimit * NSEC_PER_SEC);
+    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, delay), dispatch_get_main_queue(), ^{
+      [weakSelf letSurfaceGo];
+    });
+}
+
+// The surface tells its stage off the main queue, from its start and its stop. React Native's hosting view follows it
+// as before; a gone screen's surface that starts stops on the next turn of the main queue, once its start ended. The
+// block keeps this view, and with it the surface, until then, so their last release is on the main queue.
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated"
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+- (void)surface:(RCTSurface *)surface didChangeStage:(RCTSurfaceStage)stage {
+    [super surface:surface didChangeStage:stage];
+    if (!RCTSurfaceStageIsRunning(stage)) {
+        return;
+    }
+    dispatch_async(dispatch_get_main_queue(), ^{
+      [self stopSurfaceIfAsked];
+    });
+}
+#pragma clang diagnostic pop
+
+- (void)stopSurfaceIfAsked {
+    if (!_stopsWhenRunning) {
+        return;
+    }
+    RCTFabricSurface *surface = [self fabricSurface];
+    if (surface && RCTSurfaceStageIsRunning(surface.stage)) {
+        [surface stop];
+    }
+    [ANNHostingViewsStoppingAtStart removeObject:self];
+}
+
+// The limit: the surface hasn't started. It gets a delegate of its own that stops it at any later start, and this
+// view lets it go. The delegate changes before the check: a start told before the change reaches this view, which
+// stops the surface (its block keeps the view); one told after it reaches the new delegate.
+- (void)letSurfaceGo {
+    if (![ANNHostingViewsStoppingAtStart containsObject:self]) {
+        return;
+    }
+    RCTFabricSurface *surface = [self fabricSurface];
+    ANNSurfaceStopper *stopper = [ANNSurfaceStopper new];
+    objc_setAssociatedObject(surface, ANNSurfaceStopperKey, stopper,
+                             OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+    surface.delegate = stopper;
+    if (RCTSurfaceStageIsRunning(surface.stage)) {
+        [surface stop];
+    }
+    [ANNHostingViewsStoppingAtStart removeObject:self];
+}
+
 - (nullable RCTFabricSurface *)fabricSurface {
     id surface = self.surface;
     return [surface isKindOfClass:RCTFabricSurface.class] ? surface : nil;

package/ios/TopBar/ANNBackButtonPresenter.mm

@@ -2,6 +2,7 @@
 #import "ANNExternalViewController.h"
 #import "ANNIconButtonImage.h"
 #import "ANNStackController.h"
+#import "ANNTabsDesign.h"
 #import <objc/runtime.h>
 
 // The item below that the core configured: what it set may go again.
@@ -141,10 +142,8 @@ static const void *ANNBackButtonConfiguredKey = &ANNBackButtonConfiguredKey;
     ANNBackBarButtonItem *item = [ANNBackBarButtonItem new];
     item.allowsMenu = [backButton.enableMenu withDefault:YES];
     item.style = UIBarButtonItemStylePlain;
-    BOOL before26 = YES;
-    if (@available(iOS 26.0, *)) {
-        before26 = NO;
-    }
+    // The compatibility mode of iOS 26 shows the title below too, as the design before it.
+    BOOL before26 = !ANNTabsDesign.isGlass;
     item.title = title ?: (before26 ? belowTitle : nil);
     UIColor *background = [self iconBackgroundColorOf:backButton];
     if (background) {
@@ -165,7 +164,9 @@ static const void *ANNBackButtonConfiguredKey = &ANNBackButtonConfiguredKey;
                                      [iconBackground.height withDefault:0])
                    insets:UIEdgeInsetsZero];
         if (@available(iOS 26.0, *)) {
-            item.hidesSharedBackground = [backButton.hideSharedBackground withDefault:YES];
+            if (ANNTabsDesign.isGlass) {
+                item.hidesSharedBackground = [backButton.hideSharedBackground withDefault:YES];
+            }
         }
     }
     return item;

package/ios/TopBar/ANNBarAppearance.h

@@ -45,7 +45,8 @@ typedef struct {
 /// (a clear color is a clear bar). The one rule for the bar, its color in the list and the top edge effect.
 + (nullable UIColor *)solidColorOf:(nullable Color *)color traits:(UITraitCollection *)traits;
 
-/// A 1×1 image of `color` resolved for `traits`.
+/// A 1×1 image of `color` resolved for `traits`, with a variant for each style: the same image for the same resolved
+/// colors, so a look filled again equals the one before (as the back button's tinted arrow).
 + (UIImage *)imageOfColor:(UIColor *)color traits:(UITraitCollection *)traits;
 
 @end