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

package/Common/cpp/headers/NativeModules/NativeReanimatedModule.h

@@ -1,18 +1,17 @@
 #pragma once
 
-#include "NativeReanimatedModuleSpec.h"
-#include "Scheduler.h"
-#include "ErrorHandler.h"
-#include "RuntimeDecorator.h"
-#include "PlatformDepMethodsHolder.h"
 #include <unistd.h>
 #include <memory>
 #include <vector>
-#include "RuntimeManager.h"
+#include "ErrorHandler.h"
 #include "LayoutAnimationsProxy.h"
+#include "NativeReanimatedModuleSpec.h"
+#include "PlatformDepMethodsHolder.h"
+#include "RuntimeDecorator.h"
+#include "RuntimeManager.h"
+#include "Scheduler.h"
 
-namespace reanimated
-{
+namespace reanimated {
 
 using FrameCallback = std::function<void(double)>;
 
@@ -21,41 +20,51 @@ class MutableValue;
 class MapperRegistry;
 class EventHandlerRegistry;
 
-class NativeReanimatedModule : public NativeReanimatedModuleSpec, public RuntimeManager
-{
+class NativeReanimatedModule : public NativeReanimatedModuleSpec,
+                               public RuntimeManager {
   friend ShareableValue;
   friend MutableValue;
-  
-public:
-  NativeReanimatedModule(std::shared_ptr<CallInvoker> jsInvoker,
-                         std::shared_ptr<Scheduler> scheduler,
-                         std::shared_ptr<jsi::Runtime> rt,
-                         std::shared_ptr<ErrorHandler> errorHandler,
-                         std::function<jsi::Value(jsi::Runtime &, const int, const jsi::String &)> propObtainer,
-                         std::shared_ptr<LayoutAnimationsProxy> layoutAnimationsProxy,
-                         PlatformDepMethodsHolder platformDepMethodsHolder);
 
-  virtual ~NativeReanimatedModule();
+ public:
+  NativeReanimatedModule(
+      std::shared_ptr<CallInvoker> jsInvoker,
+      std::shared_ptr<Scheduler> scheduler,
+      std::shared_ptr<jsi::Runtime> rt,
+      std::shared_ptr<ErrorHandler> errorHandler,
+      std::function<jsi::Value(jsi::Runtime &, const int, const jsi::String &)>
+          propObtainer,
+      std::shared_ptr<LayoutAnimationsProxy> layoutAnimationsProxy,
+      PlatformDepMethodsHolder platformDepMethodsHolder);
 
-  void installCoreFunctions(jsi::Runtime &rt, const jsi::Value &valueSetter) override;
+  void installCoreFunctions(jsi::Runtime &rt, const jsi::Value &valueSetter)
+      override;
 
   jsi::Value makeShareable(jsi::Runtime &rt, const jsi::Value &value) override;
   jsi::Value makeMutable(jsi::Runtime &rt, const jsi::Value &value) override;
   jsi::Value makeRemote(jsi::Runtime &rt, const jsi::Value &value) override;
 
-  jsi::Value startMapper(jsi::Runtime &rt,
-                         const jsi::Value &worklet,
-                         const jsi::Value &inputs,
-                         const jsi::Value &outputs,
-                         const jsi::Value &updater,
-                         const jsi::Value &tag,
-                         const jsi::Value &name) override;
+  jsi::Value startMapper(
+      jsi::Runtime &rt,
+      const jsi::Value &worklet,
+      const jsi::Value &inputs,
+      const jsi::Value &outputs,
+      const jsi::Value &updater,
+      const jsi::Value &viewDescriptors) override;
   void stopMapper(jsi::Runtime &rt, const jsi::Value &mapperId) override;
 
-  jsi::Value registerEventHandler(jsi::Runtime &rt, const jsi::Value &eventHash, const jsi::Value &worklet) override;
-  void unregisterEventHandler(jsi::Runtime &rt, const jsi::Value &registrationId) override;
+  jsi::Value registerEventHandler(
+      jsi::Runtime &rt,
+      const jsi::Value &eventHash,
+      const jsi::Value &worklet) override;
+  void unregisterEventHandler(
+      jsi::Runtime &rt,
+      const jsi::Value &registrationId) override;
 
-  jsi::Value getViewProp(jsi::Runtime &rt, const jsi::Value &viewTag, const jsi::Value &propName, const jsi::Value &callback) override;
+  jsi::Value getViewProp(
+      jsi::Runtime &rt,
+      const jsi::Value &viewTag,
+      const jsi::Value &propName,
+      const jsi::Value &callback) override;
 
   void onRender(double timestampMs);
   void onEvent(std::string eventName, std::string eventAsString);
@@ -63,14 +72,16 @@ public:
 
   void maybeRequestRender();
   UpdaterFunction updaterFunction;
-private:
+
+ private:
   std::shared_ptr<MapperRegistry> mapperRegistry;
   std::shared_ptr<EventHandlerRegistry> eventHandlerRegistry;
-  std::function<void(FrameCallback&, jsi::Runtime&)> requestRender;
+  std::function<void(FrameCallback &, jsi::Runtime &)> requestRender;
   std::shared_ptr<jsi::Value> dummyEvent;
   std::vector<FrameCallback> frameCallbacks;
   bool renderRequested = false;
-  std::function<jsi::Value(jsi::Runtime &, const int, const jsi::String &)> propObtainer;
+  std::function<jsi::Value(jsi::Runtime &, const int, const jsi::String &)>
+      propObtainer;
   std::function<void(double)> onRenderCallback;
   std::shared_ptr<LayoutAnimationsProxy> layoutAnimationsProxy;
 };

package/Common/cpp/headers/NativeModules/NativeReanimatedModuleSpec.h

@@ -5,9 +5,9 @@
 #include <vector>
 
 #ifdef ONANDROID
-  #include "TurboModule.h"
+#include "TurboModule.h"
 #else
-  #include <ReactCommon/TurboModule.h>
+#include <ReactCommon/TurboModule.h>
 #endif
 
 #include <ReactCommon/CallInvoker.h>
@@ -15,37 +15,49 @@
 using namespace facebook;
 using namespace react;
 
-namespace reanimated
-{
+namespace reanimated {
 
 class JSI_EXPORT NativeReanimatedModuleSpec : public TurboModule {
  protected:
   NativeReanimatedModuleSpec(std::shared_ptr<CallInvoker> jsInvoker);
 
  public:
-  virtual void installCoreFunctions(jsi::Runtime &rt, const jsi::Value &valueSetter) = 0;
+  virtual void installCoreFunctions(
+      jsi::Runtime &rt,
+      const jsi::Value &valueSetter) = 0;
 
   // SharedValue
-  virtual jsi::Value makeShareable(jsi::Runtime &rt, const jsi::Value &value) = 0;
+  virtual jsi::Value makeShareable(
+      jsi::Runtime &rt,
+      const jsi::Value &value) = 0;
   virtual jsi::Value makeMutable(jsi::Runtime &rt, const jsi::Value &value) = 0;
   virtual jsi::Value makeRemote(jsi::Runtime &rt, const jsi::Value &value) = 0;
 
   // mappers
-  virtual jsi::Value startMapper(jsi::Runtime &rt,
-                                 const jsi::Value &worklet,
-                                 const jsi::Value &inputs,
-                                 const jsi::Value &outputs,
-                                 const jsi::Value &updater,
-                                 const jsi::Value &tag,
-                                 const jsi::Value &name) = 0;
+  virtual jsi::Value startMapper(
+      jsi::Runtime &rt,
+      const jsi::Value &worklet,
+      const jsi::Value &inputs,
+      const jsi::Value &outputs,
+      const jsi::Value &updater,
+      const jsi::Value &viewDescriptors) = 0;
   virtual void stopMapper(jsi::Runtime &rt, const jsi::Value &mapperId) = 0;
 
   // events
-  virtual jsi::Value registerEventHandler(jsi::Runtime &rt, const jsi::Value &eventHash, const jsi::Value &worklet) = 0;
-  virtual void unregisterEventHandler(jsi::Runtime &rt, const jsi::Value &registrationId) = 0;
+  virtual jsi::Value registerEventHandler(
+      jsi::Runtime &rt,
+      const jsi::Value &eventHash,
+      const jsi::Value &worklet) = 0;
+  virtual void unregisterEventHandler(
+      jsi::Runtime &rt,
+      const jsi::Value &registrationId) = 0;
 
   // views
-  virtual jsi::Value getViewProp(jsi::Runtime &rt, const jsi::Value &viewTag, const jsi::Value &propName, const jsi::Value &callback) = 0;
+  virtual jsi::Value getViewProp(
+      jsi::Runtime &rt,
+      const jsi::Value &viewTag,
+      const jsi::Value &propName,
+      const jsi::Value &callback) = 0;
 };
 
 } // namespace reanimated

package/Common/cpp/headers/Registries/EventHandlerRegistry.h

@@ -1,12 +1,12 @@
 #pragma once
 
-#include <vector>
+#include <jsi/jsi.h>
 #include <map>
+#include <mutex>
 #include <set>
-#include <unordered_map>
 #include <string>
-#include <jsi/jsi.h>
-#include <mutex>
+#include <unordered_map>
+#include <vector>
 
 using namespace facebook;
 
@@ -15,16 +15,22 @@ namespace reanimated {
 class WorkletEventHandler;
 
 class EventHandlerRegistry {
-  std::map<std::string, std::unordered_map<unsigned long, std::shared_ptr<WorkletEventHandler>>> eventMappings;
+  std::map<
+      std::string,
+      std::unordered_map<unsigned long, std::shared_ptr<WorkletEventHandler>>>
+      eventMappings;
   std::map<unsigned long, std::shared_ptr<WorkletEventHandler>> eventHandlers;
   std::mutex instanceMutex;
 
-public:
+ public:
   void registerEventHandler(std::shared_ptr<WorkletEventHandler> eventHandler);
   void unregisterEventHandler(unsigned long id);
 
-  void processEvent(jsi::Runtime &rt, std::string eventName, std::string eventPayload);
+  void processEvent(
+      jsi::Runtime &rt,
+      std::string eventName,
+      std::string eventPayload);
   bool isAnyHandlerWaitingForEvent(std::string eventName);
 };
 
-}
+} // namespace reanimated

package/Common/cpp/headers/Registries/MapperRegistry.h

@@ -1,8 +1,8 @@
 #pragma once
 
-#include <vector>
-#include <unordered_map>
 #include <jsi/jsi.h>
+#include <unordered_map>
+#include <vector>
 
 using namespace facebook;
 
@@ -16,7 +16,7 @@ class MapperRegistry {
   void updateOrder();
   bool updatedSinceLastExecute = false;
 
-public:
+ public:
   void startMapper(std::shared_ptr<Mapper> mapper);
   void stopMapper(unsigned long id);
 
@@ -25,4 +25,4 @@ public:
   bool needRunOnRender();
 };
 
-}
+} // namespace reanimated

package/Common/cpp/headers/Registries/WorkletsCache.h

@@ -1,22 +1,24 @@
 #pragma once
 
-#include <stdio.h>
-#include <unordered_map>
 #include <jsi/jsi.h>
+#include <stdio.h>
 #include <memory>
+#include <unordered_map>
 
-namespace reanimated
-{
+namespace reanimated {
 
 using namespace facebook;
 
 class FrozenObject;
 
 class WorkletsCache {
-private:
+ private:
   std::unordered_map<long long, std::shared_ptr<jsi::Function>> worklets;
-public:
-  std::shared_ptr<jsi::Function> getFunction(jsi::Runtime & rt, std::shared_ptr<reanimated::FrozenObject> frozenObj);
+
+ public:
+  std::shared_ptr<jsi::Function> getFunction(
+      jsi::Runtime &rt,
+      std::shared_ptr<reanimated::FrozenObject> frozenObj);
 };
 
 } // namespace reanimated

package/Common/cpp/headers/SharedItems/FrozenObject.h

@@ -1,9 +1,9 @@
 #pragma once
 
-#include "WorkletsCache.h"
-#include "SharedParent.h"
-#include "RuntimeManager.h"
 #include <jsi/jsi.h>
+#include "RuntimeManager.h"
+#include "SharedParent.h"
+#include "WorkletsCache.h"
 
 using namespace facebook;
 
@@ -11,18 +11,22 @@ namespace reanimated {
 
 class FrozenObject : public jsi::HostObject {
   friend WorkletsCache;
-  friend void extractMutables(jsi::Runtime &rt,
-                              std::shared_ptr<ShareableValue> sv,
-                              std::vector<std::shared_ptr<MutableValue>> &res);
+  friend void extractMutables(
+      jsi::Runtime &rt,
+      std::shared_ptr<ShareableValue> sv,
+      std::vector<std::shared_ptr<MutableValue>> &res);
 
-  private:
+ private:
   std::unordered_map<std::string, std::shared_ptr<ShareableValue>> map;
+  std::vector<std::string> namesOrder;
 
-  public:
-
-  FrozenObject(jsi::Runtime &rt, const jsi::Object &object, RuntimeManager *runtimeManager);
+ public:
+  FrozenObject(
+      jsi::Runtime &rt,
+      const jsi::Object &object,
+      RuntimeManager *runtimeManager);
   jsi::Object shallowClone(jsi::Runtime &rt);
   bool containsHostFunction = false;
 };
 
-}
+} // namespace reanimated

package/Common/cpp/headers/SharedItems/HostFunctionHandler.h

@@ -2,23 +2,25 @@
 
 #include <jsi/jsi.h>
 
+using namespace facebook;
+
 namespace reanimated {
 
 struct HostFunctionHandler : jsi::HostObject {
   std::shared_ptr<jsi::Function> pureFunction;
   std::string functionName;
   jsi::Runtime *hostRuntime;
-    jsi::HostObject a;
-    
+  jsi::HostObject a;
+
   HostFunctionHandler(std::shared_ptr<jsi::Function> f, jsi::Runtime &rt) {
     pureFunction = f;
     functionName = f->getProperty(rt, "name").asString(rt).utf8(rt);
     hostRuntime = &rt;
   }
-  
+
   std::shared_ptr<jsi::Function> getPureFunction() {
     return pureFunction;
   }
 };
 
-}
+} // namespace reanimated

