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

package/ios/Layouts/Modal/ANNModalHostViewComponentView.h

@@ -0,0 +1,13 @@
+#import <React/RCTModalHostViewComponentView.h>
+
+/**
+ * React Native's `<Modal>` under navigation: it is presented by the screen it is on, and when a
+ * navigation modal covers that screen UIKit refuses to present it. This one is presented by the
+ * view controller on top, as React Native lets a subclass do.
+ */
+@interface ANNModalHostViewComponentView : RCTModalHostViewComponentView
+
+/** Makes `<Modal>` use this class; before the first `<Modal>` mounts. */
++ (void)registerForModalHostView;
+
+@end

package/ios/Layouts/Modal/ANNModalHostViewComponentView.mm

@@ -0,0 +1,24 @@
+#import "ANNModalHostViewComponentView.h"
+#import <React/RCTComponentViewFactory.h>
+#import <React/UIView+React.h>
+
+@implementation ANNModalHostViewComponentView
+
++ (void)registerForModalHostView {
+    // The class has the descriptor of ModalHostView and replaces React Native's for it.
+    [[RCTComponentViewFactory currentComponentViewFactory] registerComponentViewClass:self];
+}
+
+- (void)presentViewController:(UIViewController *)modalViewController
+                     animated:(BOOL)animated
+                   completion:(void (^)(void))completion {
+    UIViewController *presenter = [self reactViewController];
+    // The presented view controller of a screen is also the one its parents present.
+    while (presenter.presentedViewController &&
+           !presenter.presentedViewController.isBeingDismissed) {
+        presenter = presenter.presentedViewController;
+    }
+    [presenter presentViewController:modalViewController animated:animated completion:completion];
+}
+
+@end

package/ios/Layouts/Modal/ANNModalPresentation.h

@@ -0,0 +1,73 @@
+#import "ANNNavigationOptions.h"
+#import <UIKit/UIKit.h>
+
+@class ANNTransitionPlan;
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// What decides the show of a modal (`modalPresentationStyle`, `modalTransitionStyle`), read once, at the present, from
+/// the modal root's resolved options (its own, over them its visible screen's, under them the defaults). A
+/// `mergeOptions` never changes the style or the transition after the show. Main queue.
+@interface ANNModalPresentation : NSObject
+
+/// The decisions of `resolved`. `animated` nil: by `animations.showModal.enter.enabled`; else as given (a lower modal
+/// of a `setRoot` layout shows without animation).
+- (instancetype)initWithOptions:(ANNNavigationOptions *)resolved
+                       animated:(nullable NSNumber *)animated NS_DESIGNATED_INITIALIZER;
+
+- (instancetype)init NS_UNAVAILABLE;
++ (instancetype)new NS_UNAVAILABLE;
+
+/// `modalPresentationStyle`: one to one; unset is UIKit's automatic style; an unknown string full screen.
+@property(nonatomic, readonly) UIModalPresentationStyle style;
+/// `modalTransitionStyle`: `coverVertical` unless one of the others is given.
+@property(nonatomic, readonly) UIModalTransitionStyle transitionStyle;
+/// The present is animated: `enter.enabled` is not `false`.
+@property(nonatomic, readonly) BOOL animated;
+/// UIKit shows the modal in its sheet: page sheet, form sheet, the automatic style (`modal.sheet`).
+@property(nonatomic, readonly) BOOL isSheet;
+
+/// `animations.showModal` when the show is animated, not a sheet (a sheet moves by UIKit's sheet motion) and has its
+/// own animation (`ANNAnimationRules modalIsOwn:`); nil otherwise (UIKit's show, or its zoom).
+@property(nonatomic, strong, readonly, nullable) ANNModalAnimationOptions *showAnimation;
+
+/// The plan of the custom show, once made (`showPlanOf:…`); kept for a dismissal without its own animation, which
+/// fades a popover over the show's length.
+@property(nonatomic, strong, readonly, nullable) ANNTransitionPlan *showPlan;
+
+/// The custom show's plan of `root` over `under` (`showAnimation`), with its wait: at most `waitLimit`; nil without a
+/// custom show.
+- (nullable ANNTransitionPlan *)showPlanOf:(UIViewController *)root
+                                     under:(nullable UIViewController *)under
+                                 waitLimit:(NSTimeInterval)waitLimit;
+
+/// The plan of the core's dismissal of `root`: `animation` when it is its own; else, for a popover shown with its own
+/// animation, a fade over the show's length; nil for a sheet and for UIKit's own.
+- (nullable ANNTransitionPlan *)dismissPlanOf:(UIViewController *)root
+                                    animation:(nullable ANNModalAnimationOptions *)animation
+                                        under:(nullable UIViewController *)under;
+
+/// Why UIKit can't make this show from `presenting` (`partialCurl` only full screen, to and from), as the reason of the
+/// rejection; nil when it can. `windowRoot` is the main window's root.
+- (nullable NSString *)problemPresentingFrom:(UIViewController *)presenting
+                                  windowRoot:(nullable UIViewController *)windowRoot;
+
+/// Before `presentViewController:`: the style and the transition, the presentation's delegate, the popover kept a
+/// popover (`adaptive: false`), the sheet, the size, the popover's source on `presentingLayout`, the hold, the
+/// `testID`.
+- (void)prepare:(UIViewController *)root
+            options:(ANNNavigationOptions *)resolved
+           delegate:(id<UIAdaptivePresentationControllerDelegate>)delegate
+    presentingLayout:(UIViewController *)presentingLayout;
+
+/// The hold of the modal: `isModalInPresentation` of the presented root is its resolved `modal.swipeToDismiss` turned
+/// around (default `true`: no hold), as the screen it shows now has it.
++ (void)applyHoldTo:(UIViewController *)root;
+
+/// The `testID` of the modal's container: the root's view takes `modal.testID`, a sheet `modal.sheet.testID` before it;
+/// a view without one loses the old one.
++ (void)applyTestIDTo:(UIViewController *)root sheet:(BOOL)isSheet;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/Layouts/Modal/ANNModalPresentation.mm

