@apexnative/navigation 1.0.0-alpha.5 → 1.0.0-alpha.7

package/ios/Layouts/Stack/ANNPreviewPush.mm

@@ -1,11 +1,15 @@
 #import "ANNPreviewPush.h"
 #import "ANNAssert.h"
+#import "ANNCommandRunner.h"
+#import "ANNComponentViewController.h"
 #import "ANNErrorTexts.h"
+#import "ANNExternalViewController.h"
 #import "ANNLayoutFactory.h"
 #import "ANNParking.h"
 #import "ANNPopoverPresenter.h"
 #import "ANNPreviewInteraction.h"
 #import "ANNReloadCoordinator.h"
+#import "ANNSlotContainers.h"
 #import "ANNSlotScreenView.h"
 #import "ANNStackCommands.h"
 #import "ANNStackController.h"
@@ -34,6 +38,10 @@ static const NSTimeInterval ANNPreviewSearchInterval = 1.0 / 60;
 @property(nonatomic, weak, nullable) UIView<ANNComponentProtocol> *watched;
 @property(nonatomic) BOOL attached;
 @property(nonatomic) BOOL done;
+// The size of the preview, taken at the push.
+@property(nonatomic) CGSize size;
+// The screen rendered: at the push, or at the press for a screen of its own React root.
+@property(nonatomic) BOOL rendered;
 // The screen's unseen place in the main window, at its preview size, until UIKit takes its view for the menu.
 @property(nonatomic, strong, nullable) UIView *host;
 @property(nonatomic, strong, nullable) ANNParking *parking;
@@ -51,6 +59,15 @@ static NSMutableDictionary<NSString *, ANNPreviewRecord *> *ANNPreviewRecords(vo
     return records;
 }
 
+// A React screen with a root of its own renders at the press: a view with a preview costs no React root, no render and
+// no effects of the screen until the user presses it. A native screen (a kind of component screen) renders as it is
+// made, and a screen of the app's one tree renders in JavaScript as its slot is added: both render at the push.
+static BOOL ANNPreviewRendersAtPress(UIViewController *screen) {
+    return [screen isKindOfClass:ANNComponentViewController.class] &&
+           ![screen isKindOfClass:ANNExternalViewController.class] &&
+           ![screen.layoutInfo.name hasPrefix:ANNSlotPrefix];
+}
+
 @implementation ANNPreviewPush
 
 + (void)push:(ANNLayoutNode *)layout
