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

package/ios/TopBar/ANNBarAppearance.mm

@@ -1,5 +1,12 @@
 #import "ANNBarAppearance.h"
 #import "ANNBackButtonPresenter.h"
+#import "ANNTabsDesign.h"
+#import <objc/runtime.h>
+
+// The icon an indicator was tinted from: an entry found by the icon's address counts only for that icon. An indicator
+// that is the icon itself (already an original image) carries nothing: the icon must not hold itself, and it may be
+// the image the options' cache keeps.
+static const void *ANNIndicatorIconKey = &ANNIndicatorIconKey;
 
 // UIKit's fonts of the places the options build over: the title of the row, the large title, the text of the back
 // button.
@@ -28,6 +35,27 @@ static BOOL ANNIsClear(UIColor *color, UITraitCollection *traits) {
     return CGColorGetAlpha([color resolvedColorWithTraitCollection:traits].CGColor) == 0;
 }
 
+// The images the looks are made of, by what they are drawn from, so a look filled again from the same options is
+// equal to the one before (UIKit compares appearances by value, images by identity) and nothing is set again. Main
+// queue; a memory warning empties it.
+static NSCache<id, UIImage *> *ANNLookImages(void) {
+    static NSCache<id, UIImage *> *images;
+    static dispatch_once_t once;
+    dispatch_once(&once, ^{
+      images = [NSCache new];
+      images.countLimit = 64;
+    });
+    return images;
+}
+
+// A color of the options as a key: a pair by its sides (its dynamic color is made anew), else its value.
+static NSArray *ANNColorKeyOf(Color *color) {
+    if (color.light || color.dark) {
+        return @[ color.light ?: NSNull.null, color.dark ?: NSNull.null ];
+    }
+    return @[ color.value ?: NSNull.null ];
+}
+
 static NSDictionary<NSAttributedStringKey, id> *ANNTextAttributes(ANNFontOptions *font,
                                                                  Color *color,
                                                                  UIFont *placeFont) {
@@ -104,16 +132,14 @@ static NSDictionary<NSAttributedStringKey, id> *ANNTextAttributes(ANNFontOptions
     return resolved && !ANNIsClear(resolved, traits) ? resolved : nil;
 }
 
+// The glass bar is translucent by default; the design before iOS 26 (and its compatibility mode) opaque.
 + (BOOL)translucentByDefault {
-    if (@available(iOS 26.0, *)) {
-        return YES;
-    }
-    return NO;
+    return ANNTabsDesign.isGlass;
 }
 
-// `color` beats `blur` and `translucent`; a clear color is a clear bar. On iOS 26 a color is a solid bar: a clear base
-// with the color and a 1×1 image of it, without the system effect. `blur` is the system's chrome material on a clear
-// base, with no view of its own in the bar.
+// `color` beats `blur` and `translucent`; a clear color is a clear bar. On the glass of iOS 26 a color is a solid
+// bar: a clear base with the color and a 1×1 image of it, without the system effect. `blur` is the system's chrome
+// material on a clear base, with no view of its own in the bar.
 + (void)configure:(UINavigationBarAppearance *)appearance
             color:(UIColor *)color
              blur:(BOOL)blur
@@ -124,7 +150,7 @@ static NSDictionary<NSAttributedStringKey, id> *ANNTextAttributes(ANNFontOptions
             [appearance configureWithTransparentBackground];
             return;
         }
-        if (@available(iOS 26.0, *)) {
+        if (ANNTabsDesign.isGlass) {
             [appearance configureWithTransparentBackground];
             appearance.backgroundEffect = nil;
             appearance.backgroundColor = color;
@@ -219,23 +245,51 @@ static NSDictionary<NSAttributedStringKey, id> *ANNTextAttributes(ANNFontOptions
         if (!color) {
             return nil;
         }
-        icon = [UIImage systemImageNamed:@"chevron.backward"];
+        symbol = @"chevron.backward";
+        icon = [UIImage systemImageNamed:symbol];
         isSymbol = YES;
     }
+    // A symbol by its name; an image by its object, which the entry keeps, so its address is never another's.
+    id iconKey = isSymbol ? symbol : [NSValue valueWithNonretainedObject:icon];
+    NSArray *key = @[
+        @"back", iconKey, color ? ANNColorKeyOf(backButton.color) : NSNull.null
+    ];
+    NSCache<id, UIImage *> *images = ANNLookImages();
+    UIImage *cached = [images objectForKey:key];
+    if (cached && (isSymbol || cached == icon ||
+                   objc_getAssociatedObject(cached, ANNIndicatorIconKey) == icon)) {
+        return cached;
+    }
+    UIImage *indicator = nil;
     if (color) {
-        return [icon imageWithTintColor:color renderingMode:UIImageRenderingModeAlwaysOriginal];
+        indicator = [icon imageWithTintColor:color
+                               renderingMode:UIImageRenderingModeAlwaysOriginal];
+    } else {
+        indicator =
+            isSymbol ? icon : [icon imageWithRenderingMode:UIImageRenderingModeAlwaysOriginal];
+    }
+    if (!isSymbol && indicator != icon) {
+        objc_setAssociatedObject(indicator, ANNIndicatorIconKey, icon,
+                                 OBJC_ASSOCIATION_RETAIN_NONATOMIC);
     }
-    return isSymbol ? icon : [icon imageWithRenderingMode:UIImageRenderingModeAlwaysOriginal];
+    [images setObject:indicator forKey:key];
+    return indicator;
 }
 
+// One for the app: every look that hides the arrow holds the same image.
 + (UIImage *)emptyIndicator {
-    UIGraphicsImageRendererFormat *format = [UIGraphicsImageRendererFormat preferredFormat];
-    format.opaque = NO;
-    UIGraphicsImageRenderer *renderer =
-        [[UIGraphicsImageRenderer alloc] initWithSize:CGSizeMake(1, 1) format:format];
-    UIImage *empty = [renderer imageWithActions:^(UIGraphicsImageRendererContext *context){
-    }];
-    return [empty imageWithRenderingMode:UIImageRenderingModeAlwaysOriginal];
+    static UIImage *empty;
+    static dispatch_once_t once;
+    dispatch_once(&once, ^{
+      UIGraphicsImageRendererFormat *format = [UIGraphicsImageRendererFormat preferredFormat];
+      format.opaque = NO;
+      UIGraphicsImageRenderer *renderer =
+          [[UIGraphicsImageRenderer alloc] initWithSize:CGSizeMake(1, 1) format:format];
+      UIImage *drawn = [renderer imageWithActions:^(UIGraphicsImageRendererContext *context){
+      }];
+      empty = [drawn imageWithRenderingMode:UIImageRenderingModeAlwaysOriginal];
+    });
+    return empty;
 }
 
 + (UIColor *)pinnedTitleColor:(Color *)color traits:(UITraitCollection *)traits {
@@ -244,8 +298,44 @@ static NSDictionary<NSAttributedStringKey, id> *ANNTextAttributes(ANNFontOptions
 }
 
 // The 1×1 picture of the color in both styles: the bar's image view picks the variant of its own style, so a `{ light,
-// dark }` color follows a switch of the style without a new appearance.
+// dark }` color follows a switch of the style without a new appearance. Made once for the two resolved colors and the
+// style picked.
 + (UIImage *)imageOfColor:(UIColor *)color traits:(UITraitCollection *)traits {
+    UITraitCollection *light =
+        [UITraitCollection traitCollectionWithUserInterfaceStyle:UIUserInterfaceStyleLight];
+    UITraitCollection *dark =
+        [UITraitCollection traitCollectionWithUserInterfaceStyle:UIUserInterfaceStyleDark];
+    // Each variant is drawn with the window's other traits (contrast, elevation) and registered by its style only.
+    NSArray<UITraitCollection *> *base = traits ? @[ traits ] : @[];
+    UITraitCollection *lightTraits = [UITraitCollection
+        traitCollectionWithTraitsFromCollections:[base arrayByAddingObject:light]];
+    UITraitCollection *darkTraits = [UITraitCollection
+        traitCollectionWithTraitsFromCollections:[base arrayByAddingObject:dark]];
+    UIColor *lightColor = [color resolvedColorWithTraitCollection:lightTraits];
+    UIColor *darkColor = [color resolvedColorWithTraitCollection:darkTraits];
+    BOOL isDark = traits.userInterfaceStyle == UIUserInterfaceStyleDark;
+    NSArray *key = @[ @"color", lightColor, darkColor, @(isDark) ];
+    NSCache<id, UIImage *> *images = ANNLookImages();
+    UIImage *cached = [images objectForKey:key];
+    if (cached) {
+        return cached;
+    }
+    UIImage *image = [self drawImageOf:color
+                                 light:light
+                                  dark:dark
+                           lightTraits:lightTraits
+                            darkTraits:darkTraits
+                                isDark:isDark];
+    [images setObject:image forKey:key];
+    return image;
+}
+
++ (UIImage *)drawImageOf:(UIColor *)color
+                   light:(UITraitCollection *)light
+                    dark:(UITraitCollection *)dark
+             lightTraits:(UITraitCollection *)lightTraits
+              darkTraits:(UITraitCollection *)darkTraits
+                  isDark:(BOOL)isDark {
     UIImage * (^draw)(UITraitCollection *) = ^UIImage *(UITraitCollection *variant) {
       UIColor *resolved = [color resolvedColorWithTraitCollection:variant];
       UIGraphicsImageRendererFormat *format = [UIGraphicsImageRendererFormat preferredFormat];
@@ -257,20 +347,11 @@ static NSDictionary<NSAttributedStringKey, id> *ANNTextAttributes(ANNFontOptions
         [context fillRect:CGRectMake(0, 0, 1, 1)];
       }];
     };
-    UITraitCollection *light =
-        [UITraitCollection traitCollectionWithUserInterfaceStyle:UIUserInterfaceStyleLight];
-    UITraitCollection *dark =
-        [UITraitCollection traitCollectionWithUserInterfaceStyle:UIUserInterfaceStyleDark];
-    // Each variant is drawn with the window's other traits (contrast, elevation) and registered by its style only.
-    NSArray<UITraitCollection *> *base = traits ? @[ traits ] : @[];
-    UIImage *lightImage =
-        draw([UITraitCollection traitCollectionWithTraitsFromCollections:[base arrayByAddingObject:light]]);
-    UIImage *darkImage =
-        draw([UITraitCollection traitCollectionWithTraitsFromCollections:[base arrayByAddingObject:dark]]);
+    UIImage *lightImage = draw(lightTraits);
+    UIImage *darkImage = draw(darkTraits);
     UIImageAsset *asset = [UIImageAsset new];
     [asset registerImage:lightImage withTraitCollection:light];
     [asset registerImage:darkImage withTraitCollection:dark];
-    BOOL isDark = traits.userInterfaceStyle == UIUserInterfaceStyleDark;
     UIImage *picked = [asset imageWithTraitCollection:isDark ? dark : light];
     return picked ?: (isDark ? darkImage : lightImage);
 }

package/ios/TopBar/ANNBarBackgroundComponent.mm

@@ -1,4 +1,5 @@
 #import "ANNBarBackgroundComponent.h"
+#import <React/RCTLog.h>
 #import <objc/runtime.h>
 
 // The background a bar shows now.
@@ -13,6 +14,21 @@ static UIView *ANNBackgroundHostOf(UINavigationBar *bar) {
             return subview;
         }
     }
+#if DEBUG
+    // The name is UIKit's private one: a system that renames the view puts the components on the bar itself. Told
+    // once, in development, and only for a bar that has its views already (one not laid out yet has none).
+    static BOOL told = NO;
+    if (!told && bar.subviews.count > 0) {
+        told = YES;
+        NSMutableArray<NSString *> *names = [NSMutableArray new];
+        for (UIView *subview in bar.subviews) {
+            [names addObject:NSStringFromClass(subview.class)];
+        }
+        RCTLogWarn(@"[ApexNavigation] the bar has no view named …BarBackground, so a background "
+                   @"component goes on the bar itself at index 1; its views: %@",
+                   [names componentsJoinedByString:@", "]);
+    }
+#endif
     return bar;
 }
 