@@ -0,0 +1,189 @@
+#import "ANNModalPresentation.h"
+#import "ANNAnimationRules.h"
+#import "ANNModalSizePresenter.h"
+#import "ANNPopoverPresenter.h"
+#import "ANNSheetPresenter.h"
+#import "ANNTransitionPlan.h"
+#import "UIViewController+LayoutProtocol.h"
+
+// UIKit's styles by the names of `modalPresentationStyle`.
+static NSDictionary<NSString *, NSNumber *> *ANNPresentationStyles(void) {
+    static NSDictionary<NSString *, NSNumber *> *styles;
+    static dispatch_once_t once;
+    dispatch_once(&once, ^{
+      styles = @{
+          @"pageSheet" : @(UIModalPresentationPageSheet),
+          @"formSheet" : @(UIModalPresentationFormSheet),
+          @"fullScreen" : @(UIModalPresentationFullScreen),
+          @"overFullScreen" : @(UIModalPresentationOverFullScreen),
+          @"overCurrentContext" : @(UIModalPresentationOverCurrentContext),
+          @"currentContext" : @(UIModalPresentationCurrentContext),
+          @"popover" : @(UIModalPresentationPopover),
+      };
+    });
+    return styles;
+}
+
+// UIKit's transitions by the names of `modalTransitionStyle`.
+static NSDictionary<NSString *, NSNumber *> *ANNTransitionStyles(void) {
+    static NSDictionary<NSString *, NSNumber *> *styles;
+    static dispatch_once_t once;
+    dispatch_once(&once, ^{
+      styles = @{
+          @"coverVertical" : @(UIModalTransitionStyleCoverVertical),
+          @"crossDissolve" : @(UIModalTransitionStyleCrossDissolve),
+          @"flipHorizontal" : @(UIModalTransitionStyleFlipHorizontal),
+          @"partialCurl" : @(UIModalTransitionStylePartialCurl),
+      };
+    });
+    return styles;
+}
+
+@implementation ANNModalPresentation {
+    // `animations.showModal.enter.waitForRender` of the show.
+    Bool *_waitForRender;
+}
+
+- (instancetype)initWithOptions:(ANNNavigationOptions *)resolved animated:(NSNumber *)animated {
+    if (self = [super init]) {
+        NSString *styleName = [resolved.modalPresentationStyle withDefault:nil];
+        if (styleName.length == 0) {
+            _style = UIModalPresentationAutomatic;
+        } else {
+            NSNumber *style = ANNPresentationStyles()[styleName];
+            _style = style ? (UIModalPresentationStyle)style.integerValue
+                           : UIModalPresentationFullScreen;
+        }
+        NSString *transitionName = [resolved.modalTransitionStyle withDefault:nil];
+        NSNumber *transition = transitionName ? ANNTransitionStyles()[transitionName] : nil;
+        _transitionStyle = transition ? (UIModalTransitionStyle)transition.integerValue
+                                      : UIModalTransitionStyleCoverVertical;
+        ANNModalAnimationOptions *showModal = resolved.animations.showModal;
+        if (animated) {
+            _animated = animated.boolValue;
+        } else {
+            // `showModal.enter.enabled: false` turns the whole show's animation off.
+            _animated = ![ANNAnimationRules sideIsDisabled:showModal.enter];
+        }
+        _isSheet = _style == UIModalPresentationPageSheet ||
+                   _style == UIModalPresentationFormSheet ||
+                   _style == UIModalPresentationAutomatic;
+        // A custom show only off a sheet: a sheet keeps UIKit's sheet motion.
+        if (_animated && !_isSheet && [ANNAnimationRules modalIsOwn:showModal]) {
+            _showAnimation = showModal;
+        }
+        _waitForRender = showModal.enter.waitForRender;
+    }
+    return self;
+}
+
+- (ANNTransitionPlan *)showPlanOf:(UIViewController *)root
+                            under:(UIViewController *)under
+                        waitLimit:(NSTimeInterval)waitLimit {
+    if (!_showAnimation) {
+        return nil;
+    }
+    // The screen under a modal is in the transition only for a full-screen modal.
+    _showPlan = [ANNTransitionPlan presentPlanWithAnimation:_showAnimation
+                                              waitForRender:_waitForRender
+                                                  waitLimit:waitLimit
+                                          underInTransition:_style == UIModalPresentationFullScreen
+                                                      under:under
+                                                      modal:root];
+    return _showPlan;
+}
+
+- (ANNTransitionPlan *)dismissPlanOf:(UIViewController *)root
+                           animation:(ANNModalAnimationOptions *)animation
+                               under:(UIViewController *)under {
+    if (_isSheet) {
+        return nil;
+    }
+    BOOL popover = _style == UIModalPresentationPopover;
+    ANNTransitionPlan *plan =
+        [ANNTransitionPlan dismissPlanWithAnimation:animation
+                                  underInTransition:_style == UIModalPresentationFullScreen
+                                              modal:root
+                                              under:under];
+    if (plan) {
+        // A popover with nothing to play fades out over the length.
+        plan.fadesWhenNothingPlays = popover;
+        return plan;
+    }
+    // Shown with its own animation and closed without: a full screen closes as UIKit does it, a popover fades over the
+    // show's length; the show's `exit` (for the screen under) never plays on it.
+    if (popover && _showPlan && _showPlan.length > 0) {
+        return [ANNTransitionPlan fadeOutPlanOfModal:root under:under length:_showPlan.length];
+    }
+    return nil;
+}
+
+// UIKit takes `partialCurl` only for a full-screen modal over a controller that fills the screen, and a controller
+// shown with `partialCurl` presents nothing more: the command rejects before it asks UIKit.
+- (NSString *)problemPresentingFrom:(UIViewController *)presenting
+                         windowRoot:(UIViewController *)windowRoot {
+    if (presenting.presentingViewController &&
+        presenting.modalTransitionStyle == UIModalTransitionStylePartialCurl) {
+        return @"partialCurl needs a full screen modal";
+    }
+    if (_transitionStyle != UIModalTransitionStylePartialCurl) {
+        return nil;
+    }
+    BOOL presentingFills = presenting == windowRoot ||
+                           presenting.modalPresentationStyle == UIModalPresentationFullScreen;
+    if (_style != UIModalPresentationFullScreen || !presentingFills) {
+        return @"partialCurl needs a full screen modal";
+    }
+    return nil;
+}
+
+- (void)prepare:(UIViewController *)root
+             options:(ANNNavigationOptions *)resolved
+            delegate:(id<UIAdaptivePresentationControllerDelegate>)delegate
+    presentingLayout:(UIViewController *)presentingLayout {
+    root.modalPresentationStyle = _style;
+    root.modalTransitionStyle = _transitionStyle;
+    // The presentation controller is made for the style just set; the delegate hears the user's closes, the tries
+    // on a held modal and the detents the finger chose.
+    root.presentationController.delegate = delegate;
+    ANNModalOptions *modal = resolved.modal;
+    BOOL popover = _style == UIModalPresentationPopover;
+    if (popover && ![modal.popover.adaptive withDefault:YES]) {
+        [ANNPopoverPresenter keepPopoverOf:root delegate:delegate];
+    }
+    if (_isSheet) {
+        [ANNSheetPresenter applyOptions:modal.sheet toModal:root];
+    }
+    [ANNModalSizePresenter applyOptions:modal toModal:root];
+    if (popover) {
+        [ANNPopoverPresenter anchorPopover:root.popoverPresentationController
+                                   options:modal.popover
+                                presenting:presentingLayout];
+    }
+    [ANNModalPresentation applyHoldTo:root];
+    [ANNModalPresentation applyTestIDTo:root sheet:_isSheet];
+}
+
++ (void)applyHoldTo:(UIViewController *)root {
+    BOOL held = ![[root resolveOptionsWithDefault].modal.swipeToDismiss withDefault:YES];
+    if (root.modalInPresentation != held) {
+        root.modalInPresentation = held;
+    }
+}
+
++ (void)applyTestIDTo:(UIViewController *)root sheet:(BOOL)isSheet {
+    if (!root.isViewLoaded) {
+        return;
+    }
+    ANNModalOptions *modal = [root resolveOptionsWithDefault].modal;
+    NSString *testID = isSheet ? [modal.sheet.testID withDefault:nil] : nil;
+    if (testID.length == 0) {
+        testID = [modal.testID withDefault:nil];
+    }
+    NSString *identifier = testID.length > 0 ? testID : nil;
+    if (![root.view.accessibilityIdentifier ?: @"" isEqualToString:identifier ?: @""]) {
+        root.view.accessibilityIdentifier = identifier;
+    }
+}
+
+@end

