react-native-navigation 8.0.0 → 8.1.0-alpha01

package/lib/ios/ScreenAnimationController.h

@@ -4,20 +4,38 @@
 #import <React/RCTUIManagerObserverCoordinator.h>
 #import <React/RCTUIManagerUtils.h>
 
+#ifdef RCT_NEW_ARCH_ENABLED
+#import <React-RuntimeApple/ReactCommon/RCTHost.h>
+#import <React/RCTSurfacePresenterStub.h>
+#endif
+
+
 @interface ScreenAnimationController
-    : NSObject <UIViewControllerTransitioningDelegate, UIViewControllerAnimatedTransitioning,
-                RCTUIManagerObserver>
+	: NSObject <UIViewControllerTransitioningDelegate, UIViewControllerAnimatedTransitioning,
+#ifdef RCT_NEW_ARCH_ENABLED
+RCTSurfacePresenterObserver,
+#endif
+RCTUIManagerObserver>
+
+- (instancetype)initWithContentTransition:(RNNEnterExitAnimation *)contentTransition
+					   elementTransitions:(NSArray<ElementTransitionOptions *> *)elementTransitions
+				 sharedElementTransitions:
+					 (NSArray<SharedElementTransitionOptions *> *)sharedElementTransitions
+								 duration:(CGFloat)duration
+								   bridge:(RCTBridge *)bridge;
 
+#ifdef RCT_NEW_ARCH_ENABLED
 - (instancetype)initWithContentTransition:(RNNEnterExitAnimation *)contentTransition
-                       elementTransitions:(NSArray<ElementTransitionOptions *> *)elementTransitions
-                 sharedElementTransitions:
-                     (NSArray<SharedElementTransitionOptions *> *)sharedElementTransitions
-                                 duration:(CGFloat)duration
-                                   bridge:(RCTBridge *)bridge;
+					   elementTransitions:(NSArray<ElementTransitionOptions *> *)elementTransitions
+				 sharedElementTransitions:
+					 (NSArray<SharedElementTransitionOptions *> *)sharedElementTransitions
+								 duration:(CGFloat)duration
+								   host:(RCTHost *)host;
+#endif
 
 - (NSArray *)createTransitionsFromVC:(UIViewController *)fromVC
-                                toVC:(UIViewController *)toVC
-                       containerView:(UIView *)containerView;
+								toVC:(UIViewController *)toVC
+					   containerView:(UIView *)containerView;
 
 @property(nonatomic, strong) RNNEnterExitAnimation *content;
 @property(nonatomic, strong) NSArray<ElementTransitionOptions *> *elementTransitions;

package/lib/ios/ScreenAnimationController.mm

