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

package/Common/cpp/Tools/CollectionUtils.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <algorithm>
+
+namespace reanimated {
+namespace collection {
+
+template <class CollectionType, class ValueType>
+inline bool contains(CollectionType &collection, const ValueType &value) {
+  return collection.find(value) != collection.end();
+}
+
+} // namespace collection
+} // namespace reanimated

package/Common/cpp/Tools/JsiUtils.cpp

@@ -0,0 +1,26 @@
+#include "JsiUtils.h"
+#include <vector>
+
+using namespace facebook;
+
+namespace reanimated::jsi_utils {
+
+jsi::Array convertStringToArray(
+    jsi::Runtime &rt,
+    const std::string &value,
+    const unsigned int expectedSize) {
+  std::vector<float> transformMatrixList;
+  std::istringstream stringStream(value);
+  std::copy(
+      std::istream_iterator<float>(stringStream),
+      std::istream_iterator<float>(),
+      std::back_inserter(transformMatrixList));
+  assert(transformMatrixList.size() == expectedSize);
+  jsi::Array matrix(rt, expectedSize);
+  for (int i = 0; i < expectedSize; i++) {
+    matrix.setValueAtIndex(rt, i, transformMatrixList[i]);
+  }
+  return matrix;
+}
+
+} // namespace reanimated::jsi_utils

package/Common/cpp/Tools/JsiUtils.h

@@ -0,0 +1,176 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <sstream>
+#include <string>
+#include <tuple>
+#include <utility>
+
+using namespace facebook;
+
+namespace reanimated {
+namespace jsi_utils {
+
+// `get` functions take a pointer to `jsi::Value` and
+// call an appropriate method to cast to the native type
+template <typename T>
+inline T get(jsi::Runtime &rt, const jsi::Value *value);
+
+template <>
+inline double get<double>(jsi::Runtime &rt, const jsi::Value *value) {
+  return value->asNumber();
+}
+
+template <>
+inline int get<int>(jsi::Runtime &rt, const jsi::Value *value) {
+  return value->asNumber();
+}
+
+template <>
+inline bool get<bool>(jsi::Runtime &rt, const jsi::Value *value) {
+  if (!value->isBool()) {
+    throw jsi::JSINativeException("Expected a boolean");
+  }
+  return value->getBool();
+}
+
+template <>
+inline jsi::Object get<jsi::Object>(jsi::Runtime &rt, const jsi::Value *value) {
+  return value->asObject(rt);
+}
+
+template <>
+inline jsi::Value const &get<jsi::Value const &>(
+    jsi::Runtime &rt,
+    const jsi::Value *value) {
+  return *value;
+}
+
+// `convertArgs` functions take a variadic template parameter of target (C++)
+// argument types `Targs` and a `jsi::Value` array `args`, and converts `args`
+// to a tuple of typed C++ arguments to be passed to the native implementation.
+// This is accomplished by dispatching (at compile time) to the correct
+// implementation based on the first type of `Targs`, using SFINAE to select the
+// correct specialization, and concatenating with the result of recursion on the
+// rest of `Targs`
+
+// BEGIN implementations for `convertArgs` specializations.
+// specialization for empty `Targs` - returns an empty tuple
+template <typename... Args>
+inline std::enable_if_t<(sizeof...(Args) == 0), std::tuple<>> convertArgs(
+    jsi::Runtime &rt,
+    const jsi::Value *args) {
+  return std::make_tuple();
+}
+
+// calls `get<First>` on the first argument to retrieve the native type,
+// then calls recursively on the rest of `args`
+// and returns the concatenation of results
+template <typename T, typename... Rest>
+inline std::tuple<T, Rest...> convertArgs(
+    jsi::Runtime &rt,
+    const jsi::Value *args) {
+  auto arg = std::tuple<T>(get<T>(rt, args));
+  auto rest = convertArgs<Rest...>(rt, std::next(args));
+  return std::tuple_cat(std::move(arg), std::move(rest));
+}
+// END implementations for `convertArgs` specializations.
+
+// returns a tuple with the result of casting `args` to appropriate
+// native C++ types needed to call `function`
+template <typename Ret, typename... Args>
+std::tuple<Args...> getArgsForFunction(
+    std::function<Ret(Args...)> function,
+    jsi::Runtime &rt,
+    const jsi::Value *args,
+    const size_t count) {
+  assert(sizeof...(Args) == count);
+  return convertArgs<Args...>(rt, args);
+}
+
+// returns a tuple with the result of casting `args` to appropriate
+// native C++ types needed to call `function`,
+// passing `rt` as the first argument
+template <typename Ret, typename... Args>
+std::tuple<jsi::Runtime &, Args...> getArgsForFunction(
+    std::function<Ret(jsi::Runtime &, Args...)> function,
+    jsi::Runtime &rt,
+    const jsi::Value *args,
+    const size_t count) {
+  assert(sizeof...(Args) == count);
+  return std::tuple_cat(std::tie(rt), convertArgs<Args...>(rt, args));
+}
+
+// calls `function` with `args`
+template <typename Ret, typename... Args>
+inline jsi::Value apply(
+    std::function<Ret(Args...)> function,
+    std::tuple<Args...> args) {
+  return std::apply(function, std::move(args));
+}
+
+// calls void-returning `function` with `args`,
+// and returns `undefined`
+template <typename... Args>
+inline jsi::Value apply(
+    std::function<void(Args...)> function,
+    std::tuple<Args...> args) {
+  std::apply(function, std::move(args));
+  return jsi::Value::undefined();
+}
+
+// returns a function with JSI calling convention
+// from a native function `function`
+template <typename Fun>
+jsi::HostFunctionType createHostFunction(Fun function) {
+  return [function](
+             jsi::Runtime &rt,
+             const jsi::Value &thisValue,
+             const jsi::Value *args,
+             const size_t count) {
+    auto argz = getArgsForFunction(function, rt, args, count);
+    return apply(function, std::move(argz));
+  };
+}
+
+// used to determine if `function<Ret(Args...)>`
+// takes `Runtime &` as its first argument
+template <typename... Args>
+struct takes_runtime {
+  static constexpr size_t value = 0;
+};
+
+// specialization for `function<Ret(Runtime &, Rest...)`
+template <typename... Rest>
+struct takes_runtime<jsi::Runtime &, Rest...> {
+  static constexpr size_t value = 1;
+};
+
+// creates a JSI compatible function from `function`
+// and installs it as a global function named `name`
+// in the `rt` JS runtime
+template <typename Ret, typename... Args>
+void installJsiFunction(
+    jsi::Runtime &rt,
+    std::string_view name,
+    std::function<Ret(Args...)> function) {
+  auto clb = createHostFunction(function);
+  auto argsCount = sizeof...(Args) - takes_runtime<Args...>::value;
+  jsi::Value jsiFunction = jsi::Function::createFromHostFunction(
+      rt, jsi::PropNameID::forAscii(rt, name.data()), argsCount, clb);
+  rt.global().setProperty(rt, name.data(), jsiFunction);
+}
+
+// this should take care of passing types convertible to `function`
+template <typename Fun>
+void installJsiFunction(jsi::Runtime &rt, std::string_view name, Fun function) {
+  installJsiFunction(rt, name, std::function(std::forward<Fun>(function)));
+}
+
+jsi::Array convertStringToArray(
+    jsi::Runtime &rt,
+    const std::string &value,
+    const unsigned int expectedSize);
+
+} // namespace jsi_utils
+} // namespace reanimated

