react-native-reanimated 2.3.0-alpha.1 → 2.3.0-beta.2

package/ios/LayoutReanimation/REAUIManager.mm

@@ -0,0 +1,348 @@
+#import "REAUIManager.h"
+#import <Foundation/Foundation.h>
+#import "RCTComponentData.h"
+#import "RCTUIManagerObserverCoordinator.h"
+#import "RCTRootShadowView.h"
+#import "RCTRootViewInternal.h"
+#import "RCTLayoutAnimation.h"
+#import "RCTLayoutAnimationGroup.h"
+#import "REAIOSScheduler.h"
+#include "Scheduler.h"
+
+#if __has_include(<RNScreens/RNSScreen.h>)
+#import <RNScreens/RNSScreen.h>
+#endif
+
+@interface RCTUIManager(REA)
+- (void)_manageChildren:(NSNumber *)containerTag
+        moveFromIndices:(NSArray<NSNumber *> *)moveFromIndices
+          moveToIndices:(NSArray<NSNumber *> *)moveToIndices
+      addChildReactTags:(NSArray<NSNumber *> *)addChildReactTags
+           addAtIndices:(NSArray<NSNumber *> *)addAtIndices
+        removeAtIndices:(NSArray<NSNumber *> *)removeAtIndices
+               registry:(NSMutableDictionary<NSNumber *, id<RCTComponent>> *)registry;
+
+- (NSArray<id<RCTComponent>> *)_childrenToRemoveFromContainer:(id<RCTComponent>)container
+                                                    atIndices:(NSArray<NSNumber *> *)atIndices;
+@end
+
+@implementation REAUIManager
+
+BOOL blockSetter = false;
+NSMutableDictionary<NSNumber*, NSMutableSet<id<RCTComponent>>*>* _toBeRemovedRegister;
+NSMutableDictionary<NSNumber*, NSNumber*>* _parentMapper;
+REAAnimationsManager* _animationsManager;
+std::weak_ptr<reanimated::Scheduler> _scheduler;
+
++ (NSString*)moduleName
+{
+  return NSStringFromClass([RCTUIManager class]);
+}
+
+- (void)setBridge:(RCTBridge *)bridge
+{
+  if(!_blockSetter) {
+    _blockSetter = true;
+
+    self.bridge = bridge;
+    [super setValue:bridge forKey:@"_bridge"];
+    [self setValue:[bridge.uiManager valueForKey:@"_shadowViewRegistry"] forKey:@"_shadowViewRegistry"];
+    [self setValue:[bridge.uiManager valueForKey:@"_viewRegistry"] forKey:@"_viewRegistry"];
+    [self setValue:[bridge.uiManager valueForKey:@"_nativeIDRegistry"] forKey:@"_nativeIDRegistry"];
+    [self setValue:[bridge.uiManager valueForKey:@"_shadowViewsWithUpdatedProps"] forKey:@"_shadowViewsWithUpdatedProps"];
+    [self setValue:[bridge.uiManager valueForKey:@"_shadowViewsWithUpdatedChildren"] forKey:@"_shadowViewsWithUpdatedChildren"];
+    [self setValue:[bridge.uiManager valueForKey:@"_pendingUIBlocks"] forKey:@"_pendingUIBlocks"];
+    [self setValue:[bridge.uiManager valueForKey:@"_rootViewTags"] forKey:@"_rootViewTags"];
+    [self setValue:[bridge.uiManager valueForKey:@"_observerCoordinator"] forKey:@"_observerCoordinator"];
+    [self setValue:[bridge.uiManager valueForKey:@"_componentDataByName"] forKey:@"_componentDataByName"];
+
+    _blockSetter = false;
+  }
+}
+
+- (void)_manageChildren:(NSNumber *)containerTag
+        moveFromIndices:(NSArray<NSNumber *> *)moveFromIndices
+          moveToIndices:(NSArray<NSNumber *> *)moveToIndices
+      addChildReactTags:(NSArray<NSNumber *> *)addChildReactTags
+           addAtIndices:(NSArray<NSNumber *> *)addAtIndices
+        removeAtIndices:(NSArray<NSNumber *> *)removeAtIndices
+               registry:(NSMutableDictionary<NSNumber *, id<RCTComponent>> *)registry
+{
+  BOOL isUIViewRegistry = ((id)registry == (id)[self valueForKey:@"_viewRegistry"]);
+  id<RCTComponent> container;
+  NSArray<id<RCTComponent>> *permanentlyRemovedChildren;
+  if(isUIViewRegistry) {
+    container = registry[containerTag];
+    for(id<RCTComponent> toRemoveChild in _toBeRemovedRegister[containerTag]) {
+      [container removeReactSubview:toRemoveChild];
+    }
+
+    permanentlyRemovedChildren = [super _childrenToRemoveFromContainer:container atIndices:removeAtIndices];
+    if(permanentlyRemovedChildren != nil) {
+      for(id<RCTComponent> permanentlyRemovedChild in permanentlyRemovedChildren) {
+        if(_toBeRemovedRegister[containerTag] == nil) {
+          _toBeRemovedRegister[containerTag] = [[NSMutableSet<id<RCTComponent>> alloc] init];
+        }
+        [_toBeRemovedRegister[containerTag] addObject:permanentlyRemovedChild];
+      }
+    }
+  }
+
+  [super _manageChildren:containerTag
+         moveFromIndices:moveFromIndices
+           moveToIndices:moveToIndices
+       addChildReactTags:addChildReactTags
+            addAtIndices:addAtIndices
+         removeAtIndices:removeAtIndices
+                registry:registry];
+
+  if(isUIViewRegistry) {
+    NSMutableDictionary<NSNumber *, id<RCTComponent>> *viewRegistry = [self valueForKey:@"_viewRegistry"];
+    for(id<RCTComponent> toRemoveChild in _toBeRemovedRegister[containerTag]) {
+      NSInteger lastIndex = [container reactSubviews].count - 1;
+      if(lastIndex < 0) {
+        lastIndex = 0;
+      }
+      [container insertReactSubview:toRemoveChild atIndex:lastIndex];
+      viewRegistry[toRemoveChild.reactTag] = toRemoveChild;
+    }
+
+    for (UIView *removedChild in permanentlyRemovedChildren) {
+      [self callAnimationForTree: removedChild parentTag:containerTag];
+    }
+  }
+}
+
+- (void) callAnimationForTree:(UIView*) view parentTag:(NSNumber*) parentTag
+{
+  REASnapshot* snapshot = [[REASnapshot alloc] init:view];
+  _parentMapper[view.reactTag] = parentTag;
+  [_animationsManager onViewRemoval:view before:snapshot];
+
+  for(UIView* subView in view.reactSubviews) {
+    [self callAnimationForTree:subView parentTag:view.reactTag];
+  }
+}
+
+// Overrided https://github.com/facebook/react-native/blob/v0.65.0/React/Modules/RCTUIManager.m#L530
+- (RCTViewManagerUIBlock)uiBlockWithLayoutUpdateForRootView:(RCTRootShadowView *)rootShadowView
+{
+  NSHashTable<RCTShadowView *> *affectedShadowViews = [NSHashTable weakObjectsHashTable];
+  [rootShadowView layoutWithAffectedShadowViews:affectedShadowViews];
+
+  if (!affectedShadowViews.count) {
+    // no frame change results in no UI update block
+    return nil;
+  }
+
+  typedef struct {
+    CGRect frame;
+    UIUserInterfaceLayoutDirection layoutDirection;
+    BOOL isNew;
+    BOOL parentIsNew;
+    RCTDisplayType displayType;
+  } RCTFrameData;
+
+  // Construct arrays then hand off to main thread
+  NSUInteger count = affectedShadowViews.count;
+  NSMutableArray *reactTags = [[NSMutableArray alloc] initWithCapacity:count];
+  NSMutableData *framesData = [[NSMutableData alloc] initWithLength:sizeof(RCTFrameData) * count];
+  {
+    NSUInteger index = 0;
+    RCTFrameData *frameDataArray = (RCTFrameData *)framesData.mutableBytes;
+    for (RCTShadowView *shadowView in affectedShadowViews) {
+      reactTags[index] = shadowView.reactTag;
+      RCTLayoutMetrics layoutMetrics = shadowView.layoutMetrics;
+      frameDataArray[index++] = (RCTFrameData){layoutMetrics.frame,
+                                               layoutMetrics.layoutDirection,
+                                               shadowView.isNewView,
+                                               shadowView.superview.isNewView,
+                                               layoutMetrics.displayType};
+    }
+  }
+
+  for (RCTShadowView *shadowView in affectedShadowViews) {
+    // We have to do this after we build the parentsAreNew array.
+    shadowView.newView = NO;
+
+    NSNumber *reactTag = shadowView.reactTag;
+
+    if (shadowView.onLayout) {
+      CGRect frame = shadowView.layoutMetrics.frame;
+      shadowView.onLayout(@{
+        @"layout" : @{
+          @"x" : @(frame.origin.x),
+          @"y" : @(frame.origin.y),
+          @"width" : @(frame.size.width),
+          @"height" : @(frame.size.height),
+        },
+      });
+    }
+
+    if (RCTIsReactRootView(reactTag) && [shadowView isKindOfClass:[RCTRootShadowView class]]) {
+      CGSize contentSize = shadowView.layoutMetrics.frame.size;
+
+      RCTExecuteOnMainQueue(^{
+        NSMutableDictionary<NSNumber *, UIView *>* viewRegistry = [self valueForKey:@"_viewRegistry"];
+        UIView *view = viewRegistry[reactTag];
+        RCTAssert(view != nil, @"view (for ID %@) not found", reactTag);
+
+        RCTRootView *rootView = (RCTRootView *)[view superview];
+        if ([rootView isKindOfClass:[RCTRootView class]]) {
+          rootView.intrinsicContentSize = contentSize;
+        }
+      });
+    }
+  }
+
+  // Perform layout (possibly animated)
+  return ^(__unused RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+    const RCTFrameData *frameDataArray = (const RCTFrameData *)framesData.bytes;
+    RCTLayoutAnimationGroup *layoutAnimationGroup = [uiManager valueForKey:@"_layoutAnimationGroup"];
+
+    __block NSUInteger completionsCalled = 0;
+
+    NSInteger index = 0;
+    for (NSNumber *reactTag in reactTags) {
+      RCTFrameData frameData = frameDataArray[index++];
+
+      UIView *view = viewRegistry[reactTag];
+      CGRect frame = frameData.frame;
+
+      UIUserInterfaceLayoutDirection layoutDirection = frameData.layoutDirection;
+      BOOL isNew = frameData.isNew;
+      RCTLayoutAnimation *updatingLayoutAnimation = isNew ? nil : layoutAnimationGroup.updatingLayoutAnimation;
+      BOOL shouldAnimateCreation = isNew && !frameData.parentIsNew;
+      RCTLayoutAnimation *creatingLayoutAnimation =
+          shouldAnimateCreation ? layoutAnimationGroup.creatingLayoutAnimation : nil;
+      BOOL isHidden = frameData.displayType == RCTDisplayTypeNone;
+
+      void (^completion)(BOOL) = ^(BOOL finished) {
+        completionsCalled++;
+        if (layoutAnimationGroup.callback && completionsCalled == count) {
+          layoutAnimationGroup.callback(@[ @(finished) ]);
+
+          // It's unsafe to call this callback more than once, so we nil it out here
+          // to make sure that doesn't happen.
+          layoutAnimationGroup.callback = nil;
+        }
+      };
+
+      if (view.reactLayoutDirection != layoutDirection) {
+        view.reactLayoutDirection = layoutDirection;
+      }
+
+      if (view.isHidden != isHidden) {
+        view.hidden = isHidden;
+      }
+
+      REASnapshot* snapshotBefore = [[REASnapshot alloc] init:view];
+      if (creatingLayoutAnimation) {
+        // Animate view creation
+        [view reactSetFrame:frame];
+
+        CATransform3D finalTransform = view.layer.transform;
+        CGFloat finalOpacity = view.layer.opacity;
+
+        NSString *property = creatingLayoutAnimation.property;
+        if ([property isEqualToString:@"scaleXY"]) {
+          view.layer.transform = CATransform3DMakeScale(0, 0, 0);
+        } else if ([property isEqualToString:@"scaleX"]) {
+          view.layer.transform = CATransform3DMakeScale(0, 1, 0);
+        } else if ([property isEqualToString:@"scaleY"]) {
+          view.layer.transform = CATransform3DMakeScale(1, 0, 0);
+        } else if ([property isEqualToString:@"opacity"]) {
+          view.layer.opacity = 0.0;
+        } else {
+          RCTLogError(@"Unsupported layout animation createConfig property %@", creatingLayoutAnimation.property);
+        }
+
+        [creatingLayoutAnimation
+              performAnimations:^{
+                if ([property isEqualToString:@"scaleX"] || [property isEqualToString:@"scaleY"] ||
+                    [property isEqualToString:@"scaleXY"]) {
+                  view.layer.transform = finalTransform;
+                } else if ([property isEqualToString:@"opacity"]) {
+                  view.layer.opacity = finalOpacity;
+                }
+              }
+            withCompletionBlock:completion];
+
+      } else if (updatingLayoutAnimation) {
+        // Animate view update
+        [updatingLayoutAnimation
+              performAnimations:^{
+                [view reactSetFrame:frame];
+              }
+            withCompletionBlock:completion];
+
+      } else {
+        // Update without animation
+        [view reactSetFrame:frame];
+        completion(YES);
+      }
+
+      if(isNew) {
+        REASnapshot* snapshot = [[REASnapshot alloc] init:view];
+        [_animationsManager onViewCreate:view after:snapshot];
+      }
+      else {
+        REASnapshot* snapshotAfter = [[REASnapshot alloc] init:view];
+        [_animationsManager onViewUpdate:view before:snapshotBefore after:snapshotAfter];
+      }
+
+    }
+
+    [_animationsManager removeLeftovers];
+    // Clean up
+    [uiManager setValue:nil forKey:@"_layoutAnimationGroup"];
+  };
+}
+
+- (Class)class
+{
+    return [RCTUIManager class];
+}
+
++ (Class)class
+{
+    return [RCTUIManager class];
+}
+
+- (void)setUp:(REAAnimationsManager*) animationsManager
+{
+  _animationsManager = animationsManager;
+  _toBeRemovedRegister = [[NSMutableDictionary<NSNumber*, NSMutableSet<id<RCTComponent>>*> alloc] init];
+  _parentMapper = [[NSMutableDictionary<NSNumber*, NSNumber*> alloc] init];
+}
+
+- (void)unregisterView:(id<RCTComponent>) view
+{
+  NSNumber* tag = _parentMapper[view.reactTag];
+  if(tag == nil) {
+    return;
+  }
+
+  [_toBeRemovedRegister[tag] removeObject:view];
+  if(_toBeRemovedRegister[tag].count == 0) {
+    [_toBeRemovedRegister removeObjectForKey:tag];
+  }
+  NSMutableDictionary<NSNumber *, id<RCTComponent>> *viewRegistry = [self valueForKey:@"_viewRegistry"];
+  [view.reactSuperview removeReactSubview:view];
+  id<RCTComponent> parentView = viewRegistry[tag];
+  [parentView removeReactSubview:view];
+#if __has_include(<RNScreens/RNSScreen.h>)
+  if ([view isKindOfClass:[RNSScreenView class]]) {
+    [parentView didUpdateReactSubviews];
+  }
+#endif
+  [viewRegistry removeObjectForKey:view.reactTag];
+}
+
+- (void)batchDidComplete
+{
+  self.flushUiOperations();
+  [super batchDidComplete];
+}
+
+@end

