react-native-reanimated 3.0.0-rc.7 → 3.0.0-rc.8

package/Common/cpp/SharedItems/Shareables.h

@@ -0,0 +1,455 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#include <react/renderer/uimanager/primitives.h>
+#endif
+
+#include "ReanimatedRuntime.h"
+#include "RuntimeManager.h"
+#include "Scheduler.h"
+
+#define HAS_JS_WEAK_OBJECTS JS_RUNTIME_HERMES
+
+using namespace facebook;
+
+namespace reanimated {
+
+class CoreFunction;
+
+class JSRuntimeHelper {
+ private:
+  jsi::Runtime *rnRuntime_; // React-Native's main JS runtime
+  jsi::Runtime *uiRuntime_; // UI runtime created by Reanimated
+  std::shared_ptr<Scheduler> scheduler_;
+
+ public:
+  JSRuntimeHelper(
+      jsi::Runtime *rnRuntime,
+      jsi::Runtime *uiRuntime,
+      const std::shared_ptr<Scheduler> &scheduler)
+      : rnRuntime_(rnRuntime), uiRuntime_(uiRuntime), scheduler_(scheduler) {}
+
+  volatile bool uiRuntimeDestroyed;
+  std::shared_ptr<CoreFunction> valueUnpacker;
+
+  inline jsi::Runtime *uiRuntime() const {
+    return uiRuntime_;
+  }
+
+  inline jsi::Runtime *rnRuntime() const {
+    return rnRuntime_;
+  }
+
+  inline bool isUIRuntime(const jsi::Runtime &rt) const {
+    return &rt == uiRuntime_;
+  }
+
+  inline bool isRNRuntime(const jsi::Runtime &rt) const {
+    return &rt == rnRuntime_;
+  }
+
+  void scheduleOnUI(std::function<void()> job) {
+    scheduler_->scheduleOnUI(job);
+  }
+
+  void scheduleOnJS(std::function<void()> job) {
+    scheduler_->scheduleOnJS(job);
+  }
+};
+
+// Core functions are not allowed to capture outside variables, otherwise they'd
+// try to access _closure variable which is something we want to avoid for
+// simplicity reasons.
+class CoreFunction {
+ private:
+  std::unique_ptr<jsi::Function> rnFunction_;
+  std::unique_ptr<jsi::Function> uiFunction_;
+  std::string functionBody_;
+  std::string location_;
+  JSRuntimeHelper
+      *runtimeHelper_; // runtime helper holds core function references, so we
+                       // use normal pointer here to avoid ref cycles.
+  std::unique_ptr<jsi::Function> &getFunction(jsi::Runtime &rt);
+
+ public:
+  CoreFunction(JSRuntimeHelper *runtimeHelper, const jsi::Value &workletObject);
+  template <typename... Args>
+  jsi::Value call(jsi::Runtime &rt, Args &&...args) {
+    return getFunction(rt)->call(rt, args...);
+  }
+};
+
+class Shareable {
+ protected:
+  virtual jsi::Value toJSValue(jsi::Runtime &rt) = 0;
+
+ public:
+  virtual ~Shareable();
+
+  enum ValueType {
+    UndefinedType,
+    NullType,
+    BooleanType,
+    NumberType,
+    // SymbolType, TODO
+    // BigIntType, TODO
+    StringType,
+    ObjectType,
+    ArrayType,
+    WorkletType,
+    RemoteFunctionType,
+    HandleType,
+    SynchronizedDataHolder,
+#ifdef RCT_NEW_ARCH_ENABLED
+    ShadowNode,
+#endif
+  };
+
+  explicit Shareable(ValueType valueType) : valueType_(valueType) {}
+  virtual jsi::Value getJSValue(jsi::Runtime &rt) {
+    return toJSValue(rt);
+  }
+
+  inline ValueType valueType() const {
+    return valueType_;
+  }
+
+  static std::shared_ptr<Shareable> undefined();
+
+ protected:
+  ValueType valueType_;
+};
+
+class RetainingShareable : public Shareable {
+ protected:
+  std::shared_ptr<JSRuntimeHelper> runtimeHelper_;
+
+#if HAS_JS_WEAK_OBJECTS
+
+ private:
+  std::unique_ptr<jsi::WeakObject> remoteValue_;
+
+ public:
+  jsi::Value getJSValue(jsi::Runtime &rt) final;
+
+  RetainingShareable(
+      const std::shared_ptr<JSRuntimeHelper> &runtimeHelper,
+      jsi::Runtime &rt,
+      ValueType valueType)
+      : Shareable(valueType), runtimeHelper_(runtimeHelper) {}
+
+  ~RetainingShareable();
+#else
+
+ public:
+  RetainingShareable(
+      const std::shared_ptr<JSRuntimeHelper> &runtimeHelper,
+      jsi::Runtime &rt,
+      ValueType valueType)
+      : Shareable(valueType), runtimeHelper_(runtimeHelper) {}
+#endif
+};
+
+class ShareableJSRef : public jsi::HostObject {
+ private:
+  std::shared_ptr<Shareable> value_;
+
+ public:
+  explicit ShareableJSRef(std::shared_ptr<Shareable> value) : value_(value) {}
+  std::shared_ptr<Shareable> value() const {
+    return value_;
+  }
+
+  static jsi::Object newHostObject(
+      jsi::Runtime &rt,
+      const std::shared_ptr<Shareable> &value) {
+    return jsi::Object::createFromHostObject(
+        rt, std::make_shared<ShareableJSRef>(value));
+  }
+};
+
+std::shared_ptr<Shareable> extractShareableOrThrow(
+    jsi::Runtime &rt,
+    const jsi::Value &maybeShareableValue,
+    const char *errorMessage = nullptr);
+
+template <typename T>
+std::shared_ptr<T> extractShareableOrThrow(
+    jsi::Runtime &rt,
+    const jsi::Value &shareableRef,
+    const char *errorMessage = nullptr) {
+  auto res = std::dynamic_pointer_cast<T>(
+      extractShareableOrThrow(rt, shareableRef, errorMessage));
+  if (!res) {
+    throw new std::runtime_error(
+        errorMessage != nullptr
+            ? errorMessage
+            : "provided shareable object is of an incompatible type");
+  }
+  return res;
+}
+
+class ShareableArray : public RetainingShareable {
+ public:
+  ShareableArray(
+      const std::shared_ptr<JSRuntimeHelper> &runtimeHelper,
+      jsi::Runtime &rt,
+      const jsi::Array &array);
+
+  jsi::Value toJSValue(jsi::Runtime &rt) override {
+    auto size = data_.size();
+    auto ary = jsi::Array(rt, size);
+    for (size_t i = 0; i < size; i++) {
+      ary.setValueAtIndex(rt, i, data_[i]->getJSValue(rt));
+    }
+    return ary;
+  }
+
+ protected:
+  std::vector<std::shared_ptr<Shareable>> data_;
+};
+
+class ShareableObject : public RetainingShareable {
+ public:
+  ShareableObject(
+      const std::shared_ptr<JSRuntimeHelper> &runtimeHelper,
+      jsi::Runtime &rt,
+      const jsi::Object &object);
+  jsi::Value toJSValue(jsi::Runtime &rt) override {
+    auto obj = jsi::Object(rt);
+    for (size_t i = 0, size = data_.size(); i < size; i++) {
+      obj.setProperty(
+          rt, data_[i].first.c_str(), data_[i].second->getJSValue(rt));
+    }
+    return obj;
+  }
+
+ protected:
+  std::vector<std::pair<std::string, std::shared_ptr<Shareable>>> data_;
+};
+
+#ifdef RCT_NEW_ARCH_ENABLED
+class ShareableShadowNodeWrapper : public Shareable {
+ private:
+  react::ShadowNode::Shared shadowNode_;
+
+ public:
+  ShareableShadowNodeWrapper(
+      const std::shared_ptr<JSRuntimeHelper> &runtimeHelper,
+      jsi::Runtime &rt,
+      const jsi::Object &wrapperObject)
+      : Shareable(ShadowNode) {
+    shadowNode_ =
+        wrapperObject.getHostObject<ShadowNodeWrapper>(rt)->shadowNode;
+  }
+  jsi::Value toJSValue(jsi::Runtime &rt) override {
+    return jsi::Object::createFromHostObject(
+        rt, std::make_shared<ShadowNodeWrapper>(shadowNode_));
+  }
+};
+#endif
+
+class ShareableWorklet : public ShareableObject {
+ public:
+  ShareableWorklet(
+      const std::shared_ptr<JSRuntimeHelper> &runtimeHelper,
+      jsi::Runtime &rt,
+      const jsi::Object &worklet)
+      : ShareableObject(runtimeHelper, rt, worklet) {
+    valueType_ = WorkletType;
+  }
+  jsi::Value toJSValue(jsi::Runtime &rt) override {
+    jsi::Value obj = ShareableObject::toJSValue(rt);
+    return runtimeHelper_->valueUnpacker->call(rt, obj);
+  }
+};
+
+class ShareableRemoteFunction
+    : public RetainingShareable,
+      public std::enable_shared_from_this<ShareableRemoteFunction> {
+ private:
+  jsi::Function function_;
+
+ public:
+  ShareableRemoteFunction(
+      const std::shared_ptr<JSRuntimeHelper> &runtimeHelper,
+      jsi::Runtime &rt,
+      jsi::Function &&function)
+      : RetainingShareable(runtimeHelper, rt, RemoteFunctionType),
+        function_(std::move(function)) {}
+  jsi::Value toJSValue(jsi::Runtime &rt) override {
+    if (runtimeHelper_->isUIRuntime(rt)) {
+#ifdef DEBUG
+      return runtimeHelper_->valueUnpacker->call(
+          rt,
+          ShareableJSRef::newHostObject(rt, shared_from_this()),
+          jsi::String::createFromAscii(rt, "RemoteFunction"));
+#else
+      return ShareableJSRef::newHostObject(rt, shared_from_this());
+#endif
+    } else {
+      return jsi::Value(rt, function_);
+    }
+  }
+};
+
+class ShareableHandle : public Shareable {
+ private:
+  std::shared_ptr<JSRuntimeHelper> runtimeHelper_;
+  std::unique_ptr<ShareableObject> initializer_;
+  std::unique_ptr<jsi::Value> remoteValue_;
+
+ public:
+  ShareableHandle(
+      const std::shared_ptr<JSRuntimeHelper> runtimeHelper,
+      jsi::Runtime &rt,
+      const jsi::Object &initializerObject)
+      : Shareable(HandleType), runtimeHelper_(runtimeHelper) {
+    initializer_ =
+        std::make_unique<ShareableObject>(runtimeHelper, rt, initializerObject);
+  }
+  ~ShareableHandle() {
+    if (runtimeHelper_->uiRuntimeDestroyed) {
+      // The below use of unique_ptr.release prevents the smart pointer from
+      // calling the destructor of the kept object. This effectively results in
+      // leaking some memory. We do this on purpose, as sometimes we would keep
+      // references to JSI objects past the lifetime of its runtime (e.g.,
+      // shared values references from the RN VM holds reference to JSI objects
+      // on the UI runtime). When the UI runtime is terminated, the orphaned JSI
+      // objects would crash the app when their destructors are called, because
+      // they call into a memory that's managed by the terminated runtime. We
+      // accept the tradeoff of leaking memory here, as it has a limited impact.
+      // This scenario can only occur when the React instance is torn down which
+      // happens in development mode during app reloads, or in production when
+      // the app is being shut down gracefully by the system. An alternative
+      // solution would require us to keep track of all JSI values that are in
+      // use which would require additional data structure and compute spent on
+      // bookkeeping that only for the sake of destroying the values in time
+      // before the runtime is terminated. Note that the underlying memory that
+      // jsi::Value refers to is managed by the VM and gets freed along with the
+      // runtime.
+      remoteValue_.release();
+    }
+  }
+  jsi::Value toJSValue(jsi::Runtime &rt) override {
+    if (initializer_ != nullptr) {
+      auto initObj = initializer_->getJSValue(rt);
+      remoteValue_ = std::make_unique<jsi::Value>(
+          runtimeHelper_->valueUnpacker->call(rt, initObj));
+      initializer_ = nullptr; // we can release ref to initializer as this
+                              // method should be called at most once
+    }
+    return jsi::Value(rt, *remoteValue_);
+  }
+};
+
+class ShareableSynchronizedDataHolder
+    : public Shareable,
+      public std::enable_shared_from_this<ShareableSynchronizedDataHolder> {
+ private:
+  std::shared_ptr<JSRuntimeHelper> runtimeHelper_;
+  std::shared_ptr<Shareable> data_;
+  std::shared_ptr<jsi::Value> uiValue_;
+  std::shared_ptr<jsi::Value> rnValue_;
+  std::mutex dataAccessLock_;
+
+ public:
+  ShareableSynchronizedDataHolder(
+      std::shared_ptr<JSRuntimeHelper> runtimeHelper,
+      jsi::Runtime &rt,
+      const jsi::Value &initialValue)
+      : Shareable(SynchronizedDataHolder),
+        runtimeHelper_(runtimeHelper),
+        data_(extractShareableOrThrow(rt, initialValue)) {}
+
+  jsi::Value get(jsi::Runtime &rt) {
+    std::unique_lock<std::mutex> read_lock(dataAccessLock_);
+    if (runtimeHelper_->isUIRuntime(rt)) {
+      if (uiValue_ == nullptr) {
+        auto value = data_->getJSValue(rt);
+        uiValue_ = std::make_shared<jsi::Value>(rt, value);
+        return value;
+      } else {
+        return jsi::Value(rt, *uiValue_);
+      }
+    } else {
+      if (rnValue_ == nullptr) {
+        auto value = data_->getJSValue(rt);
+        rnValue_ = std::make_shared<jsi::Value>(rt, value);
+        return value;
+      } else {
+        return jsi::Value(rt, *rnValue_);
+      }
+    }
+  }
+
+  void set(jsi::Runtime &rt, const jsi::Value &data) {
+    std::unique_lock<std::mutex> write_lock(dataAccessLock_);
+    data_ = extractShareableOrThrow(rt, data);
+    uiValue_.reset();
+    rnValue_.reset();
+  }
+
+  jsi::Value toJSValue(jsi::Runtime &rt) override {
+    return ShareableJSRef::newHostObject(rt, shared_from_this());
+  };
+};
+
+class ShareableString : public Shareable {
+ public:
+  ShareableString(jsi::Runtime &rt, const jsi::String &string)
+      : Shareable(StringType) {
+    data = string.utf8(rt);
+  }
+  jsi::Value toJSValue(jsi::Runtime &rt) override {
+    return jsi::String::createFromUtf8(rt, data);
+  }
+
+ protected:
+  std::string data;
+};
+
+class ShareableScalar : public Shareable {
+ public:
+  explicit ShareableScalar(double number) : Shareable(NumberType) {
+    data_.number = number;
+  }
+  explicit ShareableScalar(bool boolean) : Shareable(BooleanType) {
+    data_.boolean = boolean;
+  }
+  ShareableScalar() : Shareable(UndefinedType) {}
+  explicit ShareableScalar(std::nullptr_t) : Shareable(NullType) {}
+
+  jsi::Value toJSValue(jsi::Runtime &rt) override {
+    switch (valueType_) {
+      case Shareable::UndefinedType:
+        return jsi::Value();
+      case Shareable::NullType:
+        return jsi::Value(nullptr);
+      case Shareable::BooleanType:
+        return jsi::Value(data_.boolean);
+      case Shareable::NumberType:
+        return jsi::Value(data_.number);
+      default:
+        throw std::runtime_error(
+            "attempted to convert object that's not of a scalar type");
+    }
+  }
+
+ protected:
+  union Data {
+    bool boolean;
+    double number;
+  };
+
+ private:
+  Data data_;
+};
+
+} // namespace reanimated

