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

package/ios/Layouts/Stack/ANNSwipePopInteraction.mm

@@ -0,0 +1,185 @@
+#import "ANNSwipePopInteraction.h"
+#import "ANNAssert.h"
+#import "ANNTransitionAnimator.h"
+
+// A flick faster than this, in points a second, ends the swipe by its direction alone.
+static const CGFloat ANNSwipeFlickSpeed = 500;
+
+// The rest of the pop plays at most this many times as fast as its own animation.
+static const CGFloat ANNSwipeMostSpeedUp = 3;
+
+@implementation ANNSwipePopInteraction {
+    ANNTransitionAnimator *_strongAnimator;
+    __weak UIPanGestureRecognizer *_recognizer;
+    __weak UIView *_view;
+    id<UIViewControllerContextTransitioning> _context;
+    // The interaction keeps itself while it follows the gesture: UIKit may let it go before the finger does.
+    ANNSwipePopInteraction *_keep;
+    // The gesture ended before UIKit started the transition: the end is chosen at the start.
+    BOOL _endedEarly;
+    BOOL _gaveUpEarly;
+    CGFloat _completionSpeed;
+}
+
+- (instancetype)initWithAnimator:(ANNTransitionAnimator *)animator
+                      recognizer:(UIPanGestureRecognizer *)recognizer
+                            view:(UIView *)view {
+    if (self = [super init]) {
+        _animator = animator;
+        _strongAnimator = animator;
+        _recognizer = recognizer;
+        _view = view;
+        _completionSpeed = 1;
+        _keep = self;
+        [recognizer addTarget:self action:@selector(swipe:)];
+    }
+    return self;
+}
+
+#pragma mark - UIViewControllerInteractiveTransitioning
+
+- (void)startInteractiveTransition:(id<UIViewControllerContextTransitioning>)transitionContext {
+    ANNAssertMainQueue();
+    ANNTransitionAnimator *animator = _strongAnimator;
+    if (!animator || _context) {
+        return;
+    }
+    _context = transitionContext;
+    [animator animateFollowingGesture:transitionContext];
+    UIGestureRecognizerState state = _recognizer.state;
+    BOOL moving = state == UIGestureRecognizerStateBegan || state == UIGestureRecognizerStateChanged;
+    if (_gaveUpEarly) {
+        [self endFinishing:NO speed:1];
+        return;
+    }
+    if (_endedEarly || !moving) {
+        [self letGo];
+        return;
+    }
+    [self follow];
+}
+
+- (CGFloat)completionSpeed {
+    return _completionSpeed;
+}
+
+// The frames play at an even pace to their end, so UIKit's part (the bar) does too.
+- (UIViewAnimationCurve)completionCurve {
+    return UIViewAnimationCurveLinear;
+}
+
+- (BOOL)wantsInteractiveStart {
+    return YES;
+}
+
+#pragma mark - The gesture
+
+- (void)swipe:(UIPanGestureRecognizer *)recognizer {
+    switch (recognizer.state) {
+        case UIGestureRecognizerStateBegan:
+        case UIGestureRecognizerStateChanged:
+            [self follow];
+            break;
+        case UIGestureRecognizerStateEnded:
+            [self letGo];
+            break;
+        case UIGestureRecognizerStateCancelled:
+        case UIGestureRecognizerStateFailed:
+            [self giveUp];
+            break;
+        default:
+            break;
+    }
+}
+
+- (void)follow {
+    if (!_context) {
+        return;
+    }
+    if (_strongAnimator.isCompleted) {
+        [self stop];
+        return;
+    }
+    CGFloat progress = [self progress];
+    [_strongAnimator setProgress:progress];
+    [_context updateInteractiveTransition:progress];
+}
+
+// The finger left: a flick decides by its direction, a slow release by how far the swipe went.
+- (void)letGo {
+    if (!_context) {
+        [self endedEarlyGivingUp:NO];
+        return;
+    }
+    CGFloat velocity = [self alongBack:[_recognizer velocityInView:_view].x];
+    BOOL finish = velocity > ANNSwipeFlickSpeed ||
+                  (velocity >= -ANNSwipeFlickSpeed && [self progress] > 0.5);
+    // The rest takes the finger's pace when that is quicker than the animation's: the animation would cover the width
+    // in its length, the finger in width / velocity.
+    CGFloat width = MAX(_view.bounds.size.width, 1);
+    BOOL withFinger = finish ? velocity > 0 : velocity < 0;
+    CGFloat speed = withFinger ? fabs(velocity) * _strongAnimator.length / width : 1;
+    [self endFinishing:finish speed:MIN(MAX(speed, 1.0), ANNSwipeMostSpeedUp)];
+}
+
+// The system took the touch (a call, a second gesture): the screen goes back.
+- (void)giveUp {
+    if (!_context) {
+        [self endedEarlyGivingUp:YES];
+        return;
+    }
+    [self endFinishing:NO speed:1];
+}
+
+// UIKit holds an interaction it starts; one it never starts goes once the gesture ended.
+- (void)endedEarlyGivingUp:(BOOL)gaveUp {
+    _endedEarly = YES;
+    _gaveUpEarly = gaveUp;
+    [_recognizer removeTarget:self action:@selector(swipe:)];
+    _keep = nil;
+}
+
+- (void)endFinishing:(BOOL)finish speed:(CGFloat)speed {
+    id<UIViewControllerContextTransitioning> context = _context;
+    ANNTransitionAnimator *animator = _strongAnimator;
+    [self stop];
+    if (!context || !animator || animator.isCompleted) {
+        return;
+    }
+    // UIKit reads the speed as it ends its own part of the transition.
+    _completionSpeed = speed;
+    if (finish) {
+        [context finishInteractiveTransition];
+        [animator finishWithSpeed:speed];
+    } else {
+        [context cancelInteractiveTransition];
+        [animator rewindWithSpeed:speed];
+    }
+}
+
+// The part of the width the finger went in the direction of the swipe back.
+- (CGFloat)progress {
+    UIView *view = _view;
+    CGFloat width = view.bounds.size.width;
+    if (width <= 0) {
+        return 0;
+    }
+    CGFloat along = [self alongBack:[_recognizer translationInView:view].x];
+    return MIN(MAX(along / width, 0.0), 1.0);
+}
+
+// A move across the view, positive in the direction of the swipe back: rightward, leftward in a right-to-left layout.
+- (CGFloat)alongBack:(CGFloat)x {
+    BOOL rightToLeft =
+        _view.effectiveUserInterfaceLayoutDirection == UIUserInterfaceLayoutDirectionRightToLeft;
+    return rightToLeft ? -x : x;
+}
+
+- (void)stop {
+    [_recognizer removeTarget:self action:@selector(swipe:)];
+    _context = nil;
+    _strongAnimator = nil;
+    _keep = nil;
+}
+
+@end