package/ios/Nodes/REAAlwaysNode.m

@@ -1,24 +1,24 @@
 #import "REAAlwaysNode.h"
-#import "REAUtils.h"
-#import "REANodesManager.h"
-#import "REAStyleNode.h"
-#import "REAModule.h"
-#import <React/RCTLog.h>
 #import <React/RCTConvert.h>
+#import <React/RCTLog.h>
 #import <React/RCTUIManager.h>
+#import "REAModule.h"
+#import "REANodesManager.h"
+#import "REAStyleNode.h"
+#import "REAUtils.h"
 
-@implementation REAAlwaysNode
-{
-  NSNumber * _nodeToBeEvaluated;
+@implementation REAAlwaysNode {
+  NSNumber *_nodeToBeEvaluated;
 }
 
-- (instancetype)initWithID:(REANodeID)nodeID config:(NSDictionary<NSString *,id> *)config
+- (instancetype)initWithID:(REANodeID)nodeID config:(NSDictionary<NSString *, id> *)config
 {
-    if ((self = [super initWithID:nodeID config:config])) {
-      _nodeToBeEvaluated = [RCTConvert NSNumber:config[@"what"]];
-      REA_LOG_ERROR_IF_NIL(_nodeToBeEvaluated, @"Reanimated: First argument passed to always node is either of wrong type or is missing.");
-    }
-    return self;
+  if ((self = [super initWithID:nodeID config:config])) {
+    _nodeToBeEvaluated = [RCTConvert NSNumber:config[@"what"]];
+    REA_LOG_ERROR_IF_NIL(
+        _nodeToBeEvaluated, @"Reanimated: First argument passed to always node is either of wrong type or is missing.");
+  }
+  return self;
 }
 
 - (id)evaluate
@@ -33,4 +33,3 @@
 }
 
 @end