package/ios/Layouts/Modal/ANNModalSizePresenter.h

@@ -0,0 +1,13 @@
+#import "ANNModalOptions.h"
+#import <UIKit/UIKit.h>
+
+/** `modal.contentSize`: the size of a form sheet or a popover. */
+@interface ANNModalSizePresenter : NSObject
+
+/** Before the modal is presented, and once it is shown (the content is measured at its width). */
++ (void)applyOptions:(ANNModalOptions *)options toModal:(UIViewController *)modal;
+
+/** `mergeOptions` of a screen in a shown modal: the modal takes the size of the options. */
++ (void)mergeOptions:(ANNModalOptions *)options ofViewController:(UIViewController *)viewController;
+
+@end

package/ios/Layouts/Modal/ANNModalSizePresenter.mm

@@ -0,0 +1,65 @@
+#import "ANNModalSizePresenter.h"
+#import "ANNReactView.h"
+#import "ANNSheetPresenter.h"
+#import "UIViewController+LayoutProtocol.h"
+
+static NSString *const ANNContentSize = @"contentSize";
+
+@implementation ANNModalSizePresenter
+
++ (void)applyOptions:(ANNModalOptions *)options toModal:(UIViewController *)modal {
+    ANNModalContentSizeOptions *size = options.contentSize;
+    if (!size.hasValue) {
+        return;
+    }
+    [self setSize:size ofModal:modal];
+    // Fabric reports no size changes: the content is measured after it mounts.
+    UIView<ANNComponentProtocol> *reactView = modal.presentedComponentViewController.reactView;
+    if (![[size.height withDefault:nil] isEqual:@"content"]) {
+        [reactView setContentDidMount:nil forKey:ANNContentSize];
+        return;
+    }
+    __weak UIViewController *weakModal = modal;
+    [reactView
+        setContentDidMount:^{
+          [self setSize:size ofModal:weakModal];
+        }
+                    forKey:ANNContentSize];
+}
+
++ (void)mergeOptions:(ANNModalOptions *)options
+    ofViewController:(UIViewController *)viewController {
+    if (!options.contentSize.hasValue) {
+        return;
+    }
+    UIViewController *modal = viewController;
+    while (modal.parentViewController) {
+        modal = modal.parentViewController;
+    }
+    if (modal.presentingViewController) {
+        [self applyOptions:modal.resolveOptionsWithDefault.modal toModal:modal];
+    }
+}
+
+// A width of 0 is the width UIKit gives the style; the content is measured at the modal's width.
++ (void)setSize:(ANNModalContentSizeOptions *)size ofModal:(UIViewController *)modal {
+    if (!modal) {
+        return;
+    }
+    CGFloat width = [size.width withDefault:0];
+    id height = [size.height withDefault:@0];
+    CGFloat points = 0;
+    if ([height isEqual:@"content"]) {
+        points =
+            [ANNSheetPresenter contentHeightOf:modal
+                                         width:width > 0 ? width : modal.view.bounds.size.width];
+    } else if ([height isKindOfClass:NSNumber.class]) {
+        points = [height doubleValue];
+    }
+    CGSize preferred = CGSizeMake(width, points);
+    if (!CGSizeEqualToSize(modal.preferredContentSize, preferred)) {
+        modal.preferredContentSize = preferred;
+    }
+}
+
+@end

