@apexnative/navigation 0.0.0-stage → 1.0.0-alpha.0

package/ios/Layouts/Tabs/ANNMoreNavigationDelegate.h

@@ -0,0 +1,24 @@
+#import <UIKit/UIKit.h>
+
+@class ANNBottomTabsController;
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// The delegate of UIKit's More navigation the tabs set: UIKit selects a tab picked in the More list without any
+/// delegate of the tab bar, and its selection is already set when the More navigation is about to show the tab's
+/// screen. The tabs hear `willShow` and `didShow` there; every message goes on to the delegate the More navigation had
+/// before, so UIKit's own More keeps its behavior.
+@interface ANNMoreNavigationDelegate : NSObject <UINavigationControllerDelegate>
+
+- (instancetype)initWithTabs:(ANNBottomTabsController *)tabs
+                    previous:(nullable id<UINavigationControllerDelegate>)previous;
+
+- (instancetype)init NS_UNAVAILABLE;
++ (instancetype)new NS_UNAVAILABLE;
+
+/// The delegate the More navigation had before (kept weakly, as UIKit keeps its delegate).
+@property(nonatomic, weak, readonly, nullable) id<UINavigationControllerDelegate> previous;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/Layouts/Tabs/ANNMoreNavigationDelegate.mm

@@ -0,0 +1,58 @@
+#import "ANNMoreNavigationDelegate.h"
+#import "ANNBottomTabsController.h"
+
+@implementation ANNMoreNavigationDelegate {
+    __weak ANNBottomTabsController *_tabs;
+}
+
+- (instancetype)initWithTabs:(ANNBottomTabsController *)tabs
+                    previous:(id<UINavigationControllerDelegate>)previous {
+    if (self = [super init]) {
+        _tabs = tabs;
+        _previous = previous;
+    }
+    return self;
+}
+
+#pragma mark - Forwarding
+
+// Whatever the earlier delegate answers, it keeps answering: the animation, the orientations, the rest.
+- (BOOL)respondsToSelector:(SEL)selector {
+    return [super respondsToSelector:selector] || [_previous respondsToSelector:selector];
+}
+
+- (id)forwardingTargetForSelector:(SEL)selector {
+    id<UINavigationControllerDelegate> previous = _previous;
+    if ([previous respondsToSelector:selector]) {
+        return previous;
+    }
+    return [super forwardingTargetForSelector:selector];
+}
+
+#pragma mark - UINavigationControllerDelegate
+
+- (void)navigationController:(UINavigationController *)navigationController
+      willShowViewController:(UIViewController *)viewController
+                    animated:(BOOL)animated {
+    id<UINavigationControllerDelegate> previous = _previous;
+    if ([previous respondsToSelector:_cmd]) {
+        [previous navigationController:navigationController
+                willShowViewController:viewController
+                              animated:animated];
+    }
+    [_tabs moreNavigation:navigationController willShowViewController:viewController];
+}
+
+- (void)navigationController:(UINavigationController *)navigationController
+       didShowViewController:(UIViewController *)viewController
+                    animated:(BOOL)animated {
+    id<UINavigationControllerDelegate> previous = _previous;
+    if ([previous respondsToSelector:_cmd]) {
+        [previous navigationController:navigationController
+                 didShowViewController:viewController
+                              animated:animated];
+    }
+    [_tabs moreNavigation:navigationController didShowViewController:viewController];
+}
+
+@end

package/ios/Layouts/Tabs/ANNScrollToTop.h

@@ -0,0 +1,23 @@
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// The repeat press on a tab whose stack is on its first screen: the screen's content goes to its top, animated. It
+/// reads the views only and moves only the scroll offset: nothing of React Native's layout changes.
+@interface ANNScrollToTop : NSObject
+
+- (instancetype)init NS_UNAVAILABLE;
++ (instancetype)new NS_UNAVAILABLE;
+
+/// The first `UIScrollView` under `view` (depth first, shown ones only) that scrolls more than horizontally goes to its
+/// top with its content inset, animated. With a large title that can show in `navigationBar` (shown), "the top" is
+/// where the title is expanded, as at the screen's first show: the bar measures its insets collapsed while the list is
+/// scrolled, so the list goes past that top by the large title's row and UIKit expands the title as it tracks the
+/// list. NO when there is no such scroll view.
++ (BOOL)scrollToTopIn:(nullable UIView *)view
+        navigationBar:(nullable UINavigationBar *)navigationBar
+      largeTitleShows:(BOOL)largeTitleShows;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/Layouts/Tabs/ANNScrollToTop.mm