@@ -0,0 +1,180 @@
+#import "ScreenAnimationController.h"
+#import "DisplayLinkAnimator.h"
+#import "RNNScreenTransitionsCreator.h"
+#import "SharedElementAnimator.h"
+#import "UIViewController+LayoutProtocol.h"
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#include <React/RCTSurfacePresenter.h>
+#include <React/RCTMountingManager.h>
+#endif
+
+@implementation ScreenAnimationController {
+	RCTBridge *_bridge;
+#ifdef RCT_NEW_ARCH_ENABLED
+	RCTHost *_host;
+#endif
+	id<UIViewControllerContextTransitioning> _transitionContext;
+	SharedElementAnimator *_sharedElementAnimator;
+	BOOL _animate;
+	CGFloat _duration;
+}
+
+- (instancetype)initWithContentTransition:(RNNEnterExitAnimation *)contentTransition
+					   elementTransitions:(NSArray<ElementTransitionOptions *> *)elementTransitions
+				 sharedElementTransitions:
+					 (NSArray<SharedElementTransitionOptions *> *)sharedElementTransitions
+								 duration:(CGFloat)duration
+								   bridge:(RCTBridge *)bridge {
+	self = [super init];
+	_bridge = bridge;
+	_content = contentTransition;
+	_elementTransitions = elementTransitions;
+	_sharedElementTransitions = sharedElementTransitions;
+	_duration = duration;
+	return self;
+}
+
+#ifdef RCT_NEW_ARCH_ENABLED
+- (instancetype)initWithContentTransition:(RNNEnterExitAnimation *)contentTransition
+					   elementTransitions:(NSArray<ElementTransitionOptions *> *)elementTransitions
+				 sharedElementTransitions:
+					 (NSArray<SharedElementTransitionOptions *> *)sharedElementTransitions
+								 duration:(CGFloat)duration
+									 host:(RCTHost *)host {
+	self = [super init];
+	_host = host;
+	_content = contentTransition;
+	_elementTransitions = elementTransitions;
+	_sharedElementTransitions = sharedElementTransitions;
+	_duration = duration;
+	return self;
+}
+#endif
+
+- (void)animateTransition:(id<UIViewControllerContextTransitioning>)transitionContext {
+#ifdef RCT_NEW_ARCH_ENABLED
+	if (_host != nil) {
+		[_host.surfacePresenter addObserver:self];
+	} else {
+		[_bridge.uiManager.observerCoordinator addObserver:self];
+	}
+#else
+	[_bridge.uiManager.observerCoordinator addObserver:self];
+#endif
+	
+	_animate = YES;
+	_transitionContext = transitionContext;
+	[self prepareTransitionContext:transitionContext];
+
+	UIViewController *fromVC =
+		[transitionContext viewControllerForKey:UITransitionContextFromViewControllerKey];
+	if (![fromVC.navigationController.childViewControllers containsObject:fromVC]) {
+		[self performAnimationOnce];
+	}
+}
+
+- (void)prepareTransitionContext:(id<UIViewControllerContextTransitioning>)transitionContext {
+	UINavigationController *toViewController =
+		[transitionContext viewControllerForKey:UITransitionContextToViewControllerKey];
+	toViewController.view.alpha = 0;
+	UIView *fromView = [transitionContext viewForKey:UITransitionContextFromViewKey];
+
+	[transitionContext.containerView addSubview:fromView];
+	[transitionContext.containerView addSubview:toViewController.view];
+	[toViewController prepareForTransition];
+}
+
+- (NSArray *)createTransitionsFromVC:(UIViewController *)fromVC
+								toVC:(UIViewController *)toVC
+					   containerView:(UIView *)containerView {
+	NSArray *transitions =
+		[RNNScreenTransitionsCreator createTransitionsFromVC:fromVC
+														toVC:toVC
+											   containerView:containerView
+										   contentTransition:self.content
+										  elementTransitions:self.elementTransitions];
+	_sharedElementAnimator =
+		[[SharedElementAnimator alloc] initWithTransitions:self.sharedElementTransitions
+													fromVC:fromVC
+													  toVC:toVC
+											 containerView:containerView];
+	return [transitions arrayByAddingObjectsFromArray:[_sharedElementAnimator create]];
+}
+
+- (void)performAnimationOnce {
+	if (_animate) {
+		_animate = NO;
+		RCTExecuteOnMainQueue(^{
+		  id<UIViewControllerContextTransitioning> transitionContext = self->_transitionContext;
+		  UIViewController *fromVC =
+			  [transitionContext viewControllerForKey:UITransitionContextFromViewControllerKey];
+		  UIViewController *toVC =
+			  [transitionContext viewControllerForKey:UITransitionContextToViewControllerKey];
+		  NSArray *transitions = [self createTransitionsFromVC:fromVC
+														  toVC:toVC
+												 containerView:transitionContext.containerView];
+		  [self animateTransitions:transitions andTransitioningContext:transitionContext];
+		});
+	}
+}
+
+- (void)animateTransitions:(NSArray<id<DisplayLinkAnimatorDelegate>> *)animators
+	andTransitioningContext:(id<UIViewControllerContextTransitioning>)transitionContext {
+	DisplayLinkAnimator *displayLinkAnimator = [[DisplayLinkAnimator alloc]
+		initWithDisplayLinkAnimators:animators
+							duration:[self transitionDuration:transitionContext]];
+
+	[displayLinkAnimator setOnStart:^{
+	  [transitionContext viewControllerForKey:UITransitionContextToViewControllerKey].view.alpha =
+		  1.f;
+	}];
+
+	[displayLinkAnimator setCompletion:^{
+	  if (![transitionContext transitionWasCancelled]) {
+		  [transitionContext completeTransition:![transitionContext transitionWasCancelled]];
+	  }
+	}];
+
+	[displayLinkAnimator start];
+}
+
+- (NSTimeInterval)transitionDuration:(id<UIViewControllerContextTransitioning>)transitionContext {
+	return _duration;
+}
+
+// TODO: TEST THIS
+#ifdef RCT_NEW_ARCH_ENABLED
+- (void)didMountComponentsWithRootTag:(NSInteger)rootTag {
+	[self performAnimationOnce];
+}
+#endif
+
+- (void)uiManagerDidPerformMounting:(RCTUIManager *)manager {
+	[self performAnimationOnce];
+}
+
+- (id<UIViewControllerAnimatedTransitioning>)
+	animationControllerForPresentedController:(UIViewController *)presented
+						 presentingController:(UIViewController *)presenting
+							 sourceController:(UIViewController *)source {
+	return self;
+}
+
+- (id<UIViewControllerAnimatedTransitioning>)animationControllerForDismissedController:
+	(UIViewController *)dismissed {
+	return self;
+}
+
+- (void)animationEnded:(BOOL)transitionCompleted {
+	UIView *toView = [_transitionContext viewForKey:UITransitionContextToViewKey];
+	UIView *fromView = [_transitionContext viewForKey:UITransitionContextFromViewKey];
+	[_sharedElementAnimator animationEnded];
+	toView.layer.transform = CATransform3DIdentity;
+	fromView.layer.transform = CATransform3DIdentity;
+	toView.alpha = 1.f;
+	_transitionContext = nil;
+	_sharedElementAnimator = nil;
+}
+
+@end