package/ios/Layouts/Modal/ANNModalTransitions.h

@@ -0,0 +1,29 @@
+#import <UIKit/UIKit.h>
+
+@class ANNTransitionPlan;
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// The transitioning delegate of one modal with a custom show or dismissal, held by its record (UIKit holds
+/// `transitioningDelegate` weakly). It gives UIKit the core's transition object for the show it was made for, and for a
+/// dismissal only while the core itself dismisses the modal (`coreDismissal`, set right before the core's
+/// `dismissViewControllerAnimated:` and cleared in its completion): the user's swipe or a dismissal of anyone else gets
+/// UIKit's own (nil). It never answers a presentation controller, so the style's own one stays (a popover, a full
+/// screen). Sheets never get one: they move by UIKit's sheet motion. Main queue.
+@interface ANNModalTransitions : NSObject <UIViewControllerTransitioningDelegate>
+
+/// The plan of the show; nil once UIKit took it.
+@property(nonatomic, strong, nullable) ANNTransitionPlan *showPlan;
+
+/// The plan of the core's dismissal that runs now; nil when the core dismisses without its own animation.
+@property(nonatomic, strong, nullable) ANNTransitionPlan *dismissPlan;
+
+/// The core's own dismissal runs (between its call to UIKit and its completion).
+@property(nonatomic) BOOL coreDismissal;
+
+/// A reload or the record's end during a transition: the running custom transition ends at its end state.
+- (void)cancel;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/Layouts/Modal/ANNModalTransitions.mm

