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

package/ios/Transitioning/REATransition.h

@@ -1,6 +1,6 @@
-#import <UIKit/UIKit.h>
 #import <QuartzCore/QuartzCore.h>
 #import <React/RCTView.h>
+#import <UIKit/UIKit.h>
 
 #import "REATransitionAnimation.h"
 #import "REATransitionValues.h"
@@ -53,12 +53,13 @@ typedef NS_ENUM(NSInteger, REATransitionPropagationType) {
 - (void)playInRoot:(UIView *)root;
 - (REATransitionValues *)findStartValuesForKey:(NSNumber *)key;
 - (REATransitionValues *)findEndValuesForKey:(NSNumber *)key;
-- (REATransitionAnimation *)animationForTransitioning:(REATransitionValues*)startValues
-                                               endValues:(REATransitionValues*)endValues
-                                                 forRoot:(UIView *)root;
-- (NSArray<REATransitionAnimation*> *)animationsForTransitioning:(NSMutableDictionary<NSNumber*, REATransitionValues*> *)startValues
-                                                          endValues:(NSMutableDictionary<NSNumber*, REATransitionValues*> *)endValues
-                                                            forRoot:(UIView *)root;
+- (REATransitionAnimation *)animationForTransitioning:(REATransitionValues *)startValues
+                                            endValues:(REATransitionValues *)endValues
+                                              forRoot:(UIView *)root;
+- (NSArray<REATransitionAnimation *> *)
+    animationsForTransitioning:(NSMutableDictionary<NSNumber *, REATransitionValues *> *)startValues
+                     endValues:(NSMutableDictionary<NSNumber *, REATransitionValues *> *)endValues
+                       forRoot:(UIView *)root;
 
 + (REATransition *)inflate:(NSDictionary *)config;
 @end

package/ios/Transitioning/REATransition.m

@@ -1,11 +1,11 @@
-#import <UIKit/UIKit.h>
 #import <QuartzCore/QuartzCore.h>
 #import <React/RCTConvert.h>
 #import <React/RCTViewManager.h>
+#import <UIKit/UIKit.h>
 
+#import "RCTConvert+REATransition.h"
 #import "REATransition.h"
 #import "REATransitionValues.h"
-#import "RCTConvert+REATransition.h"
 
 #define DEFAULT_PROPAGATION_SPEED 3
 
@@ -17,8 +17,8 @@
 
 @interface REAVisibilityTransition : REATransition
 @property (nonatomic) REATransitionAnimationType animationType;
-- (REATransitionAnimation *)appearView:(UIView*)view inParent:(UIView*)parent;
-- (REATransitionAnimation *)disappearView:(UIView*)view fromParent:(UIView*)parent;
+- (REATransitionAnimation *)appearView:(UIView *)view inParent:(UIView *)parent;
+- (REATransitionAnimation *)disappearView:(UIView *)view fromParent:(UIView *)parent;
 - (instancetype)initWithConfig:(NSDictionary *)config;
 @end
 
@@ -36,8 +36,8 @@
 
 @implementation REATransition {
   __weak UIView *_root;
-  NSMutableDictionary<NSNumber*, REATransitionValues*> *_startValues;
-  NSMutableDictionary<NSNumber*, REATransitionValues*> *_endValues;
+  NSMutableDictionary<NSNumber *, REATransitionValues *> *_startValues;
+  NSMutableDictionary<NSNumber *, REATransitionValues *> *_endValues;
 }
 
 + (REATransition *)inflate:(NSDictionary *)config
@@ -70,7 +70,9 @@
   return self;
 }
 
