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

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

@@ -1,54 +1,58 @@
 #pragma once
 
-#include "WorkletsCache.h"
-#include "SharedParent.h"
-#include "ValueWrapper.h"
+#include <jsi/jsi.h>
+#include <mutex>
+#include <string>
+#include <unordered_map>
 #include "HostFunctionHandler.h"
 #include "JSIStoreValueUser.h"
+#include "LayoutAnimationsProxy.h"
 #include "RuntimeManager.h"
 #include "Scheduler.h"
-#include <string>
-#include <mutex>
-#include <unordered_map>
-#include <jsi/jsi.h>
-#include "LayoutAnimationsProxy.h"
+#include "SharedParent.h"
+#include "ValueWrapper.h"
+#include "WorkletsCache.h"
 
 using namespace facebook;
 
 namespace reanimated {
 
-class ShareableValue: public std::enable_shared_from_this<ShareableValue>, public StoreUser {
-friend WorkletsCache;
-friend FrozenObject;
-friend LayoutAnimationsProxy;
-friend void extractMutables(jsi::Runtime &rt,
-                            std::shared_ptr<ShareableValue> sv,
-                            std::vector<std::shared_ptr<MutableValue>> &res);
-
-private:
+class ShareableValue : public std::enable_shared_from_this<ShareableValue>,
+                       public StoreUser {
+  friend WorkletsCache;
+  friend FrozenObject;
+  friend LayoutAnimationsProxy;
+  friend void extractMutables(
+      jsi::Runtime &rt,
+      std::shared_ptr<ShareableValue> sv,
+      std::vector<std::shared_ptr<MutableValue>> &res);
+
+ private:
   RuntimeManager *runtimeManager;
   std::unique_ptr<ValueWrapper> valueContainer;
   std::unique_ptr<jsi::Value> hostValue;
   std::weak_ptr<jsi::Value> remoteValue;
   bool containsHostFunction = false;
 
-  ShareableValue(RuntimeManager *runtimeManager, std::shared_ptr<Scheduler> s): StoreUser(s), runtimeManager(runtimeManager) {}
+  ShareableValue(RuntimeManager *runtimeManager, std::shared_ptr<Scheduler> s)
+      : StoreUser(s, *runtimeManager), runtimeManager(runtimeManager) {}
 
   jsi::Value toJSValue(jsi::Runtime &rt);
-  jsi::Object createHost(jsi::Runtime &rt, std::shared_ptr<jsi::HostObject> host);
+  jsi::Object createHost(
+      jsi::Runtime &rt,
+      std::shared_ptr<jsi::HostObject> host);
   void adapt(jsi::Runtime &rt, const jsi::Value &value, ValueType objectType);
   void adaptCache(jsi::Runtime &rt, const jsi::Value &value);
+  std::string demangleExceptionName(std::string toDemangle);
 
-public:
+ public:
   ValueType type = ValueType::UndefinedType;
   static std::shared_ptr<ShareableValue> adapt(
-    jsi::Runtime &rt,
-    const jsi::Value &value,
-    RuntimeManager *runtimeManager,
-    ValueType objectType = ValueType::UndefinedType
-  );
+      jsi::Runtime &rt,
+      const jsi::Value &value,
+      RuntimeManager *runtimeManager,
+      ValueType objectType = ValueType::UndefinedType);
   jsi::Value getValue(jsi::Runtime &rt);
-
 };
 
-}
+} // namespace reanimated

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

@@ -8,9 +8,12 @@ enum class ValueType {
   BoolType,
   NumberType,
   StringType,
-  RemoteObjectType, /* object that can be instantiated on host side and modified on the remote (worklet) side */
-  MutableValueType, /* object with 'value' property that can be updated and read from any thread */
-  HostFunctionType, /* function that will be executed asynchronously on the host runtime */
+  RemoteObjectType, /* object that can be instantiated on host side and modified
+                       on the remote (worklet) side */
+  MutableValueType, /* object with 'value' property that can be updated and read
+                       from any thread */
+  HostFunctionType, /* function that will be executed asynchronously on the host
+                       runtime */
   WorkletFunctionType, /* function that gets run on the UI thread */
   FrozenObjectType, /* frozen object, can only be set and never modified */
   FrozenArrayType, /* frozen array, can only be set and never modified */
@@ -21,4 +24,4 @@ class MutableValue;
 class RemoteObject;
 class NativeReanimatedModule;
 
-}
+} // namespace reanimated

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

