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

package/ios/TopBar/ANNBarComponentsWait.h

@@ -0,0 +1,37 @@
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// The limits of a wait for the React components of the bars of some screens, in seconds from the wait's start; 0: no
+/// limit of its own (the caller's limit ends it).
+typedef struct {
+    /// The title and the background (1 s for a push).
+    NSTimeInterval titleAndBackground;
+    /// The component buttons (0.5 s for a push).
+    NSTimeInterval buttons;
+} ANNBarWaitLimits;
+
+/// A wait for the React components of the bars of `screens` (title, background, component buttons): each screen makes
+/// the roots its resolved options name and doesn't have yet, then the kinds are waited together from the start, each to
+/// its own limit; the wait is done when every kind is ready or past its limit. A kind with nothing to wait for (none
+/// named, or its own `waitForRender: false`) is ready at once. A wait that ends at a limit marks nothing ready: the
+/// roots' own appearance events stay with the dispatcher. Main queue.
+@interface ANNBarComponentsWait : NSObject
+
+/// Starts a wait; nil when there is nothing to wait for (`done` is not called then).
++ (nullable instancetype)waitForScreens:(NSArray<UIViewController *> *)screens
+                                 limits:(ANNBarWaitLimits)limits
+                                   done:(dispatch_block_t)done;
+
+- (instancetype)init NS_UNAVAILABLE;
++ (instancetype)new NS_UNAVAILABLE;
+
+/// The wait ends without calling `done`.
+- (void)cancel;
+
+/// Whether `done` ran or the wait was cancelled.
+@property(nonatomic, readonly) BOOL finished;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/TopBar/ANNBarComponentsWait.mm

@@ -0,0 +1,116 @@
+#import "ANNBarComponentsWait.h"
+#import "ANNAssert.h"
+#import "ANNTopBarPresenter.h"
+
+@implementation ANNBarComponentsWait {
+    dispatch_block_t _done;
+    // What each kind still waits for, and whether its limit passed.
+    NSUInteger _titleAndBackgroundLeft;
+    NSUInteger _buttonsLeft;
+    BOOL _titleAndBackgroundEnded;
+    BOOL _buttonsEnded;
+}
+
++ (instancetype)waitForScreens:(NSArray<UIViewController *> *)screens
+                        limits:(ANNBarWaitLimits)limits
+                          done:(dispatch_block_t)done {
+    ANNAssertMainQueue();
+    ANNBarComponentsWait *wait = [[self alloc] initWithDone:done];
+    [wait startWithScreens:screens limits:limits];
+    return wait.finished ? nil : wait;
+}
+
+- (instancetype)initWithDone:(dispatch_block_t)done {
+    if (self = [super init]) {
+        _done = [done copy];
+    }
+    return self;
+}
+
+- (void)startWithScreens:(NSArray<UIViewController *> *)screens limits:(ANNBarWaitLimits)limits {
+    NSMutableArray<dispatch_block_t> *subscriptions = [NSMutableArray new];
+    __weak ANNBarComponentsWait *weakSelf = self;
+    for (UIViewController *screen in screens) {
+        ANNTopBarPresenter *presenter = [ANNTopBarPresenter presenterOfScreen:screen];
+        if (!presenter) {
+            continue;
+        }
+        ANNReactComponentRegistry *registry = presenter.registry;
+        [presenter collectWaitedComponents:^(NSString *componentId, BOOL isButton) {
+          if (isButton) {
+              self->_buttonsLeft++;
+          } else {
+              self->_titleAndBackgroundLeft++;
+          }
+          [subscriptions addObject:^{
+            [registry whenComponentReady:componentId
+                                      do:^{
+                                        [weakSelf componentReady:isButton];
+                                      }];
+          }];
+        }];
+    }
+    _titleAndBackgroundEnded = _titleAndBackgroundLeft == 0;
+    _buttonsEnded = _buttonsLeft == 0;
+    if (_titleAndBackgroundEnded && _buttonsEnded) {
+        _finished = YES;
+        return;
+    }
+    // Each kind to its own limit, all from now.
+    [self limit:limits.titleAndBackground buttons:NO];
+    [self limit:limits.buttons buttons:YES];
+    for (dispatch_block_t subscribe in subscriptions) {
+        subscribe();
+    }
+}
+
+- (void)limit:(NSTimeInterval)limit buttons:(BOOL)buttons {
+    if (limit <= 0 || (buttons ? _buttonsEnded : _titleAndBackgroundEnded)) {
+        return;
+    }
+    __weak ANNBarComponentsWait *weakSelf = self;
+    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(limit * NSEC_PER_SEC)),
+                   dispatch_get_main_queue(), ^{
+                     [weakSelf kindEnded:buttons];
+                   });
+}
+
+- (void)componentReady:(BOOL)isButton {
+    if (_finished) {
+        return;
+    }
+    if (isButton) {
+        if (_buttonsLeft > 0 && --_buttonsLeft == 0) {
+            [self kindEnded:YES];
+        }
+    } else if (_titleAndBackgroundLeft > 0 && --_titleAndBackgroundLeft == 0) {
+        [self kindEnded:NO];
+    }
+}
+
+- (void)kindEnded:(BOOL)buttons {
+    if (_finished) {
+        return;
+    }
+    if (buttons) {
+        _buttonsEnded = YES;
+    } else {
+        _titleAndBackgroundEnded = YES;
+    }
+    if (!_buttonsEnded || !_titleAndBackgroundEnded) {
+        return;
+    }
+    _finished = YES;
+    dispatch_block_t done = _done;
+    _done = nil;
+    if (done) {
+        done();
+    }
+}
+
+- (void)cancel {
+    _finished = YES;
+    _done = nil;
+}
+
+@end