@@ -0,0 +1,55 @@
+#import "ANNScrollToTop.h"
+
+// UIKit's row of an expanded large title, and the height under which a bar shows no expanded large title (a bar with a
+// large title is at least the row taller than its 44–54 pt collapsed height).
+static const CGFloat ANNLargeTitleRowHeight = 52;
+static const CGFloat ANNCollapsedBarLimit = 70;
+
+// A scroll view that scrolls only horizontally has content no taller than itself and no vertical bounce.
+static BOOL ANNScrollsVertically(UIScrollView *scrollView) {
+    UIEdgeInsets inset = scrollView.adjustedContentInset;
+    CGFloat contentHeight = scrollView.contentSize.height + inset.top + inset.bottom;
+    CGFloat contentWidth = scrollView.contentSize.width + inset.left + inset.right;
+    BOOL onlyHorizontal = contentWidth > scrollView.bounds.size.width &&
+                          contentHeight <= scrollView.bounds.size.height &&
+                          !scrollView.alwaysBounceVertical;
+    return !onlyHorizontal;
+}
+
+static UIScrollView *_Nullable ANNFirstVerticalScrollView(UIView *view) {
+    if (view.hidden || view.alpha <= 0) {
+        return nil;
+    }
+    if ([view isKindOfClass:UIScrollView.class] && ANNScrollsVertically((UIScrollView *)view)) {
+        return (UIScrollView *)view;
+    }
+    for (UIView *subview in view.subviews) {
+        UIScrollView *found = ANNFirstVerticalScrollView(subview);
+        if (found) {
+            return found;
+        }
+    }
+    return nil;
+}
+
+@implementation ANNScrollToTop
+
++ (BOOL)scrollToTopIn:(UIView *)view
+        navigationBar:(UINavigationBar *)navigationBar
+      largeTitleShows:(BOOL)largeTitleShows {
+    UIScrollView *scrollView = view ? ANNFirstVerticalScrollView(view) : nil;
+    if (!scrollView) {
+        return NO;
+    }
+    CGFloat top = -scrollView.adjustedContentInset.top;
+    // Scrolled under a large title that collapsed: past the collapsed top by the title's row.
+    BOOL scrolled = scrollView.contentOffset.y > top + 0.5;
+    if (largeTitleShows && scrolled && navigationBar.prefersLargeTitles &&
+        navigationBar.frame.size.height < ANNCollapsedBarLimit) {
+        top -= ANNLargeTitleRowHeight;
+    }
+    [scrollView setContentOffset:CGPointMake(scrollView.contentOffset.x, top) animated:YES];
+    return YES;
+}
+
+@end

package/ios/Layouts/Tabs/ANNTabDotView.h

@@ -0,0 +1,19 @@
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// The dot of a tab before iOS 26 and in the compatibility mode: a round view of its own over the tab bar, its center
+/// on the top right corner of the tab's icon. Placed by frame, never by constraints (a tab bar under its controller
+/// throws on a change of constraints), and placed again at every layout of the tabs. Takes no touches.
+@interface ANNTabDotView : UIView
+
+/// The dot's diameter (`dotIndicator.size`, 6 by default) and color (red by default).
+- (void)setDiameter:(CGFloat)diameter color:(UIColor *)color;
+
+/// The dot over `button` (the tab's button in `bar`): at the top right corner of its icon, or hidden when the button or
+/// its icon isn't there.
+- (void)placeOverButton:(nullable UIView *)button inBar:(UITabBar *)bar;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/Layouts/Tabs/ANNTabDotView.mm

