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

package/ios/Layouts/Stack/InteractivePopGestureDelegate.h

@@ -0,0 +1,53 @@
+#import <UIKit/UIKit.h>
+
+@class ANNStackController;
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// The delegate of one of a stack's swipes back: the edge swipe (`interactivePopGestureRecognizer`) or, on iOS 26, the
+/// swipe from the content (`interactiveContentPopGestureRecognizer`). It keeps UIKit's own delegate of the recognizer
+/// and hands it every question it doesn't answer itself, so the links UIKit makes between the swipe and the gestures of
+/// the content stay (a horizontal list scrolls and bounces at its start). The side menu reads `enabled` of the content
+/// swipe's delegate and asks the edge swipe's delegate whether it takes a touch.
+@interface InteractivePopGestureDelegate : NSObject <UIGestureRecognizerDelegate>
+
+/// A delegate of no stack: it answers only `enabled`.
+- (instancetype)init;
+
+/// The delegate of a swipe of `stack`, over UIKit's own delegate of the recognizer. `content` is the swipe from the
+/// content.
+- (instancetype)initWithStack:(nullable ANNStackController *)stack
+               systemDelegate:(nullable id<UIGestureRecognizerDelegate>)systemDelegate
+                      content:(BOOL)content NS_DESIGNATED_INITIALIZER;
+
+/// `popGesture` of the screen on top lets this swipe go back: the edge swipe unless it is `false`, the swipe from
+/// the content only when it is `true` (`popGesture`). The stack sets it at each appearance of a top screen and at each
+/// `mergeOptions` of it.
+@property(nonatomic) BOOL enabled;
+
+/// UIKit's own delegate of the recognizer.
+@property(nonatomic, strong, readonly, nullable) id<UIGestureRecognizerDelegate> systemDelegate;
+
+/// The bar of the navigation that shows the stack's screens is hidden. UIKit's delegate refuses every swipe back
+/// then, in questions of its own that come before the public ones; while the bar is hidden the swipe passes UIKit's
+/// delegate only the public questions of `UIGestureRecognizerDelegate`, and the core decides. A change sets the
+/// delegate on the recognizer again (UIKit reads which questions a delegate answers when it is set). The stack sets
+/// it as the bar shows or hides.
+@property(nonatomic) BOOL barHidden;
+
+/// The one way a swipe back gets the delegate of `stack`: on the stack's own navigation and on UIKit's More navigation
+/// while it shows the stack's screens. UIKit's own delegate stays under it, also when a delegate of another stack
+/// was there. `barSwipe` (the navigation's `barHideOnSwipeGestureRecognizer`) waits for the swipe to fail, once, so that
+/// a horizontal swipe still goes back with `hidesBarsOnSwipe`. Returns the delegate on the
+/// recognizer, the one there when it is already this stack's.
++ (nullable InteractivePopGestureDelegate *)installOn:(nullable UIGestureRecognizer *)recognizer
+                                                stack:(ANNStackController *)stack
+                                              content:(BOOL)content
+                                             barSwipe:(nullable UIGestureRecognizer *)barSwipe;
+
+/// The recognizer gets UIKit's own delegate back when a delegate of a stack is on it (the More list shows again).
++ (void)restoreSystemDelegateOf:(nullable UIGestureRecognizer *)recognizer;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/Layouts/Stack/InteractivePopGestureDelegate.mm

