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

package/ios/Layouts/Tabs/ANNBottomTabsPresenter.mm

@@ -12,9 +12,6 @@
 
 // The dot of a tab before iOS 26: its default size and color.
 static const CGFloat ANNDotDefaultSize = 6;
-// A button not there yet gets its `testID` again this often, at most this many times (`bottomTab.testID`).
-static const NSTimeInterval ANNTestIDRetryInterval = 0.15;
-static const NSUInteger ANNTestIDRetries = 5;
 
 // A picture of `color` (both of its styles when it is dynamic): the bar's 1×1 background and the border's line.
 static UIImage *ANNImageOfColor(UIColor *color, CGSize size) {
@@ -63,13 +60,23 @@ static id ANNValue(NSArray *list, NSUInteger index) {
     NSMutableArray<NSNumber *> *_roleItems;
     // The identifiers the buttons had before the core gave them a `testID`, to give back.
     NSMapTable<UIView *, NSString *> *_buttonIds;
+    // What the `testID`s and the dots were last applied to: the bar's items, the button of each tab and of More, the
+    // bar's size and its traits. UIKit makes the buttons anew (rotation, text size, items moving between the bar and
+    // More), and a layout that finds other buttons applies them again.
+    NSPointerArray *_appliedButtons;
+    CGSize _appliedBarSize;
+    UITraitCollection *_appliedBarTraits;
     BOOL _tabsAreSet;
     BOOL _titlesHidden;
+    // A dot that shows was placed while its button had no window (the tabs under a full-screen modal): it hides then,
+    // and the next layout in the window places it, whatever the check of the buttons says.
+    BOOL _dotsWaitForWindow;
     // The bar's look: its options, and the background and border every item's look starts from.
     ANNBottomTabsOptions *_barOptions;
     UITabBarAppearance *_base;
     ANNBottomTabsCustomRow *_row;
-    // The accessory shown (its id), and the content view of each accessory made, kept until the tabs go.
+    // The accessory shown (its id), and the content view of each accessory made: kept while hidden, until another
+    // accessory shows or the tabs go.
     NSString *_accessoryId;
     NSMutableDictionary<NSString *, ANNBottomTabsAccessoryView *> *_accessoryViews;
     // The pictures of the bar's colors by color and size.
@@ -123,6 +130,7 @@ static id ANNValue(NSArray *list, NSUInteger index) {
     _dotViews = [NSMutableArray new];
     _roleItems = [NSMutableArray new];
     _buttonIds = [NSMapTable weakToStrongObjectsMapTable];
+    _appliedButtons = [NSPointerArray weakObjectsPointerArray];
     _accessoryViews = [NSMutableDictionary new];
     _colorImages = [NSMutableDictionary new];
     _iconLoads = [NSMutableDictionary new];
@@ -251,7 +259,7 @@ static id ANNValue(NSArray *list, NSUInteger index) {
         [_row applyOptions:resolvedOptions.bottomTabs.customRow];
     }
     [self applyAccessoryOf:resolvedOptions animated:NO];
-    [self applyButtonTestIDsWithRetries:ANNTestIDRetries];
+    [self applyButtonTestIDs];
 }
 
 #pragma mark - ANNNodePresenter
@@ -315,7 +323,7 @@ static id ANNValue(NSArray *list, NSUInteger index) {
     }
     [self buildItemAtIndex:index bottomTab:bottomTab updatesBadgeAndDot:badgeAndDot];
     [self updateCells];
-    [self applyButtonTestIDsWithRetries:mergeOptions.testID.hasValue ? ANNTestIDRetries : 0];
+    [self applyButtonTestIDs];
 }
 
 // The whole item from `bottomTab`; the badge and the dot from it only with `updatesBadgeAndDot`.
@@ -589,6 +597,7 @@ static ANNBottomTabOptions *ANNWithIcons(ANNBottomTabOptions *bottomTab, NSArray
     if (anyDot) {
         [bar layoutIfNeeded];
     }
+    BOOL waitsForWindow = NO;
     for (NSUInteger index = 0; index < tabs.layoutTabs.count; index++) {
         ANNTabDotView *view = ANNValue(_dotViews, index);
         if (!view) {
@@ -602,49 +611,36 @@ static ANNBottomTabOptions *ANNWithIcons(ANNBottomTabOptions *bottomTab, NSArray
         }
         UITabBarItem *item = tabs.layoutTabs[index].tabBarItem;
         BOOL inBar = [bar.items indexOfObjectIdenticalTo:item] != NSNotFound;
-        [view placeOverButton:inBar ? [bar viewOfItem:item] : nil inBar:bar];
+        UIView *button = inBar ? [bar viewOfItem:item] : nil;
+        waitsForWindow = waitsForWindow || (inBar && !button.window);
+        [view placeOverButton:button inBar:bar];
     }
+    _dotsWaitForWindow = waitsForWindow;
 }
 
 #pragma mark - testID (`bottomTab.testID`, `bottomTabs.moreTestID`)
 
-// Each tab's button carries its `testID`; a button not there yet gets it again after 0.15 s, at most 5 times; a
-// removed `testID` gives the button its identifier back.
-- (void)applyButtonTestIDsWithRetries:(NSUInteger)retries {
+// Each tab's button carries its `testID`; a removed `testID` gives the button its identifier back. A button not
+// there yet gets it at the layout that finds it (`tabsDidLayOut`).
+- (void)applyButtonTestIDs {
     ANNBottomTabsController *tabs = self.tabs;
     UITabBar *bar = tabs.tabBar;
     if (!tabs || !bar) {
         return;
     }
-    BOOL missing = NO;
     for (NSUInteger index = 0; index < tabs.layoutTabs.count; index++) {
         UITabBarItem *item = tabs.layoutTabs[index].tabBarItem;
-        NSString *testID = item.accessibilityIdentifier;
         UIView *button = [bar viewOfItem:item];
-        if (!button) {
-            missing = missing || testID.length > 0;
-            continue;
+        if (button) {
+            [self setTestID:item.accessibilityIdentifier ofButton:button];
         }
-        [self setTestID:testID ofButton:button];
     }
     if (tabs.layoutTabs.count > 5) {
-        NSString *moreTestID = [_barOptions.moreTestID withDefault:nil];
         UIView *button = [bar viewOfItem:tabs.moreNavigationController.tabBarItem];
         if (button) {
-            [self setTestID:moreTestID ofButton:button];
-        } else {
-            missing = missing || moreTestID.length > 0;
+            [self setTestID:[_barOptions.moreTestID withDefault:nil] ofButton:button];
         }
     }
-    if (!missing || retries == 0) {
-        return;
-    }
-    __weak ANNBottomTabsPresenter *weakSelf = self;
-    dispatch_after(
-        dispatch_time(DISPATCH_TIME_NOW, (int64_t)(ANNTestIDRetryInterval * NSEC_PER_SEC)),
-        dispatch_get_main_queue(), ^{
-          [weakSelf applyButtonTestIDsWithRetries:retries - 1];
-        });
 }
 
 - (void)setTestID:(NSString *)testID ofButton:(UIView *)button {
@@ -728,8 +724,9 @@ static ANNBottomTabOptions *ANNWithIcons(ANNBottomTabOptions *bottomTab, NSArray
                     warned = YES;
                     RCTLogWarn(
                         @"[ApexNavigation] bottomTabs.backgroundColor is ignored with Liquid "
-                        @"Glass (iOS 26). It applies with UIDesignRequiresCompatibility and on "
-                        @"earlier iOS versions.");
+                        @"Glass (iOS 26). It applies before iOS 26 and where UIKit keeps the "
+                        @"earlier design for UIDesignRequiresCompatibility (iOS 26; iOS 27 only "
+                        @"for an app built with an SDK before iOS 27).");
                 }
             }
         }
@@ -969,14 +966,15 @@ static ANNBottomTabOptions *ANNWithIcons(ANNBottomTabOptions *bottomTab, NSArray
         [tabs updateRootLayoutOfShownScreens];
     }
     if (mergeOptions.testID.hasValue || mergeOptions.moreTestID.hasValue) {
-        [self applyButtonTestIDsWithRetries:ANNTestIDRetries];
+        [self applyButtonTestIDs];
     }
 }
 
 #pragma mark - The accessory (iOS 26)
 
-// No name or `visible: false`: no accessory. The same id shown: nothing; another: a new one. A root of an id stays
-// with the tabs once made, so one hidden and shown again keeps its state.
+// No name or `visible: false`: no accessory. The same id shown: nothing; another: a new one. A hidden accessory keeps
+// its root, so one hidden and shown again keeps its state; the roots of the other ids stop once another accessory
+// shows and theirs is out of the window.
 - (void)applyAccessoryOf:(ANNNavigationOptions *)options animated:(BOOL)animated {
     if (@available(iOS 26.0, *)) {
         ANNBottomTabsController *tabs = self.tabs;
@@ -1012,8 +1010,37 @@ static ANNBottomTabOptions *ANNWithIcons(ANNBottomTabOptions *bottomTab, NSArray
             return;
         }
         _accessoryId = componentId;
+        [view whenOutOfWindow:nil];
         UITabAccessory *tabAccessory = [[UITabAccessory alloc] initWithContentView:view];
         [tabs setBottomAccessory:tabAccessory animated:animated && inWindow];
+        [self stopAccessoriesOtherThan:componentId];
+    }
+}
+
+// The roots of the accessories not shown stop, each once its view is out of the window, unless it shows again first.
+- (void)stopAccessoriesOtherThan:(NSString *)shownId {
+    ANNBottomTabsController *tabs = self.tabs;
+    __weak ANNBottomTabsPresenter *weakSelf = self;
+    __weak ANNReactComponentRegistry *weakComponents = tabs.components;
+    for (NSString *componentId in _accessoryViews.allKeys) {
+        if ([componentId isEqualToString:shownId]) {
+            continue;
+        }
+        ANNBottomTabsAccessoryView *view = _accessoryViews[componentId];
+        __weak ANNBottomTabsAccessoryView *weakView = view;
+        [view whenOutOfWindow:^{
+          ANNBottomTabsPresenter *presenter = weakSelf;
+          ANNBottomTabsAccessoryView *gone = weakView;
+          if (!presenter || !gone || presenter->_accessoryViews[componentId] != gone ||
+              [presenter->_accessoryId isEqualToString:componentId]) {
+              return;
+          }
+          [presenter->_accessoryViews removeObjectForKey:componentId];
+          ANNReactComponentRegistry *components = weakComponents;
+          if ([components existingComponent:componentId] == gone.reactView) {
+              [components removeChildComponent:componentId];
+          }
+        }];
     }
 }
 
@@ -1062,18 +1089,78 @@ static ANNBottomTabOptions *ANNWithIcons(ANNBottomTabOptions *bottomTab, NSArray
     [self updateCells];
 }
 
+// The `testID`s and the dots go on the buttons again only when the bar has other buttons than they were applied to,
+// another size or other traits; a merge and a rebuilt item apply them at once. A dot placed out of the window waits
+// for the next layout.
 - (void)tabsDidLayOut {
     if (!_tabsAreSet) {
         return;
     }
     [self updateHiddenTitles];
-    if (!ANNTabsDesign.isGlass) {
+    BOOL changed = [self barChangedSinceApplied];
+    if ((changed || _dotsWaitForWindow) && !ANNTabsDesign.isGlass) {
         [self placeDots];
     }
-    [self applyButtonTestIDsWithRetries:0];
+    if (changed) {
+        [self applyButtonTestIDs];
+    }
     [_row layOutInTabs];
 }
 
+- (void)tabsDidAppear {
+    if (_tabsAreSet && _dotsWaitForWindow && !ANNTabsDesign.isGlass) {
+        [self placeDots];
+    }
+}
+
+// The bar's items and the button of each tab and of More, by pointer, against those last seen; no walk through the
+// buttons. An item moving between the bar and More changes the items. The tabs lay out before the bar does: a tab in
+// the bar without its button yet makes the bar lay out first.
+- (BOOL)barChangedSinceApplied {
+    ANNBottomTabsController *tabs = self.tabs;
+    UITabBar *bar = tabs.tabBar;
+    if (!tabs || !bar) {
+        return NO;
+    }
+    NSArray<UIViewController *> *layoutTabs = tabs.layoutTabs;
+    NSArray<UITabBarItem *> *barItems = bar.items;
+    NSUInteger tabCount = layoutTabs.count + (layoutTabs.count > 5 ? 1 : 0);
+    NSMutableArray *seen = [NSMutableArray arrayWithArray:barItems];
+    BOOL laidOut = NO;
+    for (NSUInteger index = 0; index < tabCount; index++) {
+        UITabBarItem *item = index < layoutTabs.count ? layoutTabs[index].tabBarItem
+                                                      : tabs.moreNavigationController.tabBarItem;
+        UIView *button = [bar viewOfItem:item];
+        if (!button && !laidOut && bar.window &&
+            [barItems indexOfObjectIdenticalTo:item] != NSNotFound) {
+            laidOut = YES;
+            [bar layoutIfNeeded];
+            button = [bar viewOfItem:item];
+        }
+        [seen addObject:button ?: NSNull.null];
+    }
+    NSUInteger count = seen.count;
+    BOOL changed = _appliedButtons.count != count;
+    for (NSUInteger index = 0; index < count && !changed; index++) {
+        id object = seen[index] == NSNull.null ? nil : seen[index];
+        changed = (__bridge void *)object != [_appliedButtons pointerAtIndex:index];
+    }
+    CGSize size = bar.bounds.size;
+    UITraitCollection *traits = bar.traitCollection;
+    changed = changed || !CGSizeEqualToSize(size, _appliedBarSize) ||
+              ![traits isEqual:_appliedBarTraits];
+    if (!changed) {
+        return NO;
+    }
+    _appliedButtons.count = 0;
+    for (id object in seen) {
+        [_appliedButtons addPointer:object == NSNull.null ? NULL : (__bridge void *)object];
+    }
+    _appliedBarSize = size;
+    _appliedBarTraits = traits;
+    return YES;
+}
+
 // The glass bar measures a title when it is set and keeps that size: a title set before the bar was ever in a window
 // was measured in a button of its first layout there, when the bar's floating platter had no size yet, and stays cut
 // short ("Sec…") and lower than a title measured later. Neither a layout of the bar nor of its buttons measures it

package/ios/Layouts/Tabs/ANNTabsDesign.h

@@ -2,16 +2,17 @@
 
 NS_ASSUME_NONNULL_BEGIN
 
-/// Which design UIKit draws the bars in: the Liquid Glass of iOS 26, or the design before it, which iOS 26 keeps when
-/// the app's Info.plist has `UIDesignRequiresCompatibility = YES` (the compatibility mode). The key is read once per
-/// process. Every place of the core that depends on the design asks here (the module `UITabBar+utils` keeps its own
-/// copy).
+/// Which design UIKit draws the bars in: the Liquid Glass of iOS 26, or the design before it, which UIKit keeps when
+/// the app's Info.plist has `UIDesignRequiresCompatibility = YES` (the compatibility mode): on iOS 26, and on iOS 27
+/// only for an app built with an SDK before iOS 27. The key is read once per process. Every place of the core that
+/// depends on the design asks here.
 @interface ANNTabsDesign : NSObject
 
 /// iOS 26 or later, and not the compatibility mode.
 @property(class, nonatomic, readonly) BOOL isGlass;
 
-/// iOS 26 or later with `UIDesignRequiresCompatibility = YES`: the bars look as before iOS 26.
+/// iOS 26 or later with `UIDesignRequiresCompatibility = YES`, where UIKit honors it (not on iOS 27 and later for an
+/// app built with the iOS 27 SDK): the bars look as before iOS 26.
 @property(class, nonatomic, readonly) BOOL isCompatibilityMode;
 
 /// iOS 18 and later on an iPad or a Mac in a regular width: the system's tab bar is on top (or in the sidebar), and

package/ios/Layouts/Tabs/ANNTabsDesign.mm

@@ -2,7 +2,10 @@
 
 @implementation ANNTabsDesign
 
-// Read once: the Info.plist of a running app doesn't change.
+// Read once: the Info.plist of a running app doesn't change. iOS 26 keeps the earlier design for the key; iOS 27 keeps
+// it only for an app built with an SDK before iOS 27 and ignores it for one built with the iOS 27 SDK (an app linked
+// against the iOS 26 SDK keeps the earlier design on iOS 27, one linked against the iOS 27 SDK gets the glass). The
+// core is compiled with the app, so the SDK it is compiled with is the app's.
 + (BOOL)isCompatibilityMode {
     static BOOL compatibility;
     static dispatch_once_t once;
@@ -11,6 +14,11 @@
           id value = NSBundle.mainBundle.infoDictionary[@"UIDesignRequiresCompatibility"];
           compatibility = [value respondsToSelector:@selector(boolValue)] && [value boolValue];
       }
+#if __IPHONE_OS_VERSION_MAX_ALLOWED >= 270000
+      if (@available(iOS 27.0, *)) {
+          compatibility = NO;
+      }
+#endif
     });
     return compatibility;
 }