-- (void)captureRecursiveIn:(UIView *)view to:(NSMutableDictionary<NSNumber*, REATransitionValues*> *)map forRoot:(UIView *)root
+- (void)captureRecursiveIn:(UIView *)view
+                        to:(NSMutableDictionary<NSNumber *, REATransitionValues *> *)map
+                   forRoot:(UIView *)root
 {
   NSNumber *tag = view.reactTag;
   if (tag != nil) {
@@ -91,9 +93,7 @@
 {
   _endValues = [NSMutableDictionary new];
   [self captureRecursiveIn:root to:_endValues forRoot:root];
-  NSArray *animations = [self animationsForTransitioning:_startValues
-                                               endValues:_endValues
-                                                 forRoot:root];
+  NSArray *animations = [self animationsForTransitioning:_startValues endValues:_endValues forRoot:root];
   for (REATransitionAnimation *animation in animations) {
     [animation play];
   }
@@ -164,15 +164,16 @@
 }
 
 - (REATransitionAnimation *)animationForTransitioning:(REATransitionValues *)startValues
-                                               endValues:(REATransitionValues *)endValues
-                                                 forRoot:(UIView *)root
+                                            endValues:(REATransitionValues *)endValues
+                                              forRoot:(UIView *)root
 {
   return nil;
 }
 
-- (NSArray<REATransitionAnimation*> *)animationsForTransitioning:(NSMutableDictionary<NSNumber *,REATransitionValues *> *)startValues
-                                                          endValues:(NSMutableDictionary<NSNumber *,REATransitionValues *> *)endValues
-                                                            forRoot:(UIView *)root
+- (NSArray<REATransitionAnimation *> *)
+    animationsForTransitioning:(NSMutableDictionary<NSNumber *, REATransitionValues *> *)startValues
+                     endValues:(NSMutableDictionary<NSNumber *, REATransitionValues *> *)endValues
+                       forRoot:(UIView *)root
 {
   NSMutableArray *animations = [NSMutableArray new];
   [startValues enumerateKeysAndObjectsUsingBlock:^(NSNumber *key, REATransitionValues *startValue, BOOL *stop) {
@@ -182,7 +183,9 @@
       animation.animation.timingFunction = self.mediaTiming;
       animation.animation.duration = self.duration;
       [animation delayBy:self.delay];
-      CFTimeInterval propagationDelay = [self propagationDelayForTransitioning:startValue endValues:endValue forRoot:root];
+      CFTimeInterval propagationDelay = [self propagationDelayForTransitioning:startValue
+                                                                     endValues:endValue
+                                                                       forRoot:root];
       [animation delayBy:propagationDelay];
       //      animation.animation.duration -= propagationDelay;
       [animations addObject:animation];

package/ios/Transitioning/REATransitionAnimation.h

@@ -8,7 +8,7 @@
 
 + (REATransitionAnimation *)transitionWithAnimation:(CAAnimation *)animation
                                               layer:(CALayer *)layer
-                                         andKeyPath:(NSString*)keyPath;
+                                         andKeyPath:(NSString *)keyPath;
 - (void)play;
 - (void)delayBy:(CFTimeInterval)delay;
 - (CFTimeInterval)finishTime;

package/ios/Transitioning/REATransitionAnimation.m

@@ -2,7 +2,6 @@
 
 #import "REATransitionAnimation.h"
 
-
 #define DEFAULT_DURATION 0.25
 
 #if TARGET_IPHONE_SIMULATOR
@@ -31,7 +30,7 @@ CGFloat SimAnimationDragCoefficient()
 
 + (REATransitionAnimation *)transitionWithAnimation:(CAAnimation *)animation
                                               layer:(CALayer *)layer
-                                         andKeyPath:(NSString*)keyPath;
+                                         andKeyPath:(NSString *)keyPath;
 {
   REATransitionAnimation *anim = [REATransitionAnimation new];
   anim.animation = animation;
@@ -47,7 +46,7 @@ CGFloat SimAnimationDragCoefficient()
   it calls mach_absolute_time() which is based on the last time the device booted
   which might cause the delay
   */
-  if (_delay > 0){
+  if (_delay > 0) {
     _animation.beginTime = CACurrentMediaTime() + _delay * SimAnimationDragCoefficient();
   }
   _animation.duration = self.duration * SimAnimationDragCoefficient();

package/ios/Transitioning/REATransitionManager.m

@@ -35,7 +35,7 @@
 
 - (void)uiManagerWillPerformMounting:(RCTUIManager *)manager
 {
-  [manager addUIBlock:^(RCTUIManager *uiManager, NSDictionary<NSNumber *,UIView *> *viewRegistry) {
+  [manager addUIBlock:^(RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
     [_pendingTransition playInRoot:_pendingTransitionRoot];
     _pendingTransitionRoot = nil;
     _pendingTransition = nil;
@@ -45,7 +45,7 @@
 - (void)animateNextTransitionInRoot:(NSNumber *)reactTag withConfig:(NSDictionary *)config
 {
   [_uiManager.observerCoordinator addObserver:self];
-  [_uiManager prependUIBlock:^(RCTUIManager *uiManager, NSDictionary<NSNumber *,UIView *> *viewRegistry) {
+  [_uiManager prependUIBlock:^(RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
     UIView *view = viewRegistry[reactTag];
     NSArray *transitionConfigs = [RCTConvert NSArray:config[@"transitions"]];
     for (id transitionConfig in transitionConfigs) {
@@ -54,7 +54,7 @@
     }
   }];
   __weak id weakSelf = self;
-  [_uiManager addUIBlock:^(RCTUIManager *uiManager, NSDictionary<NSNumber *,UIView *> *viewRegistry) {
+  [_uiManager addUIBlock:^(RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
     [uiManager.observerCoordinator removeObserver:weakSelf];
   }];
 }

package/ios/native/NativeMethods.h

@@ -1,11 +1,21 @@
 #import <Foundation/Foundation.h>
-#import <vector>
-#import <string>
 #import <React/RCTUIManager.h>
+#include <string>
+#import <string>
+#include <utility>
+#include <vector>
+#import <vector>
 
 namespace reanimated {
 
-std::vector<std::pair<std::string,double>> measure(int viewTag, RCTUIManager *uiManager);
-void scrollTo(int scrollViewTag, RCTUIManager *uiManager, double x, double y, bool animated);
+std::vector<std::pair<std::string, double>> measure(
+    int viewTag,
+    RCTUIManager *uiManager);
+void scrollTo(
+    int scrollViewTag,
+    RCTUIManager *uiManager,
+    double x,
+    double y,
+    bool animated);
 
-}
+} // namespace reanimated

package/ios/native/NativeProxy.h

@@ -1,12 +1,13 @@
 #import <React/RCTEventDispatcher.h>
 
 #if __cplusplus
-
 #import <RNReanimated/NativeReanimatedModule.h>
+#include <memory>
 
 namespace reanimated {
- 
-std::shared_ptr<reanimated::NativeReanimatedModule> createReanimatedModule(std::shared_ptr<facebook::react::CallInvoker> jsInvoker);
+
+std::shared_ptr<reanimated::NativeReanimatedModule> createReanimatedModule(
+    std::shared_ptr<facebook::react::CallInvoker> jsInvoker);
 
 }
 

package/ios/native/NativeProxy.mm

@@ -9,9 +9,11 @@
 #import <React/RCTUIManager.h>
 #import "LayoutAnimationsProxy.h"
 #import "REAAnimationsManager.h"
-#import "REAReactBatchObserver.h"
+#import "REAUIManager.h"
 
-#if __has_include(<hermes/hermes.h>)
+#if __has_include(<reacthermes/HermesExecutorFactory.h>)
+#import <reacthermes/HermesExecutorFactory.h>
+#elif __has_include(<hermes/hermes.h>)
 #import <hermes/hermes.h>
 #else
 #import <jsi/JSCRuntime.h>
@@ -113,8 +115,9 @@ std::shared_ptr<NativeReanimatedModule> createReanimatedModule(std::shared_ptr<C
       return val;
   };
 
-
-#if __has_include(<hermes/hermes.h>)
+#if __has_include(<reacthermes/HermesExecutorFactory.h>)
+  std::shared_ptr<jsi::Runtime> animatedRuntime = facebook::hermes::makeHermesRuntime();
+#elif __has_include(<hermes/hermes.h>)
   std::shared_ptr<jsi::Runtime> animatedRuntime = facebook::hermes::makeHermesRuntime();
 #else
   std::shared_ptr<jsi::Runtime> animatedRuntime = facebook::jsc::makeJSCRuntime();
@@ -124,6 +127,14 @@ std::shared_ptr<NativeReanimatedModule> createReanimatedModule(std::shared_ptr<C
   std::shared_ptr<ErrorHandler> errorHandler = std::make_shared<REAIOSErrorHandler>(scheduler);
   std::shared_ptr<NativeReanimatedModule> module;
 
+  __block std::weak_ptr<Scheduler> weakScheduler = scheduler;
+  ((REAUIManager*)uiManager).flushUiOperations = ^void() {
+    std::shared_ptr<Scheduler> scheduler = weakScheduler.lock();
+    if (scheduler != nullptr) {
+      scheduler->triggerUI();
+    }
+  };
+  
   auto requestRender = [reanimatedModule, &module](std::function<void(double)> onRender, jsi::Runtime &rt) {
     [reanimatedModule.nodesManager postOnAnimation:^(CADisplayLink *displayLink) {
       double frameTimestamp = displayLink.targetTimestamp * 1000;
@@ -140,7 +151,10 @@ std::shared_ptr<NativeReanimatedModule> createReanimatedModule(std::shared_ptr<C
   };
   
   // Layout Animations start
-  __weak REAAnimationsManager *animationsManager = reanimatedModule.reactBatchObserver.animationsManager;
+  REAUIManager* reaUiManagerNoCast = [bridge moduleForClass:[REAUIManager class]];
+  RCTUIManager* reaUiManager = reaUiManagerNoCast;
+  REAAnimationsManager *animationsManager = [[REAAnimationsManager alloc] initWithUIManager:reaUiManager];
+  [reaUiManagerNoCast setUp:animationsManager];
   
   auto notifyAboutProgress = [=](int tag, jsi::Object newStyle) {
     if (animationsManager) {

package/ios/native/REAIOSErrorHandler.h

@@ -1,20 +1,23 @@
 #pragma once
 
+#include <memory>
+#include <string>
 #include "ErrorHandler.h"
 #include "Scheduler.h"
 
 namespace reanimated {
 
 class REAIOSErrorHandler : public ErrorHandler {
-    std::shared_ptr<Scheduler> scheduler;
-    void raiseSpec() override;
-    std::shared_ptr<ErrorWrapper> error;
-    public:
-      REAIOSErrorHandler(std::shared_ptr<Scheduler> scheduler);
-      std::shared_ptr<Scheduler> getScheduler() override;
-      std::shared_ptr<ErrorWrapper> getError() override;
-      void setError(std::string message) override;
-      virtual ~REAIOSErrorHandler() {}
+  std::shared_ptr<Scheduler> scheduler;
+  void raiseSpec() override;
+  std::shared_ptr<ErrorWrapper> error;
+
+ public:
+  REAIOSErrorHandler(std::shared_ptr<Scheduler> scheduler);
+  std::shared_ptr<Scheduler> getScheduler() override;
+  std::shared_ptr<ErrorWrapper> getError() override;
+  void setError(std::string message) override;
+  virtual ~REAIOSErrorHandler() {}
 };
 
-}
+} // namespace reanimated

package/ios/native/REAIOSLogger.h

@@ -1,17 +1,17 @@
 #pragma once
 
-#include "ReanimatedHiddenHeaders.h"
 #include <stdio.h>
+#include "ReanimatedHiddenHeaders.h"
 
 namespace reanimated {
 
 class REAIOSLogger : public LoggerInterface {
-  public:
-    void log(const char* str) override;
-    void log(double d) override;
-    void log(int i) override;
-    void log(bool b) override;
-    virtual ~REAIOSLogger() {}
+ public:
+  void log(const char *str) override;
+  void log(double d) override;
+  void log(int i) override;
+  void log(bool b) override;
+  virtual ~REAIOSLogger() {}
 };
 
-}
+} // namespace reanimated

package/ios/native/REAIOSScheduler.h

@@ -1,18 +1,18 @@
 #pragma once
 
+#import <React/RCTUIManager.h>
+#import <ReactCommon/CallInvoker.h>
 #include <stdio.h>
+#include <memory>
 #include "Scheduler.h"
-#import <ReactCommon/CallInvoker.h>
-#import <React/RCTUIManager.h>
 
-namespace reanimated
-{
+namespace reanimated {
 
 using namespace facebook;
 using namespace react;
 
 class REAIOSScheduler : public Scheduler {
-  public:
+ public:
   REAIOSScheduler(std::shared_ptr<CallInvoker> jsInvoker);
   void scheduleOnUI(std::function<void()> job) override;
   virtual ~REAIOSScheduler();

package/ios/native/REAIOSScheduler.mm

@@ -25,12 +25,14 @@ void REAIOSScheduler::scheduleOnUI(std::function<void()> job) {
     if (runtimeManager.lock()) triggerUI();
     return;
   }
+  
+  if (!this->scheduledOnUI) {
+    __block std::weak_ptr<RuntimeManager> blockRuntimeManager = runtimeManager;
 
-  __block std::weak_ptr<RuntimeManager> blockRuntimeManager = runtimeManager;
-
-  dispatch_async(dispatch_get_main_queue(), ^{
-    if (blockRuntimeManager.lock()) triggerUI();
-  });
+    dispatch_async(dispatch_get_main_queue(), ^{
+      if (blockRuntimeManager.lock()) triggerUI();
+    });
+  }
 }
 
 REAIOSScheduler::~REAIOSScheduler(){

package/ios/native/REAInitializer.h

@@ -0,0 +1,37 @@
+//
+//  REAInitializer.h
+//  RNReanimated
+//
+//  Created by Szymon Kapala on 27/07/2021.
+//
+
+#import <Foundation/Foundation.h>
+#import <RNReanimated/NativeProxy.h>
+#import <RNReanimated/REAEventDispatcher.h>
+#import <RNReanimated/REAModule.h>
+#import <React/RCTBridge+Private.h>
+#import <React/RCTCxxBridgeDelegate.h>
+#import <ReactCommon/RCTTurboModuleManager.h>
+#import <jsireact/JSIExecutor.h>
+
+#if RNVERSION >= 64
+#import <React/RCTJSIExecutorRuntimeInstaller.h>
+#endif
+
+#if RNVERSION < 63
+#import <ReactCommon/BridgeJSCallInvoker.h>
+#endif
+
+NS_ASSUME_NONNULL_BEGIN
+
+namespace reanimated {
+
+using namespace facebook;
+using namespace react;
+
+JSIExecutor::RuntimeInstaller REAJSIExecutorRuntimeInstaller(
+    RCTBridge *bridge,
+    JSIExecutor::RuntimeInstaller runtimeInstallerToWrap);
+
+} // namespace reanimated
+NS_ASSUME_NONNULL_END

package/ios/native/REAInitializer.mm

@@ -0,0 +1,63 @@
+#import "REAInitializer.h"
+#import "REAUIManager.h"
+
+@interface RCTEventDispatcher(Reanimated)
+
+- (void)setBridge:(RCTBridge*)bridge;
+
+@end
+
+namespace reanimated {
+
+using namespace facebook;
+using namespace react;
+
+JSIExecutor::RuntimeInstaller REAJSIExecutorRuntimeInstaller(
+    RCTBridge* bridge,
+    JSIExecutor::RuntimeInstaller runtimeInstallerToWrap)
+{
+    [bridge moduleForClass:[RCTUIManager class]];
+    REAUIManager* reaUiManager = [REAUIManager new];
+    [reaUiManager setBridge:bridge];
+    RCTUIManager* uiManager = reaUiManager;
+    [bridge updateModuleWithInstance:uiManager];
+  
+    [bridge moduleForClass:[RCTEventDispatcher class]];
+    RCTEventDispatcher *eventDispatcher = [REAEventDispatcher new];
+#if RNVERSION >= 66
+    RCTCallableJSModules *callableJSModules = [RCTCallableJSModules new];
+    [bridge setValue:callableJSModules forKey:@"_callableJSModules"];
+    [callableJSModules setBridge:bridge];
+    [eventDispatcher setValue:callableJSModules forKey:@"_callableJSModules"];
+    [eventDispatcher setValue:bridge forKey:@"_bridge"];
+    [eventDispatcher initialize];
+#else
+    [eventDispatcher setBridge:bridge];
+#endif
+    [bridge updateModuleWithInstance:eventDispatcher];
+    _bridge_reanimated = bridge;
+    const auto runtimeInstaller = [bridge, runtimeInstallerToWrap](facebook::jsi::Runtime &runtime) {
+      if (!bridge) {
+        return;
+      }
+#if RNVERSION >= 63
+    auto reanimatedModule = reanimated::createReanimatedModule(bridge.jsCallInvoker);
+#else
+    auto callInvoker = std::make_shared<react::BridgeJSCallInvoker>(bridge.reactInstance);
+    auto reanimatedModule = reanimated::createReanimatedModule(callInvoker);
+#endif
+    runtime.global().setProperty(runtime,
+                                 jsi::PropNameID::forAscii(runtime, "__reanimatedModuleProxy"),
+                                 jsi::Object::createFromHostObject(runtime, reanimatedModule));
+        
+        if (runtimeInstallerToWrap) {
+            runtimeInstallerToWrap(runtime);
+        }
+    };
+    return runtimeInstaller;
+}
+
+
+}
+
+

package/ios/native/UIResponder+Reanimated.mm

@@ -1,21 +1,11 @@
 #import "UIResponder+Reanimated.h"
-#import <React/RCTCxxBridgeDelegate.h>
-#import <RNReanimated/NativeProxy.h>
-#import <RNReanimated/REAModule.h>
-#import <ReactCommon/RCTTurboModuleManager.h>
-#import <React/RCTBridge+Private.h>
-#import <React/RCTCxxBridgeDelegate.h>
-#import <RNReanimated/REAEventDispatcher.h>
+#import "REAUIManager.h"
+#import "REAInitializer.h"
 
-#if RNVERSION >= 64
-#import <React/RCTJSIExecutorRuntimeInstaller.h>
-#endif
-
-#if RNVERSION < 63
-#import <ReactCommon/BridgeJSCallInvoker.h>
-#endif
-
-#if __has_include(<React/HermesExecutorFactory.h>)
+#if __has_include(<reacthermes/HermesExecutorFactory.h>)
+#import <reacthermes/HermesExecutorFactory.h>
+typedef HermesExecutorFactory ExecutorFactory;
+#elif __has_include(<React/HermesExecutorFactory.h>)
 #import <React/HermesExecutorFactory.h>
 typedef HermesExecutorFactory ExecutorFactory;
 #else
@@ -25,45 +15,16 @@ typedef JSCExecutorFactory ExecutorFactory;
 
 #ifndef DONT_AUTOINSTALL_REANIMATED
 
-@interface RCTEventDispatcher(Reanimated)
-
-- (void)setBridge:(RCTBridge*)bridge;
-
-@end
-
 @implementation UIResponder (Reanimated)
 - (std::unique_ptr<facebook::react::JSExecutorFactory>)jsExecutorFactoryForBridge:(RCTBridge *)bridge
 {
-  [bridge moduleForClass:[RCTEventDispatcher class]];
-  RCTEventDispatcher *eventDispatcher = [REAEventDispatcher new];
-  [eventDispatcher setBridge:bridge];
-  [bridge updateModuleWithInstance:eventDispatcher];
-   _bridge_reanimated = bridge;
-  __weak __typeof(self) weakSelf = self;
-
-  const auto executor = [weakSelf, bridge](facebook::jsi::Runtime &runtime) {
-    if (!bridge) {
-      return;
-    }
-    __typeof(self) strongSelf = weakSelf;
-    if (strongSelf) {
-#if RNVERSION >= 63
-      auto reanimatedModule = reanimated::createReanimatedModule(bridge.jsCallInvoker);
-#else
-      auto callInvoker = std::make_shared<react::BridgeJSCallInvoker>(bridge.reactInstance);
-      auto reanimatedModule = reanimated::createReanimatedModule(callInvoker);
-#endif
-      runtime.global().setProperty(runtime,
-                                   jsi::PropNameID::forAscii(runtime, "__reanimatedModuleProxy"),
-                                   jsi::Object::createFromHostObject(runtime, reanimatedModule));
-    }
-  };
+  const auto installer = reanimated::REAJSIExecutorRuntimeInstaller(bridge, NULL);
 
 #if RNVERSION >= 64
   // installs globals such as console, nativePerformanceNow, etc.
-  return std::make_unique<ExecutorFactory>(RCTJSIExecutorRuntimeInstaller(executor));
+  return std::make_unique<ExecutorFactory>(RCTJSIExecutorRuntimeInstaller(installer));
 #else
-  return std::make_unique<ExecutorFactory>(executor);
+  return std::make_unique<ExecutorFactory>(installer);
 #endif
 }
 

package/lib/ConfigHelper.js

@@ -103,6 +103,7 @@ let NATIVE_THREAD_PROPS_WHITELIST = {
   color: true,
   tintColor: true,
   shadowColor: true,
+  placeholderTextColor: true,
 };
 
 function configureProps() {

package/lib/ReanimatedModule.native.js

@@ -1,5 +1,13 @@
 import { NativeModules } from 'react-native';
+import ReanimatedModuleCompat from './ReanimatedModuleCompat';
+import { nativeShouldBeMock } from './reanimated2/PlatformChecker';
 
-const { ReanimatedModule } = NativeModules;
+let exportedModule;
+if (nativeShouldBeMock()) {
+  exportedModule = ReanimatedModuleCompat;
+} else {
+  const { ReanimatedModule } = NativeModules;
+  exportedModule = ReanimatedModule;
+}
 
-export default ReanimatedModule;
+export default exportedModule;