package/Common/cpp/headers/SharedItems/MutableValue.h

@@ -1,20 +1,22 @@
 #pragma once
 
-#include "SharedParent.h"
-#include "MutableValueSetterProxy.h"
-#include <mutex>
 #include <jsi/jsi.h>
 #include <map>
+#include <mutex>
 #include "JSIStoreValueUser.h"
-#include "RuntimeManager.h"
 #include "LayoutAnimationsProxy.h"
+#include "MutableValueSetterProxy.h"
+#include "RuntimeManager.h"
+#include "SharedParent.h"
 
 using namespace facebook;
 
 namespace reanimated {
 
-class MutableValue : public jsi::HostObject, public std::enable_shared_from_this<MutableValue>, public StoreUser {
-private:
+class MutableValue : public jsi::HostObject,
+                     public std::enable_shared_from_this<MutableValue>,
+                     public StoreUser {
+ private:
   friend MutableValueSetterProxy;
   RuntimeManager *runtimeManager;
   friend LayoutAnimationsProxy;
@@ -26,15 +28,22 @@ private:
   void setValue(jsi::Runtime &rt, const jsi::Value &newValue);
   jsi::Value getValue(jsi::Runtime &rt);
 
-public:
-  MutableValue(jsi::Runtime &rt, const jsi::Value &initial, RuntimeManager *runtimeManager, std::shared_ptr<Scheduler> s);
+ public:
+  MutableValue(
+      jsi::Runtime &rt,
+      const jsi::Value &initial,
+      RuntimeManager *runtimeManager,
+      std::shared_ptr<Scheduler> s);
 
-public:
-  void set(jsi::Runtime &rt, const jsi::PropNameID &name, const jsi::Value &value);
+ public:
+  void
+  set(jsi::Runtime &rt, const jsi::PropNameID &name, const jsi::Value &value);
   jsi::Value get(jsi::Runtime &rt, const jsi::PropNameID &name);
   std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt);
-  unsigned long addListener(unsigned long listenerId, std::function<void()> listener);
+  unsigned long addListener(
+      unsigned long listenerId,
+      std::function<void()> listener);
   void removeListener(unsigned long listenerId);
 };
 
-}
+} // namespace reanimated