@@ -0,0 +1,46 @@
+#import "ANNTabDotView.h"
+#import "UIView+Utils.h"
+
+@implementation ANNTabDotView
+
+- (instancetype)initWithFrame:(CGRect)frame {
+    if (self = [super initWithFrame:frame]) {
+        self.userInteractionEnabled = NO;
+        self.hidden = YES;
+        self.layer.masksToBounds = YES;
+    }
+    return self;
+}
+
+- (void)setDiameter:(CGFloat)diameter color:(UIColor *)color {
+    CGPoint center = self.center;
+    self.bounds = CGRectMake(0, 0, diameter, diameter);
+    self.center = center;
+    self.layer.cornerRadius = diameter / 2;
+    self.backgroundColor = color;
+}
+
+// The icon is the button's image view (the module finds it the same way for the centered icons); without one the
+// dot sits at the top right of the button's middle.
+- (void)placeOverButton:(UIView *)button inBar:(UITabBar *)bar {
+    if (!button || button.hidden || !button.window) {
+        self.hidden = YES;
+        return;
+    }
+    if (self.superview != bar) {
+        [bar addSubview:self];
+    }
+    [bar bringSubviewToFront:self];
+    UIView *icon = [button findDescendantByClass:UIImageView.class];
+    CGRect iconFrame =
+        icon ? [icon convertRect:icon.bounds toView:bar]
+             : [button convertRect:CGRectInset(button.bounds, button.bounds.size.width / 3, 8)
+                            toView:bar];
+    CGPoint corner = CGPointMake(CGRectGetMaxX(iconFrame), CGRectGetMinY(iconFrame));
+    if (!CGPointEqualToPoint(self.center, corner)) {
+        self.center = corner;
+    }
+    self.hidden = NO;
+}
+
+@end

package/ios/Layouts/Tabs/ANNTabLongPress.h

@@ -0,0 +1,28 @@
+#import <UIKit/UIKit.h>
+
+@class ANNBottomTabsController;
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// The long press on the tab bar's buttons. On iOS 26 the system selects tabs with its own gesture: the recognizer
+/// works together with it, and the tabs cancel UIKit's selection of the long-pressed tab at the release. Before iOS 26
+/// the long press cancels the touch of the button by itself. The tab is found by the frame of each tab's own button
+/// (the module's `viewOfItem:` with the tab's item), converted into the bar's coordinates, among the tabs of the
+/// layout: More and the room between the buttons send nothing. The iPad's top bar is another view of the system: no
+/// long press there.
+@interface ANNTabLongPress : NSObject <UIGestureRecognizerDelegate>
+
+- (instancetype)initWithTabs:(ANNBottomTabsController *)tabs;
+
+- (instancetype)init NS_UNAVAILABLE;
++ (instancetype)new NS_UNAVAILABLE;
+
+/// The recognizer goes onto the tabs' bar (once).
+- (void)attach;
+
+/// The recognizer leaves the bar.
+- (void)detach;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/Layouts/Tabs/ANNTabLongPress.mm

@@ -0,0 +1,98 @@
+#import "ANNTabLongPress.h"
+#import "ANNBottomTabsController.h"
+#import "UITabBar+utils.h"
+
+@implementation ANNTabLongPress {
+    __weak ANNBottomTabsController *_tabs;
+    UILongPressGestureRecognizer *_recognizer;
+}
+
+- (instancetype)initWithTabs:(ANNBottomTabsController *)tabs {
+    if (self = [super init]) {
+        _tabs = tabs;
+    }
+    return self;
+}
+
+- (void)attach {
+    UITabBar *bar = _tabs.tabBar;
+    if (!bar || _recognizer.view == bar) {
+        return;
+    }
+    if (!_recognizer) {
+        _recognizer = [[UILongPressGestureRecognizer alloc] initWithTarget:self
+                                                                    action:@selector(longPressed:)];
+        _recognizer.delegate = self;
+    }
+    // On iOS 26 the system's selection gesture takes the touch: the long press works along with it. Before, the long
+    // press cancels the button's touch by itself, so the tab isn't selected.
+    if (@available(iOS 26.0, *)) {
+        _recognizer.cancelsTouchesInView = NO;
+    }
+    [bar addGestureRecognizer:_recognizer];
+}
+
+- (void)detach {
+    [_recognizer.view removeGestureRecognizer:_recognizer];
+}
+
+#pragma mark - The gesture
+
+- (void)longPressed:(UILongPressGestureRecognizer *)recognizer {
+    ANNBottomTabsController *tabs = _tabs;
+    if (!tabs) {
+        return;
+    }
+    switch (recognizer.state) {
+        case UIGestureRecognizerStateBegan: {
+            NSUInteger index = [self tabIndexAt:[recognizer locationInView:tabs.tabBar]];
+            if (index == NSNotFound) {
+                return;
+            }
+            BOOL marksSelection = NO;
+            if (@available(iOS 26.0, *)) {
+                marksSelection = YES;
+            }
+            [tabs longPressTabAtIndex:index marksSelection:marksSelection];
+            break;
+        }
+        case UIGestureRecognizerStateEnded:
+        case UIGestureRecognizerStateCancelled:
+        case UIGestureRecognizerStateFailed:
+            [tabs longPressEnded];
+            break;
+        default:
+            break;
+    }
+}
+
+// Each tab's own button, by its item (never by UIKit's index, which counts More and another order); the buttons sit in
+// their platter on iOS 26, so their frames go into the bar's coordinates.
+- (NSUInteger)tabIndexAt:(CGPoint)point {
+    ANNBottomTabsController *tabs = _tabs;
+    UITabBar *bar = tabs.tabBar;
+    NSArray<UIViewController *> *list = tabs.layoutTabs;
+    for (NSUInteger index = 0; index < list.count; index++) {
+        UIView *button = [bar viewOfItem:list[index].tabBarItem];
+        if (!button || button.hidden || button.window != bar.window) {
+            continue;
+        }
+        CGRect frame = [button convertRect:button.bounds toView:bar];
+        if (CGRectContainsPoint(frame, point)) {
+            return index;
+        }
+    }
+    return NSNotFound;
+}
+
+#pragma mark - UIGestureRecognizerDelegate
+
+- (BOOL)gestureRecognizer:(UIGestureRecognizer *)gestureRecognizer
+    shouldRecognizeSimultaneouslyWithGestureRecognizer:(UIGestureRecognizer *)other {
+    if (@available(iOS 26.0, *)) {
+        return YES;
+    }
+    return NO;
+}
+
+@end

