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

package/ios/Animations/Elements/ANNElementFinder.mm

@@ -1,8 +1,58 @@
 #import "ANNElementFinder.h"
 #import "ANNAppearanceDispatcher.h"
+#import "ANNElementTransitionOptions.h"
+#import "ANNSharedElementTransitionOptions.h"
+#import "Text.h"
 #import "UIViewController+LayoutProtocol.h"
+#import <React/RCTLog.h>
 #import <React/RCTViewComponentView.h>
 
+static NSString *ANNNativeIDOfView(UIView *view) {
+    return [view isKindOfClass:RCTViewComponentView.class]
+               ? ((RCTViewComponentView *)view).nativeId
+               : nil;
+}
+
+// Depth first, as the search by one id: the first view of the walk with an id keeps it. NO once every id is found.
+static BOOL ANNCollectViews(UIView *view, NSSet<NSString *> *nativeIDs,
+                            NSMutableDictionary<NSString *, UIView *> *found) {
+    NSString *nativeID = ANNNativeIDOfView(view);
+    if (nativeID && !found[nativeID] && [nativeIDs containsObject:nativeID]) {
+        found[nativeID] = view;
+        if (found.count == nativeIDs.count) {
+            return NO;
+        }
+    }
+    for (UIView *subview in view.subviews) {
+        if (!ANNCollectViews(subview, nativeIDs, found)) {
+            return NO;
+        }
+    }
+    return YES;
+}
+
+NSString *ANNNativeIDOf(Text *value) {
+    NSString *text = [value withDefault:nil];
+    return [text isKindOfClass:NSString.class] && text.length > 0 ? text : nil;
+}
+
+void ANNElementSkipped(NSString *element, NSString *reason) {
+    RCTLogWarn(@"[ApexNavigation] the transition's element %@ is skipped, it shows and hides with "
+               @"its screen while the rest plays: %@",
+               element, reason);
+}
+
+BOOL ANNElementStep(NSString *element, NS_NOESCAPE dispatch_block_t work) {
+    @try {
+        work();
+        return YES;
+    } @catch (NSException *exception) {
+        ANNElementSkipped(element, [NSString stringWithFormat:@"%@ (%@)", exception.reason ?: @"",
+                                                              exception.name]);
+        return NO;
+    }
+}
+
 @implementation ANNElementFinder
 
 + (UIView *)searchRootOf:(UIViewController *)node {
@@ -17,8 +67,7 @@
     if (nativeID.length == 0 || !root) {
         return nil;
     }
-    if ([root isKindOfClass:RCTViewComponentView.class] &&
-        [((RCTViewComponentView *)root).nativeId isEqualToString:nativeID]) {
+    if ([ANNNativeIDOfView(root) isEqualToString:nativeID]) {
         return root;
     }
     for (UIView *subview in root.subviews) {
@@ -34,4 +83,127 @@
     return [self viewWithNativeID:nativeID inView:[self searchRootOf:node]];
 }
 
++ (NSDictionary<NSString *, UIView *> *)viewsWithNativeIDs:(NSSet<NSString *> *)nativeIDs
+                                                    inView:(UIView *)root {
+    NSMutableDictionary<NSString *, UIView *> *found = [NSMutableDictionary new];
+    if (root && nativeIDs.count > 0) {
+        ANNCollectViews(root, nativeIDs, found);
+    }
+    return found;
+}
+
+@end
+
+@implementation ANNTransitionViews {
+    NSSet<NSString *> *_leavingIDs;
+    NSSet<NSString *> *_targetIDs;
+    NSSet<NSString *> *_elementIDs;
+    NSDictionary<NSString *, UIView *> *_leavingViews;
+    NSDictionary<NSString *, UIView *> *_arrivingViews;
+}
+
+- (instancetype)initWithPairs:(NSArray<ANNSharedElementTransitionOptions *> *)pairs
+                     elements:(NSArray<ANNElementTransitionOptions *> *)elements
+                     fromNode:(UIViewController *)fromNode
+                       toNode:(UIViewController *)toNode {
+    if (self = [super init]) {
+        _leavingRoot = [ANNElementFinder searchRootOf:fromNode];
+        _arrivingRoot = [ANNElementFinder searchRootOf:toNode];
+        NSMutableSet<NSString *> *sources = [NSMutableSet new];
+        NSMutableSet<NSString *> *targets = [NSMutableSet new];
+        NSMutableSet<NSString *> *identifiers = [NSMutableSet new];
+        for (ANNSharedElementTransitionOptions *pair in pairs) {
+            NSString *fromId = ANNNativeIDOf(pair.fromId);
+            NSString *toId = ANNNativeIDOf(pair.toId);
+            if (fromId) {
+                [sources addObject:fromId];
+            }
+            if (toId) {
+                [targets addObject:toId];
+            }
+        }
+        for (ANNElementTransitionOptions *element in elements) {
+            NSString *identifier = ANNNativeIDOf(element.identifier);
+            if (identifier) {
+                [identifiers addObject:identifier];
+            }
+        }
+        [sources unionSet:identifiers];
+        _leavingIDs = sources;
+        _targetIDs = targets;
+        _elementIDs = identifiers;
+    }
+    return self;
+}
+
+- (UIView *)leavingViewWithNativeID:(NSString *)nativeID {
+    if (nativeID.length == 0) {
+        return nil;
+    }
+    if (!_leavingViews) {
+        _leavingViews = [ANNElementFinder viewsWithNativeIDs:_leavingIDs inView:_leavingRoot];
+    }
+    return _leavingViews[nativeID];
+}
+
+- (UIView *)arrivingViewWithNativeID:(NSString *)nativeID {
+    if (nativeID.length == 0) {
+        return nil;
+    }
+    if (!_arrivingViews) {
+        // An element is looked for in the arriving screen only when the leaving one doesn't have it: the walk stops
+        // sooner.
+        NSMutableSet<NSString *> *ids = [_targetIDs mutableCopy];
+        for (NSString *identifier in _elementIDs) {
+            if (![self leavingViewWithNativeID:identifier]) {
+                [ids addObject:identifier];
+            }
+        }
+        _arrivingViews = [ANNElementFinder viewsWithNativeIDs:ids inView:_arrivingRoot];
+    }
+    return _arrivingViews[nativeID];
+}
+
+@end
+
+@implementation ANNIsolatedElement {
+    id<ANNFrameClient> _client;
+    NSString *_name;
+    BOOL _failed;
+}
+
+- (instancetype)initWithClient:(id<ANNFrameClient>)client name:(NSString *)name {
+    if (self = [super init]) {
+        _client = client;
+        _name = [name copy];
+    }
+    return self;
+}
+
+#pragma mark - ANNFrameClient
+
+- (void)addAnimationsWithLength:(NSTimeInterval)length {
+    if (_failed) {
+        return;
+    }
+    id<ANNFrameClient> client = _client;
+    if (!ANNElementStep(_name, ^{
+          [client addAnimationsWithLength:length];
+        })) {
+        _failed = YES;
+        [self restore];
+    }
+}
+
+- (NSTimeInterval)endTime {
+    return _client.endTime;
+}
+
+- (void)restore {
+    id<ANNFrameClient> client = _client;
+    ANNElementStep(_name, ^{
+      [client restore];
+    });
+}
+
 @end

package/ios/Animations/Elements/ANNElementTransition.h

@@ -2,29 +2,31 @@
 #import <UIKit/UIKit.h>
 
 @class ANNElementTransitionOptions;
+@class ANNTransitionViews;
 
 NS_ASSUME_NONNULL_BEGIN
 
-/// One `elementTransitions[]` item on its React view: the view's own `transform` and `alpha` animate in place, its
-/// parents clip it as usual; at the end, at a cancel and at a destroy the values read before come back. Nothing else of
-/// the React view changes (no frame, no subview, never `layer.zPosition`).
+/// One `elementTransitions[]` item on its React view: its `transform` and `opacity` animate in place, its parents clip
+/// it as usual; at the end, at a cancel and at a destroy the animations go and the view shows its own values. Nothing
+/// of the React view is written (no value, no frame, no subview, never `layer.zPosition`).
 @interface ANNElementTransition : NSObject <ANNFrameClient>
 
 /// The items found: each `id` first in the leaving screen's React view, then in the arriving one; an item not found or
-/// without an animating property is left out.
+/// without an animating property is left out, and so is one whose start fails (`ANNElementStep`).
 + (NSArray<ANNElementTransition *> *)
     transitionsOf:(nullable NSArray<ANNElementTransitionOptions *> *)elements
-      leavingRoot:(nullable UIView *)leavingRoot
-     arrivingRoot:(nullable UIView *)arrivingRoot;
+            views:(ANNTransitionViews *)views;
 
 /// Every item's `id` is found in one of the two screens (the wait's test).
 + (BOOL)allFound:(nullable NSArray<ANNElementTransitionOptions *> *)elements
-     leavingRoot:(nullable UIView *)leavingRoot
-    arrivingRoot:(nullable UIView *)arrivingRoot;
+           views:(ANNTransitionViews *)views;
 
 - (instancetype)init NS_UNAVAILABLE;
 + (instancetype)new NS_UNAVAILABLE;
 
+/// The item's `id`, in quotes: its name in the log.
+@property(nonatomic, copy, readonly) NSString *name;
+
 @end
 
 NS_ASSUME_NONNULL_END

package/ios/Animations/Elements/ANNElementTransition.mm

@@ -7,51 +7,49 @@
     ANNViewTracks *_tracks;
 }
 
-- (instancetype)initWithTracks:(ANNViewTracks *)tracks {
+- (instancetype)initWithTracks:(ANNViewTracks *)tracks name:(NSString *)name {
     if (self = [super init]) {
         _tracks = tracks;
+        _name = [name copy];
     }
     return self;
 }
 
-+ (UIView *)viewOf:(ANNElementTransitionOptions *)element
-       leavingRoot:(UIView *)leavingRoot
-      arrivingRoot:(UIView *)arrivingRoot {
-    NSString *identifier = [element.identifier withDefault:nil];
-    if (![identifier isKindOfClass:NSString.class] || identifier.length == 0) {
-        return nil;
-    }
-    return [ANNElementFinder viewWithNativeID:identifier inView:leavingRoot]
-               ?: [ANNElementFinder viewWithNativeID:identifier inView:arrivingRoot];
++ (UIView *)viewOf:(NSString *)identifier views:(ANNTransitionViews *)views {
+    return [views leavingViewWithNativeID:identifier]
+               ?: [views arrivingViewWithNativeID:identifier];
 }
 
 + (NSArray<ANNElementTransition *> *)
     transitionsOf:(NSArray<ANNElementTransitionOptions *> *)elements
-      leavingRoot:(UIView *)leavingRoot
-     arrivingRoot:(UIView *)arrivingRoot {
+            views:(ANNTransitionViews *)views {
     NSMutableArray<ANNElementTransition *> *transitions = [NSMutableArray new];
     // One view takes one item: a second item for the same view would read the values the first one writes.
     NSHashTable<UIView *> *taken = [NSHashTable weakObjectsHashTable];
     for (ANNElementTransitionOptions *element in elements) {
-        UIView *view = [self viewOf:element leavingRoot:leavingRoot arrivingRoot:arrivingRoot];
+        NSString *identifier = ANNNativeIDOf(element.identifier);
+        UIView *view = [self viewOf:identifier views:views];
         if (!view || [taken containsObject:view]) {
             continue;
         }
-        ANNViewTracks *tracks = [[ANNViewTracks alloc] initWithView:view element:element];
-        if (!tracks.hasTracks) {
+        NSString *name = [NSString stringWithFormat:@"'%@'", identifier];
+        __block ANNViewTracks *tracks = nil;
+        if (!ANNElementStep(name, ^{
+              tracks = [[ANNViewTracks alloc] initWithView:view element:element];
+            }) ||
+            !tracks.hasTracks) {
             continue;
         }
         [taken addObject:view];
-        [transitions addObject:[[ANNElementTransition alloc] initWithTracks:tracks]];
+        [transitions addObject:[[ANNElementTransition alloc] initWithTracks:tracks name:name]];
     }
     return transitions;
 }
 
 + (BOOL)allFound:(NSArray<ANNElementTransitionOptions *> *)elements
-     leavingRoot:(UIView *)leavingRoot
-    arrivingRoot:(UIView *)arrivingRoot {
+           views:(ANNTransitionViews *)views {
     for (ANNElementTransitionOptions *element in elements) {
-        if (![self viewOf:element leavingRoot:leavingRoot arrivingRoot:arrivingRoot]) {
+        if (![self viewOf:ANNNativeIDOf(element.identifier) views:views]) {
             return NO;
         }
     }
@@ -60,8 +58,8 @@
 
 #pragma mark - ANNFrameClient
 
-- (void)applyAtTime:(NSTimeInterval)time {
-    [_tracks applyAtTime:time];
+- (void)addAnimationsWithLength:(NSTimeInterval)length {
+    [_tracks addAnimationsWithLength:length];
 }
 
 - (NSTimeInterval)endTime {

package/ios/Animations/Elements/ANNSharedElementFlight.h

@@ -2,15 +2,16 @@
 #import <UIKit/UIKit.h>
 
 @class ANNSharedElementTransitionOptions;
+@class ANNTransitionViews;
 
 NS_ASSUME_NONNULL_BEGIN
 
 /// One shared pair in flight: a plain view of the core, the copy, flies in the transition's container from the `from`
 /// view to the `to` view with two pictures of them (`renderInContext:` at the screen's scale). The React views are
 /// neither moved nor changed: they are only `hidden` while the copy flies and get back what they had before the
-/// transition completes. All geometry is in the container's coordinates. Each frame the copy's size, center, visible
-/// part (a mask), corner radius and layer transform go from the `from` values to the `to` values on the pair's curve,
-/// delay and duration.
+/// transition completes. All geometry is in the container's coordinates. The copy's size, center, visible part (a
+/// mask), corner radius and layer transform go from the `from` values to the `to` values on the pair's curve, delay and
+/// duration, in Core Animation's animations of the copy's layers.
 ///
 /// A view (not a text): both pictures fill the copy, the copy clips to its corners, the `to` picture fades in over the
 /// flight. A text (React's paragraph): the pictures keep their aspect, as tall as the copy, at the line's start (the
@@ -18,18 +19,19 @@ NS_ASSUME_NONNULL_BEGIN
 /// grows, the last when it shrinks.
 @interface ANNSharedElementFlight : NSObject <ANNFrameClient>
 
-/// The flights of the pairs whose two views are found (`fromId` in the leaving screen, `toId` in the arriving one) and
-/// have a size; the others are skipped and their views stay as they are. The pictures are taken now, then the React
-/// views hide and the copies go into `container` by the `zIndex` of their `to` views, ascending (no `layer.zPosition`).
+/// The flights of the pairs whose two views are found (`fromId` in the leaving screen, `toId` in the arriving one); the
+/// others are skipped and their views stay as they are. A pair found that can't fly — a view without a size, a
+/// picture that can't be taken, a place that can't be worked out, an exception in its start (`ANNElementStep`) — is
+/// skipped too, with a line in the log. The pictures are taken now, then the React views hide and the copies go into
+/// `container` by the `zIndex` of their `to` views, ascending (no `layer.zPosition`).
 + (NSArray<ANNSharedElementFlight *> *)
-       flightsOf:(nullable NSArray<ANNSharedElementTransitionOptions *> *)pairs
-     leavingRoot:(nullable UIView *)leavingRoot
-    arrivingRoot:(nullable UIView *)arrivingRoot
-       container:(UIView *)container;
+    flightsOf:(nullable NSArray<ANNSharedElementTransitionOptions *> *)pairs
+        views:(ANNTransitionViews *)views
+    container:(UIView *)container;
 
 /// Every pair's `toId` is found in the arriving screen (the wait's test).
 + (BOOL)allTargetsFound:(nullable NSArray<ANNSharedElementTransitionOptions *> *)pairs
-           arrivingRoot:(nullable UIView *)arrivingRoot;
+                  views:(ANNTransitionViews *)views;
 
 - (instancetype)init NS_UNAVAILABLE;
 + (instancetype)new NS_UNAVAILABLE;
@@ -37,6 +39,9 @@ NS_ASSUME_NONNULL_BEGIN
 /// The copy that flies (a view of the core in the container).
 @property(nonatomic, strong, readonly) UIView *copyView;
 
+/// The pair's two ids, in quotes: its name in the log.
+@property(nonatomic, copy, readonly) NSString *name;
+
 @end
 
 NS_ASSUME_NONNULL_END