package/Common/cpp/headers/SharedItems/MutableValueSetterProxy.h

@@ -1,20 +1,23 @@
 #pragma once
 
-#include "SharedParent.h"
 #include <jsi/jsi.h>
+#include "SharedParent.h"
 
 using namespace facebook;
 
 namespace reanimated {
 
-class MutableValueSetterProxy: public jsi::HostObject {
-private:
+class MutableValueSetterProxy : public jsi::HostObject {
+ private:
   friend MutableValue;
   std::shared_ptr<MutableValue> mutableValue;
-public:
-  MutableValueSetterProxy(std::shared_ptr<MutableValue> mutableValue): mutableValue(std::move(mutableValue)) {}
-  void set(jsi::Runtime &rt, const jsi::PropNameID &name, const jsi::Value &value);
+
+ public:
+  MutableValueSetterProxy(std::shared_ptr<MutableValue> mutableValue)
+      : mutableValue(std::move(mutableValue)) {}
+  void
+  set(jsi::Runtime &rt, const jsi::PropNameID &name, const jsi::Value &value);
   jsi::Value get(jsi::Runtime &rt, const jsi::PropNameID &name);
 };
 
-}
+} // namespace reanimated

package/Common/cpp/headers/SharedItems/RemoteObject.h

@@ -1,24 +1,32 @@
 #pragma once
 