package/ios/TopBar/ANNBarButtonComponentView.h

@@ -4,10 +4,10 @@
 NS_ASSUME_NONNULL_BEGIN
 
 /// The slot of a React button (`topBar.leftButtons[].component`) as the custom view of its bar item. It takes a content
-/// view (`UIView<ANNComponentProtocol>`), never a class of the roots. On iOS 26 without `UIDesignRequiresCompatibility`
-/// in the app's Info.plist the slot is 44 pt high and as wide as the content, at least 44 pt; the width follows the
-/// content both ways (measured after every mount; a change over 0.5 pt only), and the slot's constraints live with the
-/// view, so a new item built around it reuses them. With that key and before iOS 26: the content's size, no
+/// view (`UIView<ANNComponentProtocol>`), never a class of the roots. In the glass design of iOS 26 (`ANNTabsDesign`)
+/// the slot is 44 pt high and as wide as the content, at least 44 pt; the width follows the content both ways
+/// (measured after every mount; a change over 0.5 pt only), and the slot's constraints live with the view, so a new
+/// item built around it reuses them. In the compatibility mode and before iOS 26: the content's size, no
 /// constraints. A button rendered before the screen shows enters at its width. The core measures only the surface and
 /// never moves the views inside it: the JS wrapper centres them.
 @interface ANNBarButtonComponentView : UIView