package/ios/TopBar/ANNIconButtonImage.h

@@ -0,0 +1,25 @@
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// The image of an image button (`iconBackground` with a color, or `iconInsets`;
+/// `topBar.leftButtons[].iconBackground`, `topBar.backButton.iconBackground`): the icon drawn on a rounded rectangle of
+/// the background color, or with its insets, into one image with a light and a dark variant, which UIKit picks by the
+/// style shown.
+@interface ANNIconButtonImage : NSObject
+
+- (instancetype)init NS_UNAVAILABLE;
++ (instancetype)new NS_UNAVAILABLE;
+
+/// `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.
++ (UIImage *)imageWithIcon:(UIImage *)icon
+                      tint:(nullable UIColor *)tint
+                background:(nullable UIColor *)background
+              cornerRadius:(CGFloat)cornerRadius
+                      size:(CGSize)size
+                    insets:(UIEdgeInsets)insets;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/TopBar/ANNIconButtonImage.mm

@@ -0,0 +1,94 @@
+#import "ANNIconButtonImage.h"
+#import "ANNUtils.h"
+
+@implementation ANNIconButtonImage
+
++ (UIImage *)imageWithIcon:(UIImage *)icon
+                      tint:(UIColor *)tint
+                background:(UIColor *)background
+              cornerRadius:(CGFloat)cornerRadius
+                      size:(CGSize)size
+                    insets:(UIEdgeInsets)insets {
+    // Each variant carries a scale with its style: an asset of style-only traits gives back an image of scale 1, its
+    // pixels taken as points (a 32 pt background drawn 96 pt wide). The current scale and the usual ones are drawn,
+    // so a screen of another scale still finds its style. Each variant is an original image, so that a variant UIKit
+    // picks after a light/dark switch never becomes a template that takes the bar's tint.
+    UITraitCollection *current = UITraitCollection.currentTraitCollection;
+    CGFloat scale = current.displayScale > 0 ? current.displayScale : ANNUtils.mainScreen.scale;
+    NSMutableOrderedSet<NSNumber *> *scales = [NSMutableOrderedSet orderedSetWithObject:@(scale)];
+    [scales addObjectsFromArray:@[ @1, @2, @3 ]];
+    UIImageAsset *asset = [UIImageAsset new];
+    for (NSNumber *variantScale in scales) {
+        for (NSNumber *style in @[ @(UIUserInterfaceStyleLight), @(UIUserInterfaceStyleDark) ]) {
+            UITraitCollection *traits =
+                [self traitsWithStyle:(UIUserInterfaceStyle)style.integerValue
+                                scale:variantScale.doubleValue];
+            UIImage *drawn = [self drawIcon:icon
+                                       tint:tint
+                                 background:background
+                               cornerRadius:cornerRadius
+                                       size:size
+                                     insets:insets
+                                     traits:traits];
+            [asset registerImage:[drawn imageWithRenderingMode:UIImageRenderingModeAlwaysOriginal]
+                 withTraitCollection:traits];
+        }
+    }
+    UIUserInterfaceStyle style = current.userInterfaceStyle == UIUserInterfaceStyleDark
+                                     ? UIUserInterfaceStyleDark
+                                     : UIUserInterfaceStyleLight;
+    UIImage *image = [asset imageWithTraitCollection:[self traitsWithStyle:style scale:scale]];
+    return [image imageWithRenderingMode:UIImageRenderingModeAlwaysOriginal];
+}
+
++ (UITraitCollection *)traitsWithStyle:(UIUserInterfaceStyle)style scale:(CGFloat)scale {
+    if (@available(iOS 17.0, *)) {
+        return [UITraitCollection traitCollectionWithTraits:^(id<UIMutableTraits> traits) {
+          traits.userInterfaceStyle = style;
+          traits.displayScale = scale;
+        }];
+    }
+    return [UITraitCollection traitCollectionWithTraitsFromCollections:@[
+        [UITraitCollection traitCollectionWithUserInterfaceStyle:style],
+        [UITraitCollection traitCollectionWithDisplayScale:scale],
+    ]];
+}
+
++ (UIImage *)drawIcon:(UIImage *)icon
+                 tint:(UIColor *)tint
+           background:(UIColor *)background
+         cornerRadius:(CGFloat)cornerRadius
+                 size:(CGSize)size
+               insets:(UIEdgeInsets)insets
+               traits:(UITraitCollection *)traits {
+    CGSize iconSize = icon.size;
+    CGSize padded = CGSizeMake(iconSize.width + insets.left + insets.right,
+                               iconSize.height + insets.top + insets.bottom);
+    CGSize canvas = CGSizeMake(size.width > 0 ? size.width : padded.width,
+                               size.height > 0 ? size.height : padded.height);
+    UIImage *drawn = icon;
+    if (tint) {
+        drawn = [icon imageWithTintColor:[tint resolvedColorWithTraitCollection:traits]
+                           renderingMode:UIImageRenderingModeAlwaysOriginal];
+    } else if (icon.isSymbolImage) {
+        UIColor *label = [UIColor.labelColor resolvedColorWithTraitCollection:traits];
+        drawn = [icon imageWithTintColor:label renderingMode:UIImageRenderingModeAlwaysOriginal];
+    }
+    UIGraphicsImageRendererFormat *format =
+        [UIGraphicsImageRendererFormat formatForTraitCollection:traits];
+    format.scale = traits.displayScale;
+    UIGraphicsImageRenderer *renderer = [[UIGraphicsImageRenderer alloc] initWithSize:canvas
+                                                                               format:format];
+    return [renderer imageWithActions:^(UIGraphicsImageRendererContext *context) {
+      if (background) {
+          [[background resolvedColorWithTraitCollection:traits] setFill];
+          [[UIBezierPath bezierPathWithRoundedRect:CGRectMake(0, 0, canvas.width, canvas.height)
+                                      cornerRadius:cornerRadius] fill];
+      }
+      CGFloat x = insets.left + (canvas.width - padded.width) / 2;
+      CGFloat y = insets.top + (canvas.height - padded.height) / 2;
+      [drawn drawInRect:CGRectMake(x, y, iconSize.width, iconSize.height)];
+    }];
+}
+
+@end