-#include "SharedParent.h"
 #include "FrozenObject.h"
 #include "JSIStoreValueUser.h"
+#include "SharedParent.h"
 
 using namespace facebook;
 
 namespace reanimated {
 
-class RemoteObject: public jsi::HostObject, public StoreUser {
-private:
+class RemoteObject : public jsi::HostObject, public StoreUser {
+ private:
   std::weak_ptr<jsi::Value> backing;
   std::unique_ptr<FrozenObject> initializer;
-public:
+
+ public:
   void maybeInitializeOnWorkletRuntime(jsi::Runtime &rt);
-  RemoteObject(jsi::Runtime &rt, jsi::Object &object, RuntimeManager *runtimeManager, std::shared_ptr<Scheduler> s):
-     StoreUser(s), initializer(std::make_unique<FrozenObject>(rt, object, runtimeManager)) {}
-  void set(jsi::Runtime &rt, const jsi::PropNameID &name, const jsi::Value &value);
+  RemoteObject(
+      jsi::Runtime &rt,
+      jsi::Object &object,
+      RuntimeManager *runtimeManager,
+      std::shared_ptr<Scheduler> s)
+      : StoreUser(s, *runtimeManager),
+        initializer(
+            std::make_unique<FrozenObject>(rt, object, runtimeManager)) {}
+  void
+  set(jsi::Runtime &rt, const jsi::PropNameID &name, const jsi::Value &value);
   jsi::Value get(jsi::Runtime &rt, const jsi::PropNameID &name);
   std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt);
 };
 
-}
+} // namespace reanimated