package/ios/Layouts/Tabs/UITabBar+utils.h

@@ -4,18 +4,18 @@
 
 /**
  * The button of an item in the tab bar. UIKit has no public API for it: this reads the private
- * `view` of the item, and is nil when UIKit has no such view (or the item none).
+ * `view` of the item, the core's one private read of the bar, and is nil when the item has no
+ * button (out of the bar, or before its layout). When UIKit has no such key any more, DEBUG logs it
+ * once.
  */
 - (UIView *)viewOfItem:(UITabBarItem *)item;
 
-- (UIView *)tabBarItemViewAtIndex:(NSUInteger)index;
-
 - (void)removeTabBarItemTitles;
 
 /**
  * Icons in the middle of the buttons of this tab bar, for items without titles: before iOS 26 (and
- * in its compatibility mode) a button keeps the room of its title; the iOS 26 design centers the
- * icons itself, and this does nothing there. UIKit has no public API for it: the layout of the
+ * in its compatibility mode, `ANNTabsDesign`) a button keeps the room of its title; the iOS 26
+ * design centers the icons itself, and this does nothing there. UIKit has no public API for it: the layout of the
  * private button class changes once for the app, and only tab bars with centered images move their
  * icons (and badges). `NO` gives the buttons the layout of UIKit back.
  */