package/Common/cpp/Tools/PlatformDepMethodsHolder.h

@@ -27,7 +27,7 @@ using UpdatePropsFunction = std::function<void(
     const jsi::Value &shadowNodeValue,
     const jsi::Value &props)>;
 using RemoveShadowNodeFromRegistryFunction =
-    std::function<void(jsi::Runtime &rt, const jsi::Value &shadowNodeValue)>;
+    std::function<void(jsi::Runtime &rt, const jsi::Value &tag)>;
 using DispatchCommandFunction = std::function<void(
     jsi::Runtime &rt,
     const jsi::Value &shadowNodeValue,
@@ -42,7 +42,7 @@ using UpdatePropsFunction = std::function<void(
     jsi::Runtime &rt,
     int viewTag,
     const jsi::Value &viewName,
-    const jsi::Object &object)>;
+    jsi::Object object)>;
 using ScrollToFunction = std::function<void(int, double, double, bool)>;
 using MeasureFunction =
     std::function<std::vector<std::pair<std::string, double>>(int)>;
@@ -54,11 +54,11 @@ using RequestRender =
 using TimeProviderFunction = std::function<double(void)>;
 
 using ProgressLayoutAnimationFunction =
-    std::function<void(int, const jsi::Object &newProps)>;
+    std::function<void(int, jsi::Object newProps, bool isSharedTransition)>;
 using EndLayoutAnimationFunction = std::function<void(int, bool, bool)>;
 
 using RegisterSensorFunction =