@@ -0,0 +1,40 @@
+#import "ANNModalTransitions.h"
+#import "ANNTransitionAnimator.h"
+#import "ANNTransitionPlan.h"
+
+@implementation ANNModalTransitions {
+    __weak ANNTransitionAnimator *_running;
+}
+
+- (id<UIViewControllerAnimatedTransitioning>)
+    animationControllerForPresentedController:(UIViewController *)presented
+                         presentingController:(UIViewController *)presenting
+                             sourceController:(UIViewController *)source {
+    ANNTransitionPlan *plan = _showPlan;
+    _showPlan = nil;
+    if (!plan) {
+        return nil;
+    }
+    ANNTransitionAnimator *animator = [[ANNTransitionAnimator alloc] initWithPlan:plan];
+    _running = animator;
+    return animator;
+}
+
+- (id<UIViewControllerAnimatedTransitioning>)animationControllerForDismissedController:
+    (UIViewController *)dismissed {
+    ANNTransitionPlan *plan = _dismissPlan;
+    if (!_coreDismissal || !plan) {
+        return nil;
+    }
+    _dismissPlan = nil;
+    ANNTransitionAnimator *animator = [[ANNTransitionAnimator alloc] initWithPlan:plan];
+    _running = animator;
+    return animator;
+}
+
+- (void)cancel {
+    [_running cancel];
+    _running = nil;
+}
+
+@end

