react-native-reanimated 2.3.0-alpha.3 → 2.3.0-beta.4

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

@@ -1,55 +1,60 @@
 #pragma once
 
-#include "WorkletsCache.h"
-#include "SharedParent.h"
-#include "ValueWrapper.h"
+#include <jsi/jsi.h>
+#include <memory>
+#include <mutex>
+#include <string>
+#include <unordered_map>
+#include <vector>
 #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(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,12 +8,15 @@ 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 */
-  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 */
+  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
 };
 
 class ShareableValue;
@@ -21,4 +24,4 @@ class MutableValue;
 class RemoteObject;
 class NativeReanimatedModule;
 
-}
+} // namespace reanimated

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

@@ -1,132 +1,155 @@
 #pragma once
 
-#include "WorkletsCache.h"
-#include "SharedParent.h"
 #include <jsi/jsi.h>
+#include <memory>
 #include <string>
-#include "JSIStoreValueUser.h"
+#include <vector>
 #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() {}
+  explicit 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:
-  BooleanValueWrapper(const bool _value)
-    : ValueWrapper(ValueType::BoolType), value(_value) {};
+ public:
+  explicit BooleanValueWrapper(const bool _value)
+      : ValueWrapper(ValueType::BoolType), value(_value) {}
   bool value;
 };
 
 class NumberValueWrapper : public ValueWrapper {
-public:
-  NumberValueWrapper(const double _value)
-    : ValueWrapper(ValueType::NumberType), value(_value) {};
+ public:
+  explicit NumberValueWrapper(const double _value)
+      : ValueWrapper(ValueType::NumberType), value(_value) {}
   double value;
 };
 
 class StringValueWrapper : public ValueWrapper {
-public:
-  StringValueWrapper(const std::string & _value)
-    : ValueWrapper(ValueType::StringType), value(_value) {};
+ public:
+  explicit 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:
+  explicit 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:
+  explicit 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:
+  explicit 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) {}
+  explicit 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:
+  explicit 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 double ValueWrapper::asNumber(const std::unique_ptr<ValueWrapper>& valueContainer) {
-  return static_cast<NumberValueWrapper*>(valueContainer.get())->value;
-};
+inline bool ValueWrapper::asBoolean(
+    const std::unique_ptr<ValueWrapper> &valueContainer) {
+  return static_cast<BooleanValueWrapper *>(valueContainer.get())->value;
+}
 