package/Common/cpp/headers/SharedItems/RuntimeManager.h

@@ -1,12 +1,13 @@
 #pragma once
 
-#include "ShareableValue.h"
+#include <jsi/jsi.h>
+#include <memory>
 #include "ErrorHandler.h"
+#include "JSIStoreValueUser.h"
+#include "RuntimeDecorator.h"
 #include "Scheduler.h"
+#include "ShareableValue.h"
 #include "WorkletsCache.h"
-#include "RuntimeDecorator.h"
-#include <jsi/jsi.h>
-#include <memory>
 
 namespace reanimated {
 
@@ -16,24 +17,28 @@ using namespace facebook;
  A class that manages a jsi::Runtime apart from the React-JS runtime.
  */
 class RuntimeManager {
-public:
+ public:
   RuntimeManager(
-    std::shared_ptr<jsi::Runtime> runtime,
-    std::shared_ptr<ErrorHandler> errorHandler,
-    std::shared_ptr<Scheduler> scheduler,
-    RuntimeType runtimeType = RuntimeType::Worklet
-  ) : 
-    runtime(runtime), 
-    errorHandler(errorHandler), 
-    scheduler(scheduler), 
-    workletsCache(std::make_unique<WorkletsCache>()) 
-  { 
+      std::shared_ptr<jsi::Runtime> runtime,
+      std::shared_ptr<ErrorHandler> errorHandler,
+      std::shared_ptr<Scheduler> scheduler,
+      RuntimeType runtimeType = RuntimeType::Worklet)
+      : runtime(runtime),
+        errorHandler(errorHandler),
+        scheduler(scheduler),
+        workletsCache(std::make_unique<WorkletsCache>()),
+        storeUserData(std::make_shared<StaticStoreUser>()) {
     RuntimeDecorator::registerRuntime(this->runtime.get(), runtimeType);
   }
-public:
+
+  virtual ~RuntimeManager() {
+    clearStore();
+  }
+
+ public:
   /**
-   Holds the jsi::Function worklet that is responsible for updating values in JS.
-   Can be null.
+   Holds the jsi::Function worklet that is responsible for updating values in
+   JS. Can be null.
    */
   std::shared_ptr<ShareableValue> valueSetter;
   /**
@@ -45,13 +50,26 @@ public:
    */
   std::shared_ptr<ErrorHandler> errorHandler;
   /**
-   Holds the Scheduler that is responsible for scheduling work on the UI- or React-JS Thread.
+   Holds the Scheduler that is responsible for scheduling work on the UI- or
+   React-JS Thread.
    */
   std::shared_ptr<Scheduler> scheduler;
   /**
-   Holds a list of adapted Worklets which are cached to avoid unneccessary recreation.
+   Holds a list of adapted Worklets which are cached to avoid unneccessary
+   recreation.
    */
   std::unique_ptr<WorkletsCache> workletsCache;
+  /**
+   Holds the JSI-Value Store where JSI::Values are cached on a
+   per-RuntimeManager basis.
+   */
+  std::shared_ptr<StaticStoreUser> storeUserData;
+
+ private:
+  void clearStore() {
+    const std::lock_guard<std::recursive_mutex> lock(storeUserData->storeMutex);
+    storeUserData->store.clear();
+  }
 };
 
-}
+} // namespace reanimated