package/Common/cpp/Tools/PlatformDepMethodsHolder.h

@@ -53,6 +53,10 @@ using RequestRender =
     std::function<void(std::function<void(double)>, jsi::Runtime &rt)>;
 using TimeProviderFunction = std::function<double(void)>;
 
+using ProgressLayoutAnimationFunction =
+    std::function<void(int, const jsi::Object &newProps)>;
+using EndLayoutAnimationFunction = std::function<void(int, bool, bool)>;
+
 using RegisterSensorFunction =
     std::function<int(int, int, std::function<void(double[])>)>;
 using UnregisterSensorFunction = std::function<void(int)>;
@@ -76,6 +80,8 @@ struct PlatformDepMethodsHolder {
   ConfigurePropsFunction configurePropsFunction;
 #endif
   TimeProviderFunction getCurrentTime;
+  ProgressLayoutAnimationFunction progressLayoutAnimation;
+  EndLayoutAnimationFunction endLayoutAnimation;
   RegisterSensorFunction registerSensor;
   UnregisterSensorFunction unregisterSensor;
   SetGestureStateFunction setGestureStateFunction;

package/Common/cpp/Tools/RuntimeDecorator.cpp

@@ -1,9 +1,9 @@
 #include "RuntimeDecorator.h"
+#include <jsi/instrumentation.h>
 #include <chrono>
 #include <memory>
 #include <unordered_map>
-#include "LayoutAnimationsProxy.h"
-#include "MutableValue.h"
+#include <utility>
 #include "ReanimatedHiddenHeaders.h"
 
 namespace reanimated {
@@ -31,6 +31,7 @@ void RuntimeDecorator::decorateRuntime(
       rt, "_LABEL", jsi::String::createFromAscii(rt, label));
 
   jsi::Object dummyGlobal(rt);
+  dummyGlobal.setProperty(rt, "gc", rt.global().getProperty(rt, "gc"));
   rt.global().setProperty(rt, "global", dummyGlobal);
 
   rt.global().setProperty(rt, "jsThis", jsi::Value::undefined());
@@ -105,11 +106,15 @@ void RuntimeDecorator::decorateUIRuntime(
     const ScrollToFunction scrollTo,
 #endif
     const RequestFrameFunction requestFrame,
+    const ScheduleOnJSFunction scheduleOnJS,
+    const MakeShareableCloneFunction makeShareableClone,
+    const UpdateDataSynchronouslyFunction updateDataSynchronously,
     const TimeProviderFunction getCurrentTime,
     const RegisterSensorFunction registerSensor,
     const UnregisterSensorFunction unregisterSensor,
     const SetGestureStateFunction setGestureState,
-    std::shared_ptr<LayoutAnimationsProxy> layoutAnimationsProxy) {
+    const ProgressLayoutAnimationFunction progressLayoutAnimationFunction,
+    const EndLayoutAnimationFunction endLayoutAnimationFunction) {
   RuntimeDecorator::decorateRuntime(rt, "UI");
   rt.global().setProperty(rt, "_UI", jsi::Value(true));
 
@@ -232,6 +237,42 @@ void RuntimeDecorator::decorateUIRuntime(
       rt, jsi::PropNameID::forAscii(rt, "requestAnimationFrame"), 1, clb2);
   rt.global().setProperty(rt, "requestAnimationFrame", requestAnimationFrame);
 
+  auto clb4 = [scheduleOnJS](
+                  jsi::Runtime &rt,
+                  const jsi::Value &thisValue,
+                  const jsi::Value *args,
+                  const size_t count) -> jsi::Value {
+    scheduleOnJS(rt, args[0], args[1]);
+    return jsi::Value::undefined();
+  };
+  jsi::Value scheduleOnJSFun = jsi::Function::createFromHostFunction(
+      rt, jsi::PropNameID::forAscii(rt, "_scheduleOnJS"), 2, clb4);
+  rt.global().setProperty(rt, "_scheduleOnJS", scheduleOnJSFun);
+
+  auto clb5 = [makeShareableClone](
+                  jsi::Runtime &rt,
+                  const jsi::Value &thisValue,
+                  const jsi::Value *args,
+                  const size_t count) -> jsi::Value {
+    return makeShareableClone(rt, std::move(args[0]));
+  };
+  jsi::Value makeShareableCloneFun = jsi::Function::createFromHostFunction(
+      rt, jsi::PropNameID::forAscii(rt, "_makeShareableClone"), 1, clb5);
+  rt.global().setProperty(rt, "_makeShareableClone", makeShareableCloneFun);
+
+  auto clb51 = [updateDataSynchronously](
+                   jsi::Runtime &rt,
+                   const jsi::Value &thisValue,
+                   const jsi::Value *args,
+                   const size_t count) -> jsi::Value {
+    updateDataSynchronously(rt, std::move(args[0]), std::move(args[1]));
+    return jsi::Value::undefined();
+  };
+  jsi::Value updateDataSynchronouslyFun = jsi::Function::createFromHostFunction(
+      rt, jsi::PropNameID::forAscii(rt, "_updateDataSynchronously"), 1, clb51);
+  rt.global().setProperty(
+      rt, "_updateDataSynchronously", updateDataSynchronouslyFun);
+
   auto clb6 = [getCurrentTime](
                   jsi::Runtime &rt,
                   const jsi::Value &thisValue,
@@ -247,43 +288,30 @@ void RuntimeDecorator::decorateUIRuntime(
   rt.global().setProperty(rt, "_eventTimestamp", jsi::Value::undefined());
 
   // layout animation
-  std::weak_ptr<LayoutAnimationsProxy> layoutProxy = layoutAnimationsProxy;
-  auto clb7 = [layoutProxy](
+  auto clb7 = [progressLayoutAnimationFunction](
                   jsi::Runtime &rt,
                   const jsi::Value &thisValue,
                   const jsi::Value *args,
                   size_t count) -> jsi::Value {
-    std::shared_ptr<LayoutAnimationsProxy> proxy = layoutProxy.lock();
-    if (layoutProxy.expired()) {
-      return jsi::Value::undefined();
-    }
-    proxy->startObserving(
-        args[0].asNumber(),
-        args[1].asObject(rt).getHostObject<MutableValue>(rt),
-        rt);
+    progressLayoutAnimationFunction(args[0].asNumber(), args[1].asObject(rt));
     return jsi::Value::undefined();
   };
-  jsi::Value _startObservingProgress = jsi::Function::createFromHostFunction(
-      rt, jsi::PropNameID::forAscii(rt, "_startObservingProgress"), 0, clb7);
-  rt.global().setProperty(
-      rt, "_startObservingProgress", _startObservingProgress);
+  jsi::Value _notifyAboutProgress = jsi::Function::createFromHostFunction(
+      rt, jsi::PropNameID::forAscii(rt, "_notifyAboutProgress"), 2, clb7);
+  rt.global().setProperty(rt, "_notifyAboutProgress", _notifyAboutProgress);
 
-  auto clb8 = [layoutProxy](
+  auto clb8 = [endLayoutAnimationFunction](
                   jsi::Runtime &rt,
                   const jsi::Value &thisValue,
                   const jsi::Value *args,
                   size_t count) -> jsi::Value {
-    std::shared_ptr<LayoutAnimationsProxy> proxy = layoutProxy.lock();
-    if (layoutProxy.expired()) {
-      return jsi::Value::undefined();
-    }
-    proxy->stopObserving(
+    endLayoutAnimationFunction(
         args[0].asNumber(), args[1].getBool(), args[2].getBool());
     return jsi::Value::undefined();
   };
-  jsi::Value _stopObservingProgress = jsi::Function::createFromHostFunction(
-      rt, jsi::PropNameID::forAscii(rt, "_stopObservingProgress"), 0, clb8);
-  rt.global().setProperty(rt, "_stopObservingProgress", _stopObservingProgress);
+  jsi::Value _notifyAboutEnd = jsi::Function::createFromHostFunction(
+      rt, jsi::PropNameID::forAscii(rt, "_notifyAboutEnd"), 2, clb8);
+  rt.global().setProperty(rt, "_notifyAboutEnd", _notifyAboutEnd);
 
   auto clb9 = [setGestureState](
                   jsi::Runtime &rt,

package/Common/cpp/Tools/RuntimeDecorator.h

@@ -5,7 +5,6 @@
 #include <memory>
 #include <string>
 #include <unordered_map>
-#include "LayoutAnimationsProxy.h"
 #include "PlatformDepMethodsHolder.h"
 
 using namespace facebook;
@@ -13,6 +12,12 @@ using namespace facebook;
 namespace reanimated {
 
 using RequestFrameFunction = std::function<void(std::function<void(double)>)>;
+using ScheduleOnJSFunction =
+    std::function<void(jsi::Runtime &, const jsi::Value &, const jsi::Value &)>;
+using MakeShareableCloneFunction =
+    std::function<jsi::Value(jsi::Runtime &, const jsi::Value &)>;
+using UpdateDataSynchronouslyFunction =
+    std::function<void(jsi::Runtime &, const jsi::Value &, const jsi::Value &)>;
 
 enum RuntimeType {
   /**
@@ -40,11 +45,15 @@ class RuntimeDecorator {
       const ScrollToFunction scrollTo,
 #endif
       const RequestFrameFunction requestFrame,
+      const ScheduleOnJSFunction scheduleOnJS,
+      const MakeShareableCloneFunction makeShareableClone,
+      const UpdateDataSynchronouslyFunction updateDataSynchronously,
       const TimeProviderFunction getCurrentTime,
       const RegisterSensorFunction registerSensor,
       const UnregisterSensorFunction unregisterSensor,
       const SetGestureStateFunction setGestureState,
-      std::shared_ptr<LayoutAnimationsProxy> layoutAnimationsProxy);
+      const ProgressLayoutAnimationFunction progressLayoutAnimationFunction,
+      const EndLayoutAnimationFunction endLayoutAnimationFunction);
 
   /**
    Returns true if the given Runtime is the Reanimated UI-Thread Runtime.

package/Common/cpp/Tools/Scheduler.cpp

@@ -3,6 +3,8 @@
 #else
 #include "Scheduler.h"
 #endif
+#include "ReanimatedRuntime.h"
+#include "RuntimeManager.h"
 
 namespace reanimated {
 
@@ -16,6 +18,14 @@ void Scheduler::scheduleOnJS(std::function<void()> job) {
 
 void Scheduler::triggerUI() {
   scheduledOnUI = false;
+#if JS_RUNTIME_HERMES
+  // JSI's scope defined here allows for JSI-objects to be cleared up after
+  // each runtime loop. Within these loops we typically create some temporary
+  // JSI objects and hence it allows for such objects to be garbage collected
+  // much sooner.
+  // Apparently the scope API is only supported on Hermes at the moment.
+  auto scope = jsi::Scope(*runtimeManager.lock()->runtime);
+#endif
   while (uiJobs.getSize()) {
     auto job = uiJobs.pop();
     job();

package/Common/cpp/Tools/SingleInstanceChecker.h

@@ -29,7 +29,7 @@ class SingleInstanceChecker {
 
   // A static field will exist separately for every class template.
   // This has to be inline for automatic initialization.
-  inline static int instanceCount_;
+  inline static volatile int instanceCount_;
 };
 
 template <class T>