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

package/ios/TopBar/ANNBarButtons.mm

@@ -2,7 +2,9 @@
 #import "ANNBarButtonComponentView.h"
 #import "ANNIconButtonImage.h"
 #import "ANNShowTextButton.h"
+#import "ANNTabsDesign.h"
 #import "ANNUIBarButtonItem.h"
+#import "ANNUserChoice.h"
 #import "UIViewController+LayoutProtocol.h"
 #import <React/RCTLog.h>
 
@@ -54,6 +56,187 @@ static void ANNSetButtonsOfSide(ANNNavigationOptions *options, ANNBarButtonsSide
     }
 }
 
+static ANNButtonOptions *ANNButtonWithId(NSArray<ANNButtonOptions *> *buttons, NSString *buttonId) {
+    for (ANNButtonOptions *button in buttons) {
+        if ([[button.identifier withDefault:nil] isEqualToString:buttonId]) {
+            return button;
+        }
+    }
+    return nil;
+}
+
+// The button `buttonId` of `side` in `options` changed on a copy, in a new list; nothing when the side has no such
+// button. The other buttons stay the objects they are: nothing changes them.
+static void ANNChangeButton(ANNNavigationOptions *options,
+                            ANNBarButtonsSide side,
+                            NSString *buttonId,
+                            void (^change)(ANNButtonOptions *changed)) {
+    NSArray<ANNButtonOptions *> *list = ANNButtonsOfSide(options, side);
+    if (!ANNButtonWithId(list, buttonId)) {
+        return;
+    }
+    NSMutableArray<ANNButtonOptions *> *changedList = [NSMutableArray arrayWithCapacity:list.count];
+    for (ANNButtonOptions *button in list) {
+        if ([[button.identifier withDefault:nil] isEqualToString:buttonId]) {
+            ANNButtonOptions *copy = [button copy];
+            change(copy);
+            [changedList addObject:copy];
+        } else {
+            [changedList addObject:button];
+        }
+    }
+    ANNSetButtonsOfSide(options, side, changedList);
+}
+
+#pragma mark - The user's choices
+
+static NSString *ANNToggleChoiceKey(ANNBarButtonsSide side, NSString *buttonId) {
+    return [NSString stringWithFormat:@"buttons.%ld.selected.%@", (long)side, buttonId];
+}
+
+static NSString *ANNButtonMenuChoiceKey(ANNBarButtonsSide side, NSString *buttonId) {
+    return [NSString stringWithFormat:@"buttons.%ld.menu.%@", (long)side, buttonId];
+}
+
+// The button `buttonId` of `side` in `options`, or nil.
+static ANNButtonOptions *ANNButtonIn(ANNNavigationOptions *options, ANNBarButtonsSide side,
+                                     NSString *buttonId) {
+    return ANNButtonWithId(ANNButtonsOfSide(options, side), buttonId);
+}
+
+// A toggle the user flipped: `selected` of the button with its id, wherever its list comes from. It goes when the
+// node's resolution after a merge has no such button, or when the merge gives the button a `selected` other than the
+// app had (the own button's, else the button the node resolved to before the merge), by the rules of a menu's check.
+static ANNUserChoice *ANNToggleChoice(ANNBarButtonsSide side, NSString *buttonId, BOOL selected) {
+    return [ANNUserChoice choiceWithValue:@(selected)
+        apply:^(ANNNavigationOptions *options, id value) {
+          BOOL on = [(NSNumber *)value boolValue];
+          ANNChangeButton(options, side, buttonId, ^(ANNButtonOptions *changed) {
+            changed.selected = [Bool withValue:on];
+          });
+        }
+        merged:^id(id value, ANNNavigationOptions *merge, ANNNavigationOptions *own,
+                   ANNNavigationOptions *before, ANNNavigationOptions *after) {
+          if (!ANNButtonIn(after, side, buttonId)) {
+              return nil;
+          }
+          ANNButtonOptions *given = ANNButtonIn(merge, side, buttonId);
+          if (!given.selected.hasValue) {
+              return value;
+          }
+          ANNButtonOptions *was = ANNButtonIn(own, side, buttonId);
+          if (!was.selected.hasValue) {
+              was = ANNButtonIn(before, side, buttonId);
+          }
+          BOOL same = [given.selected withDefault:NO] == [was.selected withDefault:NO];
+          return same ? value : nil;
+        }];
+}
+
+// The items of the level (a menu's or a submenu's own list, without its submenus) that holds `itemId`, at any depth;
+// nil when no level holds it.
+static NSArray<ANNMenuItemOptions *> *ANNLevelOf(NSArray<ANNMenuItemOptions *> *items,
+                                                 NSString *itemId) {
+    NSMutableArray<ANNMenuItemOptions *> *level = [NSMutableArray new];
+    BOOL holds = NO;
+    for (ANNMenuItemOptions *item in items) {
+        NSString *leafId = item.items.count ? nil : [item.identifier withDefault:nil];
+        if (leafId) {
+            [level addObject:item];
+            holds = holds || [leafId isEqualToString:itemId];
+        }
+    }
+    if (holds) {
+        return level;
+    }
+    for (ANNMenuItemOptions *item in items) {
+        if (item.items.count) {
+            NSArray<ANNMenuItemOptions *> *found = ANNLevelOf(item.items, itemId);
+            if (found) {
+                return found;
+            }
+        }
+    }
+    return nil;
+}
+
+// The ids of the items in the level that holds `itemId`: the neighbors one pick unchecks.
+static NSArray<NSString *> *ANNNeighborsOf(NSArray<ANNMenuItemOptions *> *items, NSString *itemId) {
+    NSMutableArray<NSString *> *ids = [NSMutableArray new];
+    for (ANNMenuItemOptions *item in ANNLevelOf(items, itemId)) {
+        [ids addObject:[item.identifier withDefault:@""]];
+    }
+    return ids;
+}
+
+// The checked items of the level that holds `itemId` in `menu`: the field a merge gives that level. Nil when `menu`
+// doesn't hold the item.
+static NSSet<NSString *> *ANNCheckedInLevel(ANNMenuOptions *menu, NSString *itemId) {
+    NSArray<ANNMenuItemOptions *> *level = menu ? ANNLevelOf(menu.items, itemId) : nil;
+    if (!level) {
+        return nil;
+    }
+    NSMutableSet<NSString *> *checked = [NSMutableSet new];
+    for (ANNMenuItemOptions *item in level) {
+        if ([item.checked withDefault:NO]) {
+            [checked addObject:[item.identifier withDefault:@""]];
+        }
+    }
+    return checked;
+}
+
+// A menu that has items, or nil: a merge without items gives no menu.
+static ANNMenuOptions *ANNMenuWithItems(ANNMenuOptions *menu) {
+    return menu.items ? menu : nil;
+}
+
+// The picks of single-selection levels in one menu, in the order made: the resolution plays them again on a copy of
+// the menu it has, so a new menu from the app keeps the check where its items have the same ids. As on Android
+// (`UserChoices.yieldTo`), at each merge into the node a pick goes when the node's resolution after it no longer has
+// the item, or when the merge gives the menu with other checks in the pick's level than the app had there (the own
+// options' menu, else the menu the node resolved to before the merge); the picks of the other levels stay.
+typedef ANNMenuOptions *_Nullable (^ANNMenuOf)(ANNNavigationOptions *options);
+typedef void (^ANNSetMenu)(ANNNavigationOptions *options, ANNMenuOptions *menu);
+
+static ANNUserChoice *ANNMenuChoice(NSArray<NSString *> *picks,
+                                    ANNMenuOf menuOf,
+                                    ANNSetMenu setMenu) {
+    return [ANNUserChoice choiceWithValue:picks
+        apply:^(ANNNavigationOptions *options, id value) {
+          ANNMenuOptions *menu = menuOf(options);
+          if (menu.items.count == 0) {
+              return;
+          }
+          ANNMenuOptions *copy = [ANNBarButtons deepCopyOfMenu:menu];
+          for (NSString *itemId in (NSArray<NSString *> *)value) {
+              [copy itemPicked:itemId];
+          }
+          setMenu(options, copy);
+        }
+        merged:^id(id value, ANNNavigationOptions *merge, ANNNavigationOptions *own,
+                   ANNNavigationOptions *before, ANNNavigationOptions *after) {
+          ANNMenuOptions *now = ANNMenuWithItems(menuOf(after));
+          ANNMenuOptions *given = ANNMenuWithItems(menuOf(merge));
+          ANNMenuOptions *was = ANNMenuWithItems(menuOf(own)) ?: ANNMenuWithItems(menuOf(before));
+          NSArray<NSString *> *made = value;
+          NSMutableArray<NSString *> *kept = [NSMutableArray new];
+          for (NSString *itemId in made) {
+              BOOL gone = !now || !ANNLevelOf(now.items, itemId);
+              NSSet<NSString *> *givenChecks = given ? ANNCheckedInLevel(given, itemId) : nil;
+              NSSet<NSString *> *wasChecks = ANNCheckedInLevel(was, itemId);
+              BOOL same = givenChecks == wasChecks || [givenChecks isEqualToSet:wasChecks];
+              BOOL changed = given && !same;
+              if (!gone && !changed) {
+                  [kept addObject:itemId];
+              }
+          }
+          if (kept.count == 0) {
+              return nil;
+          }
+          return kept.count == made.count ? value : kept;
+        }];
+}
+
 static UIColor *ANNColorOf(Color *color) {
     if (!color.hasValue || color.isNoColor) {
         return nil;
@@ -119,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);
@@ -212,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;
@@ -220,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
@@ -230,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 {
@@ -244,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) {
@@ -258,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];
@@ -287,6 +633,7 @@ static UIBarButtonSystemItem ANNSystemItemOf(NSString *name) {
     } else {
         [navigationItem setRightBarButtonItems:items animated:animated];
     }
+    return NO;
 }
 
 - (NSArray<ANNBuiltButton *> *)buildSide:(ANNBarButtonsSide)side