package/ios/Layouts/Tabs/UITabBar+utils.mm

@@ -1,5 +1,7 @@
 #import "UITabBar+utils.h"
+#import "ANNTabsDesign.h"
 #import "UIView+Utils.h"
+#import <React/RCTLog.h>
 #import <objc/runtime.h>
 
 static const void *ANNItemImagesCenteredKey = &ANNItemImagesCenteredKey;
@@ -37,17 +39,16 @@ static void ANNTabBarButtonLayoutSubviews(UIView *button, SEL _cmd) {
     badge.center = CGPointMake(badge.center.x, badge.center.y + offset);
 }
 
-// The design of iOS 26 centers the icon of an item without a title itself; in its compatibility
-// mode (UIDesignRequiresCompatibility) the tab bar is drawn as before.
+// The design of iOS 26 centers the icon of an item without a title itself; the design before it
+// (before iOS 26, and the compatibility mode where UIKit keeps it) keeps the title's room.
 static BOOL ANNTabBarButtonsKeepTitleRoom(void) {
-    if (@available(iOS 26.0, *)) {
-        return [[NSBundle.mainBundle objectForInfoDictionaryKey:@"UIDesignRequiresCompatibility"]
-            boolValue];
-    }
-    return YES;
+    return !ANNTabsDesign.isGlass;
 }
 