package/ios/Layouts/Stack/InteractivePopGestureDelegate.mm

@@ -86,10 +86,11 @@ static BOOL ANNIsOwnQuestionOfUIKit(SEL selector) {
 
 #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.
+// The order: which of the stack's swipes plays first (`swipeBackTakes:`: the stack's own while the top's pop follows
+// the finger, UIKit's otherwise), then `popGesture` (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
@@ -97,6 +98,10 @@ static BOOL ANNIsOwnQuestionOfUIKit(SEL selector) {
 // 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;
+    // One swipe plays the pop: the stack's own while the top's pop follows the finger, UIKit's otherwise.
+    if (stack && ![stack swipeBackTakes:gestureRecognizer]) {
+        return NO;
+    }
     if (stack && ![stack swipeBackIsUIKits:gestureRecognizer]) {
         if (!_enabled || ![stack swipeBackMayBegin]) {
             return NO;
@@ -191,6 +196,25 @@ static BOOL ANNIsOwnQuestionOfUIKit(SEL selector) {
     return YES;
 }
 
+// A list under the stack's own swipe waits for it, as for UIKit's edge swipe: a swipe from the edge goes back, also on
+// a list that scrolls sideways. UIKit's swipes keep UIKit's answer.
+- (BOOL)gestureRecognizer:(UIGestureRecognizer *)gestureRecognizer
+    shouldBeRequiredToFailByGestureRecognizer:(UIGestureRecognizer *)otherGestureRecognizer {
+    ANNStackController *stack = _stack;
+    if (stack && [stack swipeBackIsStacks:gestureRecognizer]) {
+        UIView *view = otherGestureRecognizer.view;
+        return [view isKindOfClass:UIScrollView.class] &&
+               otherGestureRecognizer == ((UIScrollView *)view).panGestureRecognizer;
+    }
+    id<UIGestureRecognizerDelegate> systemDelegate = _systemDelegate;
+    SEL question = @selector(gestureRecognizer:shouldBeRequiredToFailByGestureRecognizer:);
+    if ([systemDelegate respondsToSelector:question]) {
+        return [systemDelegate gestureRecognizer:gestureRecognizer
+            shouldBeRequiredToFailByGestureRecognizer:otherGestureRecognizer];
+    }
+    return NO;
+}
+
 #pragma mark - The rest goes to UIKit's delegate
 
 - (void)setBarHidden:(BOOL)barHidden {

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

@@ -6,9 +6,11 @@ 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`.
+/// `showInColumn` into the split view's column `column` that is a stack: `children` in place of the stack's screens, the
+/// last one on top, from the screen `fromViewController`. A navigation controller that isn't a stack of the core
+/// rejects `[ANNErrorTexts columnNotStack:column:]`.
 - (void)setStackChildren:(NSArray<UIViewController *> *)children
+                inColumn:(NSString *)column
       fromViewController:(nullable UIViewController *)fromViewController
                 animated:(BOOL)animated
               completion:(ANNTransitionCompletionBlock)completion

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

@@ -8,6 +8,7 @@
 // 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
+                inColumn:(NSString *)column
       fromViewController:(UIViewController *)fromViewController
                 animated:(BOOL)animated
               completion:(ANNTransitionCompletionBlock)completion
@@ -21,9 +22,7 @@
         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);
+    rejection([ANNErrorTexts columnNotStack:fromId column:column], nil);
 }
 
 @end

package/ios/Layouts/Tabs/ANNBottomTabItemBuilder.h

@@ -23,6 +23,10 @@ NS_ASSUME_NONNULL_BEGIN
 /// (default `iconColor`) unless `disableSelectedIconTint`. Nil without any.
 + (nullable UIImage *)selectedIconOf:(ANNBottomTabOptions *)tab;
 
+/// The images of the options `iconOf:` and `selectedIconOf:` draw from (`bottomTab.icon`, `bottomTab.selectedIcon`):
+/// each one an SF Symbol doesn't cover. Their sources, not their images: nothing loads.
++ (NSArray<Image *> *)rastersOf:(ANNBottomTabOptions *)tab;
+
 /// `selectedIconColor`, else `iconColor` (`bottomTab.selectedIconColor`); nil without both.
 + (nullable UIColor *)selectedIconColorOf:(ANNBottomTabOptions *)tab;
 

package/ios/Layouts/Tabs/ANNBottomTabItemBuilder.mm

@@ -67,6 +67,17 @@ static void ANNSetTitleAttributes(UITabBarItemStateAppearance *state, UIColor *c
     return icon ? ANNRaster(icon, color) : nil;
 }
 
++ (NSArray<Image *> *)rastersOf:(ANNBottomTabOptions *)tab {
+    NSMutableArray<Image *> *rasters = [NSMutableArray new];
+    if (!ANNSymbol(tab.sfSymbol) && tab.icon.source) {
+        [rasters addObject:tab.icon];
+    }
+    if (!ANNSymbol(tab.sfSelectedSymbol) && tab.selectedIcon.source) {
+        [rasters addObject:tab.selectedIcon];
+    }
+    return rasters;
+}
+
 + (UIColor *)selectedIconColorOf:(ANNBottomTabOptions *)tab {
     return [tab.selectedIconColor withDefault:nil] ?: [tab.iconColor withDefault:nil];
 }

package/ios/Layouts/Tabs/ANNBottomTabsAccessoryView.h

@@ -2,6 +2,8 @@
 #import "ANNReactView.h"
 #import <UIKit/UIKit.h>
 
+NS_ASSUME_NONNULL_BEGIN
+
 /**
  * The content of the tab bar's bottom accessory (iOS 26): the React component fills it, and the
  * component gets `bottomAccessoryPlacementChanged` when UIKit moves the accessory between the
@@ -10,8 +12,17 @@
 @interface ANNBottomTabsAccessoryView : UIView
 
 - (instancetype)initWithReactView:(ANNReactView *)reactView
-                     eventEmitter:(ANNEventEmitter *)eventEmitter;
+                     eventEmitter:(nullable ANNEventEmitter *)eventEmitter;
 
 @property(nonatomic, strong, readonly) ANNReactView *reactView;
 
+/**
+ * `handler` runs once when the view is out of a window: at once when it is already, else when it
+ * leaves it, so a replaced accessory shows to the end of whatever UIKit draws of it. nil cancels a
+ * handler not run yet.
+ */
+- (void)whenOutOfWindow:(nullable dispatch_block_t)handler;
+
 @end
+
+NS_ASSUME_NONNULL_END

package/ios/Layouts/Tabs/ANNBottomTabsAccessoryView.mm

@@ -3,6 +3,7 @@
 @implementation ANNBottomTabsAccessoryView {
     ANNEventEmitter *_eventEmitter;
     NSString *_placement;
+    dispatch_block_t _outOfWindowHandler;
 }
 
 - (instancetype)initWithReactView:(ANNReactView *)reactView
@@ -32,6 +33,28 @@
     }];
 }
 
+- (void)whenOutOfWindow:(dispatch_block_t)handler {
+    _outOfWindowHandler = nil;
+    if (!handler) {
+        return;
+    }
+    if (!self.window) {
+        handler();
+        return;
+    }
+    _outOfWindowHandler = [handler copy];
+}
+
+- (void)didMoveToWindow {
+    [super didMoveToWindow];
+    dispatch_block_t handler = _outOfWindowHandler;
+    if (self.window || !handler) {
+        return;
+    }
+    _outOfWindowHandler = nil;
+    handler();
+}
+
 // UIKit sets the environment when the accessory is shown and changes it as the tab bar minimizes
 // and expands.
 - (void)tabAccessoryEnvironmentDidChange API_AVAILABLE(ios(26.0)) {

package/ios/Layouts/Tabs/ANNBottomTabsController.h

@@ -45,6 +45,9 @@ typedef NS_ENUM(NSInteger, ANNTabPressSource) {
 /// The nearest tabs among the layout parents of `node` (not `node` itself); nil out of tabs.
 + (nullable ANNBottomTabsController *)tabsOf:(UIViewController *)node;
 
+/// `node` is in a tab rendered before it shows, which renders its content in its tabs' view: in a window, not shown.
++ (BOOL)isInUnseenTab:(UIViewController *)node;
+
 /// The tabs in layout order.
 @property(nonatomic, copy, readonly) NSArray<UIViewController *> *layoutTabs;