package/ios/Layouts/Modal/ANNPopoverPresenter.h

@@ -0,0 +1,29 @@
+#import "ANNPopoverOptions.h"
+#import <UIKit/UIKit.h>
+
+/** `modal.popover`: the source a popover points at. */
+@interface ANNPopoverPresenter : NSObject
+
+/**
+ * The popover points at the button or the view of the options on the presenting screen. Without
+ * one it stands in the middle of the presenting screen without an arrow: UIKit throws when a
+ * popover has no anchor in a regular width.
+ */
++ (void)anchorPopover:(UIPopoverPresentationController *)popover
+              options:(ANNPopoverOptions *)options
+           presenting:(UIViewController *)presenting;
+
+/**
+ * `adaptive: false`: the popover stays a popover in a compact width. Its presentation controller
+ * gets a delegate that keeps the style and passes everything else to the delegate.
+ */
++ (void)keepPopoverOf:(UIViewController *)modal
+             delegate:(id<UIAdaptivePresentationControllerDelegate>)delegate;
+
+/** A top bar or toolbar button with the id on the screen the layout shows. */
++ (UIBarButtonItem *)barButtonWithId:(NSString *)buttonId in:(UIViewController *)layout;
+
+/** The React view with the `nativeID` in the hierarchy of the view. */
++ (UIView *)viewWithNativeID:(NSString *)nativeID in:(UIView *)root;
+
+@end

package/ios/Layouts/Modal/ANNPopoverPresenter.mm

