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

package/ios/TopBar/ANNIconButtonImage.mm

@@ -1,5 +1,6 @@
 #import "ANNIconButtonImage.h"
 #import "ANNUtils.h"
+#import <React/RCTLog.h>
 
 @implementation ANNIconButtonImage
 
@@ -9,6 +10,30 @@
               cornerRadius:(CGFloat)cornerRadius
                       size:(CGSize)size
                     insets:(UIEdgeInsets)insets {
+    // An icon that can't be drawn so (no size, insets that leave no room, an exception of the renderer) shows as it is.
+    @try {
+        UIImage *image = [self variantsOfIcon:icon
+                                         tint:tint
+                                   background:background
+                                 cornerRadius:cornerRadius
+                                         size:size
+                                       insets:insets];
+        if (image) {
+            return image;
+        }
+    } @catch (NSException *exception) {
+        RCTLogWarn(@"[ApexNavigation] a button's image could not be drawn on its background: %@",
+                   exception.reason);
+    }
+    return icon;
+}
+
++ (nullable UIImage *)variantsOfIcon:(UIImage *)icon
+                                tint:(UIColor *)tint
+                          background:(UIColor *)background
+                        cornerRadius:(CGFloat)cornerRadius
+                                size:(CGSize)size
+                              insets:(UIEdgeInsets)insets {
     // Each variant carries a scale with its style: an asset of style-only traits gives back an image of scale 1, its
     // pixels taken as points (a 32 pt background drawn 96 pt wide). The current scale and the usual ones are drawn,
     // so a screen of another scale still finds its style. Each variant is an original image, so that a variant UIKit
@@ -30,6 +55,9 @@
                                        size:size
                                      insets:insets
                                      traits:traits];
+            if (!drawn) {
+                return nil;
+            }
             [asset registerImage:[drawn imageWithRenderingMode:UIImageRenderingModeAlwaysOriginal]
                  withTraitCollection:traits];
         }
@@ -54,7 +82,7 @@
     ]];
 }
 
-+ (UIImage *)drawIcon:(UIImage *)icon
++ (nullable UIImage *)drawIcon:(UIImage *)icon
                  tint:(UIColor *)tint
            background:(UIColor *)background
          cornerRadius:(CGFloat)cornerRadius
@@ -66,6 +94,11 @@
                                iconSize.height + insets.top + insets.bottom);
     CGSize canvas = CGSizeMake(size.width > 0 ? size.width : padded.width,
                                size.height > 0 ? size.height : padded.height);