-// Once for the app; the buttons of other tab bars keep the layout of UIKit.
+// Once for the app; the buttons of other tab bars keep the layout of UIKit. No public API does this: in the
+// compatibility mode of iOS 26 UIKit ignores `imageInsets` and a symbol's baseline offset, and a symbol drawn into a
+// taller bitmap is scaled down and stops being a symbol. `badgePositionAdjustment` would move the badge alone, so the
+// button's layout moves both.
 static void ANNInstallTabBarButtonLayout(void) {
     static dispatch_once_t once;
     dispatch_once(&once, ^{
@@ -65,18 +66,36 @@ static void ANNInstallTabBarButtonLayout(void) {
     });
 }
 
+// Once per app run, in DEBUG: the tab items' buttons can't be found any more.
+static void ANNWarnNoButtonOfItem(void) {
+#if DEBUG
+    static dispatch_once_t once;
+    dispatch_once(&once, ^{
+      RCTLogWarn(@"[ApexNavigation] This iOS version gives no button for a tab item: "
+                 @"bottomTab.testID on the tab buttons, the dot before iOS 26 and the long "
+                 @"press on a tab don't apply.");
+    });
+#endif
+}
+
 @implementation UITabBar (utils)
 
 - (UIView *)viewOfItem:(UITabBarItem *)item {
+    if (!item) {
+        return nil;
+    }
+    // An item out of the bar (in More, or before the bar's first layout) has no button: that is no failure. Only an
+    // item without the `view` key, or with something else under it, says that UIKit changed.
     if (![item respondsToSelector:NSSelectorFromString(@"view")]) {
+        ANNWarnNoButtonOfItem();
         return nil;
     }
     id view = [item valueForKey:@"view"];
-    return [view isKindOfClass:UIView.class] ? view : nil;
-}
-
-- (UIView *)tabBarItemViewAtIndex:(NSUInteger)index {
-    return index < self.items.count ? [self viewOfItem:self.items[index]] : nil;
+    if (view && ![view isKindOfClass:UIView.class]) {
+        ANNWarnNoButtonOfItem();
+        return nil;
+    }
+    return view;
 }
 
 - (void)removeTabBarItemTitles {

package/ios/Options/ANNBottomTabsOptions.h

@@ -11,6 +11,8 @@ NS_ASSUME_NONNULL_BEGIN
 
 @property(nonatomic, strong) Bool *visible;
 @property(nonatomic, strong) Bool *animate;
+/// `'platform'` or `'none'`; read on Android only: the system switches tabs at once.
+@property(nonatomic, strong) Text *switchAnimation;
 /// The index of the tab to select; a whole number (the fraction is dropped).
 @property(nonatomic, strong) Double *currentTabIndex;
 @property(nonatomic, strong) Text *currentTabId;

package/ios/Options/ANNBottomTabsOptions.mm

@@ -6,6 +6,7 @@
     return @[
         [ANNOptionField boolField:@"visible"],
         [ANNOptionField boolField:@"animate"],
+        [ANNOptionField enumField:@"switchAnimation" values:@[ @"platform", @"none" ]],
         [ANNOptionField doubleField:@"currentTabIndex"],
         [ANNOptionField textField:@"currentTabId"],
         [ANNOptionField textField:@"testID"],

package/ios/Options/ANNOptions.h

@@ -20,6 +20,13 @@ NS_ASSUME_NONNULL_BEGIN
 /// The group of options under `key`: nil when it is not an object (`null` included), which reads as an empty group.
 NSDictionary *_Nullable ANNOptionsDictionary(NSDictionary *_Nullable dict, NSString *key);
 
+/// Two values a group of options holds are the same: params and groups by `isSameValueAs:`, arrays item by item,
+/// anything else as `ANNJSONValuesSame` says. nil is the same only as nil (an unset array is not an empty one).
+BOOL ANNOptionValuesSame(id _Nullable a, id _Nullable b);
+
+/// A hash of a value `ANNOptionValuesSame` compares: values that are the same have the same hash.
+NSUInteger ANNOptionValueHash(id _Nullable value);
+
 #if DEBUG
 /// Development only: checks the field table of `root` and of every group class reached through its group and
 /// group-array fields.
@@ -57,6 +64,17 @@ void ANNCheckOptionClassesFrom(Class root);
 /// These over a copy of `defaults`; neither changes.
 - (instancetype)withDefault:(nullable ANNOptions *)defaults;
 
+/// A group of the same class with the same options, field by field at any depth: two reads of the same JSON, a copy,
+/// two resolutions of the same layers. The fields are the field table's; a module's group (an empty table) compares
+/// every property of an options kind it declares. A value that is nil is the same only as nil.
+///
+/// Not `isEqual:`: a group changes in place (a merge, the pick of a menu's item), so a hash by value would move under
+/// a set or a dictionary that holds it. `==` and `isEqual:` stay identity.
+- (BOOL)isSameValueAs:(nullable ANNOptions *)other;
+
+/// A hash consistent with `isSameValueAs:`; it changes when the group does.
+- (NSUInteger)valueHash;
+
 @end
 
 NS_ASSUME_NONNULL_END

package/ios/Options/ANNOptions.mm

@@ -11,7 +11,6 @@ NSDictionary *ANNOptionsDictionary(NSDictionary *dict, NSString *key) {
     return [value isKindOfClass:NSDictionary.class] ? value : nil;
 }
 
-#if DEBUG
 // The kinds of property a group holds options in.
 static BOOL ANNIsOptionClass(Class cls) {
     return [cls isSubclassOfClass:ANNParam.class] || [cls isSubclassOfClass:ANNOptions.class] ||
@@ -33,6 +32,7 @@ static Class ANNPropertyClass(objc_property_t property) {
     return name ? NSClassFromString(name) : nil;
 }
 
+#if DEBUG
 // There is no iOS test target: in development each group of the core checks once that its table names every property
 // that holds options, and that every field of the table has its property (the stand-in for the whole-tree test of
 // Android). A missing field would be neither read, merged, copied nor given defaults.
@@ -86,6 +86,94 @@ static NSArray<ANNOptionField *> *ANNFieldsOf(Class cls) {
     }
 }
 
+// The properties that hold the options of a group, asked once per class: its field table's, or for a module's group
+// (its own read and merge, an empty table) every property of an options kind its classes declare up to `ANNOptions`.
+static NSArray<NSString *> *ANNValuePropertiesOf(Class cls) {
+    static NSMutableDictionary<NSString *, NSArray<NSString *> *> *propertiesByClass;
+    NSString *name = NSStringFromClass(cls);
+    @synchronized(ANNOptions.class) {
+        if (!propertiesByClass) {
+            propertiesByClass = [NSMutableDictionary new];
+        }
+        NSArray<NSString *> *names = propertiesByClass[name];
+        if (names) {
+            return names;
+        }
+    }
+    NSArray<ANNOptionField *> *fields = ANNFieldsOf(cls);
+    NSMutableArray<NSString *> *found = [NSMutableArray new];
+    if (fields.count) {
+        for (ANNOptionField *field in fields) {
+            [found addObject:field.property];
+        }
+    } else {
+        NSSet<NSString *> *inherited =
+            [NSSet setWithArray:@[ @"description", @"debugDescription" ]];
+        for (Class current = cls; current && current != ANNOptions.class;
+             current = class_getSuperclass(current)) {
+            unsigned int count = 0;
+            objc_property_t *properties = class_copyPropertyList(current, &count);
+            for (unsigned int i = 0; i < count; i++) {
+                NSString *property = @(property_getName(properties[i]));
+                Class propertyClass = ANNPropertyClass(properties[i]);
+                if (propertyClass && ANNIsOptionClass(propertyClass) &&
+                    ![inherited containsObject:property] && ![found containsObject:property]) {
+                    [found addObject:property];
+                }
+            }
+            free(properties);
+        }
+    }
+    NSArray<NSString *> *names = [found copy];
+    @synchronized(ANNOptions.class) {
+        propertiesByClass[name] = names;
+    }
+    return names;
+}
+
+BOOL ANNOptionValuesSame(id a, id b) {
+    if (a == b) {
+        return YES;
+    }
+    if ([a isKindOfClass:ANNParam.class]) {
+        return [b isKindOfClass:ANNParam.class] && [(ANNParam *)a isSameValueAs:b];
+    }
+    if ([a isKindOfClass:ANNOptions.class]) {
+        return [b isKindOfClass:ANNOptions.class] && [(ANNOptions *)a isSameValueAs:b];
+    }
+    if ([a isKindOfClass:NSArray.class]) {
+        if (![b isKindOfClass:NSArray.class] || [a count] != [b count]) {
+            return NO;
+        }
+        NSArray *items = b;
+        NSUInteger index = 0;
+        for (id item in (NSArray *)a) {
+            if (!ANNOptionValuesSame(item, items[index++])) {
+                return NO;
+            }
+        }
+        return YES;
+    }
+    return ANNJSONValuesSame(a, b);
+}
+
+NSUInteger ANNOptionValueHash(id value) {
+    if ([value isKindOfClass:ANNParam.class]) {
+        return [(ANNParam *)value valueHash];
+    }
+    if ([value isKindOfClass:ANNOptions.class]) {
+        return [(ANNOptions *)value valueHash];
+    }
+    if ([value isKindOfClass:NSArray.class]) {
+        NSUInteger hash = [value count];
+        for (id item in value) {
+            hash = hash * 31 + ANNOptionValueHash(item);
+        }
+        return hash;
+    }
+    return ANNJSONValueHash(value);
+}
+
 #if DEBUG
 // Runs the check on `root` and on every class reached through its group and group-array fields, so a class that only
 // an array holds (a button, an action of a fab, a token of the search bar) is checked although no object of it is made.
@@ -326,4 +414,27 @@ static NSArray *ANNCopyItems(NSArray *items) {
     return result;
 }
 
+- (BOOL)isSameValueAs:(ANNOptions *)other {
+    if (other == self) {
+        return YES;
+    }
+    if (other.class != self.class) {
+        return NO;
+    }
+    for (NSString *property in ANNValuePropertiesOf(self.class)) {
+        if (!ANNOptionValuesSame([self valueForKey:property], [other valueForKey:property])) {
+            return NO;
+        }
+    }
+    return YES;
+}
+
+- (NSUInteger)valueHash {
+    NSUInteger hash = (NSUInteger)(__bridge void *)self.class;
+    for (NSString *property in ANNValuePropertiesOf(self.class)) {
+        hash = hash * 31 + ANNOptionValueHash([self valueForKey:property]);
+    }
+    return hash;
+}
+
 @end