@@ -71,6 +88,7 @@ static NSMutableDictionary<NSString *, ANNPreviewRecord *> *ANNPreviewRecords(vo
     ANNPreviewRecord *record = [ANNPreviewRecord new];
     record.previewId = layout.nodeId;
     record.screen = screen;
+    record.size = size;
     record.source = source;
     record.answer = answer;
     // The key applies only once the tap made the preview a screen of the stack.
@@ -81,7 +99,9 @@ static NSMutableDictionary<NSString *, ANNPreviewRecord *> *ANNPreviewRecords(vo
     record.generation = answer.generation;
     ANNPreviewRecords()[record.previewId] = record;
     @try {
-        [self parkAndRender:record size:size];
+        if (!ANNPreviewRendersAtPress(screen)) {
+            [self parkAndRender:record];
+        }
     } @catch (NSException *exception) {
         [self finish:record];
         [screen destroy];
@@ -90,9 +110,11 @@ static NSMutableDictionary<NSString *, ANNPreviewRecord *> *ANNPreviewRecords(vo
     [self startSearch:record];
 }
 
-// The screen renders as now: its view waits unseen in the main window, at the size of the preview, so that its content
+// The screen renders, once: its view waits unseen in the main window, at the size of the preview, so that its content
 // lays out; nothing waits for it.
-+ (void)parkAndRender:(ANNPreviewRecord *)record size:(CGSize)size {
++ (void)parkAndRender:(ANNPreviewRecord *)record {
+    record.rendered = YES;
+    CGSize size = record.size;
     UIWindow *window = ApexNavigation.mainWindow;
     if (window) {
         UIView *host = [[UIView alloc] initWithFrame:CGRectMake(0, 0, size.width, size.height)];
@@ -207,6 +229,9 @@ static NSMutableDictionary<NSString *, ANNPreviewRecord *> *ANNPreviewRecords(vo
     record.attached = YES;
     [self stopWatching:record];
     __weak ANNPreviewRecord *weakRecord = record;
+    BOOL (^prepare)(void) = ^BOOL {
+      return [ANNPreviewPush renderAtPress:weakRecord];
+    };
     BOOL (^commit)(void) = ^BOOL {
       return [ANNPreviewPush commit:weakRecord];
     };
@@ -217,10 +242,35 @@ static NSMutableDictionary<NSString *, ANNPreviewRecord *> *ANNPreviewRecords(vo
                                   toView:view
                                 reactTag:view.tag
                                   source:source
+                                 prepare:prepare
                                   commit:commit
                                dismissed:dismissed];
 }
 
+#pragma mark - The press
+
+// The press starts (UIKit asks for the menu's configuration, about half a second before it shows the preview): the
+// screen renders now if it hasn't yet, so that its content is there when the preview shows. Out of the command's
+// runner, a failure rejects the push with its text and the preview goes. YES when the screen rendered. A preview of the
+// JavaScript before a reload renders nothing: its screen would start in the new one.
++ (BOOL)renderAtPress:(ANNPreviewRecord *)record {
+    if (!record || record.done || !record.answer.isCurrent) {
+        return NO;
+    }
+    if (record.rendered) {
+        return YES;
+    }
+    @try {
+        [self parkAndRender:record];
+    } @catch (NSException *exception) {
+        [self finish:record];
+        [record.screen destroy];
+        [record.answer reject:[ANNCommandRunner rejectionOf:exception what:record.what]];
+        return NO;
+    }
+    return YES;
+}
+
 #pragma mark - The tap
 
 // YES once the core took the preview: a key that leads back to an entry, or the push the queue accepted. From then on
@@ -267,7 +317,9 @@ static NSMutableDictionary<NSString *, ANNPreviewRecord *> *ANNPreviewRecords(vo
         return YES;
     }
     // The preview grows into the screen: a push without an animation, and without a wait, as the screen rendered
-    // already; its answer at the end of the transaction.
+    // already; its answer at the end of the transaction. A screen that rendered only as the menu opened (a pointer's
+    // right click, then a quick tap) may have no content yet: its push waits for it as a push does.
+    BOOL waits = ANNPreviewRendersAtPress(screen) && !screen.reactView.isReady;
     [stack setKey:key ofEntry:screen];
     [stack.queue push:screen
              answer:record.answer
@@ -275,7 +327,7 @@ static NSMutableDictionary<NSString *, ANNPreviewRecord *> *ANNPreviewRecords(vo
         componentId:record.componentId
              source:entry
            animated:NO
-              waits:NO];
+              waits:waits];
     return YES;
 }
 

package/ios/Layouts/Stack/ANNStackAnimatingDelegate.h

@@ -12,13 +12,18 @@ NS_ASSUME_NONNULL_BEGIN
                     from:(UIViewController *)from
                       to:(UIViewController *)to;
 
+/// The interaction of the swipe back that plays `animator`; nil for any other transition.
+- (nullable id<UIViewControllerInteractiveTransitioning>)interactionForAnimator:
+    (id<UIViewControllerAnimatedTransitioning>)animator;
+
 @end
 
 /// The stack's delegate while a custom animation may be needed: it answers what the stack answers as its own delegate —
 /// every method the stack implements goes to the stack — and also the choice of the transition object. A delegate with
 /// that method turns the iOS 26 content swipe off, so the stack sets this one only while the top's `animations.pop`,
-/// the pushed screen's `animations.push` or a running `setStackRoot` is its own, and itself otherwise. Never an
-/// interaction controller: the custom transitions aren't interactive, the swipe stays UIKit's.
+/// the pushed screen's `animations.push` or a running `setStackRoot` is its own, and itself otherwise. An interaction
+/// controller only while `answersInteraction`: the stack's own swipe back then plays the top's own pop under the
+/// finger; otherwise UIKit doesn't see the method, and the swipe stays UIKit's.
 @interface ANNStackAnimatingDelegate : NSObject <UINavigationControllerDelegate>
 
 - (instancetype)initWithStack:(UINavigationController<ANNStackAnimating> *)stack
@@ -27,6 +32,10 @@ NS_ASSUME_NONNULL_BEGIN
 - (instancetype)init NS_UNAVAILABLE;
 + (instancetype)new NS_UNAVAILABLE;
 
+/// The top's pop follows the swipe back (`animations.pop.interactive`). UIKit reads the delegate's methods when it is
+/// set: the stack sets the delegate again after a change.
+@property(nonatomic) BOOL answersInteraction;
+
 @end
 
 NS_ASSUME_NONNULL_END

package/ios/Layouts/Stack/ANNStackAnimatingDelegate.mm

@@ -12,16 +12,16 @@
     return self;
 }
 
-// The choice of the transition object is this delegate's own; the interaction controller is never answered. The other
-// methods of `UINavigationControllerDelegate` are the stack's when the stack has them; nothing outside the protocol is
-// forwarded (design 11).
+// The choice of the transition object is this delegate's own; the interaction controller too, answered only while
+// the top's pop follows the swipe. The other methods of `UINavigationControllerDelegate` are the stack's when the
+// stack has them; nothing outside the protocol is forwarded (design 11).
 static BOOL ANNIsOwnSelector(SEL selector) {
     SEL animation = @selector(navigationController:
                        animationControllerForOperation:fromViewController:toViewController:);
     return selector == animation;
 }
 
-static BOOL ANNIsNeverAnswered(SEL selector) {
+static BOOL ANNIsInteractionSelector(SEL selector) {
     return selector == @selector(navigationController:interactionControllerForAnimationController:);
 }
 
@@ -33,7 +33,7 @@ static BOOL ANNIsDelegateSelector(SEL selector) {
 
 // A method of the protocol this delegate passes to the stack.
 - (BOOL)forwardsToStack:(SEL)selector {
-    return !ANNIsOwnSelector(selector) && !ANNIsNeverAnswered(selector) &&
+    return !ANNIsOwnSelector(selector) && !ANNIsInteractionSelector(selector) &&
            ANNIsDelegateSelector(selector) && [_stack respondsToSelector:selector];
 }
 
@@ -41,8 +41,8 @@ static BOOL ANNIsDelegateSelector(SEL selector) {
     if (ANNIsOwnSelector(selector)) {
         return YES;
     }
-    if (ANNIsNeverAnswered(selector)) {
-        return NO;
+    if (ANNIsInteractionSelector(selector)) {
+        return _answersInteraction;
     }
     if ([super respondsToSelector:selector]) {
         return YES;
@@ -89,4 +89,11 @@ static BOOL ANNIsDelegateSelector(SEL selector) {
     return [_stack animatorForOperation:operation from:fromVC to:toVC];
 }
 
+- (id<UIViewControllerInteractiveTransitioning>)
+                   navigationController:(UINavigationController *)navigationController
+    interactionControllerForAnimationController:
+        (id<UIViewControllerAnimatedTransitioning>)animationController {
+    return [_stack interactionForAnimator:animationController];
+}
+
 @end

package/ios/Layouts/Stack/ANNStackController.h

@@ -93,6 +93,14 @@ FOUNDATION_EXPORT NSString *_Nullable ANNStackKeyOfLayout(ANNLayoutNode *node);
 /// it), or UIKit's More navigation shows the stack's first screen only (its swipe goes back to the More list).
 - (BOOL)swipeBackIsUIKits:(UIGestureRecognizer *)recognizer;
 
+/// The swipe of `recognizer` may play the pop: the stack's own swipe (from the leading edge, toward the trailing side)
+/// only while the top's pop follows the finger (`animations.pop.interactive`) and the screen under is in place, UIKit's
+/// swipes of the stack's navigation only while it doesn't. Every other swipe may.
+- (BOOL)swipeBackTakes:(UIGestureRecognizer *)recognizer;
+
+/// `recognizer` is the stack's own swipe back, not one of UIKit's.
+- (BOOL)swipeBackIsStacks:(UIGestureRecognizer *)recognizer;
+
 /// The stack has one entry: there is nowhere to go back to.
 @property(nonatomic, readonly) BOOL hasOneEntry;
 

package/ios/Layouts/Stack/ANNStackController.mm

@@ -12,7 +12,9 @@
 #import "ANNSheetPresenter.h"
 #import "ANNShownScreens.h"
 #import "ANNStackAnimatingDelegate.h"
+#import "ANNStackPopAnimationOptions.h"
 #import "ANNStackPresenter.h"
+#import "ANNSwipePopInteraction.h"
 #import "ANNSystemUI.h"
 #import "ANNTopBarPresenter.h"
 #import "ANNTransitionAnimator.h"
@@ -54,6 +56,10 @@ static BOOL ANNIsActive(UIGestureRecognizer *recognizer) {
     return state == UIGestureRecognizerStateBegan || state == UIGestureRecognizerStateChanged;
 }
 
+// How far from the leading edge of the stack's view the stack's own swipe back starts, in points: the strip the side
+// menu leaves to the swipe back (`ANNSideMenuEdgeWidth`).
+static const CGFloat ANNOwnSwipeEdgeWidth = 20;
+
 @interface ANNStackController () <ANNStackDisplay, ANNStackAnimating>
 @end
 
@@ -90,6 +96,12 @@ static BOOL ANNIsActive(UIGestureRecognizer *recognizer) {
     ANNTransitionPlan *_pendingPlan;
     ANNStackChange _pendingChange;
     __weak ANNTransitionAnimator *_runningAnimator;
+    // The interaction of the swipe back that plays the top's own pop, until UIKit asks for it.
+    __weak ANNSwipePopInteraction *_swipeInteraction;
+    // The stack's own swipe from the leading edge, on while the top's pop follows the finger: UIKit runs its swipe
+    // without asking the delegate for a transition, so that one would only slide.
+    UIPanGestureRecognizer *_ownSwipe;
+    InteractivePopGestureDelegate *_ownSwipeDelegate;
     BOOL _gateUpdateScheduled;
     // The stack is made (its helper set up): its options can be resolved.
     BOOL _madeUp;
@@ -260,6 +272,16 @@ static BOOL ANNIsActive(UIGestureRecognizer *recognizer) {
                                                                  content:YES
                                                                 barSwipe:barSwipe];
     }
+    if (!_ownSwipe) {
+        _ownSwipe = [[UIPanGestureRecognizer alloc] initWithTarget:self
+                                                            action:@selector(ownSwipeBack:)];
+        _ownSwipe.enabled = _animatingDelegate.answersInteraction;
+        [self.view addGestureRecognizer:_ownSwipe];
+    }
+    _ownSwipeDelegate = [InteractivePopGestureDelegate installOn:_ownSwipe
+                                                           stack:self
+                                                         content:NO
+                                                        barSwipe:barSwipe];
     [self updateSwipeBack];
 }
 
@@ -520,6 +542,9 @@ static BOOL ANNIsActive(UIGestureRecognizer *recognizer) {
 
 - (BOOL)isSwipingBack {
     UINavigationController *navigation = self.shownNavigationController;
+    if (navigation == self && ANNIsActive(_ownSwipe)) {
+        return YES;
+    }
     if (ANNIsActive(navigation.interactivePopGestureRecognizer)) {
         return YES;
     }
@@ -813,15 +838,20 @@ static BOOL ANNIsActive(UIGestureRecognizer *recognizer) {
 #pragma mark - The custom transitions
 
 // UIKit asks while it starts the change the queue asked for: the queue's plan when the operation and the arriving
-// entry are the plan's (the back button and the commands go through the queue, so its plan covers them); nil for
-// anything else — UIKit's own pops, the interactive swipe (UIKit never asks for it), a zoom alone.
+// entry are the plan's (the back button and the commands go through the queue, so its plan covers them); the swipe
+// back gets the top's own pop only with `animations.pop.interactive` (`swipeAnimatorFrom:to:`); nil for anything
+// else — UIKit's own pops, a zoom alone.
 - (id<UIViewControllerAnimatedTransitioning>)
     animatorForOperation:(UINavigationControllerOperation)operation
                     from:(UIViewController *)from
                       to:(UIViewController *)to {
+    if ([self isSwipingBack]) {
+        return operation == UINavigationControllerOperationPop
+                   ? [self swipeAnimatorFrom:from to:to]
+                   : nil;
+    }
     ANNTransitionPlan *plan = _pendingPlan;
-    if (!plan || operation == UINavigationControllerOperationNone || to != plan.toNode ||
-        [self isSwipingBack]) {
+    if (!plan || operation == UINavigationControllerOperationNone || to != plan.toNode) {
         return nil;
     }
     BOOL matches = _pendingChange == ANNStackChangeReplace ||
@@ -838,16 +868,73 @@ static BOOL ANNIsActive(UIGestureRecognizer *recognizer) {
     return animator;
 }
 
+// The stack's own swipe back of a top whose pop follows the finger (`animations.pop.interactive`, not
+// `enabled: false`): the pop plays under it. Nil otherwise, also when UIKit won't ask for the interaction (the gate
+// hasn't seen the option yet: a change of the default options) or the screen under hasn't settled
+// (`revealedEntrySettled:`): UIKit asks for the transition before the queue takes the swipe and moves those, and the
+// frames take the views as they are now.
+- (nullable ANNTransitionAnimator *)swipeAnimatorFrom:(UIViewController *)from
+                                                   to:(UIViewController *)to {
+    if (!ANNIsActive(_ownSwipe) || !_animatingDelegate.answersInteraction ||
+        ![self isOwnViewController:from] || ![self revealedEntrySettled:to]) {
+        return nil;
+    }
+    ANNStackPopAnimationOptions *pop = [from resolveOptionsWithDefault].animations.pop;
+    if (![ANNStackController popFollowsSwipe:pop]) {
+        return nil;
+    }
+    ANNTransitionPlan *plan = [ANNTransitionPlan stackPlanOfKind:ANNTransitionKindPop
+                                                       animation:pop
+                                                   waitForRender:nil
+                                                       waitLimit:0
+                                                            from:from
+                                                              to:to];
+    if (!plan) {
+        return nil;
+    }
+    ANNTransitionAnimator *animator = [[ANNTransitionAnimator alloc] initWithPlan:plan];
+    // The interaction keeps itself while it follows the gesture; UIKit keeps it once it starts it.
+    ANNSwipePopInteraction *interaction =
+        [[ANNSwipePopInteraction alloc] initWithAnimator:animator recognizer:_ownSwipe view:self.view];
+    _swipeInteraction = interaction;
+    _runningAnimator = animator;
+    return animator;
+}
+
+// The screen under is in place for the frames: its view made, not parked, not rendering as a lower screen.
+- (BOOL)revealedEntrySettled:(nullable UIViewController *)revealed {
+    return revealed.isViewLoaded && ![_lowerRendering objectForKey:revealed] &&
+           ![_lowerToRender containsObject:revealed] &&
+           ![[self parkedEntries] containsObject:revealed];
+}
+
++ (BOOL)popFollowsSwipe:(nullable ANNStackPopAnimationOptions *)pop {
+    return [ANNAnimationRules stackIsOwn:pop] && [pop.interactive withDefault:NO] &&
+           [pop.enabled withDefault:YES];
+}
+
+- (nullable id<UIViewControllerInteractiveTransitioning>)interactionForAnimator:
+    (id<UIViewControllerAnimatedTransitioning>)animator {
+    ANNSwipePopInteraction *interaction = _swipeInteraction;
+    return interaction && interaction.animator == animator ? interaction : nil;
+}
+
 // The animating delegate while a custom animation may be needed: a change with its own plan now, or a top whose
 // `animations.pop` is its own; the stack itself otherwise. UIKit reads the delegate's methods when it is set, so it is
-// set again at each change.
+// set again at each change, and again when the interaction of the swipe comes or goes with the top's
+// `animations.pop.interactive`.
 - (void)updateAnimationGateWith:(ANNTransitionPlan *)plan {
-    BOOL needed = plan != nil;
-    if (!needed) {
-        UIViewController *top = [self getCurrentChild];
-        needed = top && [ANNAnimationRules
-                            stackIsOwn:[top resolveOptionsWithDefault].animations.pop];
+    UIViewController *top = [self getCurrentChild];
+    ANNStackPopAnimationOptions *pop = top ? [top resolveOptionsWithDefault].animations.pop : nil;
+    BOOL needed = plan != nil || [ANNAnimationRules stackIsOwn:pop];
+    BOOL interactive = [ANNStackController popFollowsSwipe:pop];
+    if (_animatingDelegate.answersInteraction != interactive) {
+        _animatingDelegate.answersInteraction = interactive;
+        if (self.delegate == _animatingDelegate) {
+            self.delegate = self;
+        }
     }
+    _ownSwipe.enabled = interactive;
     id<UINavigationControllerDelegate> delegate =
         needed ? (id<UINavigationControllerDelegate>)_animatingDelegate : self;
     if (self.delegate != delegate) {
@@ -934,13 +1021,66 @@ static BOOL ANNIsActive(UIGestureRecognizer *recognizer) {
     if (top != nil && top != [self getCurrentChild]) {
         return YES;
     }
-    BOOL own = recognizer == self.interactivePopGestureRecognizer;
+    BOOL own = recognizer == self.interactivePopGestureRecognizer || recognizer == _ownSwipe;
     if (@available(iOS 26.0, *)) {
         own = own || recognizer == self.interactiveContentPopGestureRecognizer;
     }
     return !own && _queue.shown.count < 2;
 }
 
+- (BOOL)swipeBackIsStacks:(UIGestureRecognizer *)recognizer {
+    return recognizer != nil && recognizer == _ownSwipe;
+}
+
+- (BOOL)swipeBackTakes:(UIGestureRecognizer *)recognizer {
+    BOOL uikits = recognizer == self.interactivePopGestureRecognizer;
+    if (@available(iOS 26.0, *)) {
+        uikits = uikits || recognizer == self.interactiveContentPopGestureRecognizer;
+    }
+    if (recognizer != _ownSwipe && !uikits) {
+        return YES;
+    }
+    NSArray<UIViewController *> *shown = _queue.shown;
+    UIViewController *revealed = shown.count >= 2 ? shown[shown.count - 2] : nil;
+    // The options as they are now, as `swipeAnimatorFrom:to:` reads them: the gate may lag a change of the defaults,
+    // and a swipe of ours without the pop would be a pop the finger can't hold.
+    UIViewController *top = self.topViewController;
+    BOOL ownPlays = _ownSwipe.enabled && _animatingDelegate.answersInteraction && top &&
+                    top == [self getCurrentChild] && [self isOwnViewController:top] &&
+                    [ANNStackController
+                        popFollowsSwipe:[top resolveOptionsWithDefault].animations.pop] &&
+                    [self revealedEntrySettled:revealed];
+    if (uikits) {
+        return !ownPlays;
+    }
+    return ownPlays && [self panStartsAtLeadingEdge:_ownSwipe];
+}
+
+// A pan that starts near the leading edge of the stack's view and moves more across than along, toward the trailing
+// side: where UIKit's edge swipe starts.
+- (BOOL)panStartsAtLeadingEdge:(UIPanGestureRecognizer *)pan {
+    UIView *view = self.view;
+    CGPoint at = [pan locationInView:view];
+    CGPoint move = [pan translationInView:view];
+    BOOL rightToLeft =
+        view.effectiveUserInterfaceLayoutDirection == UIUserInterfaceLayoutDirectionRightToLeft;
+    CGFloat start = at.x - move.x;
+    CGFloat fromEdge = rightToLeft ? view.bounds.size.width - start : start;
+    if (move.x == 0 && move.y == 0) {
+        move = [pan velocityInView:view];
+    }
+    CGFloat along = rightToLeft ? -move.x : move.x;
+    return fromEdge <= ANNOwnSwipeEdgeWidth && along > fabs(move.y);
+}
+
+// The stack's own swipe began: a pop as UIKit's swipe makes it, which the stack follows as the swipe back
+// (`followUIKitTransition`); the transition asks for the top's pop and its interaction (`swipeAnimatorFrom:to:`).
+- (void)ownSwipeBack:(UIPanGestureRecognizer *)recognizer {
+    if (recognizer.state == UIGestureRecognizerStateBegan) {
+        [self popViewControllerAnimated:YES];
+    }
+}
+
 - (BOOL)hasOneEntry {
     return _queue.entries.count < 2;
 }
@@ -983,6 +1123,7 @@ static BOOL ANNIsActive(UIGestureRecognizer *recognizer) {
     BOOL edge = !(isBool && ![value boolValue]);
     BOOL content = !value || (isBool && [value boolValue]);
     _edgeSwipeDelegate.enabled = edge;
+    _ownSwipeDelegate.enabled = edge;
     _moreEdgeSwipeDelegate.enabled = edge;
     _contentSwipeDelegate.enabled = content;
     _moreContentSwipeDelegate.enabled = content;
@@ -992,6 +1133,7 @@ static BOOL ANNIsActive(UIGestureRecognizer *recognizer) {
 - (void)swipeBackFollowsBar {
     BOOL hidden = [ANNSystemUI barHiddenOf:self.shownNavigationController];
     _edgeSwipeDelegate.barHidden = hidden;
+    _ownSwipeDelegate.barHidden = hidden;
     _contentSwipeDelegate.barHidden = hidden;
     _moreEdgeSwipeDelegate.barHidden = hidden;
     _moreContentSwipeDelegate.barHidden = hidden;

package/ios/Layouts/Stack/ANNSwipePopInteraction.h

@@ -0,0 +1,26 @@
+#import <UIKit/UIKit.h>
+
+@class ANNTransitionAnimator;
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// The interaction of a swipe back that plays the screen's own pop (`animations.pop.interactive`). It follows the
+/// stack's own swipe from the leading edge (UIKit runs its swipe without asking the delegate for a transition), and
+/// shows the animator's frames as far as the finger went across `view`, in the direction of the swipe back. Letting go
+/// finishes the pop after a flick back or past half way, and puts the screen back otherwise; the rest plays faster
+/// after a quick flick, never slower, and UIKit ends its part at the same pace. An interaction UIKit never starts goes
+/// with the end of the gesture. Main queue.
+@interface ANNSwipePopInteraction : NSObject <UIViewControllerInteractiveTransitioning>
+
+- (instancetype)initWithAnimator:(ANNTransitionAnimator *)animator
+                      recognizer:(UIPanGestureRecognizer *)recognizer
+                            view:(UIView *)view NS_DESIGNATED_INITIALIZER;
+
+- (instancetype)init NS_UNAVAILABLE;
++ (instancetype)new NS_UNAVAILABLE;
+
+@property(nonatomic, weak, readonly, nullable) ANNTransitionAnimator *animator;
+
+@end
+
+NS_ASSUME_NONNULL_END