package/ios/Layouts/Tabs/ANNTabsDesign.h

@@ -0,0 +1,26 @@
+#import <UIKit/UIKit.h>
+
+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).
+@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.
+@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
+/// the bottom keeps nothing of it.
++ (BOOL)barIsOnTopIn:(UITraitCollection *)traits;
+
+- (instancetype)init NS_UNAVAILABLE;
++ (instancetype)new NS_UNAVAILABLE;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/Layouts/Tabs/ANNTabsDesign.mm

@@ -0,0 +1,34 @@
+#import "ANNTabsDesign.h"
+
+@implementation ANNTabsDesign
+
+// Read once: the Info.plist of a running app doesn't change.
++ (BOOL)isCompatibilityMode {
+    static BOOL compatibility;
+    static dispatch_once_t once;
+    dispatch_once(&once, ^{
+      if (@available(iOS 26.0, *)) {
+          id value = NSBundle.mainBundle.infoDictionary[@"UIDesignRequiresCompatibility"];
+          compatibility = [value respondsToSelector:@selector(boolValue)] && [value boolValue];
+      }
+    });
+    return compatibility;
+}
+
++ (BOOL)isGlass {
+    if (@available(iOS 26.0, *)) {
+        return !self.isCompatibilityMode;
+    }
+    return NO;
+}
+
++ (BOOL)barIsOnTopIn:(UITraitCollection *)traits {
+    if (@available(iOS 18.0, *)) {
+        UIUserInterfaceIdiom idiom = traits.userInterfaceIdiom;
+        BOOL wide = idiom == UIUserInterfaceIdiomPad || idiom == UIUserInterfaceIdiomMac;
+        return wide && traits.horizontalSizeClass == UIUserInterfaceSizeClassRegular;
+    }
+    return NO;
+}
+
+@end

package/ios/Layouts/Tabs/ANNTabsPreloadWindow.h

@@ -0,0 +1,27 @@
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// Where the React views of unselected tabs mount while the tabs render: a window of zero size that clips what it
+/// holds, hidden from accessibility, in the scene of the navigation's main window. Nothing in it is seen and its safe
+/// area views never lay out there: a tab renders its content where it shows. One per tabs node; it goes when it holds
+/// nothing more or with its tabs. Main queue.
+@interface ANNTabsPreloadWindow : UIWindow
+
+/// A new window in the scene of the main window; when the main window has no scene yet, it joins the scene as the main
+/// window connects (`mainWindowSceneDidConnect:`), before it holds anything that could be seen.
++ (instancetype)preloadWindow;
+
+/// The main window connected to its scene: every live preload window joins it.
++ (void)mainWindowSceneDidConnect:(UIWindowScene *)windowScene;
+
+/// A reload of the JavaScript: every live preload window hides at once; its views go with their old tabs after the
+/// reload's hold.
++ (void)hideAllAfterReload;
+
+/// The window goes: it hides and leaves its scene. Its views are the tabs' to take back first.
+- (void)close;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/Layouts/Tabs/ANNTabsPreloadWindow.mm