@@ -0,0 +1,158 @@
+#import "ANNPopoverPresenter.h"
+#import "ANNUIBarButtonItem.h"
+#import "UIViewController+LayoutProtocol.h"
+#import <React/RCTLog.h>
+#import <React/RCTViewComponentView.h>
+#import <objc/runtime.h>
+
+// The delegate of a popover that stays a popover: UIKit asks the delegate for the adaptive style of
+// every presentation (asking the presentation controller for it asks the delegate again), so only
+// these popovers get it.
+@interface ANNNonAdaptivePopoverDelegate : NSObject <UIPopoverPresentationControllerDelegate>
+@property(nonatomic, weak) id<UIAdaptivePresentationControllerDelegate> delegate;
+@end
+
+@implementation ANNNonAdaptivePopoverDelegate
+
+- (UIModalPresentationStyle)
+    adaptivePresentationStyleForPresentationController:(UIPresentationController *)controller
+                                       traitCollection:(UITraitCollection *)traitCollection {
+    return UIModalPresentationNone;
+}
+
+- (BOOL)respondsToSelector:(SEL)selector {
+    return [super respondsToSelector:selector] || [self.delegate respondsToSelector:selector];
+}
+
+- (id)forwardingTargetForSelector:(SEL)selector {
+    return [self.delegate respondsToSelector:selector] ? self.delegate : nil;
+}
+
+@end
+
+static const void *ANNNonAdaptivePopoverDelegateKey = &ANNNonAdaptivePopoverDelegateKey;
+
+@implementation ANNPopoverPresenter
+
++ (void)keepPopoverOf:(UIViewController *)modal
+             delegate:(id<UIAdaptivePresentationControllerDelegate>)delegate {
+    ANNNonAdaptivePopoverDelegate *popoverDelegate = [ANNNonAdaptivePopoverDelegate new];
+    popoverDelegate.delegate = delegate;
+    // The presentation controller holds its delegate weakly.
+    objc_setAssociatedObject(modal, ANNNonAdaptivePopoverDelegateKey, popoverDelegate,
+                             OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+    modal.popoverPresentationController.delegate = popoverDelegate;
+}
+
++ (void)anchorPopover:(UIPopoverPresentationController *)popover
+              options:(ANNPopoverOptions *)options
+           presenting:(UIViewController *)presenting {
+    if (!popover) {
+        return;
+    }
+    NSString *buttonId = [options.sourceButtonId withDefault:nil];
+    NSString *nativeID = [options.sourceNativeID withDefault:nil];
+    UIBarButtonItem *button = buttonId ? [self barButtonWithId:buttonId in:presenting] : nil;
+    UIView *view = !button && nativeID ? [self viewWithNativeID:nativeID in:presenting.view] : nil;
+    if (button) {
+        if (@available(iOS 16.0, *)) {
+            popover.sourceItem = button;
+        } else {
+            popover.barButtonItem = button;
+        }
+    } else if (view) {
+        popover.sourceView = view;
+        popover.sourceRect = view.bounds;
+    } else if (![self hasAnchor:popover]) {
+        if (buttonId || nativeID) {
+            RCTLogWarn(@"[ApexNavigation] modal.popover: no source %@ on the presenting screen; the popover "
+                       @"stands in the middle.",
+                       buttonId ?: nativeID);
+        }
+        UIView *screen = presenting.view;
+        popover.sourceView = screen;
+        popover.sourceRect =
+            CGRectMake(CGRectGetMidX(screen.bounds), CGRectGetMidY(screen.bounds), 0, 0);
+        popover.permittedArrowDirections = 0;
+        return;
+    }
+    popover.permittedArrowDirections = [self arrowDirections:options.arrowDirections];
+}
+
++ (BOOL)hasAnchor:(UIPopoverPresentationController *)popover {
+    if (@available(iOS 16.0, *)) {
+        if (popover.sourceItem) {
+            return YES;
+        }
+    }
+    return popover.sourceView != nil || popover.barButtonItem != nil;
+}
+
++ (UIPopoverArrowDirection)arrowDirections:(NSArray *)directions {
+    if (directions.count == 0) {
+        return UIPopoverArrowDirectionAny;
+    }
+    NSDictionary<NSString *, NSNumber *> *map = @{
+        @"up" : @(UIPopoverArrowDirectionUp),
+        @"down" : @(UIPopoverArrowDirectionDown),
+        @"left" : @(UIPopoverArrowDirectionLeft),
+        @"right" : @(UIPopoverArrowDirectionRight),
+    };
+    UIPopoverArrowDirection mask = 0;
+    for (id direction in directions) {
+        mask |= [map[direction] unsignedIntegerValue];
+    }
+    return mask ?: UIPopoverArrowDirectionAny;
+}
+
+// In the screens on screen: in a split view also the secondary column, not the primary one alone.
++ (UIBarButtonItem *)barButtonWithId:(NSString *)buttonId in:(UIViewController *)layout {
+    for (UIViewController *screen in layout.shownComponentViewControllers) {
+        UIBarButtonItem *button = [self barButtonWithId:buttonId inScreen:screen];
+        if (button) {
+            return button;
+        }
+    }
+    return nil;
+}
+
++ (UIBarButtonItem *)barButtonWithId:(NSString *)buttonId inScreen:(UIViewController *)screen {
+    UINavigationItem *navigationItem = screen.navigationItem;
+    NSMutableArray<UIBarButtonItem *> *items = [NSMutableArray new];
+    [items addObjectsFromArray:navigationItem.leftBarButtonItems ?: @[]];
+    [items addObjectsFromArray:navigationItem.rightBarButtonItems ?: @[]];
+    [items addObjectsFromArray:screen.toolbarItems ?: @[]];
+    if (@available(iOS 16.0, *)) {
+        for (NSArray<UIBarButtonItemGroup *> *groups in @[
+                 navigationItem.leadingItemGroups, navigationItem.trailingItemGroups,
+                 navigationItem.centerItemGroups
+             ]) {
+            for (UIBarButtonItemGroup *group in groups) {
+                [items addObjectsFromArray:group.barButtonItems];
+            }
+        }
+    }
+    for (UIBarButtonItem *item in items) {
+        if ([item isKindOfClass:ANNUIBarButtonItem.class] &&
+            [((ANNUIBarButtonItem *)item).buttonId isEqualToString:buttonId]) {
+            return item;
+        }
+    }
+    return nil;
+}
+
++ (UIView *)viewWithNativeID:(NSString *)nativeID in:(UIView *)root {
+    if ([root isKindOfClass:RCTViewComponentView.class] &&
+        [((RCTViewComponentView *)root).nativeId isEqualToString:nativeID]) {
+        return root;
+    }
+    for (UIView *subview in root.subviews) {
+        UIView *found = [self viewWithNativeID:nativeID in:subview];
+        if (found) {
+            return found;
+        }
+    }
+    return nil;
+}
+
+@end