-    std::function<int(int, int, std::function<void(double[])>)>;
+    std::function<int(int, int, int, std::function<void(double[], int)>)>;
 using UnregisterSensorFunction = std::function<void(int)>;
 using SetGestureStateFunction = std::function<void(int, int)>;
 using ConfigurePropsFunction = std::function<void(
@@ -66,7 +66,7 @@ using ConfigurePropsFunction = std::function<void(
     const jsi::Value &uiProps,
     const jsi::Value &nativeProps)>;
 using KeyboardEventSubscribeFunction =
-    std::function<int(std::function<void(int, int)>)>;
+    std::function<int(std::function<void(int, int)>, bool)>;
 using KeyboardEventUnsubscribeFunction = std::function<void(int)>;
 
 struct PlatformDepMethodsHolder {

package/Common/cpp/Tools/ReanimatedVersion.cpp

@@ -0,0 +1,17 @@
+#include "ReanimatedVersion.h"
+
+#ifdef REANIMATED_VERSION
+#define STRINGIZE(x) #x
+#define STRINGIZE2(x) STRINGIZE(x)
+#define REANIMATED_VERSION_STRING STRINGIZE2(REANIMATED_VERSION)
+#endif // REANIMATED_VERSION
+
+using namespace facebook;
+
+namespace reanimated {
+
+jsi::String getReanimatedVersionString(jsi::Runtime &rt) {
+  return jsi::String::createFromUtf8(rt, REANIMATED_VERSION_STRING);
+}
+
+}; // namespace reanimated

package/Common/cpp/Tools/ReanimatedVersion.h

@@ -0,0 +1,11 @@
+#pragma once
+
+#include <jsi/jsi.h>
+
+using namespace facebook;
+
+namespace reanimated {
+
+jsi::String getReanimatedVersionString(jsi::Runtime &rt);
+
+};

package/Common/cpp/Tools/RuntimeDecorator.cpp

@@ -4,10 +4,24 @@
 #include <memory>
 #include <unordered_map>
 #include <utility>
+#include "JsiUtils.h"
 #include "ReanimatedHiddenHeaders.h"
 
 namespace reanimated {
 
+static const std::function<void(jsi::Runtime &, jsi::Value const &)> logValue =
+    [](jsi::Runtime &rt, jsi::Value const &value) {
+      if (value.isString()) {
+        Logger::log(value.getString(rt).utf8(rt).c_str());
+      } else if (value.isNumber()) {
+        Logger::log(value.getNumber());
+      } else if (value.isUndefined()) {
+        Logger::log("undefined");
+      } else {
+        Logger::log("unsupported value type");
+      }
+    };
+
 std::unordered_map<RuntimePointer, RuntimeType>
     &RuntimeDecorator::runtimeRegistry() {
   static std::unordered_map<RuntimePointer, RuntimeType> runtimeRegistry;
@@ -30,69 +44,34 @@ void RuntimeDecorator::decorateRuntime(
   rt.global().setProperty(
       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());
-
-  auto callback = [](jsi::Runtime &rt,
-                     const jsi::Value &thisValue,
-                     const jsi::Value *args,
-                     size_t count) -> jsi::Value {
-    const jsi::Value *value = &args[0];
-    if (value->isString()) {
-      Logger::log(value->getString(rt).utf8(rt).c_str());
-    } else if (value->isNumber()) {
-      Logger::log(value->getNumber());
-    } else if (value->isUndefined()) {
-      Logger::log("undefined");
-    } else {
-      Logger::log("unsupported value type");
+  rt.global().setProperty(rt, "global", rt.global());
+
+#ifdef DEBUG
+  auto evalWithSourceUrl = [](jsi::Runtime &rt,
+                              const jsi::Value &thisValue,
+                              const jsi::Value *args,
+                              size_t count) -> jsi::Value {
+    auto code = std::make_shared<const jsi::StringBuffer>(
+        args[0].asString(rt).utf8(rt));
+    std::string url;
+    if (count > 1 && args[1].isString()) {
+      url = args[1].asString(rt).utf8(rt);
     }
-    return jsi::Value::undefined();
-  };
-  jsi::Value log = jsi::Function::createFromHostFunction(
-      rt, jsi::PropNameID::forAscii(rt, "_log"), 1, callback);
-  rt.global().setProperty(rt, "_log", log);
 
-  auto setGlobalConsole = [](jsi::Runtime &rt,
-                             const jsi::Value &thisValue,
-                             const jsi::Value *args,
-                             size_t count) -> jsi::Value {
-    rt.global().setProperty(rt, "console", args[0]);
-    return jsi::Value::undefined();
+    return rt.evaluateJavaScript(code, url);
   };
+
   rt.global().setProperty(
       rt,
-      "_setGlobalConsole",
+      "evalWithSourceUrl",
       jsi::Function::createFromHostFunction(
           rt,
-          jsi::PropNameID::forAscii(rt, "_setGlobalConsole"),
+          jsi::PropNameID::forAscii(rt, "evalWithSourceUrl"),
           1,
-          setGlobalConsole));
-
-  auto chronoNow = [](jsi::Runtime &rt,
-                      const jsi::Value &thisValue,
-                      const jsi::Value *args,
-                      size_t count) -> jsi::Value {
-    double now = std::chrono::system_clock::now().time_since_epoch() /
-        std::chrono::milliseconds(1);
-    return jsi::Value(now);
-  };
+          evalWithSourceUrl));
+#endif // DEBUG
 
-  rt.global().setProperty(
-      rt,
-      "_chronoNow",
-      jsi::Function::createFromHostFunction(
-          rt, jsi::PropNameID::forAscii(rt, "_chronoNow"), 0, chronoNow));
-  jsi::Object performance(rt);
-  performance.setProperty(
-      rt,
-      "now",
-      jsi::Function::createFromHostFunction(
-          rt, jsi::PropNameID::forAscii(rt, "now"), 0, chronoNow));
-  rt.global().setProperty(rt, "performance", performance);
+  jsi_utils::installJsiFunction(rt, "_log", logValue);
 }
 
 void RuntimeDecorator::decorateUIRuntime(
@@ -110,8 +89,6 @@ void RuntimeDecorator::decorateUIRuntime(
     const MakeShareableCloneFunction makeShareableClone,
     const UpdateDataSynchronouslyFunction updateDataSynchronously,
     const TimeProviderFunction getCurrentTime,
-    const RegisterSensorFunction registerSensor,
-    const UnregisterSensorFunction unregisterSensor,
     const SetGestureStateFunction setGestureState,
     const ProgressLayoutAnimationFunction progressLayoutAnimationFunction,
     const EndLayoutAnimationFunction endLayoutAnimationFunction) {
@@ -119,95 +96,17 @@ void RuntimeDecorator::decorateUIRuntime(
   rt.global().setProperty(rt, "_UI", jsi::Value(true));
 
 #ifdef RCT_NEW_ARCH_ENABLED
-  auto clb = [updateProps](
-                 jsi::Runtime &rt,
-                 const jsi::Value &thisValue,
-                 const jsi::Value *args,
-                 const size_t count) -> jsi::Value {
-    updateProps(rt, args[0], args[1]);
-    return jsi::Value::undefined();
-  };
-  jsi::Value updatePropsHostFunction = jsi::Function::createFromHostFunction(
-      rt, jsi::PropNameID::forAscii(rt, "_updatePropsFabric"), 2, clb);
-  rt.global().setProperty(rt, "_updatePropsFabric", updatePropsHostFunction);
-
-  auto _removeShadowNodeFromRegistry = [removeShadowNodeFromRegistry](
-                                           jsi::Runtime &rt,
-                                           const jsi::Value &thisValue,
-                                           const jsi::Value *args,
-                                           const size_t count) -> jsi::Value {
-    removeShadowNodeFromRegistry(rt, args[0]);
-    return jsi::Value::undefined();
-  };
-  jsi::Value removeShadowNodeFromRegistryHostFunction =
-      jsi::Function::createFromHostFunction(
-          rt,
-          jsi::PropNameID::forAscii(rt, "_removeShadowNodeFromRegistry"),
-          2,
-          _removeShadowNodeFromRegistry);
-  rt.global().setProperty(
-      rt,
-      "_removeShadowNodeFromRegistry",
-      removeShadowNodeFromRegistryHostFunction);
-
-  auto clb3 = [dispatchCommand](
-                  jsi::Runtime &rt,
-                  const jsi::Value &thisValue,
-                  const jsi::Value *args,
-                  const size_t count) -> jsi::Value {
-    dispatchCommand(rt, args[0], args[1], args[2]);
-    return jsi::Value::undefined();
-  };
-  jsi::Value dispatchCommandHostFunction =
-      jsi::Function::createFromHostFunction(
-          rt, jsi::PropNameID::forAscii(rt, "_dispatchCommand"), 3, clb3);
-  rt.global().setProperty(rt, "_dispatchCommand", dispatchCommandHostFunction);
-
-  auto _measure = [measure](
-                      jsi::Runtime &rt,
-                      const jsi::Value &thisValue,
-                      const jsi::Value *args,
-                      const size_t count) -> jsi::Value {
-    return measure(rt, args[0]);
-  };
+  jsi_utils::installJsiFunction(rt, "_updatePropsFabric", updateProps);
+  jsi_utils::installJsiFunction(
+      rt, "_removeShadowNodeFromRegistry", removeShadowNodeFromRegistry);
+  jsi_utils::installJsiFunction(rt, "_dispatchCommand", dispatchCommand);
+  jsi_utils::installJsiFunction(rt, "_measure", measure);
 #else
-  auto clb = [updateProps](
-                 jsi::Runtime &rt,
-                 const jsi::Value &thisValue,
-                 const jsi::Value *args,
-                 const size_t count) -> jsi::Value {
-    const auto viewTag = args[0].asNumber();
-    const jsi::Value *viewName = &args[1];
-    const auto params = args[2].asObject(rt);
-    updateProps(rt, viewTag, *viewName, params);
-    return jsi::Value::undefined();
-  };
-  jsi::Value updatePropsHostFunction = jsi::Function::createFromHostFunction(
-      rt, jsi::PropNameID::forAscii(rt, "_updatePropsPaper"), 3, clb);
-  rt.global().setProperty(rt, "_updatePropsPaper", updatePropsHostFunction);
+  jsi_utils::installJsiFunction(rt, "_updatePropsPaper", updateProps);
+  jsi_utils::installJsiFunction(rt, "_scrollTo", scrollTo);
 
-  auto _scrollTo = [scrollTo](
-                       jsi::Runtime &rt,
-                       const jsi::Value &thisValue,
-                       const jsi::Value *args,
-                       const size_t count) -> jsi::Value {
-    int viewTag = static_cast<int>(args[0].asNumber());
-    double x = args[1].asNumber();
-    double y = args[2].asNumber();
-    bool animated = args[3].getBool();
-    scrollTo(viewTag, x, y, animated);
-    return jsi::Value::undefined();
-  };
-  jsi::Value scrollToFunction = jsi::Function::createFromHostFunction(
-      rt, jsi::PropNameID::forAscii(rt, "_scrollTo"), 4, _scrollTo);
-  rt.global().setProperty(rt, "_scrollTo", scrollToFunction);
-
-  auto _measure = [measure](
-                      jsi::Runtime &rt,
-                      const jsi::Value &thisValue,
-                      const jsi::Value *args,
-                      const size_t count) -> jsi::Value {
-    int viewTag = static_cast<int>(args[0].asNumber());
+  std::function<jsi::Value(jsi::Runtime &, int)> _measure =
+      [measure](jsi::Runtime &rt, int viewTag) -> jsi::Value {
     auto result = measure(viewTag);
     jsi::Object resultObject(rt);
     for (auto &i : result) {
@@ -215,117 +114,38 @@ void RuntimeDecorator::decorateUIRuntime(
     }
     return resultObject;
   };
-#endif // RCT_NEW_ARCH_ENABLED
-
-  jsi::Value measureFunction = jsi::Function::createFromHostFunction(
-      rt, jsi::PropNameID::forAscii(rt, "_measure"), 1, _measure);
-  rt.global().setProperty(rt, "_measure", measureFunction);
 
-  auto clb2 = [requestFrame](
-                  jsi::Runtime &rt,
-                  const jsi::Value &thisValue,
-                  const jsi::Value *args,
-                  const size_t count) -> jsi::Value {
-    auto fun =
-        std::make_shared<jsi::Function>(args[0].asObject(rt).asFunction(rt));
-    requestFrame([&rt, fun](double timestampMs) {
-      fun->call(rt, jsi::Value(timestampMs));
-    });
-    return jsi::Value::undefined();
-  };
-  jsi::Value requestAnimationFrame = jsi::Function::createFromHostFunction(
-      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);
+  jsi_utils::installJsiFunction(rt, "_measure", _measure);
+#endif // RCT_NEW_ARCH_ENABLED
 
-  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);
+  jsi_utils::installJsiFunction(rt, "requestAnimationFrame", requestFrame);
+  jsi_utils::installJsiFunction(rt, "_scheduleOnJS", scheduleOnJS);
+  jsi_utils::installJsiFunction(rt, "_makeShareableClone", makeShareableClone);
+  jsi_utils::installJsiFunction(
+      rt, "_updateDataSynchronously", updateDataSynchronously);
 
-  auto clb6 = [getCurrentTime](
-                  jsi::Runtime &rt,
-                  const jsi::Value &thisValue,
-                  const jsi::Value *args,
-                  const size_t count) -> jsi::Value {
-    return getCurrentTime();
+  auto performanceNow = [getCurrentTime](
+                            jsi::Runtime &rt,
+                            const jsi::Value &thisValue,
+                            const jsi::Value *args,
+                            size_t count) -> jsi::Value {
+    return jsi::Value(getCurrentTime());
   };
-  jsi::Value timeFun = jsi::Function::createFromHostFunction(
-      rt, jsi::PropNameID::forAscii(rt, "_getCurrentTime"), 0, clb6);
-  rt.global().setProperty(rt, "_getCurrentTime", timeFun);
-
-  rt.global().setProperty(rt, "_frameTimestamp", jsi::Value::undefined());
-  rt.global().setProperty(rt, "_eventTimestamp", jsi::Value::undefined());
+  jsi::Object performance(rt);
+  performance.setProperty(
+      rt,
+      "now",
+      jsi::Function::createFromHostFunction(
+          rt, jsi::PropNameID::forAscii(rt, "now"), 0, performanceNow));
+  rt.global().setProperty(rt, "performance", performance);
 
   // layout animation
-  auto clb7 = [progressLayoutAnimationFunction](
-                  jsi::Runtime &rt,
-                  const jsi::Value &thisValue,
-                  const jsi::Value *args,
-                  size_t count) -> jsi::Value {
-    progressLayoutAnimationFunction(args[0].asNumber(), args[1].asObject(rt));
-    return jsi::Value::undefined();
-  };
-  jsi::Value _notifyAboutProgress = jsi::Function::createFromHostFunction(
-      rt, jsi::PropNameID::forAscii(rt, "_notifyAboutProgress"), 2, clb7);
-  rt.global().setProperty(rt, "_notifyAboutProgress", _notifyAboutProgress);
+  jsi_utils::installJsiFunction(
+      rt, "_notifyAboutProgress", progressLayoutAnimationFunction);
+  jsi_utils::installJsiFunction(
+      rt, "_notifyAboutEnd", endLayoutAnimationFunction);
 
-  auto clb8 = [endLayoutAnimationFunction](
-                  jsi::Runtime &rt,
-                  const jsi::Value &thisValue,
-                  const jsi::Value *args,
-                  size_t count) -> jsi::Value {
-    endLayoutAnimationFunction(
-        args[0].asNumber(), args[1].getBool(), args[2].getBool());
-    return jsi::Value::undefined();
-  };
-  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,
-                  const jsi::Value &thisValue,
-                  const jsi::Value *args,
-                  size_t count) -> jsi::Value {
-    int handlerTag = static_cast<int>(args[0].asNumber());
-    int newState = static_cast<int>(args[1].asNumber());
-    setGestureState(handlerTag, newState);
-    return jsi::Value::undefined();
-  };
-  jsi::Value setGestureStateFunction = jsi::Function::createFromHostFunction(
-      rt, jsi::PropNameID::forAscii(rt, "_setGestureState"), 2, clb9);
-  rt.global().setProperty(rt, "_setGestureState", setGestureStateFunction);
+  jsi_utils::installJsiFunction(rt, "_setGestureState", setGestureState);
 }
 
 } // namespace reanimated

package/Common/cpp/Tools/RuntimeDecorator.h

@@ -11,7 +11,8 @@ using namespace facebook;
 
 namespace reanimated {
 
-using RequestFrameFunction = std::function<void(std::function<void(double)>)>;
+using RequestFrameFunction =
+    std::function<void(jsi::Runtime &, const jsi::Value &)>;
 using ScheduleOnJSFunction =
     std::function<void(jsi::Runtime &, const jsi::Value &, const jsi::Value &)>;
 using MakeShareableCloneFunction =
@@ -49,8 +50,6 @@ class RuntimeDecorator {
       const MakeShareableCloneFunction makeShareableClone,
       const UpdateDataSynchronouslyFunction updateDataSynchronously,
       const TimeProviderFunction getCurrentTime,
-      const RegisterSensorFunction registerSensor,
-      const UnregisterSensorFunction unregisterSensor,
       const SetGestureStateFunction setGestureState,
       const ProgressLayoutAnimationFunction progressLayoutAnimationFunction,
       const EndLayoutAnimationFunction endLayoutAnimationFunction);