+    BOOL drawable = canvas.width > 0 && canvas.height > 0 && isfinite(canvas.width) &&
+                    isfinite(canvas.height);
+    if (!drawable) {
+        return nil;
+    }
     UIImage *drawn = icon;
     if (tint) {
         drawn = [icon imageWithTintColor:[tint resolvedColorWithTraitCollection:traits]

package/ios/TopBar/ANNLargeTitlePresenter.h

@@ -57,6 +57,19 @@ typedef struct {
 /// goes, and the bar follows what it follows at rest.
 - (void)screenDidAppear:(ANNNavigationOptions *)options list:(nullable UIScrollView *)list;
 
+/// iOS 26: a push starts that brings the screen in with its content drawn already (it waited for it parked, out of the
+/// stack). UIKit draws the large title, for the whole transition, inside the scroll view the bar follows, and takes
+/// its place from that scroll view as the transition starts: a list below the bar clips it, a list laid out before the
+/// push may give it the room of a small title, and a title that doesn't fold into the list has nothing to follow yet.
+/// The screen's view gets the place of `screenInPop:list:inlineInRow:`, at rest at `top`, the top of the safe area the
+/// screen takes on the stack (`stackTop` the stack's own), and the bar follows it until the screen appeared, also over
+/// a main list. Called before UIKit's push.
+- (void)screenInPush:(ANNNavigationOptions *)options
+                list:(nullable UIScrollView *)list
+         inlineInRow:(BOOL)inlineInRow
+                 top:(CGFloat)top
+            stackTop:(CGFloat)stackTop;
+
 /// The screen went without appearing (a swipe back given up): the place of the title of the pop goes, and the bar
 /// follows what it followed before.
 - (void)screenDidDisappear:(ANNNavigationOptions *)options list:(nullable UIScrollView *)list;

package/ios/TopBar/ANNLargeTitlePresenter.mm

@@ -3,6 +3,13 @@
 #import "ANNBarAppearance.h"
 #import "ANNMainList.h"
 #import "ANNScreenBars.h"
+#import "ANNTabsDesign.h"
+
+// The glass design of iOS 26 draws the large title inside the list the bar follows: the places, fills and bands of
+// this file are for it. The compatibility mode keeps the title in the bar, as before iOS 26 (`ANNTabsDesign`).
+static BOOL ANNTitleInList(void) {
+    return ANNTabsDesign.isGlass;
+}
 
 // How far the color reaches above the list's content: as far as a pull can show.
 static const CGFloat ANNListFillHeight = 2000;
@@ -37,9 +44,11 @@ static UINavigationItemLargeTitleDisplayMode ANNItemModeOf(NSString *mode) {
     // The push from a lower bar whose fill is pending: the old bar's bottom in the screen's coordinates.
     BOOL _titlePlacePending;
     CGFloat _oldBarBottom;
-    // The place of the title while a pop reveals the screen, and whether the bar follows it now.
+    // The place of the title while a pop reveals the screen, and whether the bar follows it now; for a push, the bar
+    // follows it until the screen appeared, also with a main list.
     UIScrollView *_titleHost;
     BOOL _hostsTitle;
+    BOOL _hostsPushTitle;
     // The largest room the bar took over the content while the screen showed at rest: that of an expanded title.
     CGFloat _expandedRoom;
 }
@@ -56,10 +65,8 @@ static UINavigationItemLargeTitleDisplayMode ANNItemModeOf(NSString *mode) {
         ![options.topBar.largeTitle.collapseOnScroll withDefault:YES]) {
         return NO;
     }
-    if (@available(iOS 26.0, *)) {
-        if (ANNAppDirection.reactNativeIsRightToLeft) {
-            return NO;
-        }
+    if (ANNTitleInList() && ANNAppDirection.reactNativeIsRightToLeft) {
+        return NO;
     }
     return YES;
 }
@@ -99,13 +106,15 @@ static UINavigationItemLargeTitleDisplayMode ANNItemModeOf(NSString *mode) {
     if (followed != _emptyScrollView) {
         _emptyScrollView = nil;
     }
-    // The place of a pop's title holds while the title can show and no main list at the top takes it over.
+    // The place of a pop's title holds while the title can show and no main list at the top takes it over; that of a
+    // push, while the title can show.
     BOOL dropsHost = NO;
     if (_hostsTitle) {
-        if (canShow && (!collapses || !list)) {
+        if (canShow && (_hostsPushTitle || !collapses || !list)) {
             followed = _titleHost;
         } else {
             _hostsTitle = NO;
+            _hostsPushTitle = NO;
             dropsHost = YES;
         }
     }
@@ -128,6 +137,9 @@ static UINavigationItemLargeTitleDisplayMode ANNItemModeOf(NSString *mode) {
 - (void)screenInPop:(ANNNavigationOptions *)options
                list:(UIScrollView *)list
         inlineInRow:(BOOL)inlineInRow {
+    if (!ANNTitleInList()) {
+        return;
+    }
     if (@available(iOS 26.0, *)) {
         UIViewController *screen = _screen;
         UIView *screenView = screen.viewIfLoaded;
@@ -159,6 +171,26 @@ static UINavigationItemLargeTitleDisplayMode ANNItemModeOf(NSString *mode) {
     }
 }
 
+- (void)screenInPush:(ANNNavigationOptions *)options
+                list:(UIScrollView *)list
+         inlineInRow:(BOOL)inlineInRow
+                 top:(CGFloat)top
+            stackTop:(CGFloat)stackTop {
+    if (!ANNTitleInList()) {
+        return;
+    }
+    if (@available(iOS 26.0, *)) {
+        UIView *screenView = _screen.viewIfLoaded;
+        if (!screenView || inlineInRow || !ANNLargeTitleCanShow(options) || top - stackTop <= 0) {
+            return;
+        }
+        [self placeTitleHostIn:screenView top:top];
+        _hostsTitle = YES;
+        _hostsPushTitle = YES;
+        [self applyCollapse:options list:list];
+    }
+}
+
 // A plain scroll view over the whole screen, at rest at its top under the bar (its content starts at `top`, where the
 // content of the screen started as it was covered): UIKit puts the title just above that start, where the bar's title
 // is at rest. It takes no touches and draws nothing itself; the core's search of the screen's list skips it.
@@ -195,6 +227,7 @@ static UINavigationItemLargeTitleDisplayMode ANNItemModeOf(NSString *mode) {
 - (void)handBackTitle:(ANNNavigationOptions *)options list:(UIScrollView *)list {
     BOOL hosted = _hostsTitle;
     _hostsTitle = NO;
+    _hostsPushTitle = NO;
     [self applyCollapse:options list:list];
     if (hosted) {
         [_titleHost removeFromSuperview];
@@ -252,6 +285,7 @@ static UINavigationItemLargeTitleDisplayMode ANNItemModeOf(NSString *mode) {
 
 - (void)removeTitleHost {
     _hostsTitle = NO;
+    _hostsPushTitle = NO;
     [_titleHost removeFromSuperview];
 }
 
@@ -259,6 +293,9 @@ static UINavigationItemLargeTitleDisplayMode ANNItemModeOf(NSString *mode) {
                   list:(UIScrollView *)list
            inlineInRow:(BOOL)inlineInRow
    backgroundComponent:(BOOL)backgroundComponent {
+    if (!ANNTitleInList()) {
+        return;
+    }
     if (@available(iOS 26.0, *)) {
         UIViewController *screen = _screen;
         UIColor *fill = [ANNBarAppearance solidColorOf:options.topBar.background.color
@@ -297,6 +334,9 @@ static UINavigationItemLargeTitleDisplayMode ANNItemModeOf(NSString *mode) {
 - (void)fillTitlePlaceFrom:(CGFloat)oldBarBottom
                       list:(UIScrollView *)list
                    options:(ANNNavigationOptions *)options {
+    if (!ANNTitleInList()) {
+        return;
+    }
     if (@available(iOS 26.0, *)) {
         [self removeTitlePlaceFill];
         if (!ANNLargeTitleCanShow(options) || [ANNLargeTitlePresenter collapsesIntoList:options]) {
@@ -311,6 +351,9 @@ static UINavigationItemLargeTitleDisplayMode ANNItemModeOf(NSString *mode) {
 // The pushed screen's content may render only during the push, so its list mounts later than the push starts: the
 // fill is placed again at each mount and layout until the screen appeared.
 - (void)updateTitlePlaceFill:(ANNNavigationOptions *)options list:(UIScrollView *)list {
+    if (!ANNTitleInList()) {
+        return;
+    }
     if (@available(iOS 26.0, *)) {
         UIViewController *screen = _screen;
         UIView *screenView = screen.viewIfLoaded;

package/ios/TopBar/ANNMainList.h

@@ -23,6 +23,9 @@ NS_ASSUME_NONNULL_BEGIN
 /// search takes it, or what is in it, for the screen's list.
 + (void)excludeView:(UIView *)view;
 
+/// The view is one of those (`excludeView:`).
++ (BOOL)isExcludedView:(UIView *)view;
+
 @end
 
 NS_ASSUME_NONNULL_END

package/ios/TopBar/ANNMainList.mm

@@ -22,6 +22,10 @@ static const CGFloat ANNMainListTolerance = 1;
     objc_setAssociatedObject(view, ANNMainListExcludedKey, @YES, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
 }
 
++ (BOOL)isExcludedView:(UIView *)view {
+    return objc_getAssociatedObject(view, ANNMainListExcludedKey) != nil;
+}
+
 - (UIScrollView *)keptList {
     UIScrollView *list = _list;
     UIView *screenView = _screenView;

package/ios/TopBar/ANNScrollEdgeEffects.h

@@ -5,9 +5,12 @@ NS_ASSUME_NONNULL_BEGIN
 
 /// The scroll edge effect of a screen's lists (iOS 26; `scrollEdgeEffect.*`): each edge's own `hidden` / `style` beat
 /// the general ones, through the public API. No top effect under a solid `background.color` (not a clear one) or
-/// `background.component` unless the screen set its own for the top or for all edges. The screen remembers the lists it
-/// set and gives them the system values back (`hidden` NO, `style` automatic) before its content goes and when it
-/// leaves, and sets them again at its appearance. Before iOS 26 nothing. Main queue.
+/// `background.component` unless the screen set its own for the top or for all edges. The lists are the scroll views
+/// of the screen's view down to 16 levels, outside hidden views (`display: none`), not inside a list that scrolls
+/// vertically (its rows) or a text view; a scroll view that doesn't (a pager, a carousel) is looked into for its
+/// lists. The screen remembers the lists it set and gives them the system values back when it leaves, at its destroy
+/// and when they leave its view for no screen (Fabric's pool; in another screen they may be that screen's already).
+/// Before iOS 26 nothing. Main queue.
 @interface ANNScrollEdgeEffects : NSObject
 
 - (instancetype)initWithScreenView:(UIView *)screenView;
@@ -15,13 +18,26 @@ NS_ASSUME_NONNULL_BEGIN
 - (instancetype)init NS_UNAVAILABLE;
 + (instancetype)new NS_UNAVAILABLE;
 
-/// At the appearance and at a merge: every scroll view in the screen's view, set again whole.
+/// At the appearance and at a merge: the lists of the screen's view, set again whole. Without a walk (only the known
+/// lists still in the view set again) when the options it reads and the traits are the same as at the last walk and
+/// no content mounted since, while the screen's content tells all its mounts (`mountsReported`) and that walk found
+/// no pager.
 - (void)applyToAllWithOptions:(ANNNavigationOptions *)options;
 
-/// After a mount of the content: the main list only; lists React took out of the screen get the system values.
+/// The screen's content tells each of its mounts, also out of the window (a React root): without it every call walks
+/// the view.
+@property(nonatomic) BOOL mountsReported;
+
+/// After a mount of the content: the main list only; lists React took out of the screen get the system values, and
+/// the next `applyToAllWithOptions:` walks the view again.
 - (void)applyToList:(nullable UIScrollView *)list options:(ANNNavigationOptions *)options;
 
-/// The lists set get the system values back (the screen leaves, its content goes, its destroy).
+/// The screen left: its lists get the system values back (a list Fabric recycles from it comes clean), and stay
+/// known for its next appearance.
+- (void)screenDidDisappear;
+
+/// The lists set get the system values back and are forgotten (the screen's content goes, its destroy); the next
+/// `applyToAllWithOptions:` walks the view again.
 - (void)reset;
 
 @end

package/ios/TopBar/ANNScrollEdgeEffects.mm

@@ -1,5 +1,16 @@
 #import "ANNScrollEdgeEffects.h"
 #import "ANNBarAppearance.h"
+#import "ANNMainList.h"
+
+// How deep the walk looks for lists, as the main list's search.
+static const NSUInteger ANNEdgeWalkMaxDepth = 16;
+static const CGFloat ANNEdgeWalkTolerance = 1;
+
+// A list that scrolls (or bounces) vertically: what is in it is its rows, which never meet a bar themselves.
+static BOOL ANNScrollsVertically(UIScrollView *list) {
+    return list.alwaysBounceVertical ||
+           list.contentSize.height > CGRectGetHeight(list.bounds) + ANNEdgeWalkTolerance;
+}
 
 // What one edge gets: whether it is hidden and its style; `nil` style is automatic.
 typedef struct {
@@ -18,6 +29,11 @@ static ANNEdgeEffect ANNEdgeEffectOf(ANNScrollEdgeEffectOptions *effect,
 @implementation ANNScrollEdgeEffects {
     __weak UIView *_screenView;
     NSHashTable<UIScrollView *> *_lists;
+    // What the last walk read (nil: walk at the next call), and whether content mounted since or the walk found a
+    // scroll view whose lists come and go without a mount (a pager's pages).
+    NSArray *_walkInputs;
+    BOOL _mountedSinceWalk;
+    BOOL _walkFoundPager;
 }
 
 - (instancetype)initWithScreenView:(UIView *)screenView {
@@ -30,46 +46,137 @@ static ANNEdgeEffect ANNEdgeEffectOf(ANNScrollEdgeEffectOptions *effect,
 
 - (void)applyToAllWithOptions:(ANNNavigationOptions *)options {
     if (@available(iOS 26.0, *)) {
-        [self reset];
         UIView *screenView = _screenView;
-        if (screenView) {
-            [self applyIn:screenView options:options];
+        if (!screenView) {
+            [self reset];
+            return;
+        }
+        NSArray *inputs = [self inputsOf:options traits:screenView.traitCollection];
+        [self dropListsOutside:screenView];
+        // The lists are the same as at the last walk: they take the values again (the screen gave them the system
+        // ones as it went), without a walk.
+        if (_walkInputs && _mountsReported && !_mountedSinceWalk && !_walkFoundPager &&
+            ANNOptionValuesSame(_walkInputs, inputs)) {
+            for (UIScrollView *list in _lists.allObjects) {
+                [self apply:options to:list];
+            }
+            return;
+        }
+        NSMutableArray<UIScrollView *> *found = [NSMutableArray new];
+        BOOL pager = NO;
+        [self collectIn:screenView depth:0 into:found pager:&pager];
+        // The screen's lists that the walk no longer finds get the system values; the others are set again.
+        for (UIScrollView *kept in _lists.allObjects) {
+            if ([found indexOfObjectIdenticalTo:kept] == NSNotFound) {
+                [ANNScrollEdgeEffects resetList:kept];
+                [_lists removeObject:kept];
+            }
+        }
+        for (UIScrollView *list in found) {
+            [self apply:options to:list];
         }
+        _walkInputs = inputs;
+        _mountedSinceWalk = NO;
+        _walkFoundPager = pager;
     }
 }
 
-- (void)applyIn:(UIView *)view options:(ANNNavigationOptions *)options API_AVAILABLE(ios(26.0)) {
+// What the effects of a list read: the effect's options, the bar's background (a solid one hides the top), the traits
+// a clear color is told by.
+- (NSArray *)inputsOf:(ANNNavigationOptions *)options traits:(UITraitCollection *)traits {
+    ANNTopBarBackgroundOptions *background = options.topBar.background;
+    return @[
+        options.scrollEdgeEffect, background.color, background.component.name,
+        @(traits.userInterfaceStyle), @(traits.accessibilityContrast)
+    ];
+}
+
+// The lists of `view`, bounded as the main list's search: hidden views (`display: none`) and the core's own views are
+// left out with what is in them. A view at alpha 0 is not: an animation (a fade in, a transition) changes it without a
+// mount. A list that scrolls vertically and a text view are set, not looked into; a scroll view that doesn't is looked
+// into for the lists of its pages, and such a walk is never skipped.
+- (void)collectIn:(UIView *)view
+            depth:(NSUInteger)depth
+             into:(NSMutableArray<UIScrollView *> *)found
+            pager:(BOOL *)pager {
+    if (depth > ANNEdgeWalkMaxDepth) {
+        return;
+    }
     for (UIView *subview in view.subviews) {
+        if (subview.hidden || [ANNMainList isExcludedView:subview]) {
+            continue;
+        }
         if ([subview isKindOfClass:UIScrollView.class]) {
-            [self apply:options to:(UIScrollView *)subview];
+            UIScrollView *list = (UIScrollView *)subview;
+            [found addObject:list];
+            if ([list isKindOfClass:UITextView.class] || ANNScrollsVertically(list)) {
+                continue;
+            }
+            *pager = YES;
         }
-        [self applyIn:subview options:options];
+        [self collectIn:subview depth:depth + 1 into:found pager:pager];
     }
 }
 
 - (void)applyToList:(UIScrollView *)list options:(ANNNavigationOptions *)options {
+    _mountedSinceWalk = YES;
     if (@available(iOS 26.0, *)) {
-        // Lists React took out of the screen (and gave to another one) get the system values now.
-        UIView *screenView = _screenView;
-        for (UIScrollView *kept in _lists.allObjects) {
-            if (!screenView || ![kept isDescendantOfView:screenView]) {
-                [ANNScrollEdgeEffects resetList:kept];
-                [_lists removeObject:kept];
-            }
-        }
+        [self dropListsOutside:_screenView];
         if (list) {
             [self apply:options to:list];
         }
     }
 }
 
-- (void)reset {
+// Whether `view` is in some screen: one of its views is the view of a view controller, in a window or not. A list in
+// Fabric's pool is not: its component view (the list's own superview) has no superview there.
+static BOOL ANNIsInAScreen(UIView *view) {
+    for (UIView *ancestor = view; ancestor; ancestor = ancestor.superview) {
+        if ([ancestor.nextResponder isKindOfClass:UIViewController.class]) {
+            return YES;
+        }
+    }
+    return NO;
+}
+
+// A list React took out of the screen is no longer the screen's: outside every screen (in the pool Fabric recycles
+// its views from, shared by every surface) it gets the system values, so it comes clean into the screen that takes it;
+// in another screen it may be that screen's already, which set its values: it is only forgotten.
+- (void)dropListsOutside:(nullable UIView *)screenView {
+    for (UIScrollView *kept in _lists.allObjects) {
+        if (screenView && [kept isDescendantOfView:screenView]) {
+            continue;
+        }
+        if (@available(iOS 26.0, *)) {
+            if (!ANNIsInAScreen(kept)) {
+                [ANNScrollEdgeEffects resetList:kept];
+            }
+        }
+        [_lists removeObject:kept];
+    }
+}
+
+// The screen's lists get the system values; with `keepingLists` they stay known, with what the last walk read, for
+// the next appearance to set them again without a walk.
+- (void)giveBackKeepingLists:(BOOL)keepingLists {
+    [self dropListsOutside:_screenView];
     if (@available(iOS 26.0, *)) {
         for (UIScrollView *list in _lists.allObjects) {
             [ANNScrollEdgeEffects resetList:list];
         }
     }
-    [_lists removeAllObjects];
+    if (!keepingLists) {
+        [_lists removeAllObjects];
+        _walkInputs = nil;
+    }
+}
+
+- (void)screenDidDisappear {
+    [self giveBackKeepingLists:YES];
+}
+
+- (void)reset {
+    [self giveBackKeepingLists:NO];
 }
 
 + (void)resetList:(UIScrollView *)list API_AVAILABLE(ios(26.0)) {