react-native-reanimated 2.3.0-beta.2 → 2.3.1

package/ios/LayoutReanimation/REAAnimationsManager.m

@@ -7,6 +7,8 @@
 
 @interface REAAnimationsManager ()
 
+typedef NS_ENUM(NSInteger, FrameConfigType) { EnteringFrame, ExitingFrame };
+
 @property (atomic, nullable) void (^startAnimationForTag)(NSNumber *, NSString *, NSDictionary *, NSNumber *);
 @property (atomic, nullable) void (^removeConfigForTag)(NSNumber *);
 
@@ -21,6 +23,8 @@
   NSMutableDictionary<NSNumber *, NSNumber *> *_states;
   NSMutableDictionary<NSNumber *, UIView *> *_viewForTag;
   NSMutableSet<NSNumber *> *_toRemove;
+  NSMutableArray<NSString *> *_targetKeys;
+  NSMutableArray<NSString *> *_currentKeys;
   BOOL _cleaningScheduled;
 }
 
@@ -43,6 +47,13 @@
     _viewForTag = [NSMutableDictionary new];
     _toRemove = [NSMutableSet new];
     _cleaningScheduled = false;
+
+    _targetKeys = [NSMutableArray new];
+    _currentKeys = [NSMutableArray new];
+    for (NSString *key in [[self class] layoutKeys]) {
+      [_targetKeys addObject:[NSString stringWithFormat:@"target%@", [key capitalizedString]]];
+      [_currentKeys addObject:[NSString stringWithFormat:@"current%@", [key capitalizedString]]];
+    }
   }
   return self;
 }
@@ -56,6 +67,8 @@
   _viewForTag = nil;
   _toRemove = nil;
   _cleaningScheduled = false;
+  _targetKeys = nil;
+  _currentKeys = nil;
 }
 
 - (void)setAnimationStartingBlock:
@@ -208,16 +221,53 @@
   [componentData setProps:newProps forView:view];
 }
 
-- (NSDictionary *)prepareDataForAnimatingWorklet:(NSMutableDictionary *)values
+- (NSDictionary *)prepareDataForAnimatingWorklet:(NSMutableDictionary *)values frameConfig:(FrameConfigType)frameConfig
+{
+  UIView *windowView = UIApplication.sharedApplication.keyWindow;
+  if (frameConfig == EnteringFrame) {
+    NSDictionary *preparedData = @{
+      @"targetWidth" : values[@"width"],
+      @"targetHeight" : values[@"height"],
+      @"targetOriginX" : values[@"originX"],
+      @"targetOriginY" : values[@"originY"],
+      @"targetGlobalOriginX" : values[@"globalOriginX"],
+      @"targetGlobalOriginY" : values[@"globalOriginY"],
+      @"windowWidth" : [NSNumber numberWithDouble:windowView.bounds.size.width],
+      @"windowHeight" : [NSNumber numberWithDouble:windowView.bounds.size.height]
+    };
+    return preparedData;
+  } else {
+    NSDictionary *preparedData = @{
+      @"currentWidth" : values[@"width"],
+      @"currentHeight" : values[@"height"],
+      @"currentOriginX" : values[@"originX"],
+      @"currentOriginY" : values[@"originY"],
+      @"currentGlobalOriginX" : values[@"globalOriginX"],
+      @"currentGlobalOriginY" : values[@"globalOriginY"],
+      @"windowWidth" : [NSNumber numberWithDouble:windowView.bounds.size.width],
+      @"windowHeight" : [NSNumber numberWithDouble:windowView.bounds.size.height]
+    };
+    return preparedData;
+  }
+}
+
+- (NSDictionary *)prepareDataForLayoutAnimatingWorklet:(NSMutableDictionary *)currentValues
+                                          targetValues:(NSMutableDictionary *)targetValues
 {
   UIView *windowView = UIApplication.sharedApplication.keyWindow;
   NSDictionary *preparedData = @{
-    @"width" : values[@"width"],
-    @"height" : values[@"height"],
-    @"originX" : values[@"originX"],
-    @"originY" : values[@"originY"],
-    @"globalOriginX" : values[@"globalOriginX"],
-    @"globalOriginY" : values[@"globalOriginY"],
+    @"currentWidth" : currentValues[@"width"],
+    @"currentHeight" : currentValues[@"height"],
+    @"currentOriginX" : currentValues[@"originX"],
+    @"currentOriginY" : currentValues[@"originY"],
+    @"currentGlobalOriginX" : currentValues[@"globalOriginX"],
+    @"currentGlobalOriginY" : currentValues[@"globalOriginY"],
+    @"targetWidth" : targetValues[@"width"],
+    @"targetHeight" : targetValues[@"height"],
+    @"targetOriginX" : targetValues[@"originX"],
+    @"targetOriginY" : targetValues[@"originY"],
+    @"targetGlobalOriginX" : targetValues[@"globalOriginX"],
+    @"targetGlobalOriginY" : targetValues[@"globalOriginY"],
     @"windowWidth" : [NSNumber numberWithDouble:windowView.bounds.size.width],
     @"windowHeight" : [NSNumber numberWithDouble:windowView.bounds.size.height]
   };
@@ -241,12 +291,13 @@
     return;
   }
   _states[tag] = [NSNumber numberWithInt:Disappearing];