@@ -0,0 +1,55 @@
+#import "ANNTabsPreloadWindow.h"
+#import "ANNAssert.h"
+#import "ApexNavigation+Internal.h"
+
+// Every live preload window, weakly: the reload hides them, the scene's connection moves them. Main queue.
+static NSHashTable<ANNTabsPreloadWindow *> *ANNPreloadWindows(void) {
+    static NSHashTable<ANNTabsPreloadWindow *> *windows;
+    if (!windows) {
+        windows = [NSHashTable weakObjectsHashTable];
+    }
+    return windows;
+}
+
+@implementation ANNTabsPreloadWindow
+
++ (instancetype)preloadWindow {
+    ANNAssertMainQueue();
+    UIWindowScene *scene = ApexNavigation.mainWindow.windowScene;
+    ANNTabsPreloadWindow *window =
+        scene ? [[self alloc] initWithWindowScene:scene] : [[self alloc] initWithFrame:CGRectZero];
+    window.frame = CGRectZero;
+    window.clipsToBounds = YES;
+    window.userInteractionEnabled = NO;
+    window.accessibilityElementsHidden = YES;
+    window.backgroundColor = UIColor.clearColor;
+    // Under every window of the app: nothing of it is ever drawn over the navigation.
+    window.windowLevel = UIWindowLevelNormal - 1;
+    window.hidden = NO;
+    [ANNPreloadWindows() addObject:window];
+    return window;
+}
+
++ (void)mainWindowSceneDidConnect:(UIWindowScene *)windowScene {
+    ANNAssertMainQueue();
+    for (ANNTabsPreloadWindow *window in ANNPreloadWindows().allObjects) {
+        if (window.windowScene != windowScene) {
+            window.windowScene = windowScene;
+        }
+    }
+}
+
++ (void)hideAllAfterReload {
+    ANNAssertMainQueue();
+    for (ANNTabsPreloadWindow *window in ANNPreloadWindows().allObjects) {
+        window.hidden = YES;
+    }
+}
+
+- (void)close {
+    self.hidden = YES;
+    [ANNPreloadWindows() removeObject:self];
+    self.windowScene = nil;
+}
+
+@end

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