-

package/ios/Nodes/REABezierNode.m

@@ -1,10 +1,10 @@
 #include <tgmath.h>
 
-#import "REABezierNode.h"
-#import "REAUtils.h"
-#import "REANodesManager.h"
 #import <React/RCTConvert.h>
 #import <React/RCTLog.h>
+#import "REABezierNode.h"
+#import "REANodesManager.h"
+#import "REAUtils.h"
 
 #define EPS 1e-5
 
@@ -13,11 +13,12 @@
   NSNumber *_inputNodeID;
 }
 
-- (instancetype)initWithID:(REANodeID)nodeID config:(NSDictionary<NSString *,id> *)config
+- (instancetype)initWithID:(REANodeID)nodeID config:(NSDictionary<NSString *, id> *)config
 {
   if ((self = [super initWithID:nodeID config:config])) {
     _inputNodeID = [RCTConvert NSNumber:config[@"input"]];
-    REA_LOG_ERROR_IF_NIL(_inputNodeID, @"Reanimated: First argument passed to bezier node is either of wrong type or is missing.");
+    REA_LOG_ERROR_IF_NIL(
+        _inputNodeID, @"Reanimated: First argument passed to bezier node is either of wrong type or is missing.");
 
     CGFloat mX1 = [config[@"mX1"] doubleValue];
     CGFloat mY1 = [config[@"mY1"] doubleValue];
@@ -27,7 +28,7 @@
     // Calculate the polynomial coefficients, implicit first and last control points are (0,0) and (1,1).
     cx = 3.0 * mX1;
     bx = 3.0 * (mX2 - mX1) - cx;
-    ax = 1.0 - cx -bx;
+    ax = 1.0 - cx - bx;
 
     cy = 3.0 * mY1;
     by = 3.0 * (mY2 - mY1) - cy;
@@ -60,7 +61,7 @@
   // First try a few iterations of Newton's method -- normally very fast.
   for (t2 = x, i = 0; i < 8; i++) {
     x2 = [self sampleCurveX:t2] - x;
-    if (fabs (x2) < epsilon)
+    if (fabs(x2) < epsilon)
       return t2;
     d2 = [self sampleCurveDerivativeX:t2];
     if (fabs(d2) < 1e-6)

package/ios/Nodes/REABlockNode.m

@@ -5,7 +5,7 @@
   NSArray<NSNumber *> *_block;
 }
 
-- (instancetype)initWithID:(REANodeID)nodeID config:(NSDictionary<NSString *,id> *)config
+- (instancetype)initWithID:(REANodeID)nodeID config:(NSDictionary<NSString *, id> *)config
 {
   if ((self = [super initWithID:nodeID config:config])) {
     _block = config[@"block"];

package/ios/Nodes/REACallFuncNode.h

@@ -4,4 +4,3 @@
 @interface REACallFuncNode : REANode
 
 @end
-

package/ios/Nodes/REACallFuncNode.m

@@ -2,22 +2,23 @@
 
 #import "REACallFuncNode.h"
 #import "REAFunctionNode.h"
-#import "REAUtils.h"
-#import "REAParamNode.h"
 #import "REANodesManager.h"
+#import "REAParamNode.h"
+#import "REAUtils.h"
 
 @implementation REACallFuncNode {
   NSNumber *_whatNodeID;
   NSArray<NSNumber *> *_args;
   NSArray<NSNumber *> *_params;
-  NSString* _prevCallID;
+  NSString *_prevCallID;
 }
 
-- (instancetype)initWithID:(REANodeID)nodeID config:(NSDictionary<NSString *,id> *)config
+- (instancetype)initWithID:(REANodeID)nodeID config:(NSDictionary<NSString *, id> *)config
 {
   if ((self = [super initWithID:nodeID config:config])) {
     _whatNodeID = config[@"what"];
-    REA_LOG_ERROR_IF_NIL(_whatNodeID, @"Reanimated: First argument passed to callFunc node is either of wrong type or is missing.");
+    REA_LOG_ERROR_IF_NIL(
+        _whatNodeID, @"Reanimated: First argument passed to callFunc node is either of wrong type or is missing.");
     _args = config[@"args"];
     _params = config[@"params"];
     _prevCallID = NULL;
@@ -27,13 +28,14 @@
 
 - (void)beginContext
 {
-  // To ensure that functions can be called multiple times in the same animation frame 
+  // To ensure that functions can be called multiple times in the same animation frame
   // (functions might have different parameters and might be called multiple times)
   // we inform the current update context about where we are called from by setting the
   // current call id - this will ensure that memoization is correct for function nodes.
   _prevCallID = self.updateContext.callID;
-  self.updateContext.callID = [NSString stringWithFormat:@"%@/%@", self.updateContext.callID, [self.nodeID stringValue]];
-  
+  self.updateContext.callID =
+      [NSString stringWithFormat:@"%@/%@", self.updateContext.callID, [self.nodeID stringValue]];
+
   // A CallFuncNode has a reference to a function node which holds the node graph that should
   // be updated. A Function node has a list of ParamNodes which are basically nodes that can
   // reference other nodes. When we start a new function call we update the parameter nodes

package/ios/Nodes/REAClockNodes.m

@@ -1,9 +1,9 @@
 #import "REAClockNodes.h"
-#import "REAUtils.h"
-#import "REANodesManager.h"
-#import "REAParamNode.h"
 #import <React/RCTConvert.h>
 #import <React/RCTLog.h>
+#import "REANodesManager.h"
+#import "REAParamNode.h"
+#import "REAUtils.h"
 
 @interface REAClockNode ()
 
@@ -13,7 +13,7 @@
 
 @implementation REAClockNode
 
-- (instancetype)initWithID:(REANodeID)nodeID config:(NSDictionary<NSString *,id> *)config
+- (instancetype)initWithID:(REANodeID)nodeID config:(NSDictionary<NSString *, id> *)config
 {
   if ((self = [super initWithID:nodeID config:config])) {
     _isRunning = NO;
@@ -23,7 +23,8 @@
 
 - (void)start
 {
-  if (_isRunning) return;
+  if (_isRunning)
+    return;
   _isRunning = YES;
 
   __block __weak void (^weak_animationClb)(CADisplayLink *displayLink);
@@ -31,7 +32,8 @@
   __weak REAClockNode *weakSelf = self;
 
   weak_animationClb = animationClb = ^(CADisplayLink *displayLink) {
-    if (!weakSelf.isRunning) return;
+    if (!weakSelf.isRunning)
+      return;
     [weakSelf markUpdated];
     [weakSelf.nodesManager postOnAnimation:weak_animationClb];
   };
@@ -55,18 +57,19 @@
   NSNumber *_clockNodeID;
 }
 
-- (instancetype)initWithID:(REANodeID)nodeID config:(NSDictionary<NSString *,id> *)config
+- (instancetype)initWithID:(REANodeID)nodeID config:(NSDictionary<NSString *, id> *)config
 {
   if ((self = [super initWithID:nodeID config:config])) {
     _clockNodeID = [RCTConvert NSNumber:config[@"clock"]];
-    REA_LOG_ERROR_IF_NIL(_clockNodeID, @"Reanimated: First argument passed to clock node is either of wrong type or is missing.");
+    REA_LOG_ERROR_IF_NIL(
+        _clockNodeID, @"Reanimated: First argument passed to clock node is either of wrong type or is missing.");
   }
   return self;
 }
 
-- (REANode*)clockNode
+- (REANode *)clockNode
 {
-  return (REANode*)[self.nodesManager findNodeByID:_clockNodeID];
+  return (REANode *)[self.nodesManager findNodeByID:_clockNodeID];
 }
 
 @end
@@ -75,11 +78,11 @@
 
 - (id)evaluate
 {
-  REANode* node = [self clockNode];
+  REANode *node = [self clockNode];
   if ([node isKindOfClass:[REAParamNode class]]) {
-    [(REAParamNode* )node start];
+    [(REAParamNode *)node start];
   } else {
-    [(REAClockNode* )node start];
+    [(REAClockNode *)node start];
   }
   return @(0);
 }
@@ -90,27 +93,26 @@
 
 - (id)evaluate
 {
-  REANode* node = [self clockNode];
+  REANode *node = [self clockNode];
   if ([node isKindOfClass:[REAParamNode class]]) {
-    [(REAParamNode* )node stop];
+    [(REAParamNode *)node stop];
   } else {
-    [(REAClockNode* )node stop];
+    [(REAClockNode *)node stop];
   }
   return @(0);
 }
 
-
 @end
 
 @implementation REAClockTestNode
 
 - (id)evaluate
 {
-  REANode* node = [self clockNode];
+  REANode *node = [self clockNode];
   if ([node isKindOfClass:[REAParamNode class]]) {
-    return @(((REAParamNode* )node).isRunning ? 1 : 0);
+    return @(((REAParamNode *)node).isRunning ? 1 : 0);
   }
-  return @([(REAClockNode* )node isRunning] ? 1 : 0);
+  return @([(REAClockNode *)node isRunning] ? 1 : 0);
 }
 
 @end

package/ios/Nodes/REAConcatNode.h

@@ -3,4 +3,3 @@
 @interface REAConcatNode : REANode
 
 @end
-

package/ios/Nodes/REAConcatNode.m

@@ -1,12 +1,12 @@
 #import "REAConcatNode.h"
-#import "REAValueNode.h"
 #import "REANodesManager.h"
+#import "REAValueNode.h"
 
 @implementation REAConcatNode {
   NSArray<NSNumber *> *_input;
 }
 
-- (instancetype)initWithID:(REANodeID)nodeID config:(NSDictionary<NSString *,id> *)config
+- (instancetype)initWithID:(REANodeID)nodeID config:(NSDictionary<NSString *, id> *)config
 {
   if ((self = [super initWithID:nodeID config:config])) {
     _input = config[@"input"];

package/ios/Nodes/REACondNode.m

@@ -1,8 +1,8 @@
 #import "REACondNode.h"
-#import "REANodesManager.h"
 #import <React/RCTConvert.h>
-#import "REAUtils.h"
 #import <React/RCTLog.h>
+#import "REANodesManager.h"
+#import "REAUtils.h"
 
 @implementation REACondNode {
   NSNumber *_condNodeID;
@@ -10,13 +10,15 @@
   NSNumber *_elseBlockID;
 }
 
-- (instancetype)initWithID:(REANodeID)nodeID config:(NSDictionary<NSString *,id> *)config
+- (instancetype)initWithID:(REANodeID)nodeID config:(NSDictionary<NSString *, id> *)config
 {
   if ((self = [super initWithID:nodeID config:config])) {
     _condNodeID = [RCTConvert NSNumber:config[@"cond"]];
-    REA_LOG_ERROR_IF_NIL(_condNodeID, @"Reanimated: First argument passed to cond node is either of wrong type or is missing.");
+    REA_LOG_ERROR_IF_NIL(
+        _condNodeID, @"Reanimated: First argument passed to cond node is either of wrong type or is missing.");
     _ifBlockID = [RCTConvert NSNumber:config[@"ifBlock"]];
-    REA_LOG_ERROR_IF_NIL(_ifBlockID, @"Reanimated: Second argument passed to cond node is either of wrong type or is missing.");
+    REA_LOG_ERROR_IF_NIL(
+        _ifBlockID, @"Reanimated: Second argument passed to cond node is either of wrong type or is missing.");
     _elseBlockID = [RCTConvert NSNumber:config[@"elseBlock"]];
   }
   return self;