-  NSDictionary *preparedValues = [self prepareDataForAnimatingWorklet:startValues];
+  NSDictionary *preparedValues = [self prepareDataForAnimatingWorklet:startValues frameConfig:ExitingFrame];
   _startAnimationForTag(tag, @"exiting", preparedValues, @(0));
 }
 
 - (void)onViewCreate:(UIView *)view after:(REASnapshot *)after
 {
+  _reaUiManager.flushUiOperations();
   NSNumber *tag = view.reactTag;
   if (_states[tag] == nil) {
     _states[tag] = [NSNumber numberWithInt:Inactive];
@@ -256,7 +307,7 @@
   ViewState state = [_states[tag] intValue];
   if (state == Inactive) {
     if (targetValues != nil) {
-      NSDictionary *preparedValues = [self prepareDataForAnimatingWorklet:targetValues];
+      NSDictionary *preparedValues = [self prepareDataForAnimatingWorklet:targetValues frameConfig:EnteringFrame];
       _startAnimationForTag(tag, @"entering", preparedValues, @(0));
     }
     return;
@@ -267,7 +318,7 @@
 {
   NSNumber *tag = view.reactTag;
   NSMutableDictionary *targetValues = after.values;
-  NSMutableDictionary *startValues = before.values;
+  NSMutableDictionary *currentValues = before.values;
   if (_states[tag] == nil) {
     return;
   }
@@ -277,8 +328,9 @@
   }
   if (state == Appearing) {
     BOOL doNotStartLayout = true;
-    for (NSString *key in [[self class] layoutKeys]) {
-      if ([((NSNumber *)startValues[key]) doubleValue] != [((NSNumber *)targetValues[key]) doubleValue]) {
+    for (int i = 0; i < [[self class] layoutKeys].count; ++i) {
+      if ([((NSNumber *)currentValues[_currentKeys[i]]) doubleValue] !=
+          [((NSNumber *)targetValues[_targetKeys[i]]) doubleValue]) {
         doNotStartLayout = false;
       }
     }
@@ -287,13 +339,7 @@
     }
   }
   _states[view.reactTag] = [NSNumber numberWithInt:Layout];
-  NSDictionary *preparedStartValues = [self prepareDataForAnimatingWorklet:startValues];
-  NSDictionary *preparedTargetValues = [self prepareDataForAnimatingWorklet:targetValues];
-  NSMutableDictionary *preparedValues = [NSMutableDictionary new];
-  [preparedValues addEntriesFromDictionary:preparedTargetValues];
-  for (NSString *key in preparedStartValues.allKeys) {
-    preparedValues[[NSString stringWithFormat:@"%@%@", @"b", key]] = preparedStartValues[key];
-  }
+  NSDictionary *preparedValues = [self prepareDataForLayoutAnimatingWorklet:currentValues targetValues:targetValues];
   _startAnimationForTag(view.reactTag, @"layout", preparedValues, @(0));
 }
 

package/ios/LayoutReanimation/REAUIManager.mm

@@ -1,19 +1,22 @@
 #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"
+#include "FeaturesConfig.h"
 #import "REAIOSScheduler.h"
 #include "Scheduler.h"
 
+#import <React/RCTComponentData.h>
+#import <React/RCTLayoutAnimation.h>
+#import <React/RCTLayoutAnimationGroup.h>
+#import <React/RCTModalHostView.h>
+#import <React/RCTRootShadowView.h>
+#import <React/RCTRootViewInternal.h>
+#import <React/RCTUIManagerObserverCoordinator.h>
+
 #if __has_include(<RNScreens/RNSScreen.h>)
 #import <RNScreens/RNSScreen.h>
 #endif
 
-@interface RCTUIManager(REA)
+@interface RCTUIManager (REA)
 - (void)_manageChildren:(NSNumber *)containerTag
         moveFromIndices:(NSArray<NSNumber *> *)moveFromIndices
           moveToIndices:(NSArray<NSNumber *> *)moveToIndices
@@ -29,19 +32,19 @@
 @implementation REAUIManager
 
 BOOL blockSetter = false;
-NSMutableDictionary<NSNumber*, NSMutableSet<id<RCTComponent>>*>* _toBeRemovedRegister;
-NSMutableDictionary<NSNumber*, NSNumber*>* _parentMapper;
-REAAnimationsManager* _animationsManager;
+NSMutableDictionary<NSNumber *, NSMutableSet<id<RCTComponent>> *> *_toBeRemovedRegister;
+NSMutableDictionary<NSNumber *, NSNumber *> *_parentMapper;
+REAAnimationsManager *_animationsManager;
 std::weak_ptr<reanimated::Scheduler> _scheduler;
 
-+ (NSString*)moduleName
++ (NSString *)moduleName
 {
   return NSStringFromClass([RCTUIManager class]);
 }
 
 - (void)setBridge:(RCTBridge *)bridge
 {
-  if(!_blockSetter) {
+  if (!_blockSetter) {
     _blockSetter = true;
 
     self.bridge = bridge;
@@ -49,8 +52,10 @@ std::weak_ptr<reanimated::Scheduler> _scheduler;
     [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:@"_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"];
@@ -68,25 +73,39 @@ std::weak_ptr<reanimated::Scheduler> _scheduler;
         removeAtIndices:(NSArray<NSNumber *> *)removeAtIndices
                registry:(NSMutableDictionary<NSNumber *, id<RCTComponent>> *)registry
 {
+  if (!reanimated::FeaturesConfig::isLayoutAnimationEnabled()) {
+    [super _manageChildren:containerTag
+           moveFromIndices:moveFromIndices
+             moveToIndices:moveToIndices
+         addChildReactTags:addChildReactTags
+              addAtIndices:addAtIndices
+           removeAtIndices:removeAtIndices
+                  registry:registry];
+    return;
+  }
+
+  // Reanimated changes /start
   BOOL isUIViewRegistry = ((id)registry == (id)[self valueForKey:@"_viewRegistry"]);
   id<RCTComponent> container;
-  NSArray<id<RCTComponent>> *permanentlyRemovedChildren;
-  if(isUIViewRegistry) {
+  NSMutableArray<id<RCTComponent>> *permanentlyRemovedChildren;
+  if (isUIViewRegistry) {
     container = registry[containerTag];
-    for(id<RCTComponent> toRemoveChild in _toBeRemovedRegister[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) {
+    permanentlyRemovedChildren = (NSMutableArray *)[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];
       }
     }
   }
+  // Reanimated changes /end
 
   [super _manageChildren:containerTag
          moveFromIndices:moveFromIndices
@@ -96,30 +115,44 @@ std::weak_ptr<reanimated::Scheduler> _scheduler;
          removeAtIndices:removeAtIndices
                 registry:registry];
 
-  if(isUIViewRegistry) {
+  // Reanimated changes /start
+  if (isUIViewRegistry) {
     NSMutableDictionary<NSNumber *, id<RCTComponent>> *viewRegistry = [self valueForKey:@"_viewRegistry"];
-    for(id<RCTComponent> toRemoveChild in _toBeRemovedRegister[containerTag]) {
+    for (id<RCTComponent> toRemoveChild in _toBeRemovedRegister[containerTag]) {
       NSInteger lastIndex = [container reactSubviews].count - 1;
-      if(lastIndex < 0) {
+      if (lastIndex < 0) {
         lastIndex = 0;
       }
-      [container insertReactSubview:toRemoveChild atIndex:lastIndex];
-      viewRegistry[toRemoveChild.reactTag] = toRemoveChild;
+      if ([toRemoveChild isKindOfClass:[RCTModalHostView class]]
+#if __has_include(<RNScreens/RNSScreen.h>)
+          || ([toRemoveChild isKindOfClass:[RNSScreenView class]])
+#endif
+      ) {
+        // we don't want layout animations when removing modals or Screens of native-stack since it brings buggy
+        // behavior
+        [_toBeRemovedRegister[container.reactTag] removeObject:toRemoveChild];
+        [permanentlyRemovedChildren removeObject:toRemoveChild];
+
+      } else {
+        [container insertReactSubview:toRemoveChild atIndex:lastIndex];
+        viewRegistry[toRemoveChild.reactTag] = toRemoveChild;
+      }
     }
 
     for (UIView *removedChild in permanentlyRemovedChildren) {
-      [self callAnimationForTree: removedChild parentTag:containerTag];
+      [self callAnimationForTree:removedChild parentTag:containerTag];
     }
   }
+  // Reanimated changes /end
 }
 
-- (void) callAnimationForTree:(UIView*) view parentTag:(NSNumber*) parentTag
+- (void)callAnimationForTree:(UIView *)view parentTag:(NSNumber *)parentTag
 {
-  REASnapshot* snapshot = [[REASnapshot alloc] init:view];
+  REASnapshot *snapshot = [[REASnapshot alloc] init:view];
   _parentMapper[view.reactTag] = parentTag;
   [_animationsManager onViewRemoval:view before:snapshot];
 
-  for(UIView* subView in view.reactSubviews) {
+  for (UIView *subView in view.reactSubviews) {
     [self callAnimationForTree:subView parentTag:view.reactTag];
   }
 }
@@ -153,11 +186,12 @@ std::weak_ptr<reanimated::Scheduler> _scheduler;
     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};
+      frameDataArray[index++] = (RCTFrameData){
+          layoutMetrics.frame,
+          layoutMetrics.layoutDirection,
+          shadowView.isNewView,
+          shadowView.superview.isNewView,
+          layoutMetrics.displayType};
     }
   }
 
@@ -183,7 +217,7 @@ std::weak_ptr<reanimated::Scheduler> _scheduler;
       CGSize contentSize = shadowView.layoutMetrics.frame.size;
 
       RCTExecuteOnMainQueue(^{
-        NSMutableDictionary<NSNumber *, UIView *>* viewRegistry = [self valueForKey:@"_viewRegistry"];
+        NSMutableDictionary<NSNumber *, UIView *> *viewRegistry = [self valueForKey:@"_viewRegistry"];
         UIView *view = viewRegistry[reactTag];
         RCTAssert(view != nil, @"view (for ID %@) not found", reactTag);
 
@@ -236,7 +270,13 @@ std::weak_ptr<reanimated::Scheduler> _scheduler;
         view.hidden = isHidden;
       }
 
-      REASnapshot* snapshotBefore = [[REASnapshot alloc] init:view];
+      // Reanimated changes /start
+      REASnapshot *snapshotBefore;
+      if (reanimated::FeaturesConfig::isLayoutAnimationEnabled()) {
+        snapshotBefore = [[REASnapshot alloc] init:view];
+      }
+      // Reanimated changes /end
+
       if (creatingLayoutAnimation) {
         // Animate view creation
         [view reactSetFrame:frame];
@@ -282,55 +322,61 @@ std::weak_ptr<reanimated::Scheduler> _scheduler;
         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];
+      // Reanimated changes /start
+      if (reanimated::FeaturesConfig::isLayoutAnimationEnabled()) {
+        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->_layoutAnimationGroup = nil;
     [uiManager setValue:nil forKey:@"_layoutAnimationGroup"];
+    // Reanimated changes /end
   };
 }
 
 - (Class)class
 {
-    return [RCTUIManager class];
+  return [RCTUIManager class];
 }
 
 + (Class)class
 {
-    return [RCTUIManager class];
+  return [RCTUIManager class];
 }
 
-- (void)setUp:(REAAnimationsManager*) animationsManager
+- (void)setUp:(REAAnimationsManager *)animationsManager
 {
   _animationsManager = animationsManager;
-  _toBeRemovedRegister = [[NSMutableDictionary<NSNumber*, NSMutableSet<id<RCTComponent>>*> alloc] init];
-  _parentMapper = [[NSMutableDictionary<NSNumber*, NSNumber*> alloc] init];
+  _toBeRemovedRegister = [[NSMutableDictionary<NSNumber *, NSMutableSet<id<RCTComponent>> *> alloc] init];
+  _parentMapper = [[NSMutableDictionary<NSNumber *, NSNumber *> alloc] init];
 }
 
-- (void)unregisterView:(id<RCTComponent>) view
+- (void)unregisterView:(id<RCTComponent>)view
 {
-  NSNumber* tag = _parentMapper[view.reactTag];
-  if(tag == nil) {
+  NSNumber *tag = _parentMapper[view.reactTag];
+  if (tag == nil) {
     return;
   }
 
   [_toBeRemovedRegister[tag] removeObject:view];
-  if(_toBeRemovedRegister[tag].count == 0) {
+  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];
+  @try {
+    [parentView removeReactSubview:view];
+  } @catch (id anException) {
+  }
 #if __has_include(<RNScreens/RNSScreen.h>)
   if ([view isKindOfClass:[RNSScreenView class]]) {
     [parentView didUpdateReactSubviews];
@@ -339,10 +385,4 @@ std::weak_ptr<reanimated::Scheduler> _scheduler;
   [viewRegistry removeObjectForKey:view.reactTag];
 }
 
-- (void)batchDidComplete
-{
-  self.flushUiOperations();
-  [super batchDidComplete];
-}
-
 @end

package/ios/Nodes/REAPropsNode.m

@@ -4,9 +4,9 @@
 #import "REANodesManager.h"
 #import "REAStyleNode.h"
 
+#import <React/RCTComponentData.h>
 #import <React/RCTLog.h>
 #import <React/RCTUIManager.h>
-#import "React/RCTComponentData.h"
 
 @implementation REAPropsNode {
   NSNumber *_connectedViewTag;

package/ios/REAEventDispatcher.m

@@ -7,7 +7,7 @@
 
 - (void)sendEvent:(id<RCTEvent>)event
 {
-  [[_bridge_reanimated moduleForName:@"ReanimatedModule"] eventDispatcherWillDispatchEvent:event];
+  [[[self bridge] moduleForName:@"ReanimatedModule"] eventDispatcherWillDispatchEvent:event];
   [super sendEvent:event];
 }
 

package/ios/REAModule.h

@@ -7,8 +7,6 @@
 
 #import "REAValueNode.h"
 
-extern RCTBridge *_bridge_reanimated;
-
 @interface REAModule : RCTEventEmitter <RCTBridgeModule, RCTEventDispatcherObserver, RCTUIManagerObserver>
 
 @property (nonatomic, readonly) REANodesManager *nodesManager;

package/ios/REAModule.m

@@ -6,8 +6,6 @@
 
 typedef void (^AnimatedOperation)(REANodesManager *nodesManager);
 
-RCTBridge *_bridge_reanimated = nil;
-
 @implementation REAModule {
   NSMutableArray<AnimatedOperation> *_operations;
   REATransitionManager *_transitionManager;
@@ -17,7 +15,6 @@ RCT_EXPORT_MODULE(ReanimatedModule);
 
 - (void)invalidate
 {
-  _bridge_reanimated = nil;
   _transitionManager = nil;
   [_nodesManager invalidate];
   [self.bridge.uiManager.observerCoordinator removeObserver:self];

package/ios/REANodesManager.m

@@ -116,6 +116,7 @@
   }
 
   _displayLink = [CADisplayLink displayLinkWithTarget:self selector:@selector(onAnimationFrame:)];
+  _displayLink.preferredFramesPerSecond = 120; // will fallback to 60 fps for devices without Pro Motion display
   [_displayLink addToRunLoop:[NSRunLoop mainRunLoop] forMode:NSRunLoopCommonModes];
   [_displayLink setPaused:true];
   return self;

package/ios/RNGestureHandlerStateManager.h

@@ -0,0 +1,5 @@
+@protocol RNGestureHandlerStateManager
+
+- (void)setGestureState:(int)state forHandler:(int)handlerTag;
+
+@end

package/ios/native/NativeMethods.h

@@ -5,6 +5,7 @@
 #include <utility>
 #include <vector>
 #import <vector>
+#import "RNGestureHandlerStateManager.h"
 
 namespace reanimated {
 
@@ -17,5 +18,9 @@ void scrollTo(
     double x,
     double y,
     bool animated);
+void setGestureState(
+    id<RNGestureHandlerStateManager> gestureHandlerStateManager,
+    int handlerTag,
+    int newState);
 
 } // namespace reanimated

package/ios/native/NativeMethods.mm

@@ -1,10 +1,11 @@
 #import "NativeMethods.h"
-#import <React/RCTScrollView.h>
 #import <React/RCTEventDispatcher.h>
+#import <React/RCTScrollView.h>
 
 namespace reanimated {
 
-std::vector<std::pair<std::string,double>> measure(int viewTag, RCTUIManager *uiManager) {
+std::vector<std::pair<std::string, double>> measure(int viewTag, RCTUIManager *uiManager)
+{
   UIView *view = [uiManager viewForReactTag:@(viewTag)];
 
   UIView *rootView = view;
@@ -17,7 +18,7 @@ std::vector<std::pair<std::string,double>> measure(int viewTag, RCTUIManager *ui
     rootView = rootView.superview;
   }
 
-  if (rootView == nil || (![rootView isReactRootView])) {
+  if (rootView == nil) {
     return std::vector<std::pair<std::string, double>>(1, std::make_pair("x", -1234567.0));
   }
 
@@ -36,11 +37,18 @@ std::vector<std::pair<std::string,double>> measure(int viewTag, RCTUIManager *ui
   return result;
 }
 
-
-void scrollTo(int scrollViewTag, RCTUIManager *uiManager, double x, double y, bool animated) {
+void scrollTo(int scrollViewTag, RCTUIManager *uiManager, double x, double y, bool animated)
+{
   UIView *view = [uiManager viewForReactTag:@(scrollViewTag)];
-  RCTScrollView *scrollView = (RCTScrollView *) view;
+  RCTScrollView *scrollView = (RCTScrollView *)view;
   [scrollView scrollToOffset:(CGPoint){(CGFloat)x, (CGFloat)y} animated:animated];
 }
 
+void setGestureState(id<RNGestureHandlerStateManager> gestureHandlerStateManager, int handlerTag, int newState)
+{
+  if (gestureHandlerStateManager != nil) {
+    [gestureHandlerStateManager setGestureState:newState forHandler:handlerTag];
+  }
+}
+
 }

package/ios/native/NativeProxy.h

@@ -7,6 +7,7 @@
 namespace reanimated {
 
 std::shared_ptr<reanimated::NativeReanimatedModule> createReanimatedModule(
+    RCTBridge *bridge,
     std::shared_ptr<facebook::react::CallInvoker> jsInvoker);
 
 }