package/ios/TopBar/ANNLargeTitlePresenter.h

@@ -0,0 +1,117 @@
+#import "ANNNavigationOptions.h"
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// The bar a pop starts from, as it is at the start: its bottom in the screen's coordinates (-1: none shows), whether
+/// its screen has a large title, whether its look is clear at its scroll edge.
+typedef struct {
+    CGFloat bottom;
+    BOOL largeTitle;
+    BOOL clearAtEdge;
+} ANNPopBar;
+
+/// The large title of a screen (`topBar.largeTitle.*`). The mode goes into the item (`ANNLargeTitleDisplayMode`);
+/// turned on for a shown screen only after `sizeToFit` of the bar and only for the top of its stack, turned off by one
+/// change of the mode. `collapseOnScroll: false` gives the bar an empty scroll view for the top edge after the screen's
+/// first appearance; while a pop reveals the screen on iOS 26 the title gets a place of its own in the window. On iOS
+/// 26 a large title in the list with a solid `background.color` (not a clear one) and no React background paints the
+/// color as a view inside the main list under its rows. Main queue.
+@interface ANNLargeTitlePresenter : NSObject
+
+- (instancetype)initWithScreen:(UIViewController *)screen;
+
+- (instancetype)init NS_UNAVAILABLE;
++ (instancetype)new NS_UNAVAILABLE;
+
+/// Whether the large title folds into the list as the content scrolls: it can show, `collapseOnScroll` isn't `false`,
+/// and on iOS 26 React Native isn't right to left (it mirrors its lists, and the title would be drawn mirrored inside
+/// them).
++ (BOOL)collapsesIntoList:(ANNNavigationOptions *)options;
+
+/// The mode of `options` into the item. `shownTop`: the screen shows and is the top of its stack, so turning the large
+/// title on sizes the bar first.
+- (void)applyMode:(ANNNavigationOptions *)options shownTop:(BOOL)shownTop;
+
+/// The scroll view the bar follows at the top edge. A title that doesn't fold into the list (`collapseOnScroll: false`,
+/// right to left): the empty scroll view once the screen appeared. A title that folds into the list: `list`, the main
+/// list the core found, so that UIKit doesn't take another scroll view, a hidden one at the screen's top. Otherwise the
+/// bar chooses by itself again. While a pop runs with the screen's title in the place of
+/// `screenInPop:list:inlineInRow:`: that place.
+- (void)applyCollapse:(ANNNavigationOptions *)options list:(nullable UIScrollView *)list;
+
+/// iOS 26: a pop or a swipe back starts that reveals the screen or takes it away. UIKit draws the screen's large
+/// title, for the whole transition, inside the scroll view the bar follows at the top edge; the empty scroll view is
+/// in no window, and a list below the bar (no main list at the screen's top) clips it. When the bar would follow one of
+/// these and the title shows expanded, the screen's view gets a scroll view of the core over its content, at rest at
+/// the top of the content (for a revealed screen, as it was covered), and the bar follows it until the screen appeared
+/// or went (or the swipe was given up). A title that folds into its list shows expanded only when the bar took the
+/// room of an expanded title (a search field that hides on scroll may have gone). Not for a covered screen whose size
+/// is not the stack's (the window turned or resized meanwhile).
+/// Called before UIKit's pop, or as UIKit's swipe starts, after the screen's will-appear.
+- (void)screenInPop:(ANNNavigationOptions *)options
+               list:(nullable UIScrollView *)list
+        inlineInRow:(BOOL)inlineInRow;
+
+/// The screen appeared: from now on `collapseOnScroll: false` takes effect at once; the place of the title of a pop
+/// goes, and the bar follows what it follows at rest.
+- (void)screenDidAppear:(ANNNavigationOptions *)options list:(nullable UIScrollView *)list;
+
+/// The screen went without appearing (a swipe back given up): the place of the title of the pop goes, and the bar
+/// follows what it followed before.
+- (void)screenDidDisappear:(ANNNavigationOptions *)options list:(nullable UIScrollView *)list;
+
+/// The pop ended for the screen that stays (a swipe back given up, the screen that was to leave): as
+/// `screenDidDisappear:list:`.
+- (void)popEnded:(ANNNavigationOptions *)options list:(nullable UIScrollView *)list;
+
+/// The screen's title is in the place of `screenInPop:list:inlineInRow:` now.
+@property(nonatomic, readonly) BOOL hostsTitle;
+
+/// The screen shows at rest (appeared, laid out): the room the bar takes over its content is noted when it is the
+/// largest seen, the room of an expanded title.
+- (void)noteTopAtRest;
+
+/// The place of the title of a pop leaves the screen's view (the screen leaves or is destroyed).
+- (void)removeTitleHost;
+
+/// The color of the bar in the main list; `inlineInRow`: the title is in the row, not in the list;
+/// `backgroundComponent`: the screen has a React bar background, which takes that place instead.
+- (void)updateListFill:(ANNNavigationOptions *)options
+                  list:(nullable UIScrollView *)list
+           inlineInRow:(BOOL)inlineInRow
+   backgroundComponent:(BOOL)backgroundComponent;
+
+/// The fill leaves the list (the screen leaves or is destroyed).
+- (void)removeListFill;
+
+/// iOS 26, a push, a pop or a swipe back from a screen with a lower bar: a large
+/// title that doesn't fold into the list fills its place from `oldBarBottom` (the screen's coordinates) to the first
+/// row, with `background.color`, or else with the bar's background (the system chrome material on a translucent bar,
+/// the opaque system color otherwise), until the screen appeared. The fill lies in the list, or under the title in the
+/// place of a pop's title while there is one. Without a list yet (the content renders during the push) the fill waits
+/// for `updateTitlePlaceFill:list:`.
+- (void)fillTitlePlaceFrom:(CGFloat)oldBarBottom
+                      list:(nullable UIScrollView *)list
+                   options:(ANNNavigationOptions *)options;
+
+/// iOS 26, a pop or a swipe back from `bar`: the fill of `fillTitlePlaceFrom:list:options:` for a title that doesn't
+/// fold into the list. Without a place of the title: as on a push, from a bar without a large title. With it, from
+/// the screen's top (the bar's whole background while its look is clear), when the bar ends above the title's band (a
+/// lower bar, a collapsed large title) or is clear at its edge; from any other bar, nothing.
+- (void)fillTitlePlaceOfPopFrom:(ANNPopBar)bar
+                           list:(nullable UIScrollView *)list
+                        options:(ANNNavigationOptions *)options;
+
+/// While the fill of a push is pending: places it again in the main list as it is now (after a mount, a layout).
+- (void)updateTitlePlaceFill:(ANNNavigationOptions *)options list:(nullable UIScrollView *)list;
+
+/// The fill of the push goes (the screen appeared).
+- (void)removeTitlePlaceFill;
+
+/// The fill of a pop lies under the title in the place of the pop's title: the band behind the title is the fill's.
+- (BOOL)drawsTitleBand;
+
+@end
+
+NS_ASSUME_NONNULL_END