-inline const std::string& ValueWrapper::asString(const std::unique_ptr<ValueWrapper>& valueContainer) {
-  return static_cast<StringValueWrapper*>(valueContainer.get())->value;
-};
+inline double ValueWrapper::asNumber(
+    const std::unique_ptr<ValueWrapper> &valueContainer) {
+  return static_cast<NumberValueWrapper *>(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::string &ValueWrapper::asString(
+    const std::unique_ptr<ValueWrapper> &valueContainer) {
+  return static_cast<StringValueWrapper *>(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<HostFunctionHandler> &ValueWrapper::asHostFunction(
+    const std::unique_ptr<ValueWrapper> &valueContainer) {
+  return static_cast<HostFunctionWrapper *>(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<FrozenObject> &ValueWrapper::asFrozenObject(
+    const std::unique_ptr<ValueWrapper> &valueContainer) {
+  return static_cast<FrozenObjectWrapper *>(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<RemoteObject> &ValueWrapper::asRemoteObject(
+    const std::unique_ptr<ValueWrapper> &valueContainer) {
+  return static_cast<RemoteObjectWrapper *>(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 std::vector<std::shared_ptr<ShareableValue>>
+    &ValueWrapper::asFrozenArray(
+        const std::unique_ptr<ValueWrapper> &valueContainer) {
+  return static_cast<FrozenArrayWrapper *>(valueContainer.get())->value;
+}
 
-inline const HostFunctionWrapper* ValueWrapper::asHostFunctionWrapper(const std::unique_ptr<ValueWrapper>& valueContainer) {
-  return static_cast<HostFunctionWrapper*>(valueContainer.get());
-};
+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());
 }
+
+} // namespace reanimated

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

@@ -1,10 +1,10 @@
 #pragma once
 
-#include "Scheduler.h"
+#include <memory>
 #include <string>
+#include "Scheduler.h"
 
-namespace reanimated
-{
+namespace reanimated {
 
 struct ErrorWrapper {
   std::string message = "";
@@ -12,22 +12,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/FeaturesConfig.h

@@ -0,0 +1,19 @@
+#pragma once
+#include <string>
+
+namespace reanimated {
+
+class FeaturesConfig {
+ public:
+  static inline bool isLayoutAnimationEnabled() {
+    return _isLayoutAnimationEnabled;
+  }
+  static inline void setLayoutAnimationEnabled(bool isLayoutAnimationEnabled) {
+    _isLayoutAnimationEnabled = isLayoutAnimationEnabled;
+  }
+
+ private:
+  static bool _isLayoutAnimationEnabled;
+};
+
+} // namespace reanimated

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

@@ -1,12 +1,11 @@
-#ifndef JSIStoreValueUser_h
-#define JSIStoreValueUser_h
+#pragma once
 
+#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;
@@ -16,25 +15,23 @@ 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;
+  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;
   std::weak_ptr<Scheduler> scheduler;
   std::shared_ptr<StaticStoreUser> storeUserData;
-  
-public:
-  StoreUser(std::shared_ptr<Scheduler> s, RuntimeManager &runtimeManager);
-  
+
+ public:
+  StoreUser(std::shared_ptr<Scheduler> s, const RuntimeManager &runtimeManager);
+
   std::weak_ptr<jsi::Value> getWeakRef(jsi::Runtime &rt);
   void removeRefs();
-  
+
   virtual ~StoreUser();
 };
 
-}
-
-#endif /* JSIStoreValueUser_h */
+} // namespace reanimated

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

@@ -1,9 +1,11 @@
 #pragma once
 
-#include "ShareableValue.h"
-#include "NativeReanimatedModule.h"
-#include <stdio.h>
 #include <jsi/jsi.h>
+#include <stdio.h>
+#include <memory>
+#include <vector>
+#include "NativeReanimatedModule.h"
+#include "ShareableValue.h"
 
 using namespace facebook;
 
@@ -18,7 +20,8 @@ struct ViewDescriptor {
 
 class Mapper : public std::enable_shared_from_this<Mapper> {
   friend MapperRegistry;
-private:
+
+ private:
   unsigned long id;
   NativeReanimatedModule *module;
   std::shared_ptr<jsi::Function> mapper;
@@ -26,23 +29,23 @@ private:
   std::vector<std::shared_ptr<MutableValue>> outputs;
   bool dirty = true;
   std::shared_ptr<jsi::Function> userUpdater;
-  UpdaterFunction* updateProps;
+  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);
+ 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
-  );
+      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,18 +1,27 @@
 #pragma once
 
-#include <stdio.h>
 #include <jsi/jsi.h>
+#include <stdio.h>
+#include <string>
+#include <utility>
+#include <vector>
 
 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)>;
+using SetGestureStateFunction = std::function<void(int, int)>;
 
 struct PlatformDepMethodsHolder {
   RequestRender requestRender;
@@ -20,6 +29,7 @@ struct PlatformDepMethodsHolder {
   ScrollToFunction scrollToFunction;
   MeasuringFunction measuringFunction;
   TimeProviderFunction getCurrentTime;
+  SetGestureStateFunction setGestureStateFunction;
 };
 
-}
+} // namespace reanimated

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

@@ -1,15 +1,11 @@
-
-#ifndef REANIMATEDEXAMPLE_REANIMATEDHIDDEN_H
-#define REANIMATEDEXAMPLE_REANIMATEDHIDDEN_H
+#pragma once
 
 #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