@@ -0,0 +1,228 @@
+#import "InteractivePopGestureDelegate.h"
+#import "ANNStackController.h"
+#import "ANNSystemUI.h"
+#import <objc/runtime.h>
+
+// The swipes a bars' swipe recognizer was made to wait for.
+static const void *ANNAwaitedSwipesKey = &ANNAwaitedSwipesKey;
+
+@implementation InteractivePopGestureDelegate {
+    __weak ANNStackController *_stack;
+    BOOL _content;
+    // The touch the swipe took last: where the pan started.
+    __weak UITouch *_touch;
+    // The recognizer this delegate is set on.
+    __weak UIGestureRecognizer *_recognizer;
+}
+
+// A question of UIKit's delegate outside the public protocol.
+static BOOL ANNIsOwnQuestionOfUIKit(SEL selector) {
+    const char *name = sel_getName(selector);
+    return name && name[0] == '_';
+}
+
+- (instancetype)init {
+    return [self initWithStack:nil systemDelegate:nil content:NO];
+}
+
+- (instancetype)initWithStack:(ANNStackController *)stack
+               systemDelegate:(id<UIGestureRecognizerDelegate>)systemDelegate
+                      content:(BOOL)content {
+    if (self = [super init]) {
+        _enabled = YES;
+        _stack = stack;
+        _systemDelegate = systemDelegate;
+        _content = content;
+    }
+    return self;
+}
+
++ (InteractivePopGestureDelegate *)installOn:(UIGestureRecognizer *)recognizer
+                                       stack:(ANNStackController *)stack
+                                     content:(BOOL)content
+                                    barSwipe:(UIGestureRecognizer *)barSwipe {
+    if (!recognizer) {
+        return nil;
+    }
+    id<UIGestureRecognizerDelegate> current = recognizer.delegate;
+    InteractivePopGestureDelegate *installed = nil;
+    if ([current isKindOfClass:InteractivePopGestureDelegate.class]) {
+        InteractivePopGestureDelegate *ours = (InteractivePopGestureDelegate *)current;
+        if (ours->_stack == stack && ours->_content == content) {
+            installed = ours;
+        } else {
+            current = ours.systemDelegate;
+        }
+    }
+    if (!installed) {
+        installed = [[InteractivePopGestureDelegate alloc] initWithStack:stack
+                                                          systemDelegate:current
+                                                                 content:content];
+        installed->_recognizer = recognizer;
+        recognizer.delegate = installed;
+    }
+    if (barSwipe) {
+        NSHashTable<UIGestureRecognizer *> *awaited =
+            objc_getAssociatedObject(barSwipe, ANNAwaitedSwipesKey);
+        if (!awaited) {
+            awaited = [NSHashTable weakObjectsHashTable];
+            objc_setAssociatedObject(barSwipe, ANNAwaitedSwipesKey, awaited,
+                                     OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+        }
+        if (![awaited containsObject:recognizer]) {
+            [awaited addObject:recognizer];
+            [barSwipe requireGestureRecognizerToFail:recognizer];
+        }
+    }
+    return installed;
+}
+
++ (void)restoreSystemDelegateOf:(UIGestureRecognizer *)recognizer {
+    id<UIGestureRecognizerDelegate> current = recognizer.delegate;
+    if ([current isKindOfClass:InteractivePopGestureDelegate.class]) {
+        recognizer.delegate = ((InteractivePopGestureDelegate *)current).systemDelegate;
+    }
+}
+
+#pragma mark - UIGestureRecognizerDelegate
+
+// The order: `popGesture` first (with `false` there is neither a swipe nor the hold's event), then one screen or a
+// stack not at rest, then the hold (its event instead of the swipe), then the edge swipe under a hidden bar begins
+// without UIKit's delegate, and otherwise UIKit's delegate decides (its direction, a vertical scroll of the content). A
+// top that isn't the stack's own (a column UIKit's split view moved in) is UIKit's.
+//
+// Every pan in the content is offered to the content swipe, so it is first sorted: a pan that isn't a swipe back
+// (vertical, the other way) is no attempt, and neither is one on a list that scrolls sideways, which takes the pan
+// itself and bounces at its start, as in plain UIKit. UIKit's delegate sorts the pans while the bar shows; under a
+// hidden bar it refuses them all, and the swipe sorts them itself, as the edge swipe begins there without it.
+- (BOOL)gestureRecognizerShouldBegin:(UIGestureRecognizer *)gestureRecognizer {
+    ANNStackController *stack = _stack;
+    if (stack && ![stack swipeBackIsUIKits:gestureRecognizer]) {
+        if (!_enabled || ![stack swipeBackMayBegin]) {
+            return NO;
+        }
+        UINavigationController *navigation = stack.shownNavigationController;
+        BOOL barHidden = [ANNSystemUI barHiddenOf:navigation];
+        if (_content) {
+            BOOL back = barHidden ? [self panGoesBack:gestureRecognizer in:navigation]
+                                  : [self systemDelegateLetsBegin:gestureRecognizer];
+            if (!back) {
+                return NO;
+            }
+            if ((barHidden || stack.backIsHeld) && [self touchIsOnSidewaysList:navigation]) {
+                return NO;
+            }
+            return ![stack holdsSwipeBack];
+        }
+        if ([stack holdsSwipeBack]) {
+            return NO;
+        }
+        if (barHidden) {
+            return YES;
+        }
+    }
+    return [self systemDelegateLetsBegin:gestureRecognizer];
+}
+
+// A pan that moves more across than along, towards the edge the screens go back to (the navigation's direction).
+- (BOOL)panGoesBack:(UIGestureRecognizer *)gestureRecognizer in:(UINavigationController *)navigation {
+    if (![gestureRecognizer isKindOfClass:UIPanGestureRecognizer.class]) {
+        return [self systemDelegateLetsBegin:gestureRecognizer];
+    }
+    UIView *view = navigation.view;
+    CGPoint move = [(UIPanGestureRecognizer *)gestureRecognizer translationInView:view];
+    if (move.x == 0 && move.y == 0) {
+        move = [(UIPanGestureRecognizer *)gestureRecognizer velocityInView:view];
+    }
+    if (fabs(move.x) <= fabs(move.y)) {
+        return NO;
+    }
+    BOOL rightToLeft =
+        view.effectiveUserInterfaceLayoutDirection == UIUserInterfaceLayoutDirectionRightToLeft;
+    return rightToLeft ? move.x < 0 : move.x > 0;
+}
+
+// The touch lies on a scroll view that scrolls sideways (read only: the content's views are React Native's).
+- (BOOL)touchIsOnSidewaysList:(UINavigationController *)navigation {
+    UIView *stop = navigation.view;
+    for (UIView *view = _touch.view; view && view != stop; view = view.superview) {
+        if (![view isKindOfClass:UIScrollView.class]) {
+            continue;
+        }
+        UIScrollView *list = (UIScrollView *)view;
+        UIEdgeInsets inset = list.adjustedContentInset;
+        CGFloat width = list.contentSize.width + inset.left + inset.right;
+        if (list.scrollEnabled &&
+            (list.alwaysBounceHorizontal || width > list.bounds.size.width + 0.5)) {
+            return YES;
+        }
+    }
+    return NO;
+}
+
+- (BOOL)systemDelegateLetsBegin:(UIGestureRecognizer *)gestureRecognizer {
+    id<UIGestureRecognizerDelegate> systemDelegate = _systemDelegate;
+    if ([systemDelegate respondsToSelector:@selector(gestureRecognizerShouldBegin:)]) {
+        return [systemDelegate gestureRecognizerShouldBegin:gestureRecognizer];
+    }
+    return YES;
+}
+
+// Whether the swipe takes the touch (the side menu asks it for the edge it opens from): never while it is off or the
+// stack has one screen. It sends nothing: the hold's event belongs to the swipe's start. Under a hidden bar UIKit's
+// delegate refuses every touch of the swipes: the swipe takes them itself there, and sorts the pans as they begin.
+- (BOOL)gestureRecognizer:(UIGestureRecognizer *)gestureRecognizer
+       shouldReceiveTouch:(UITouch *)touch {
+    ANNStackController *stack = _stack;
+    if (stack && ![stack swipeBackIsUIKits:gestureRecognizer]) {
+        if (!_enabled || stack.hasOneEntry) {
+            return NO;
+        }
+        _touch = touch;
+        [stack swipeBackReceivesTouch:touch];
+        if ([ANNSystemUI barHiddenOf:stack.shownNavigationController]) {
+            return YES;
+        }
+    }
+    id<UIGestureRecognizerDelegate> systemDelegate = _systemDelegate;
+    if ([systemDelegate respondsToSelector:@selector(gestureRecognizer:shouldReceiveTouch:)]) {
+        return [systemDelegate gestureRecognizer:gestureRecognizer shouldReceiveTouch:touch];
+    }
+    return YES;
+}
+
+#pragma mark - The rest goes to UIKit's delegate
+
+- (void)setBarHidden:(BOOL)barHidden {
+    if (_barHidden == barHidden) {
+        return;
+    }
+    _barHidden = barHidden;
+    UIGestureRecognizer *recognizer = _recognizer;
+    if (recognizer.delegate == self) {
+        recognizer.delegate = nil;
+        recognizer.delegate = self;
+    }
+}
+
+// Under a hidden bar UIKit's own questions aren't passed on: the recognizer then never asks them. A question asked
+// still goes to UIKit's delegate (one the recognizer learned of before the change).
+- (BOOL)respondsToSelector:(SEL)selector {
+    if ([super respondsToSelector:selector]) {
+        return YES;
+    }
+    if (_barHidden && ANNIsOwnQuestionOfUIKit(selector)) {
+        return NO;
+    }
+    return [_systemDelegate respondsToSelector:selector];
+}
+
+- (id)forwardingTargetForSelector:(SEL)selector {
+    id<UIGestureRecognizerDelegate> systemDelegate = _systemDelegate;
+    if ([systemDelegate respondsToSelector:selector]) {
+        return systemDelegate;
+    }
+    return [super forwardingTargetForSelector:selector];
+}
+
+@end

package/ios/Layouts/Stack/UINavigationController+ANNCommands.h

@@ -0,0 +1,19 @@
+#import "ANNLayoutProtocol.h"
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// The commands of a stack.
+@interface UINavigationController (ANNCommands)
+
+/// `setStackRoot`: `children` in place of the stack's screens, the last one on top, from the screen
+/// `fromViewController`.
+- (void)setStackChildren:(NSArray<UIViewController *> *)children
+      fromViewController:(nullable UIViewController *)fromViewController
+                animated:(BOOL)animated
+              completion:(ANNTransitionCompletionBlock)completion
+               rejection:(ANNTransitionRejectionBlock)rejection;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/Layouts/Stack/UINavigationController+ANNCommands.mm

@@ -0,0 +1,29 @@
+#import "UINavigationController+ANNCommands.h"
+#import "ANNErrorTexts.h"
+#import "ANNStackController.h"
+#import "UIViewController+LayoutProtocol.h"
+
+@implementation UINavigationController (ANNCommands)
+
+// A stack of the core takes the screens through its queue, without a wait. A navigation controller of UIKit's own (the
+// one UIKit puts around a column that is a screen alone) has no queue: it rejects.
+- (void)setStackChildren:(NSArray<UIViewController *> *)children
+      fromViewController:(UIViewController *)fromViewController
+                animated:(BOOL)animated
+              completion:(ANNTransitionCompletionBlock)completion
+               rejection:(ANNTransitionRejectionBlock)rejection {
+    if ([self isKindOfClass:ANNStackController.class]) {
+        [(ANNStackController *)self setChildren:children
+                             fromViewController:fromViewController
+                                       animated:animated
+                                     completion:completion
+                                      rejection:rejection];
+        return;
+    }
+    NSString *fromId = fromViewController.layoutInfo.componentId ?: @"";
+    NSString *what = [NSString stringWithFormat:@"set the stack of the screen '%@'", fromId];
+    NSString *reason = @"its column is not a stack of the navigation";
+    rejection([ANNErrorTexts couldNot:what reason:reason], nil);
+}
+
+@end

package/ios/Layouts/Tabs/ANNBottomTabCellView.h

@@ -0,0 +1,33 @@
+#import "ANNReactView.h"
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// The place of one tab in the custom row: it holds the tab's content view (a React root by name now; a component of
+/// the React tree can take the same place later) at its own size, carries the tab's `testID`, and takes the touches
+/// itself: the content takes none. It gives the root its native props as they change (`tabIndex`, `selected`, `badge`,
+/// `dot`, `dotColor`).
+@interface ANNBottomTabCellView : UIView
+
+- (instancetype)initWithIndex:(NSUInteger)index;
+
+- (instancetype)initWithFrame:(CGRect)frame NS_UNAVAILABLE;
+- (nullable instancetype)initWithCoder:(NSCoder *)coder NS_UNAVAILABLE;
+
+@property(nonatomic, readonly) NSUInteger index;
+
+/// What the cell shows; a new one replaces the old one in the cell (the roots stop with their tabs, not here).
+@property(nonatomic, strong, nullable) UIView<ANNComponentProtocol> *content;
+
+/// The tab's state as the root gets it: set only when something changed.
+- (void)setSelected:(BOOL)selected
+              badge:(nullable NSString *)badge
+                dot:(BOOL)dot
+           dotColor:(nullable UIColor *)dotColor;
+
+/// The tab's `testID` on the cell's place; nil removes it.
+- (void)setTestID:(nullable NSString *)testID;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/Layouts/Tabs/ANNBottomTabCellView.mm

@@ -0,0 +1,100 @@
+#import "ANNBottomTabCellView.h"
+
+// A color as React Native's style takes it from `processColor`: 0xAARRGGBB as a number.
+static NSNumber *ANNProcessedColor(UIColor *color, UITraitCollection *traits) {
+    CGFloat red = 0, green = 0, blue = 0, alpha = 0;
+    [[color resolvedColorWithTraitCollection:traits] getRed:&red
+                                                      green:&green
+                                                       blue:&blue
+                                                      alpha:&alpha];
+    uint32_t argb = ((uint32_t)lround(alpha * 255) << 24) | ((uint32_t)lround(red * 255) << 16) |
+                    ((uint32_t)lround(green * 255) << 8) | (uint32_t)lround(blue * 255);
+    return @(argb);
+}
+
+@implementation ANNBottomTabCellView {
+    BOOL _selected;
+    NSString *_badge;
+    BOOL _dot;
+    UIColor *_dotColor;
+}
+
+- (instancetype)initWithIndex:(NSUInteger)index {
+    if (self = [super initWithFrame:CGRectZero]) {
+        _index = index;
+        self.backgroundColor = UIColor.clearColor;
+        self.isAccessibilityElement = NO;
+    }
+    return self;
+}
+
+- (void)setContent:(UIView<ANNComponentProtocol> *)content {
+    if (_content == content) {
+        return;
+    }
+    if (_content.superview == self) {
+        [_content removeFromSuperview];
+    }
+    _content = content;
+    if (!content) {
+        return;
+    }
+    // The place takes the touches; the React elements inside don't.
+    content.userInteractionEnabled = NO;
+    content.frame = self.bounds;
+    content.autoresizingMask = UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight;
+    [self addSubview:content];
+    [self sendProps];
+}
+
+- (void)setSelected:(BOOL)selected
+              badge:(NSString *)badge
+                dot:(BOOL)dot
+           dotColor:(UIColor *)dotColor {
+    BOOL sameBadge = _badge == badge || [_badge isEqualToString:badge];
+    BOOL sameColor = _dotColor == dotColor || [_dotColor isEqual:dotColor];
+    if (_selected == selected && sameBadge && _dot == dot && sameColor) {
+        return;
+    }
+    _selected = selected;
+    _badge = [badge copy];
+    _dot = dot;
+    _dotColor = dotColor;
+    [self sendProps];
+}
+
+// `badge` is absent without a badge, `dotColor` only when the tab sets one.
+- (void)sendProps {
+    UIView<ANNComponentProtocol> *content = _content;
+    if (![content isKindOfClass:ANNReactView.class]) {
+        return;
+    }
+    NSMutableDictionary<NSString *, id> *props = [NSMutableDictionary new];
+    props[@"tabIndex"] = @(_index);
+    props[@"selected"] = @(_selected);
+    props[@"dot"] = @(_dot);
+    if (_badge) {
+        props[@"badge"] = _badge;
+    }
+    if (_dotColor) {
+        props[@"dotColor"] = ANNProcessedColor(_dotColor, self.traitCollection);
+    }
+    [(ANNReactView *)content setNativeProps:props];
+}
+
+// A dynamic dot color follows the light and dark styles.
+- (void)traitCollectionDidChange:(UITraitCollection *)previousTraitCollection {
+    [super traitCollectionDidChange:previousTraitCollection];
+    if (_dotColor) {
+        [self sendProps];
+    }
+}
+
+- (void)setTestID:(NSString *)testID {
+    NSString *identifier = testID.length > 0 ? testID : nil;
+    if (![self.accessibilityIdentifier ?: @"" isEqualToString:identifier ?: @""]) {
+        self.accessibilityIdentifier = identifier;
+    }
+}
+
+@end

package/ios/Layouts/Tabs/ANNBottomTabItemBuilder.h

@@ -0,0 +1,49 @@
+#import "ANNBottomTabOptions.h"
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// What a tab's item shows, from the tab's resolved `bottomTab` (`bottomTab.*`): pure functions the tabs' presenter
+/// builds each item with, whole, at creation, at a `bottomTab` merge and at the repaint. The badge and the dot are the
+/// presenter's (they hold across rebuilds).
+@interface ANNBottomTabItemBuilder : NSObject
+
+- (instancetype)init NS_UNAVAILABLE;
++ (instancetype)new NS_UNAVAILABLE;
+
+/// The text of the item (`bottomTab.text`); nil without one.
++ (nullable NSString *)titleOf:(ANNBottomTabOptions *)tab;
+
+/// The icon (`bottomTab.icon`): the SF Symbol of `sfSymbol` over the raster, which shows in its own colors or painted
+/// in `iconColor` (the color goes into the raster) unless `disableIconTint`; nil without one.
++ (nullable UIImage *)iconOf:(ANNBottomTabOptions *)tab;
+
+/// The selected icon (`bottomTab.selectedIcon`): `sfSelectedSymbol` or `selectedIcon`, else the SF Symbol of `icon`
+/// when there is one (not the raster under it), else the raster `icon`; a raster painted in `selectedIconColor`
+/// (default `iconColor`) unless `disableSelectedIconTint`. Nil without any.
++ (nullable UIImage *)selectedIconOf:(ANNBottomTabOptions *)tab;
+
+/// `selectedIconColor`, else `iconColor` (`bottomTab.selectedIconColor`); nil without both.
++ (nullable UIColor *)selectedIconColorOf:(ANNBottomTabOptions *)tab;
+
+/// The look of the item: `base` (the bar's background and border) with the item's icon colors (so the system paints SF
+/// Symbols in them), its title colors (`labelColor` without one) and font in the normal and selected states of every
+/// layout, and `badgeColor` (before iOS 26: the stacked layout's normal state; on the glass of iOS 26: every layout and
+/// state) when given.
++ (UITabBarAppearance *)appearanceOf:(ANNBottomTabOptions *)tab
+                                base:(UITabBarAppearance *)base
+                          badgeColor:(nullable UIColor *)badgeColor;
+
+/// The title's font: `fontFamily`, `fontStyle`, `fontWeight`, `fontSize` (10 by default) through React Native's font
+/// builder; nil when the tab sets none (the system's font).
++ (nullable UIFont *)titleFontOf:(ANNBottomTabOptions *)tab;
+
+/// `iconInsets`, each side alone, a missing side 0.
++ (UIEdgeInsets)iconInsetsOf:(ANNBottomTabOptions *)tab;
+
+/// Before iOS 18: the system item of `role` (`search`, `bookmarks`, … `more`); NO for an unknown one.
++ (BOOL)systemItemOfRole:(NSString *)role item:(UITabBarSystemItem *)systemItem;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/Layouts/Tabs/ANNBottomTabItemBuilder.mm

@@ -0,0 +1,153 @@
+#import "ANNBottomTabItemBuilder.h"
+
+// The size of a tab's title without `fontSize` (`bottomTab.fontSize`).
+static const CGFloat ANNTabTitleFontSize = 10;
+
+// A raster in its own colors, or painted in `color` (the color goes into the raster: the glass of iOS 26 ignores the
+// color of an unselected icon otherwise).
+static UIImage *ANNRaster(UIImage *image, UIColor *_Nullable color) {
+    if (color) {
+        return [image imageWithTintColor:color renderingMode:UIImageRenderingModeAlwaysOriginal];
+    }
+    return [image imageWithRenderingMode:UIImageRenderingModeAlwaysOriginal];
+}
+
+static UIImage *_Nullable ANNSymbol(Text *name) {
+    NSString *symbol = [name withDefault:nil];
+    return symbol.length > 0 ? [UIImage systemImageNamed:symbol] : nil;
+}
+
+static void ANNSetTitleAttributes(UITabBarItemStateAppearance *state, UIColor *color,
+                                  UIFont *_Nullable font) {
+    NSMutableDictionary<NSAttributedStringKey, id> *attributes =
+        [state.titleTextAttributes mutableCopy] ?: [NSMutableDictionary new];
+    attributes[NSForegroundColorAttributeName] = color;
+    if (font) {
+        attributes[NSFontAttributeName] = font;
+    }
+    state.titleTextAttributes = attributes;
+}
+
+@implementation ANNBottomTabItemBuilder
+
++ (NSString *)titleOf:(ANNBottomTabOptions *)tab {
+    NSString *text = [tab.text withDefault:nil];
+    return text.length > 0 ? text : nil;
+}
+
++ (UIImage *)iconOf:(ANNBottomTabOptions *)tab {
+    UIImage *symbol = ANNSymbol(tab.sfSymbol);
+    if (symbol) {
+        return symbol;
+    }
+    UIImage *icon = [tab.icon withDefault:nil];
+    if (!icon) {
+        return nil;
+    }
+    BOOL tints = ![tab.disableIconTint withDefault:NO];
+    return ANNRaster(icon, tints ? [tab.iconColor withDefault:nil] : nil);
+}
+
++ (UIImage *)selectedIconOf:(ANNBottomTabOptions *)tab {
+    UIImage *symbol = ANNSymbol(tab.sfSelectedSymbol);
+    if (symbol) {
+        return symbol;
+    }
+    BOOL tints = ![tab.disableSelectedIconTint withDefault:NO];
+    UIColor *color = tints ? [self selectedIconColorOf:tab] : nil;
+    UIImage *selected = [tab.selectedIcon withDefault:nil];
+    if (selected) {
+        return ANNRaster(selected, color);
+    }
+    UIImage *iconSymbol = ANNSymbol(tab.sfSymbol);
+    if (iconSymbol) {
+        return iconSymbol;
+    }
+    UIImage *icon = [tab.icon withDefault:nil];
+    return icon ? ANNRaster(icon, color) : nil;
+}
+
++ (UIColor *)selectedIconColorOf:(ANNBottomTabOptions *)tab {
+    return [tab.selectedIconColor withDefault:nil] ?: [tab.iconColor withDefault:nil];
+}
+
++ (UITabBarAppearance *)appearanceOf:(ANNBottomTabOptions *)tab
+                                base:(UITabBarAppearance *)base
+                          badgeColor:(UIColor *)badgeColor {
+    UITabBarAppearance *appearance = [base copy];
+    UIColor *iconColor =
+        [tab.disableIconTint withDefault:NO] ? nil : [tab.iconColor withDefault:nil];
+    UIColor *selectedIconColor =
+        [tab.disableSelectedIconTint withDefault:NO] ? nil : [self selectedIconColorOf:tab];
+    UIColor *textColor = [tab.textColor withDefault:UIColor.labelColor] ?: UIColor.labelColor;
+    UIColor *selectedTextColor =
+        [tab.selectedTextColor withDefault:UIColor.labelColor] ?: UIColor.labelColor;
+    UIFont *font = [self titleFontOf:tab];
+    BOOL everyStateBadge = NO;
+    if (@available(iOS 26.0, *)) {
+        everyStateBadge = YES;
+    }
+    NSArray<UITabBarItemAppearance *> *layouts = @[
+        appearance.stackedLayoutAppearance, appearance.inlineLayoutAppearance,
+        appearance.compactInlineLayoutAppearance
+    ];
+    for (UITabBarItemAppearance *layout in layouts) {
+        if (iconColor) {
+            layout.normal.iconColor = iconColor;
+        }
+        if (selectedIconColor) {
+            layout.selected.iconColor = selectedIconColor;
+        }
+        ANNSetTitleAttributes(layout.normal, textColor, font);
+        ANNSetTitleAttributes(layout.selected, selectedTextColor, font);
+        if (badgeColor && everyStateBadge) {
+            layout.normal.badgeBackgroundColor = badgeColor;
+            layout.selected.badgeBackgroundColor = badgeColor;
+            layout.focused.badgeBackgroundColor = badgeColor;
+            layout.disabled.badgeBackgroundColor = badgeColor;
+        }
+    }
+    if (badgeColor && !everyStateBadge) {
+        appearance.stackedLayoutAppearance.normal.badgeBackgroundColor = badgeColor;
+    }
+    return appearance;
+}
+
++ (UIFont *)titleFontOf:(ANNBottomTabOptions *)tab {
+    return [tab.font fontWithPlaceFont:[UIFont systemFontOfSize:ANNTabTitleFontSize]];
+}
+
++ (UIEdgeInsets)iconInsetsOf:(ANNBottomTabOptions *)tab {
+    ANNIconInsetsOptions *insets = tab.iconInsets;
+    return UIEdgeInsetsMake([insets.top withDefault:0], [insets.left withDefault:0],
+                            [insets.bottom withDefault:0], [insets.right withDefault:0]);
+}
+
++ (BOOL)systemItemOfRole:(NSString *)role item:(UITabBarSystemItem *)systemItem {
+    static NSDictionary<NSString *, NSNumber *> *items;
+    static dispatch_once_t once;
+    dispatch_once(&once, ^{
+      items = @{
+          @"more" : @(UITabBarSystemItemMore),
+          @"favorites" : @(UITabBarSystemItemFavorites),
+          @"featured" : @(UITabBarSystemItemFeatured),
+          @"topRated" : @(UITabBarSystemItemTopRated),
+          @"recents" : @(UITabBarSystemItemRecents),
+          @"contacts" : @(UITabBarSystemItemContacts),
+          @"history" : @(UITabBarSystemItemHistory),
+          @"bookmarks" : @(UITabBarSystemItemBookmarks),
+          @"search" : @(UITabBarSystemItemSearch),
+          @"downloads" : @(UITabBarSystemItemDownloads),
+          @"mostRecent" : @(UITabBarSystemItemMostRecent),
+          @"mostViewed" : @(UITabBarSystemItemMostViewed),
+      };
+    });
+    NSNumber *item = role ? items[role] : nil;
+    if (!item) {
+        return NO;
+    }
+    *systemItem = (UITabBarSystemItem)item.integerValue;
+    return YES;
+}
+
+@end