package/lib/ios/SharedElementAnimator.mm

@@ -0,0 +1,98 @@
+#import "SharedElementAnimator.h"
+#import "AnimatedViewFactory.h"
+#import "BaseAnimator.h"
+#import "NSArray+utils.h"
+#import "RNNElementFinder.h"
+#import "SharedElementTransition.h"
+#import "UIViewController+LayoutProtocol.h"
+#import <React/RCTImageComponentView.h>
+
+@implementation SharedElementAnimator {
+	NSArray<SharedElementTransitionOptions *> *_sharedElementTransitions;
+	NSArray *_transitions;
+	UIViewController *_fromVC;
+	UIViewController *_toVC;
+	UIView *_containerView;
+}
+
+- (instancetype)initWithTransitions:
+					(NSArray<SharedElementTransitionOptions *> *)sharedElementTransitions
+							 fromVC:(UIViewController *)fromVC
+							   toVC:(UIViewController *)toVC
+					  containerView:(UIView *)containerView {
+	self = [super init];
+	_sharedElementTransitions = sharedElementTransitions;
+	_fromVC = fromVC;
+	_toVC = toVC;
+	_containerView = containerView;
+
+	return self;
+}
+
+- (NSArray<DisplayLinkAnimatorDelegate> *)create {
+	NSMutableArray<DisplayLinkAnimatorDelegate> *transitions =
+		[NSMutableArray<DisplayLinkAnimatorDelegate> new];
+	for (SharedElementTransitionOptions *transitionOptions in _sharedElementTransitions) {
+		UIView *fromView =
+			[RNNElementFinder findElementForId:transitionOptions.fromId
+										inView:_fromVC.presentedComponentViewController.reactView];
+		
+		UIView *toView =
+			[RNNElementFinder findElementForId:transitionOptions.toId
+										inView:_toVC.presentedComponentViewController.reactView];
+
+		if (fromView == nil || toView == nil) {
+			continue;
+		}
+
+#ifdef RCT_NEW_ARCH_ENABLED
+		auto castedFromView = (RCTViewComponentView *)fromView;
+		auto castedToView = (RCTViewComponentView *)toView;
+		
+		if ([castedToView respondsToSelector:@selector(props)] && [castedFromView respondsToSelector:@selector(props)]) {
+			castedToView.reactZIndex = ((facebook::react::ViewProps *)castedToView.props.get())->zIndex.value_or(0);
+			castedFromView.reactZIndex = ((facebook::react::ViewProps *)castedFromView.props.get())->zIndex.value_or(0);
+			
+			printf("%d %d\n", castedFromView.reactZIndex, castedToView.reactZIndex);
+		}
+#endif
+		
+		SharedElementTransition *sharedElementAnimator =
+			[[SharedElementTransition alloc] initWithTransitionOptions:transitionOptions
+															  fromView:fromView
+																toView:toView
+														 containerView:_containerView];
+		[transitions addObject:sharedElementAnimator];
+	}
+
+	NSArray<DisplayLinkAnimatorDelegate> *sortedTransitions = [self sortByZIndex:transitions];
+	[self addSharedElementViews:sortedTransitions toContainerView:_containerView];
+	_transitions = transitions;
+
+	return sortedTransitions;
+}
+
+- (void)animationEnded {
+	for (SharedElementTransition *transition in _transitions.reverseObjectEnumerator) {
+		[transition.view reset];
+	}
+}
+
+- (void)addSharedElementViews:(NSArray<BaseAnimator *> *)animators
+			  toContainerView:(UIView *)containerView {
+	for (BaseAnimator *animator in animators) {
+		[containerView addSubview:animator.view];
+	}
+}
+
+- (NSArray<DisplayLinkAnimatorDelegate> *)sortByZIndex:
+	(NSArray<DisplayLinkAnimatorDelegate> *)animators {
+	return (NSArray<DisplayLinkAnimatorDelegate> *)[animators
+		sortedArrayUsingComparator:^NSComparisonResult(BaseAnimator *a, BaseAnimator *b) {
+		  id first = [a.view valueForKey:@"reactZIndex"];
+		  id second = [b.view valueForKey:@"reactZIndex"];
+		  return [first compare:second];
+		}];
+}
+
+@end