@@ -0,0 +1,24 @@
+#import <UIKit/UIKit.h>
+
+@interface UITabBar (utils)
+
+/**
+ * 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).
+ */
+- (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
+ * 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.
+ */
+- (void)setItemImagesCentered:(BOOL)centered;
+
+@end

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

@@ -0,0 +1,103 @@
+#import "UITabBar+utils.h"
+#import "UIView+Utils.h"
+#import <objc/runtime.h>
+
+static const void *ANNItemImagesCenteredKey = &ANNItemImagesCenteredKey;
+
+typedef void (*ANNLayoutSubviewsIMP)(id, SEL);
+static ANNLayoutSubviewsIMP ANNTabBarButtonLayoutSubviewsOriginal;
+
+static UITabBar *ANNTabBarOfButton(UIView *button) {
+    UIView *view = button.superview;
+    while (view && ![view isKindOfClass:UITabBar.class]) {
+        view = view.superview;
+    }
+    return (UITabBar *)view;
+}
+
+// -layoutSubviews of UITabBarButton. The button keeps the room of a title its item does not have,
+// so in a tab bar with centered images the icon moves to the middle of the button after UIKit lays
+// it out, and the badge moves with it.
+static void ANNTabBarButtonLayoutSubviews(UIView *button, SEL _cmd) {
+    ANNTabBarButtonLayoutSubviewsOriginal(button, _cmd);
+    if (![objc_getAssociatedObject(ANNTabBarOfButton(button), ANNItemImagesCenteredKey)
+            boolValue]) {
+        return;
+    }
+    // With a translucent tab bar the icons of the tabs that are not selected are inside a vibrancy
+    // view of the button.
+    UIView *icon = [button findDescendantByClass:NSClassFromString(@"UITabBarSwappableImageView")];
+    if (!icon) {
+        return;
+    }
+    CGRect iconFrame = [icon.superview convertRect:icon.frame toView:button];
+    CGFloat offset = CGRectGetMidY(button.bounds) - CGRectGetMidY(iconFrame);
+    icon.center = CGPointMake(icon.center.x, icon.center.y + offset);
+    UIView *badge = [button findDescendantByClass:NSClassFromString(@"_UIBadgeView")];
+    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.
+static BOOL ANNTabBarButtonsKeepTitleRoom(void) {
+    if (@available(iOS 26.0, *)) {
+        return [[NSBundle.mainBundle objectForInfoDictionaryKey:@"UIDesignRequiresCompatibility"]
+            boolValue];
+    }
+    return YES;
+}
+
+// Once for the app; the buttons of other tab bars keep the layout of UIKit.
+static void ANNInstallTabBarButtonLayout(void) {
+    static dispatch_once_t once;
+    dispatch_once(&once, ^{
+      Class buttonClass = NSClassFromString(@"UITabBarButton");
+      Method method =
+          buttonClass ? class_getInstanceMethod(buttonClass, @selector(layoutSubviews)) : NULL;
+      if (!method) {
+          return;
+      }
+      ANNTabBarButtonLayoutSubviewsOriginal =
+          (ANNLayoutSubviewsIMP)method_getImplementation(method);
+      // Added to the button class when it only inherits the method: other views keep theirs.
+      class_replaceMethod(buttonClass, @selector(layoutSubviews),
+                          (IMP)ANNTabBarButtonLayoutSubviews, method_getTypeEncoding(method));
+    });
+}
+
+@implementation UITabBar (utils)
+
+- (UIView *)viewOfItem:(UITabBarItem *)item {
+    if (![item respondsToSelector:NSSelectorFromString(@"view")]) {
+        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;
+}
+
+- (void)removeTabBarItemTitles {
+    for (UITabBarItem *item in self.items) {
+        item.title = nil;
+    }
+}
+
+- (void)setItemImagesCentered:(BOOL)centered {
+    centered = centered && ANNTabBarButtonsKeepTitleRoom();
+    if ([objc_getAssociatedObject(self, ANNItemImagesCenteredKey) boolValue] == centered) {
+        return;
+    }
+    if (centered) {
+        ANNInstallTabBarButtonLayout();
+    }
+    objc_setAssociatedObject(self, ANNItemImagesCenteredKey, @(centered),
+                             OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+    for (UITabBarItem *item in self.items) {
+        [[self viewOfItem:item] setNeedsLayout];
+    }
+}
+
+@end

package/ios/Options/ANNAnimationOptions.h

@@ -0,0 +1,22 @@
+#import "ANNEnterExitScreenAnimationOptions.h"
+#import "ANNModalAnimationOptions.h"
+#import "ANNOptions.h"
+#import "ANNSetStackRootAnimationOptions.h"
+#import "ANNStackAnimationOptions.h"
+#import "ANNStackPushAnimationOptions.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// `animations` (`AnimationOptions`): the animations of the commands.
+@interface ANNAnimationOptions : ANNOptions
+
+@property(nonatomic, strong) ANNStackPushAnimationOptions *push;
+@property(nonatomic, strong) ANNStackAnimationOptions *pop;
+@property(nonatomic, strong) ANNSetStackRootAnimationOptions *setStackRoot;
+@property(nonatomic, strong) ANNEnterExitScreenAnimationOptions *setRoot;
+@property(nonatomic, strong) ANNModalAnimationOptions *showModal;
+@property(nonatomic, strong) ANNModalAnimationOptions *dismissModal;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/Options/ANNAnimationOptions.mm

@@ -0,0 +1,16 @@
+#import "ANNAnimationOptions.h"
+
+@implementation ANNAnimationOptions
+
++ (NSArray<ANNOptionField *> *)optionFields {
+    return @[
+        [ANNOptionField groupField:@"push" class:ANNStackPushAnimationOptions.class],
+        [ANNOptionField groupField:@"pop" class:ANNStackAnimationOptions.class],
+        [ANNOptionField groupField:@"setStackRoot" class:ANNSetStackRootAnimationOptions.class],
+        [ANNOptionField groupField:@"setRoot" class:ANNEnterExitScreenAnimationOptions.class],
+        [ANNOptionField groupField:@"showModal" class:ANNModalAnimationOptions.class],
+        [ANNOptionField groupField:@"dismissModal" class:ANNModalAnimationOptions.class],
+    ];
+}
+
+@end