@apexnative/navigation 1.0.0-alpha.0 → 1.0.0-alpha.10

package/ios/Layouts/Stack/ANNPreviewPush.h

@@ -5,12 +5,13 @@
 
 NS_ASSUME_NONNULL_BEGIN
 
-/// The preview of a push (`usePreview`): a push that waits for a tap on its preview. Its screen is made and renders
-/// unseen, out of the stack, its key kept; the view with `preview.nativeID` is looked for on the source screen at once
-/// and on the next frames, 30 tries in all; found, the preview module (`ANNPreviewInteraction`) shows the screen from
-/// it on a long press. A tap that commits pushes the screen without an animation and without a wait, or goes back to
-/// the entry with its key; a preview that goes without being opened destroys its screen and rejects the push. Main
-/// queue.
+/// The preview of a push (`usePreview`): a push that waits for a tap on its preview. Its screen is made at once, out of
+/// the stack, its key kept, and renders unseen: a React screen with a root of its own as a press on the view starts, a
+/// native screen or one of the app's one tree at once. The view with `preview.nativeID` is looked for on the source
+/// screen at once, then at each mount of the source's content (on each frame for a slot screen), for at most 0.5 s;
+/// found, the preview module (`ANNPreviewInteraction`) shows the screen from it on a long press. A tap that commits
+/// pushes the screen without an animation (and without a wait once its content is there), or goes back to the entry
+/// with its key; a preview that goes without being opened destroys its screen and rejects the push. Main queue.
 @interface ANNPreviewPush : NSObject
 
 - (instancetype)init NS_UNAVAILABLE;

package/ios/Layouts/Stack/ANNPreviewPush.mm

@@ -1,19 +1,25 @@
 #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"
 #import "ApexNavigation+Internal.h"
 #import "UIViewController+LayoutProtocol.h"
 
-// The view of a component mounts a frame or so after the command that rendered it: it is looked for this many times,
-// a frame apart.
-static const NSUInteger ANNPreviewSearchTries = 30;
+// The view of a component mounts a frame or so after the command that rendered it: it is looked for at each mount of
+// the source's content until this limit (30 frames), then the preview goes, as with a `nativeID` no view has.
+static const NSTimeInterval ANNPreviewSearchLimit = 30.0 / 60;
+// Where the source's mounts can't be heard, a frame apart.
 static const NSTimeInterval ANNPreviewSearchInterval = 1.0 / 60;
 
 // One preview from its push to its end: the tap took it, or it went.
@@ -28,9 +34,14 @@ static const NSTimeInterval ANNPreviewSearchInterval = 1.0 / 60;
 @property(nonatomic, copy) NSString *componentId;
 @property(nonatomic, copy) NSString *what;
 @property(nonatomic) NSUInteger generation;
-@property(nonatomic) NSUInteger tries;
+// The content whose mounts the search hears, while it looks.
+@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;
@@ -48,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
@@ -68,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.
@@ -78,18 +99,22 @@ 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];
         @throw;
     }