package/lib/ios/SideMenuOpenMode.h

@@ -1,4 +1,4 @@
-#import "Number.h"
+#import "ReactNativeNavigation/Number.h"
 
 @interface SideMenuOpenMode : Number
 

package/lib/ios/StackControllerDelegate.h

@@ -1,10 +1,20 @@
+#ifdef RCT_NEW_ARCH_ENABLED
+#import "RNNTurboEventEmitter.h"
+#else
 #import "RNNEventEmitter.h"
+#endif
 #import <Foundation/Foundation.h>
 #import <UIKit/UIKit.h>
 
+@class RCTHost;
+
 @interface StackControllerDelegate : NSObject <UINavigationControllerDelegate>
 
+#ifdef RCT_NEW_ARCH_ENABLED
+- (instancetype)initWithEventEmitter:(RNNTurboEventEmitter *)eventEmitter;
+#else
 - (instancetype)initWithEventEmitter:(RNNEventEmitter *)eventEmitter;
+#endif
 
 - (BOOL)navigationController:(UINavigationController *)navigationController
                shouldPopItem:(BOOL)shouldPopItem;

package/lib/ios/{StackControllerDelegate.m → StackControllerDelegate.mm}

@@ -4,12 +4,20 @@
 #import "UIViewController+LayoutProtocol.h"
 
 @implementation StackControllerDelegate {
+#ifdef RCT_NEW_ARCH_ENABLED
+	RNNTurboEventEmitter *_eventEmitter;
+#else
     RNNEventEmitter *_eventEmitter;
+#endif
     UIViewController *_presentedViewController;
     BOOL _isPopping;
 }
 