package/ios/TopBar/ANNBarButtonComponentView.mm

@@ -7,7 +7,7 @@ static const CGFloat ANNBarButtonSlotHeight = 44;
 static const CGFloat ANNBarButtonSlotMinimumWidth = 44;
 static const CGFloat ANNBarButtonWidthTolerance = 0.5;
 
-// The slot of iOS 26's bar: unless the app keeps the earlier design (`UIDesignRequiresCompatibility`).
+// The slot of iOS 26's bar: unless UIKit keeps the earlier design for the app (`ANNTabsDesign`).
 static BOOL ANNUsesSlotConstraints(void) {
     return ANNTabsDesign.isGlass;
 }

package/ios/TopBar/ANNBarButtons.h

@@ -14,8 +14,9 @@ typedef NS_ENUM(NSInteger, ANNBarButtonsSide) {
 
 /// The buttons of one screen's bar and toolbar (`topBar.leftButtons[].*`, the side options, `overflowMenu`,
 /// `toolbar.buttons`): built from the resolved options, whole, at the screen's creation, at each appearance and at a
-/// merge of a side. Each button is an `ANNUIBarButtonItem` of the first kind its fields give (React view → icon and
-/// text → image button → SF Symbol → image → text → system item); a button without `id` is not placed. Side colors go
+/// merge of a side, when anything the side's build reads changed or the item no longer holds what it put there.
+/// Each button is an `ANNUIBarButtonItem` of the first kind its fields give (React view → icon and text → image
+/// button → SF Symbol → image → text → system item); a button without `id` is not placed. Side colors go
 /// onto what is built, never into the options; what the user chose (a toggle, a menu's check) goes into the screen's
 /// user layer. The React buttons' slots are kept by component id, so a button built again reuses its slot. Main queue.
 @interface ANNBarButtons : NSObject
@@ -27,7 +28,8 @@ typedef NS_ENUM(NSInteger, ANNBarButtonsSide) {
 + (instancetype)new NS_UNAVAILABLE;
 
 /// Sets `side` of the screen's item (left, right, center) from `options`; `animated` fades new buttons in (a side set
-/// as groups changes at once).
+/// as groups changes at once). Nothing when the side's buttons, colors, loaded images, React roots and traits are the
+/// same as at its last build and the item still holds what that build set: iOS 26 animates even equal new items.
 - (void)applySide:(ANNBarButtonsSide)side
           options:(ANNNavigationOptions *)options
          animated:(BOOL)animated;

package/ios/TopBar/ANNBarButtons.mm

@@ -2,6 +2,7 @@
 #import "ANNBarButtonComponentView.h"
 #import "ANNIconButtonImage.h"
 #import "ANNShowTextButton.h"
+#import "ANNTabsDesign.h"
 #import "ANNUIBarButtonItem.h"
 #import "ANNUserChoice.h"
 #import "UIViewController+LayoutProtocol.h"
@@ -301,6 +302,27 @@ static BOOL ANNHasComponent(ANNButtonOptions *button) {
            [button.component.componentId withDefault:nil].length > 0;
 }
 
+// The image an icon loads, for telling builds apart (NSNull without one): a source of a file, data or Metro's server
+// loads through the shared cache, which gives the same image until the file at its path changes or a failed load
+// succeeds. An SF Symbol is the system's: its name in the options says it all.
+static id ANNLoadedImageOf(Image *icon) {
+    ANNImageSource *source = icon.source;
+    if (!icon.hasValue || (source && source.kind == ANNImageSourceKindSymbol)) {
+        return NSNull.null;
+    }
+    return [icon withDefault:nil] ?: NSNull.null;
+}
+
+// The images the items of a menu load (an item with `sfSymbol` shows the symbol), at any depth.
+static void ANNAddMenuImages(NSArray<ANNMenuItemOptions *> *items, NSMutableArray *loaded) {
+    for (ANNMenuItemOptions *item in items) {
+        if (!item.sfSymbol.hasValue) {
+            [loaded addObject:ANNLoadedImageOf(item.icon)];
+        }
+        ANNAddMenuImages(item.items, loaded);
+    }
+}
+
 // The image button's background: its own `iconBackground.color`, else (only for an image icon) the side's.
 static UIColor *ANNIconBackgroundOf(ANNButtonOptions *button, Color *sideBackground) {
     UIColor *own = ANNColorOf(button.iconBackground.color);
@@ -394,6 +416,60 @@ static UIBarButtonSystemItem ANNSystemItemOf(NSString *name) {
 @implementation ANNButtonPress
 @end
 
+// The same objects, one by one: what a build read by identity (a loaded image, a React button's slot) and what it put
+// on the navigation item. A string (the item's customization id) by its value.
+static BOOL ANNSameObjects(NSArray *a, NSArray *b) {
+    if (a.count != b.count) {
+        return NO;
+    }
+    for (NSUInteger index = 0; index < a.count; index++) {
+        id mine = a[index];
+        id theirs = b[index];
+        if (mine != theirs && !([mine isKindOfClass:NSString.class] && [mine isEqual:theirs])) {
+            return NO;
+        }
+    }
+    return YES;
+}
+
+// Everything the build of one side reads: the side's buttons, its colors and the customization id of the middle by
+// value; the images it loads and the slots of its React buttons by identity (a file written again at its path loads as
+// another image, a reload gives other roots); the traits it builds under (a text button's font follows the text size,
+// a drawn image the scale and the style).
+@interface ANNSideInputs : NSObject
+@property(nonatomic, strong, nullable) NSArray<ANNButtonOptions *> *buttons;
+@property(nonatomic, strong, nullable) Color *color;
+@property(nonatomic, strong, nullable) Color *disabledColor;
+@property(nonatomic, strong, nullable) Color *background;
+@property(nonatomic, strong, nullable) Text *customizationId;
+@property(nonatomic, copy) NSArray *loaded;
+@property(nonatomic, copy) NSArray *traits;
+@end
+
+@implementation ANNSideInputs
+
+- (BOOL)isSameAs:(ANNSideInputs *)other {
+    return ANNOptionValuesSame(_buttons, other.buttons) &&
+           ANNOptionValuesSame(_color, other.color) &&
+           ANNOptionValuesSame(_disabledColor, other.disabledColor) &&
+           ANNOptionValuesSame(_background, other.background) &&
+           ANNOptionValuesSame(_customizationId, other.customizationId) &&
+           ANNSameObjects(_loaded, other.loaded) && [_traits isEqualToArray:other.traits];
+}
+
+@end
+
+// The last build of one side: what it read and what the navigation item held right after it.
+@interface ANNSideBuild : NSObject
+@property(nonatomic, strong) ANNSideInputs *inputs;
+// The side went in as groups (`leadingItemGroups`, …), not as a list of items.
+@property(nonatomic) BOOL grouped;
+@property(nonatomic, copy) NSArray *placed;
+@end
+
+@implementation ANNSideBuild
+@end
+
 @implementation ANNBarButtons {
     __weak UIViewController *_screen;
     ANNReactComponentRegistry *_registry;
@@ -402,6 +478,8 @@ static UIBarButtonSystemItem ANNSystemItemOf(NSString *name) {
     NSMutableDictionary<NSString *, NSNumber *> *_selected;
     // What a press of each sender (an item, a button of an item) means.
     NSMapTable<id, ANNButtonPress *> *_presses;
+    // The last build of each side, by the side.
+    NSMutableDictionary<NSNumber *, ANNSideBuild *> *_builds;
 }
 
 - (instancetype)initWithScreen:(UIViewController *)screen
@@ -412,12 +490,16 @@ static UIBarButtonSystemItem ANNSystemItemOf(NSString *name) {
         _slots = [NSMutableDictionary new];
         _selected = [NSMutableDictionary new];
         _presses = [NSMapTable weakToStrongObjectsMapTable];
+        _builds = [NSMutableDictionary new];
     }
     return self;
 }
 
 #pragma mark - The sides
 
+// From iOS 26 UIKit animates any change of the bar's items, also to equal ones and with `animated:NO`: new items on
+// each appearance would morph, close an open menu and drop a pressed state. So a side is built again only when what
+// its build reads changed, or when the item no longer holds what the last build put there.
 - (void)applySide:(ANNBarButtonsSide)side
           options:(ANNNavigationOptions *)options
          animated:(BOOL)animated {
@@ -426,12 +508,92 @@ static UIBarButtonSystemItem ANNSystemItemOf(NSString *name) {
         return;
     }
     UINavigationItem *navigationItem = screen.navigationItem;
+    ANNSideInputs *inputs = [self inputsOfSide:side options:options];
+    ANNSideBuild *last = _builds[@(side)];
+    if (last && [last.inputs isSameAs:inputs]) {
+        NSArray *placed = [self placedOf:side grouped:last.grouped item:navigationItem];
+        if (ANNSameObjects(last.placed, placed)) {
+            return;
+        }
+    }
+    ANNSideBuild *build = [ANNSideBuild new];
+    build.inputs = inputs;
+    build.grouped = [self placeSide:side options:options item:navigationItem animated:animated];
+    build.placed = [self placedOf:side grouped:build.grouped item:navigationItem];
+    _builds[@(side)] = build;
+}
+
+- (ANNSideInputs *)inputsOfSide:(ANNBarButtonsSide)side options:(ANNNavigationOptions *)options {
+    ANNTopBarOptions *topBar = options.topBar;
+    ANNSideInputs *inputs = [ANNSideInputs new];
+    inputs.buttons = ANNButtonsOfSide(options, side);
+    inputs.color = ANNSideColor(topBar, side);
+    inputs.disabledColor = ANNSideDisabledColor(topBar, side);
+    inputs.background = ANNSideBackgroundColor(topBar, side);
+    inputs.customizationId = side == ANNBarButtonsSideCenter ? topBar.customizationId : nil;
+    NSMutableArray *loaded = [NSMutableArray new];
+    for (ANNButtonOptions *button in inputs.buttons ?: @[]) {
+        if (ANNHasComponent(button)) {
+            [loaded addObject:[self slotFor:button] ?: NSNull.null];
+        }
+        [loaded addObject:ANNLoadedImageOf(button.icon)];
+        ANNAddMenuImages(button.menu.items, loaded);
+    }
+    inputs.loaded = loaded;
+    UITraitCollection *traits = UITraitCollection.currentTraitCollection;
+    inputs.traits = @[
+        @(traits.userInterfaceStyle), @(traits.displayScale),
+        traits.preferredContentSizeCategory ?: @"", @(traits.legibilityWeight)
+    ];
+    return inputs;
+}
+
+// What the navigation item holds of `side` now, as the side's build put it there.
+- (NSArray *)placedOf:(ANNBarButtonsSide)side
+              grouped:(BOOL)grouped
+                 item:(UINavigationItem *)navigationItem {
+    NSMutableArray *placed = [NSMutableArray new];
+    BOOL left = side == ANNBarButtonsSideLeft;
+    switch (side) {
+        case ANNBarButtonsSideLeft:
+        case ANNBarButtonsSideRight: {
+            NSArray *shown =
+                left ? navigationItem.leftBarButtonItems : navigationItem.rightBarButtonItems;
+            if (@available(iOS 16.0, *)) {
+                if (grouped) {
+                    shown = left ? navigationItem.leadingItemGroups
+                                 : navigationItem.trailingItemGroups;
+                }
+                if (!left) {
+                    [placed addObject:navigationItem.pinnedTrailingGroup ?: NSNull.null];
+                }
+            }
+            [placed addObjectsFromArray:shown ?: @[]];
+            break;
+        }
+        case ANNBarButtonsSideCenter:
+            if (@available(iOS 16.0, *)) {
+                [placed addObjectsFromArray:navigationItem.centerItemGroups ?: @[]];
+                [placed addObject:navigationItem.customizationIdentifier ?: NSNull.null];
+            }
+            break;
+        case ANNBarButtonsSideToolbar:
+            break;
+    }
+    return placed;
+}
+
+// Builds `side` whole and puts it on the item; YES when it went in as groups.
+- (BOOL)placeSide:(ANNBarButtonsSide)side
+          options:(ANNNavigationOptions *)options
+             item:(UINavigationItem *)navigationItem
+         animated:(BOOL)animated {
     NSArray<ANNBuiltButton *> *built = [self buildSide:side options:options];
     if (side == ANNBarButtonsSideCenter) {
         if (@available(iOS 16.0, *)) {
             [self setCenter:built options:options item:navigationItem];
         }
-        return;
+        return YES;
     }
     NSMutableArray<ANNBuiltButton *> *placed = [built mutableCopy];
     if (side == ANNBarButtonsSideRight) {
@@ -440,26 +602,28 @@ static UIBarButtonSystemItem ANNSystemItemOf(NSString *name) {
         }
     }
     if (@available(iOS 26.0, *)) {
-        if ([self hasGroupOfSeveral:placed]) {
+        if (ANNTabsDesign.isGlass && [self hasGroupOfSeveral:placed]) {
             NSArray<UIBarButtonItemGroup *> *groups = [self groupsOf:placed];
             if (side == ANNBarButtonsSideLeft) {
                 navigationItem.leadingItemGroups = groups;
             } else {
                 navigationItem.trailingItemGroups = groups.reverseObjectEnumerator.allObjects;
             }
-            return;
+            return YES;
         }
     }
     NSMutableArray<UIBarButtonItem *> *items = [NSMutableArray new];
     for (ANNBuiltButton *button in placed) {
         if (@available(iOS 26.0, *)) {
             // Each button its own capsule: a zero-width space between neighbours, and the right ones never share the
-            // capsule of "•••".
-            if (items.count > 0) {
-                [items addObject:[UIBarButtonItem fixedSpaceItemOfWidth:0]];
-            }
-            if (side == ANNBarButtonsSideRight) {
-                button.item.sharesBackground = NO;
+            // capsule of "•••". The compatibility mode has no capsules.
+            if (ANNTabsDesign.isGlass) {
+                if (items.count > 0) {
+                    [items addObject:[UIBarButtonItem fixedSpaceItemOfWidth:0]];
+                }
+                if (side == ANNBarButtonsSideRight) {
+                    button.item.sharesBackground = NO;
+                }
             }
         }
         [items addObject:button.item];
@@ -469,6 +633,7 @@ static UIBarButtonSystemItem ANNSystemItemOf(NSString *name) {
     } else {
         [navigationItem setRightBarButtonItems:items animated:animated];
     }
+    return NO;
 }
 
 - (NSArray<ANNBuiltButton *> *)buildSide:(ANNBarButtonsSide)side
@@ -559,7 +724,7 @@ static UIBarButtonSystemItem ANNSystemItemOf(NSString *name) {
         NSMutableArray<UIBarButtonItem *> *items = [NSMutableArray new];
         for (ANNBuiltButton *button in run) {
             if (@available(iOS 26.0, *)) {
-                if (run.count == 1) {
+                if (run.count == 1 && ANNTabsDesign.isGlass) {
                     button.item.sharesBackground = NO;
                 }
             }
@@ -667,7 +832,7 @@ static UIBarButtonSystemItem ANNSystemItemOf(NSString *name) {
         BOOL icon = kind == ANNBarButtonKindSymbol || kind == ANNBarButtonKindImage ||
                     kind == ANNBarButtonKindImageButton || kind == ANNBarButtonKindShowText;
         NSString *group = icon ? [button.group withDefault:nil] : nil;
-        if (@available(iOS 26.0, *)) {
+        if (ANNTabsDesign.isGlass) {
             // Only icons of one group share a capsule (the toolbar has no groups): any other neighbours get a
             // zero-width space, unless a space of the options is there already.
             BOOL sameGroup = group.length > 0 && [group isEqualToString:previousIconGroup];
@@ -835,10 +1000,12 @@ static UIBarButtonSystemItem ANNSystemItemOf(NSString *name) {
     }
     BOOL prominent = [[button.style withDefault:nil] isEqualToString:@"prominent"];
     if (prominent) {
+        // The capsule of the glass; the design before it (and its compatibility mode) has the bold `done` style.
+        item.style = UIBarButtonItemStyleDone;
         if (@available(iOS 26.0, *)) {
-            item.style = UIBarButtonItemStyleProminent;
-        } else {
-            item.style = UIBarButtonItemStyleDone;
+            if (ANNTabsDesign.isGlass) {
+                item.style = UIBarButtonItemStyleProminent;
+            }
         }
     }
     // The color: the tint, and for a plain button also the text's; `prominent` takes it only into the tint, and a font
@@ -1021,9 +1188,11 @@ static UIBarButtonSystemItem ANNSystemItemOf(NSString *name) {
                  kind:(ANNBarButtonKind)kind
                    to:(UIBarButtonItem *)item {
     if (@available(iOS 26.0, *)) {
-        BOOL ownBackground =
-            kind == ANNBarButtonKindComponent || kind == ANNBarButtonKindImageButton;
-        item.hidesSharedBackground = [button.hideSharedBackground withDefault:ownBackground];
+        if (ANNTabsDesign.isGlass) {
+            BOOL ownBackground =
+                kind == ANNBarButtonKindComponent || kind == ANNBarButtonKindImageButton;
+            item.hidesSharedBackground = [button.hideSharedBackground withDefault:ownBackground];
+        }
     }
 #if __IPHONE_OS_VERSION_MAX_ALLOWED >= 270000
     if (@available(iOS 27.0, *)) {

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;
@@ -58,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;
 }
@@ -132,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;
@@ -168,6 +176,9 @@ static UINavigationItemLargeTitleDisplayMode ANNItemModeOf(NSString *mode) {
          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) {
@@ -282,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
@@ -320,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]) {
@@ -334,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;