@@ -1,132 +1,151 @@
 #pragma once
 
-#include "WorkletsCache.h"
-#include "SharedParent.h"
 #include <jsi/jsi.h>
 #include <string>
-#include "JSIStoreValueUser.h"
 #include "HostFunctionHandler.h"
+#include "JSIStoreValueUser.h"
+#include "SharedParent.h"
+#include "WorkletsCache.h"
 
 namespace reanimated {
 
 class HostFunctionWrapper;
 
 class ValueWrapper {
-public:
-  ValueWrapper() {};
-  ValueWrapper(ValueType _type) : type(_type) {};
+ public:
+  ValueWrapper(){};
+  ValueWrapper(ValueType _type) : type(_type){};
   ValueType getType() const {
     return type;
   }
 
   virtual ~ValueWrapper() {}
 
-  static inline bool asBoolean(const std::unique_ptr<ValueWrapper>& valueContainer);
-  static inline double asNumber(const std::unique_ptr<ValueWrapper>& valueContainer);
-  static inline const std::string& asString(const std::unique_ptr<ValueWrapper>& valueContainer);
-  static inline const std::shared_ptr<HostFunctionHandler>& asHostFunction(const std::unique_ptr<ValueWrapper>& valueContainer);
-  static inline const std::shared_ptr<FrozenObject>& asFrozenObject(const std::unique_ptr<ValueWrapper>& valueContainer);
-  static inline const std::shared_ptr<RemoteObject>& asRemoteObject(const std::unique_ptr<ValueWrapper>& valueContainer);
-  static inline std::vector<std::shared_ptr<ShareableValue>>& asFrozenArray(const std::unique_ptr<ValueWrapper>& valueContainer);
-  static inline const std::shared_ptr<MutableValue>& asMutableValue(const std::unique_ptr<ValueWrapper>& valueContainer);
-
-  static const HostFunctionWrapper* asHostFunctionWrapper(const std::unique_ptr<ValueWrapper>& valueContainer);
-
-protected:
-    ValueType type;
+  static inline bool asBoolean(
+      const std::unique_ptr<ValueWrapper> &valueContainer);
+  static inline double asNumber(
+      const std::unique_ptr<ValueWrapper> &valueContainer);
+  static inline const std::string &asString(
+      const std::unique_ptr<ValueWrapper> &valueContainer);
+  static inline const std::shared_ptr<HostFunctionHandler> &asHostFunction(
+      const std::unique_ptr<ValueWrapper> &valueContainer);
+  static inline const std::shared_ptr<FrozenObject> &asFrozenObject(
+      const std::unique_ptr<ValueWrapper> &valueContainer);
+  static inline const std::shared_ptr<RemoteObject> &asRemoteObject(
+      const std::unique_ptr<ValueWrapper> &valueContainer);
+  static inline std::vector<std::shared_ptr<ShareableValue>> &asFrozenArray(
+      const std::unique_ptr<ValueWrapper> &valueContainer);
+  static inline const std::shared_ptr<MutableValue> &asMutableValue(
+      const std::unique_ptr<ValueWrapper> &valueContainer);
+
+  static const HostFunctionWrapper *asHostFunctionWrapper(
+      const std::unique_ptr<ValueWrapper> &valueContainer);
+
+ protected:
+  ValueType type;
 };
 
 class BooleanValueWrapper : public ValueWrapper {
-public:
+ public:
   BooleanValueWrapper(const bool _value)
-    : ValueWrapper(ValueType::BoolType), value(_value) {};
+      : ValueWrapper(ValueType::BoolType), value(_value){};
   bool value;
 };
 
 class NumberValueWrapper : public ValueWrapper {
-public:
+ public:
   NumberValueWrapper(const double _value)
-    : ValueWrapper(ValueType::NumberType), value(_value) {};
+      : ValueWrapper(ValueType::NumberType), value(_value){};
   double value;
 };
 
 class StringValueWrapper : public ValueWrapper {
-public:
-  StringValueWrapper(const std::string & _value)
-    : ValueWrapper(ValueType::StringType), value(_value) {};
+ public:
+  StringValueWrapper(const std::string &_value)
+      : ValueWrapper(ValueType::StringType), value(_value){};
   std::string value;
 };
 
 class HostFunctionWrapper : public ValueWrapper {
-public:
-  HostFunctionWrapper(const std::shared_ptr<HostFunctionHandler> & _value)
-    : ValueWrapper(ValueType::HostFunctionType), value(_value) {};
+ public:
+  HostFunctionWrapper(const std::shared_ptr<HostFunctionHandler> &_value)
+      : ValueWrapper(ValueType::HostFunctionType), value(_value){};
   std::shared_ptr<HostFunctionHandler> value;
 };
 
 class FrozenObjectWrapper : public ValueWrapper {
-public:
-  FrozenObjectWrapper(const std::shared_ptr<FrozenObject> & _value)
-    : ValueWrapper(ValueType::FrozenObjectType), value(_value) {};
+ public:
+  FrozenObjectWrapper(const std::shared_ptr<FrozenObject> &_value)
+      : ValueWrapper(ValueType::FrozenObjectType), value(_value){};
   std::shared_ptr<FrozenObject> value;
 };
 
 class RemoteObjectWrapper : public ValueWrapper {
-public:
-  RemoteObjectWrapper(const std::shared_ptr<RemoteObject> & _value)
-    : ValueWrapper(ValueType::RemoteObjectType), value(_value) {};
+ public:
+  RemoteObjectWrapper(const std::shared_ptr<RemoteObject> &_value)
+      : ValueWrapper(ValueType::RemoteObjectType), value(_value){};
   std::shared_ptr<RemoteObject> value;
 };
 
 class FrozenArrayWrapper : public ValueWrapper {
-public:
-  FrozenArrayWrapper() : ValueWrapper(ValueType::FrozenArrayType) {};
-  FrozenArrayWrapper(const std::vector<std::shared_ptr<ShareableValue>> & _value)
-    : ValueWrapper(ValueType::FrozenArrayType), value(_value) {};
+ public:
+  FrozenArrayWrapper() : ValueWrapper(ValueType::FrozenArrayType){};
+  FrozenArrayWrapper(const std::vector<std::shared_ptr<ShareableValue>> &_value)
+      : ValueWrapper(ValueType::FrozenArrayType), value(_value){};
   std::vector<std::shared_ptr<ShareableValue>> value;
 };
 
 class MutableValueWrapper : public ValueWrapper {
-public:
-  MutableValueWrapper(const std::shared_ptr<MutableValue> & _value)
-    : ValueWrapper(ValueType::MutableValueType), value(_value) {};
+ public:
+  MutableValueWrapper(const std::shared_ptr<MutableValue> &_value)
+      : ValueWrapper(ValueType::MutableValueType), value(_value){};
   std::shared_ptr<MutableValue> value;
 };
 
-inline bool ValueWrapper::asBoolean(const std::unique_ptr<ValueWrapper>& valueContainer) {
-  return static_cast<BooleanValueWrapper*>(valueContainer.get())->value;
+inline bool ValueWrapper::asBoolean(
+    const std::unique_ptr<ValueWrapper> &valueContainer) {
+  return static_cast<BooleanValueWrapper *>(valueContainer.get())->value;
 };
 
-inline double ValueWrapper::asNumber(const std::unique_ptr<ValueWrapper>& valueContainer) {
-  return static_cast<NumberValueWrapper*>(valueContainer.get())->value;
+inline double ValueWrapper::asNumber(
+    const std::unique_ptr<ValueWrapper> &valueContainer) {
+  return static_cast<NumberValueWrapper *>(valueContainer.get())->value;
 };
 
-inline const std::string& ValueWrapper::asString(const std::unique_ptr<ValueWrapper>& valueContainer) {
-  return static_cast<StringValueWrapper*>(valueContainer.get())->value;
+inline const std::string &ValueWrapper::asString(
+    const std::unique_ptr<ValueWrapper> &valueContainer) {
+  return static_cast<StringValueWrapper *>(valueContainer.get())->value;
 };
 
-inline const std::shared_ptr<HostFunctionHandler>& ValueWrapper::asHostFunction(const std::unique_ptr<ValueWrapper>& valueContainer) {
-  return static_cast<HostFunctionWrapper*>(valueContainer.get())->value;
+inline const std::shared_ptr<HostFunctionHandler> &ValueWrapper::asHostFunction(
+    const std::unique_ptr<ValueWrapper> &valueContainer) {
+  return static_cast<HostFunctionWrapper *>(valueContainer.get())->value;
 };
 
-inline const std::shared_ptr<FrozenObject>& ValueWrapper::asFrozenObject(const std::unique_ptr<ValueWrapper>& valueContainer) {
-  return static_cast<FrozenObjectWrapper*>(valueContainer.get())->value;
+inline const std::shared_ptr<FrozenObject> &ValueWrapper::asFrozenObject(
+    const std::unique_ptr<ValueWrapper> &valueContainer) {
+  return static_cast<FrozenObjectWrapper *>(valueContainer.get())->value;
 };
 
-inline const std::shared_ptr<RemoteObject>& ValueWrapper::asRemoteObject(const std::unique_ptr<ValueWrapper>& valueContainer) {
-  return static_cast<RemoteObjectWrapper*>(valueContainer.get())->value;
+inline const std::shared_ptr<RemoteObject> &ValueWrapper::asRemoteObject(
+    const std::unique_ptr<ValueWrapper> &valueContainer) {
+  return static_cast<RemoteObjectWrapper *>(valueContainer.get())->value;
 };
 
-inline std::vector<std::shared_ptr<ShareableValue>>& ValueWrapper::asFrozenArray(const std::unique_ptr<ValueWrapper>& valueContainer) {
-  return static_cast<FrozenArrayWrapper*>(valueContainer.get())->value;
+inline std::vector<std::shared_ptr<ShareableValue>>
+    &ValueWrapper::asFrozenArray(
+        const std::unique_ptr<ValueWrapper> &valueContainer) {
+  return static_cast<FrozenArrayWrapper *>(valueContainer.get())->value;
 };
 
-inline const std::shared_ptr<MutableValue>& ValueWrapper::asMutableValue(const std::unique_ptr<ValueWrapper>& valueContainer) {
-  return static_cast<MutableValueWrapper*>(valueContainer.get())->value;
+inline const std::shared_ptr<MutableValue> &ValueWrapper::asMutableValue(
+    const std::unique_ptr<ValueWrapper> &valueContainer) {
+  return static_cast<MutableValueWrapper *>(valueContainer.get())->value;
 };
 
-inline const HostFunctionWrapper* ValueWrapper::asHostFunctionWrapper(const std::unique_ptr<ValueWrapper>& valueContainer) {
-  return static_cast<HostFunctionWrapper*>(valueContainer.get());
+inline const HostFunctionWrapper *ValueWrapper::asHostFunctionWrapper(
+    const std::unique_ptr<ValueWrapper> &valueContainer) {
+  return static_cast<HostFunctionWrapper *>(valueContainer.get());
 };
 
-}
+} // namespace reanimated

package/Common/cpp/headers/SpecTools/ErrorHandler.h

@@ -1,10 +1,9 @@
 #pragma once
 
-#include "Scheduler.h"
 #include <string>
+#include "Scheduler.h"
 
-namespace reanimated
-{
+namespace reanimated {
 
 struct ErrorWrapper {
   std::string message = "";
@@ -12,22 +11,21 @@ struct ErrorWrapper {
 };
 
 class ErrorHandler {
-  public:
-    bool raise() {
-      if (getError()->handled) {
-        return false;
-      }
-      this->getScheduler()->scheduleOnUI([this]() mutable {
-        this->raiseSpec();
-      });
-      return true;
+ public:
+  bool raise() {
+    if (getError()->handled) {
+      return false;
     }
-    virtual std::shared_ptr<Scheduler> getScheduler() = 0;
-    virtual std::shared_ptr<ErrorWrapper> getError() = 0;
-    virtual void setError(std::string message) = 0;
-    virtual ~ErrorHandler() {}
-  protected:
-    virtual void raiseSpec() = 0;
+    this->getScheduler()->scheduleOnUI([this]() mutable { this->raiseSpec(); });
+    return true;
+  }
+  virtual std::shared_ptr<Scheduler> getScheduler() = 0;
+  virtual std::shared_ptr<ErrorWrapper> getError() = 0;
+  virtual void setError(std::string message) = 0;
+  virtual ~ErrorHandler() {}
+
+ protected:
+  virtual void raiseSpec() = 0;
 };
 
-}
+} // namespace reanimated

package/Common/cpp/headers/Tools/JSIStoreValueUser.h

@@ -1,35 +1,40 @@
 #ifndef JSIStoreValueUser_h
 #define JSIStoreValueUser_h
 
+#include <jsi/jsi.h>
 #include <stdio.h>
 #include <memory>
-#include <vector>
-#include <unordered_map>
-#include <jsi/jsi.h>
 #include <mutex>
+#include <unordered_map>
+#include <vector>
 #include "Scheduler.h"
 
 using namespace facebook;
 
 namespace reanimated {
 
+class RuntimeManager;
+
+struct StaticStoreUser {
+  std::atomic<int> ctr;
+  std::unordered_map<int, std::vector<std::shared_ptr<jsi::Value>>> store;
+  std::recursive_mutex storeMutex;
+};
+
 class StoreUser {
   int identifier = 0;
-  static std::atomic<int> ctr;
-  static std::unordered_map<int, std::vector<std::shared_ptr<jsi::Value>>> store;
-  static std::recursive_mutex storeMutex;
   std::weak_ptr<Scheduler> scheduler;
-  
-public:
-  StoreUser(std::shared_ptr<Scheduler> s);
-  
+  std::shared_ptr<StaticStoreUser> storeUserData;
+
+ public:
+  StoreUser(std::shared_ptr<Scheduler> s, RuntimeManager &runtimeManager);
+
   std::weak_ptr<jsi::Value> getWeakRef(jsi::Runtime &rt);
   void removeRefs();
-  
-  static void clearStore();
+
   virtual ~StoreUser();
 };
 
-}
+} // namespace reanimated
 
 #endif /* JSIStoreValueUser_h */

package/Common/cpp/headers/Tools/Mapper.h

@@ -1,9 +1,9 @@
 #pragma once
 
-#include "ShareableValue.h"
-#include "NativeReanimatedModule.h"
-#include <stdio.h>
 #include <jsi/jsi.h>
+#include <stdio.h>
+#include "NativeReanimatedModule.h"
+#include "ShareableValue.h"
 
 using namespace facebook;
 
@@ -11,9 +11,15 @@ namespace reanimated {
 
 class MapperRegistry;
 
+struct ViewDescriptor {
+  int tag;
+  jsi::Value name;
+};
+
 class Mapper : public std::enable_shared_from_this<Mapper> {
   friend MapperRegistry;
-private:
+
+ private:
   unsigned long id;
   NativeReanimatedModule *module;
   std::shared_ptr<jsi::Function> mapper;
@@ -21,23 +27,23 @@ private:
   std::vector<std::shared_ptr<MutableValue>> outputs;
   bool dirty = true;
   std::shared_ptr<jsi::Function> userUpdater;
-  UpdaterFunction* updateProps;
-  jsi::Value viewName;
-  int viewTag;
+  UpdaterFunction *updateProps;
   int optimalizationLvl = 0;
+  std::shared_ptr<ShareableValue> viewDescriptors;
 
-public:
-  Mapper(NativeReanimatedModule *module,
-         unsigned long id,
-         std::shared_ptr<jsi::Function> mapper,
-         std::vector<std::shared_ptr<MutableValue>> inputs,
-         std::vector<std::shared_ptr<MutableValue>> outputs,
-         std::shared_ptr<ShareableValue> updater,
-         const int viewTag,
-         const std::string& viewName,
-         const int optimalizationLvl);
+ public:
+  Mapper(
+      NativeReanimatedModule *module,
+      unsigned long id,
+      std::shared_ptr<jsi::Function> mapper,
+      std::vector<std::shared_ptr<MutableValue>> inputs,
+      std::vector<std::shared_ptr<MutableValue>> outputs);
   void execute(jsi::Runtime &rt);
+  void enableFastMode(
+      const int optimalizationLvl,
+      const std::shared_ptr<ShareableValue> &updater,
+      const std::shared_ptr<ShareableValue> &jsViewDescriptors);
   virtual ~Mapper();
 };
 
-}
+} // namespace reanimated

package/Common/cpp/headers/Tools/PlatformDepMethodsHolder.h

@@ -1,17 +1,22 @@
 #pragma once
 
-#include <stdio.h>
 #include <jsi/jsi.h>
+#include <stdio.h>
 
 using namespace facebook;
 
-namespace reanimated
-{
+namespace reanimated {
 
-using UpdaterFunction = std::function<void(jsi::Runtime &rt, int viewTag, const jsi::Value &viewName, const jsi::Object &object)>;
-using RequestRender = std::function<void(std::function<void(double)>, jsi::Runtime &rt)>;
+using UpdaterFunction = std::function<void(
+    jsi::Runtime &rt,
+    int viewTag,
+    const jsi::Value &viewName,
+    const jsi::Object &object)>;
+using RequestRender =
+    std::function<void(std::function<void(double)>, jsi::Runtime &rt)>;
 using ScrollToFunction = std::function<void(int, double, double, bool)>;
-using MeasuringFunction = std::function<std::vector<std::pair<std::string, double>>(int)>;
+using MeasuringFunction =
+    std::function<std::vector<std::pair<std::string, double>>(int)>;
 using TimeProviderFunction = std::function<double(void)>;
 
 struct PlatformDepMethodsHolder {
@@ -22,4 +27,4 @@ struct PlatformDepMethodsHolder {
   TimeProviderFunction getCurrentTime;
 };
 
-}
+} // namespace reanimated

package/Common/cpp/headers/Tools/ReanimatedHiddenHeaders.h

@@ -3,13 +3,13 @@
 #define REANIMATEDEXAMPLE_REANIMATEDHIDDEN_H
 
 #if defined(ONANDROID)
-    #include "Logger.h"
-    #include "LoggerInterface.h"
-    #include "SpeedChecker.h"
+#include "Logger.h"
+#include "LoggerInterface.h"
+#include "SpeedChecker.h"
 #else
-    #include "Common/cpp/hidden_headers/Logger.h"
-    #include "Common/cpp/hidden_headers/LoggerInterface.h"
-    #include "Common/cpp/hidden_headers/SpeedChecker.h"
+#include "Common/cpp/hidden_headers/Logger.h"
+#include "Common/cpp/hidden_headers/LoggerInterface.h"
+#include "Common/cpp/hidden_headers/SpeedChecker.h"
 #endif
 
-#endif //REANIMATEDEXAMPLE_REANIMATEDHIDDEN_H
+#endif // REANIMATEDEXAMPLE_REANIMATEDHIDDEN_H

package/Common/cpp/headers/Tools/RuntimeDecorator.h

@@ -1,10 +1,10 @@
 #pragma once
 
-#include "PlatformDepMethodsHolder.h"
+#include <jsi/jsi.h>
 #include <stdio.h>
 #include <unordered_map>
-#include <jsi/jsi.h>
 #include "LayoutAnimationsProxy.h"
+#include "PlatformDepMethodsHolder.h"
 
 using namespace facebook;
 
@@ -22,25 +22,27 @@ enum RuntimeType {
    */
   UI
 };
-typedef jsi::Runtime* RuntimePointer;
+typedef jsi::Runtime *RuntimePointer;
 
 class RuntimeDecorator {
-public:
+ public:
   static void decorateRuntime(jsi::Runtime &rt, const std::string &label);
-  static void decorateUIRuntime(jsi::Runtime &rt,
-                                const UpdaterFunction updater,
-                                const RequestFrameFunction requestFrame,
-                                const ScrollToFunction scrollTo,
-                                const MeasuringFunction measure,
-                                const TimeProviderFunction getCurrentTime,
-                                std::shared_ptr<LayoutAnimationsProxy> layoutAnimationsProxy);
-  
+  static void decorateUIRuntime(
+      jsi::Runtime &rt,
+      const UpdaterFunction updater,
+      const RequestFrameFunction requestFrame,
+      const ScrollToFunction scrollTo,
+      const MeasuringFunction measure,
+      const TimeProviderFunction getCurrentTime,
+      std::shared_ptr<LayoutAnimationsProxy> layoutAnimationsProxy);
+
   /**
    Returns true if the given Runtime is the Reanimated UI-Thread Runtime.
    */
   inline static bool isUIRuntime(jsi::Runtime &rt);
   /**
-   Returns true if the given Runtime is a Runtime that supports the concept of Workletization. (REA, Vision, ...)
+   Returns true if the given Runtime is a Runtime that supports the concept of
+   Workletization. (REA, Vision, ...)
    */
   inline static bool isWorkletRuntime(jsi::Runtime &rt);
   /**
@@ -48,31 +50,35 @@ public:
    */
   inline static bool isReactRuntime(jsi::Runtime &rt);
   /**
-   Register the given Runtime. This function is required for every RuntimeManager, otherwise future runtime checks will fail.
+   Register the given Runtime. This function is required for every
+   RuntimeManager, otherwise future runtime checks will fail.
    */
-  static void registerRuntime(jsi::Runtime* runtime, RuntimeType runtimeType);
+  static void registerRuntime(jsi::Runtime *runtime, RuntimeType runtimeType);
 
-private:
+ private:
   static std::unordered_map<RuntimePointer, RuntimeType> runtimeRegistry;
 };
 
-inline bool RuntimeDecorator::isUIRuntime(jsi::Runtime& rt) {
+inline bool RuntimeDecorator::isUIRuntime(jsi::Runtime &rt) {
   auto iterator = runtimeRegistry.find(&rt);
-  if (iterator == runtimeRegistry.end()) return false;
+  if (iterator == runtimeRegistry.end())
+    return false;
   return iterator->second == RuntimeType::UI;
 }
 
-inline bool RuntimeDecorator::isWorkletRuntime(jsi::Runtime& rt) {
+inline bool RuntimeDecorator::isWorkletRuntime(jsi::Runtime &rt) {
   auto iterator = runtimeRegistry.find(&rt);
-  if (iterator == runtimeRegistry.end()) return false;
+  if (iterator == runtimeRegistry.end())
+    return false;
   auto type = iterator->second;
   return type == RuntimeType::UI || type == RuntimeType::Worklet;
 }
 
-inline bool RuntimeDecorator::isReactRuntime(jsi::Runtime& rt) {
+inline bool RuntimeDecorator::isReactRuntime(jsi::Runtime &rt) {
   auto iterator = runtimeRegistry.find(&rt);
-  if (iterator == runtimeRegistry.end()) return true;
+  if (iterator == runtimeRegistry.end())
+    return true;
   return false;
 }
 
-}
+} // namespace reanimated