+#ifdef RCT_NEW_ARCH_ENABLED
+- (instancetype)initWithEventEmitter:(RNNTurboEventEmitter *)eventEmitter {
+#else
 - (instancetype)initWithEventEmitter:(RNNEventEmitter *)eventEmitter {
+#endif
     self = [super init];
     _eventEmitter = eventEmitter;
     return self;
@@ -63,21 +71,57 @@
     if (operation == UINavigationControllerOperationPush &&
         toVCOptionsWithDefault.animations.push.hasCustomAnimation) {
         RNNScreenTransition *screenTransition = toVCOptionsWithDefault.animations.push;
-        return [[ScreenAnimationController alloc]
+#ifdef RCT_NEW_ARCH_ENABLED
+		if (_eventEmitter.host != nil) {
+			return [[ScreenAnimationController alloc]
+				initWithContentTransition:screenTransition.content
+					   elementTransitions:screenTransition.elementTransitions
+				 sharedElementTransitions:screenTransition.sharedElementTransitions
+								 duration:screenTransition.maxDuration
+								   host:_eventEmitter.host];
+		} else {
+			return [[ScreenAnimationController alloc]
+				initWithContentTransition:screenTransition.content
+					   elementTransitions:screenTransition.elementTransitions
+				 sharedElementTransitions:screenTransition.sharedElementTransitions
+								 duration:screenTransition.maxDuration
+								   bridge:_eventEmitter.bridge];
+		}
+#else
+		return [[ScreenAnimationController alloc]
             initWithContentTransition:screenTransition.content
                    elementTransitions:screenTransition.elementTransitions
              sharedElementTransitions:screenTransition.sharedElementTransitions
                              duration:screenTransition.maxDuration
                                bridge:_eventEmitter.bridge];
+#endif
     } else if (operation == UINavigationControllerOperationPop &&
                fromVCOptionsWithDefault.animations.pop.hasCustomAnimation) {
         RNNScreenTransition *screenTransition = fromVCOptionsWithDefault.animations.pop;
+#ifdef RCT_NEW_ARCH_ENABLED
+		if (_eventEmitter.host != nil) {
+			return [[ScreenReversedAnimationController alloc]
+				initWithContentTransition:screenTransition.content
+					   elementTransitions:screenTransition.elementTransitions
+				 sharedElementTransitions:screenTransition.sharedElementTransitions
+								 duration:screenTransition.maxDuration
+								   host:_eventEmitter.host];
+		} else {
+			return [[ScreenReversedAnimationController alloc]
+				initWithContentTransition:screenTransition.content
+					   elementTransitions:screenTransition.elementTransitions
+				 sharedElementTransitions:screenTransition.sharedElementTransitions
+								 duration:screenTransition.maxDuration
+								   bridge:_eventEmitter.bridge];
+		}
+#else
         return [[ScreenReversedAnimationController alloc]
             initWithContentTransition:screenTransition.content
                    elementTransitions:screenTransition.elementTransitions
              sharedElementTransitions:screenTransition.sharedElementTransitions
                              duration:screenTransition.maxDuration
                                bridge:_eventEmitter.bridge];
+#endif
     } else {
         return nil;
     }

package/lib/ios/{TopBarTitlePresenter.m → TopBarTitlePresenter.mm}

@@ -2,6 +2,7 @@
 #import "RNNReactTitleView.h"
 #import "RNNTitleViewHelper.h"
 #import "UIViewController+RNNOptions.h"
+#import "RNNUtils.h"
 
 @implementation TopBarTitlePresenter {
     RNNReactTitleView *_customTitleView;
@@ -69,7 +70,7 @@
 - (void)setCustomNavigationTitleView:(RNNTopBarOptions *)options
                              perform:(RNNReactViewReadyCompletionBlock)readyBlock {
     UIViewController<RNNLayoutProtocol> *viewController = self.boundViewController;
-    if (![options.title.component.waitForRender withDefault:NO] && readyBlock) {
+    if (![options.title.component.waitForRender withDefault: [RNNUtils getDefaultWaitForRender]] && readyBlock) {
         readyBlock();
         readyBlock = nil;
     }
@@ -88,8 +89,6 @@
 
         viewController.navigationItem.titleView = nil;
         viewController.navigationItem.titleView = _customTitleView;
-        [_customTitleView componentWillAppear];
-        [_customTitleView componentDidAppear];
     } else {
         [_customTitleView removeFromSuperview];
         if (readyBlock) {

package/lib/ios/{TransitionOptions.m → TransitionOptions.mm}

@@ -1,4 +1,5 @@
 #import "TransitionOptions.h"
+#import "RNNUtils.h"
 
 @implementation TransitionOptions
 
@@ -15,7 +16,7 @@
     self.rotationX = [[TransitionDetailsOptions alloc] initWithDict:dict[@"rotationX"]];
     self.rotationY = [[TransitionDetailsOptions alloc] initWithDict:dict[@"rotationY"]];
 
-    self.waitForRender = [BoolParser parse:dict key:@"waitForRender"];
+	self.waitForRender = [Bool withValue:[[BoolParser parse:dict key:@"waitForRender"] withDefault:[RNNUtils getDefaultWaitForRender]]];
     self.enable = [BoolParser parse:dict key:@"enabled"];
 
     return self;
@@ -54,7 +55,7 @@
 }
 
 - (BOOL)shouldWaitForRender {
-    return [self.waitForRender withDefault:NO] || self.hasAnimation;
+	return [self.waitForRender withDefault:[RNNUtils getDefaultWaitForRender]] || self.hasAnimation;
 }
 
 - (NSTimeInterval)maxDuration {

package/lib/ios/TurboModules/RNNTurboCommandsHandler.h

@@ -0,0 +1,13 @@
+#ifndef RNNTurboCommandsHandler_h
+#define RNNTurboCommandsHandler_h
+
+@class RNNCommandsHandler;
+
+@interface RNNTurboCommandsHandler : NSObject
+
++(RNNCommandsHandler *) sharedInstance;
++(void)setSharedInstance:(RNNCommandsHandler *) shared;
+
+@end
+
+#endif

package/lib/ios/TurboModules/RNNTurboCommandsHandler.mm

@@ -0,0 +1,16 @@
+#import <Foundation/Foundation.h>
+#import "RNNTurboCommandsHandler.h"
+
+static RNNCommandsHandler *_sharedCommandsHandler = nil;
+
+@implementation RNNTurboCommandsHandler
+
++ (void)setSharedInstance:(RNNCommandsHandler *)shared {
+	_sharedCommandsHandler = shared;
+}
+
++ (RNNCommandsHandler *)sharedInstance {
+	return _sharedCommandsHandler;
+}
+
+@end

package/lib/ios/TurboModules/RNNTurboEventEmitter.h

@@ -0,0 +1,14 @@
+#ifdef RCT_NEW_ARCH_ENABLED
+#import "RNNEventEmitter.h"
+#import <rnnavigation/rnnavigation.h>
+
+@class RCTHost;
+
+@interface RNNTurboEventEmitter : RNNEventEmitter <NativeRNNTurboEventEmitterSpec>
+
+- (void)setHost:(RCTHost *)host;
+
+@property(nonatomic, strong, readonly) RCTHost *host;
+
+@end
+#endif

package/lib/ios/TurboModules/RNNTurboEventEmitter.mm

@@ -0,0 +1,22 @@
+#ifdef RCT_NEW_ARCH_ENABLED
+#import "RNNTurboEventEmitter.h"
+
+@implementation RNNTurboEventEmitter {}
+
+RCT_EXPORT_MODULE()
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+	(const facebook::react::ObjCTurboModule::InitParams &)params
+{
+	return std::make_shared<facebook::react::NativeRNNTurboEventEmitterSpecJSI>(params);
+}
+
+- (void)setHost:(RCTHost *)host {
+	if (_host != nil) {
+		return;
+	}
+	_host = host;
+}
+
+@end
+#endif

package/lib/ios/TurboModules/RNNTurboManager.h

@@ -0,0 +1,23 @@
+
+#ifndef RNNTurboManager_h
+#define RNNTurboManager_h
+
+#import <Foundation/Foundation.h>
+
+@class RCTHost;
+
+typedef UIViewController * (^RNNExternalHostViewCreator)(NSDictionary *props, RCTHost *host);
+
+@interface RNNTurboManager : NSObject
+
+@property(readonly, nonatomic, strong) RCTHost *host;
+
+- (instancetype)initWithHost:(RCTHost *)host mainWindow:(UIWindow *)mainWindow;
+
+- (UIViewController *)findComponentForId:(NSString *)componentId;
+
+- (void)registerExternalComponent:(NSString *)name callback:(RNNExternalHostViewCreator)callback;
+
+@end
+
+#endif