-    [self search:record];
+    [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)];
@@ -110,42 +135,103 @@ static NSMutableDictionary<NSString *, ANNPreviewRecord *> *ANNPreviewRecords(vo
 
 #pragma mark - The search
 
-// Each try asks first whether the preview still lives: a source that went makes it go, a reload stops it silently.
-+ (void)search:(ANNPreviewRecord *)record {
-    if (record.done || record.attached) {
+// The view is looked for at once; else again at each mount of the source's content, where it comes with one of them,
+// and a last time at the limit, when the preview goes. Both later steps keep the generation they were made with: after
+// a reload they do nothing.
++ (void)startSearch:(ANNPreviewRecord *)record {
+    if ([self search:record last:NO]) {
         return;
     }
+    UIViewController *source = record.source;
+    // A source that is a container (a stack) is heard through the screen it shows.
+    UIView<ANNComponentProtocol> *content =
+        source.reactView ?: source.presentedComponentViewController.reactView;
+    __weak ANNPreviewRecord *weakRecord = record;
+    NSUInteger generation = record.generation;
+    // A slot screen hears only the first mount of its slot, not those deeper in it, and a container may show no React
+    // content yet: there the view is looked for on each frame until the limit.
+    if (!content || [content isKindOfClass:ANNSlotScreenView.class]) {
+        [self searchNextFrame:record];
+    } else {
+        record.watched = content;
+        [content setContentDidMount:^{
+          ANNPreviewRecord *searching = weakRecord;
+          if (searching && generation == ANNReloadCoordinator.generation) {
+              [ANNPreviewPush search:searching last:NO];
+          }
+        }
+                             forKey:[self mountKeyOf:record]];
+    }
+    int64_t delay = (int64_t)(ANNPreviewSearchLimit * NSEC_PER_SEC);
+    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, delay), dispatch_get_main_queue(), ^{
+      ANNPreviewRecord *searching = weakRecord;
+      if (searching && generation == ANNReloadCoordinator.generation) {
+          [ANNPreviewPush search:searching last:YES];
+      }
+    });
+}
+
+// One more search on the next frame, and so on until the view is found or the preview goes; after a reload, none.
++ (void)searchNextFrame:(ANNPreviewRecord *)record {
+    __weak ANNPreviewRecord *weakRecord = record;
+    NSUInteger generation = record.generation;
+    int64_t delay = (int64_t)(ANNPreviewSearchInterval * NSEC_PER_SEC);
+    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, delay), dispatch_get_main_queue(), ^{
+      ANNPreviewRecord *searching = weakRecord;
+      if (searching && generation == ANNReloadCoordinator.generation &&
+          ![ANNPreviewPush search:searching last:NO]) {
+          [ANNPreviewPush searchNextFrame:searching];
+      }
+    });
+}
+
+// YES when the search is over: the view was found, or the preview went or stopped. Each search asks first whether the
+// preview still lives: a source that went makes it go, a reload stops it silently. The last one, not finding the view,
+// makes the preview go.
++ (BOOL)search:(ANNPreviewRecord *)record last:(BOOL)last {
+    if (record.done || record.attached) {
+        return YES;
+    }
     if (record.generation != ANNReloadCoordinator.generation) {
-        return;
+        return YES;
     }
     UIViewController *source = record.source;
     if (!source || source.nodeHelper.destroyed) {
         [self gone:record];
-        return;
+        return YES;
     }
     // Read only: the view is found by its `nativeID`, and its tag is its current Fabric tag.
     UIView *view = [ANNPopoverPresenter viewWithNativeID:record.nativeID in:source.viewIfLoaded];
     if (view) {
         [self attach:record toView:view source:source];
-        return;
+        return YES;
     }
-    if (++record.tries >= ANNPreviewSearchTries) {
+    if (last) {
         [self gone:record];
-        return;
+        return YES;
     }
-    __weak ANNPreviewRecord *weakRecord = record;
-    int64_t delay = (int64_t)(ANNPreviewSearchInterval * NSEC_PER_SEC);
-    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, delay), dispatch_get_main_queue(), ^{
-      ANNPreviewRecord *searching = weakRecord;
-      if (searching) {
-          [ANNPreviewPush search:searching];
-      }
-    });
+    return NO;
+}
+
+// The key of the search's mount handler: one per preview, so that two previews of one source don't replace each other.
++ (NSString *)mountKeyOf:(ANNPreviewRecord *)record {
+    return [@"preview." stringByAppendingString:record.previewId];
+}
+
+// The search stops hearing the mounts: only its own handler goes.
++ (void)stopWatching:(ANNPreviewRecord *)record {
+    UIView<ANNComponentProtocol> *content = record.watched;
+    record.watched = nil;
+    [content setContentDidMount:nil forKey:[self mountKeyOf:record]];
 }
 
 + (void)attach:(ANNPreviewRecord *)record toView:(UIView *)view source:(UIViewController *)source {
     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];
     };
@@ -156,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
@@ -206,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
@@ -214,7 +327,7 @@ static NSMutableDictionary<NSString *, ANNPreviewRecord *> *ANNPreviewRecords(vo
         componentId:record.componentId
              source:entry
            animated:NO
-              waits:NO];
+              waits:waits];
     return YES;
 }
 
@@ -231,9 +344,10 @@ static NSMutableDictionary<NSString *, ANNPreviewRecord *> *ANNPreviewRecords(vo
     [record.answer reject:[ANNErrorTexts previewGone:record.previewId]];
 }
 
-// The record is done: the screen leaves its unseen place, the table forgets it.
+// The record is done: the search stops, the screen leaves its unseen place, the table forgets it.
 + (void)finish:(ANNPreviewRecord *)record {
     record.done = YES;
+    [self stopWatching:record];
     [self unpark:record];
     if (ANNPreviewRecords()[record.previewId] == record) {
         [ANNPreviewRecords() removeObjectForKey:record.previewId];
@@ -286,6 +400,7 @@ static NSMutableDictionary<NSString *, ANNPreviewRecord *> *ANNPreviewRecords(vo
     NSMutableArray<UIViewController *> *screens = [NSMutableArray new];
     for (ANNPreviewRecord *record in ANNPreviewRecords().allValues) {
         record.done = YES;
+        [self stopWatching:record];
         [self unpark:record];
         if (!record.attached) {
             [screens addObject:record.screen];

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/ANNStackCommands.mm

@@ -274,6 +274,7 @@
     if (target == stack.queue.entries.lastObject) {
         [stack.queue noneWithValue:componentId
                             answer:answer
+                              what:what
                        componentId:componentId
                             source:target];
         return;

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;