@@ -377,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;
                 }
             }
@@ -438,11 +785,12 @@ static UIBarButtonSystemItem ANNSystemItemOf(NSString *name) {
               }
               UIMenu *built = [current menuWithPickHandler:^(NSString *itemId) {
                 [weakSelf menuItemPicked:itemId
-                    menuOf:^ANNMenuOptions *(ANNNavigationOptions *resolved) {
-                      return resolved.topBar.overflowMenu;
+                    choiceKey:@"topBar.overflowMenu"
+                    menuOf:^ANNMenuOptions *(ANNNavigationOptions *options) {
+                      return options.topBar.overflowMenu;
                     }
-                    setMenu:^(ANNNavigationOptions *own, ANNMenuOptions *copy) {
-                      own.topBar.overflowMenu = copy;
+                    setMenu:^(ANNNavigationOptions *options, ANNMenuOptions *copy) {
+                      options.topBar.overflowMenu = copy;
                     }];
               }];
               UIMenu *section = [UIMenu menuWithTitle:built.title
@@ -484,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];
@@ -652,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
@@ -838,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, *)) {
@@ -880,16 +1232,14 @@ static UIBarButtonSystemItem ANNSystemItemOf(NSString *name) {
     __weak ANNBarButtons *weakSelf = self;
     item.menu = [menu menuWithPickHandler:^(NSString *itemId) {
       [weakSelf menuItemPicked:itemId
+          choiceKey:ANNButtonMenuChoiceKey(side, buttonId)
           menuOf:^ANNMenuOptions *(ANNNavigationOptions *options) {
-            return [ANNBarButtons buttonWithId:buttonId in:ANNButtonsOfSide(options, side)].menu;
+            return ANNButtonWithId(ANNButtonsOfSide(options, side), buttonId).menu;
           }
-          setMenu:^(ANNNavigationOptions *own, ANNMenuOptions *copy) {
-            [weakSelf changeButton:buttonId
-                              side:side
-                           inOwn:own
-                            change:^(ANNButtonOptions *changed) {
-                              changed.menu = copy;
-                            }];
+          setMenu:^(ANNNavigationOptions *options, ANNMenuOptions *copy) {
+            ANNChangeButton(options, side, buttonId, ^(ANNButtonOptions *changed) {
+              changed.menu = copy;
+            });
           }];
     }];
     if (![button.menuOnLongPress withDefault:NO]) {
@@ -948,22 +1298,15 @@ static UIBarButtonSystemItem ANNSystemItemOf(NSString *name) {
         [screen.eventEmitter sendOnNavigationButtonPressed:componentId buttonId:press.buttonId];
         return;
     }
-    // A toggle flips, the options keep the new state, then the event tells it.
+    // A toggle flips, the user layer keeps the new state, then the event tells it.
     ANNUIBarButtonItem *item = press.item;
     BOOL selected = !item.selected;
     item.selected = selected;
     _selected[press.buttonId] = @(selected);
-    __weak ANNBarButtons *weakSelf = self;
     NSString *buttonId = press.buttonId;
     ANNBarButtonsSide side = press.side;
-    [screen changeOwnOptions:^(ANNNavigationOptions *own) {
-      [weakSelf changeButton:buttonId
-                        side:side
-                     inOwn:own
-                      change:^(ANNButtonOptions *changed) {
-                        changed.selected = [Bool withValue:selected];
-                      }];
-    }];
+    [screen setUserChoice:ANNToggleChoice(side, buttonId, selected)
+                   forKey:ANNToggleChoiceKey(side, buttonId)];
     [screen.eventEmitter sendOnNavigationButtonPressed:componentId
                                               buttonId:buttonId
                                               selected:@(selected)];
@@ -971,46 +1314,15 @@ static UIBarButtonSystemItem ANNSystemItemOf(NSString *name) {
 
 + (nullable ANNButtonOptions *)buttonWithId:(NSString *)buttonId
                                         in:(NSArray<ANNButtonOptions *> *)buttons {
-    for (ANNButtonOptions *button in buttons) {
-        if ([[button.identifier withDefault:nil] isEqualToString:buttonId]) {
-            return button;
-        }
-    }
-    return nil;
-}
-
-// The button `buttonId` of `side` in the own options, changed on a copy: the own list when it has the button, else the
-// list the screen shows (from its stack or the defaults), copied into the own options first. Lists are new arrays.
-- (void)changeButton:(NSString *)buttonId
-                side:(ANNBarButtonsSide)side
-               inOwn:(ANNNavigationOptions *)own
-              change:(void (^)(ANNButtonOptions *changed))change {
-    NSArray<ANNButtonOptions *> *list = ANNButtonsOfSide(own, side);
-    if (![ANNBarButtons buttonWithId:buttonId in:list]) {
-        list = ANNButtonsOfSide([_screen resolveOptionsWithDefault], side);
-    }
-    if (![ANNBarButtons buttonWithId:buttonId in:list]) {
-        return;
-    }
-    NSMutableArray<ANNButtonOptions *> *changedList = [NSMutableArray arrayWithCapacity:list.count];
-    for (ANNButtonOptions *button in list) {
-        ANNButtonOptions *copy = [button copy];
-        if (button.menu.items.count > 0) {
-            copy.menu = [ANNBarButtons deepCopyOfMenu:button.menu];
-        }
-        if ([[button.identifier withDefault:nil] isEqualToString:buttonId]) {
-            change(copy);
-        }
-        [changedList addObject:copy];
-    }
-    ANNSetButtonsOfSide(own, side, changedList);
+    return ANNButtonWithId(buttons, buttonId);
 }
 
 #pragma mark - Menus
 
 - (void)menuItemPicked:(NSString *)itemId
+             choiceKey:(NSString *)choiceKey
                 menuOf:(ANNMenuOptions *_Nullable (^)(ANNNavigationOptions *options))menuOf
-               setMenu:(void (^)(ANNNavigationOptions *own, ANNMenuOptions *menu))setMenu {
+               setMenu:(void (^)(ANNNavigationOptions *options, ANNMenuOptions *menu))setMenu {
     UIViewController *screen = _screen;
     NSString *componentId = screen.layoutInfo.componentId;
     if (!screen || componentId.length == 0) {
@@ -1021,13 +1333,18 @@ static UIBarButtonSystemItem ANNSystemItemOf(NSString *name) {
     if (!menu || ![ANNBarButtons menu:menu hasSingleSelectionOf:itemId]) {
         return;
     }
-    // The check lands on the screen's own copy, which shares nothing with the menus of the stack, the defaults or
-    // other screens.
-    ANNMenuOptions *copy = [ANNBarButtons deepCopyOfMenu:menu];
-    [copy itemPicked:itemId];
-    [screen changeOwnOptions:^(ANNNavigationOptions *own) {
-      setMenu(own, copy);
-    }];
+    // The new pick goes last; the earlier picks of its own list go, so a pick the app takes away later doesn't bring
+    // back one the user replaced.
+    NSArray<NSString *> *made = [screen userChoiceForKey:choiceKey].value ?: @[];
+    NSArray<NSString *> *neighbors = ANNNeighborsOf(menu.items, itemId);
+    NSMutableArray<NSString *> *picks = [NSMutableArray new];
+    for (NSString *pick in made) {
+        if (![neighbors containsObject:pick]) {
+            [picks addObject:pick];
+        }
+    }
+    [picks addObject:itemId];
+    [screen setUserChoice:ANNMenuChoice(picks, menuOf, setMenu) forKey:choiceKey];
 }
 
 + (BOOL)menu:(ANNMenuOptions *)menu hasSingleSelectionOf:(NSString *)itemId {

package/ios/TopBar/ANNIconButtonImage.h

@@ -13,6 +13,7 @@ NS_ASSUME_NONNULL_BEGIN
 
 /// `tint` colors the icon (nil: its own colors); `background` fills the rectangle of `size` (zero: the icon's size)
 /// rounded by `cornerRadius`; `insets` pad the icon. Colors may be dynamic: each variant resolves them.
+/// An icon that can't be drawn so (no room, an exception while drawing) comes back as it is.
 + (UIImage *)imageWithIcon:(UIImage *)icon
                       tint:(nullable UIColor *)tint
                 background:(nullable UIColor *)background