@react-native-ohos/react-native-reanimated 3.18.2-rc.2 → 4.0.1

package/harmony/reanimated/src/main/cpp/Common/cpp/worklets/Tools/AsyncQueue.cpp

@@ -1,52 +0,0 @@
-#include <worklets/Tools/AsyncQueue.h>
-
-#include <utility>
-
-namespace worklets {
-
-AsyncQueue::AsyncQueue(std::string name)
-    : state_(std::make_shared<AsyncQueueState>()) {
-  auto thread = std::thread([name, state = state_] {
-#if __APPLE__
-    pthread_setname_np(name.c_str());
-#endif
-    while (state->running) {
-      std::unique_lock<std::mutex> lock(state->mutex);
-      state->cv.wait(
-          lock, [state] { return !state->queue.empty() || !state->running; });
-      if (!state->running) {
-        return;
-      }
-      if (state->queue.empty()) {
-        continue;
-      }
-      auto job = std::move(state->queue.front());
-      state->queue.pop();
-      lock.unlock();
-      job();
-    }
-  });
-#ifdef ANDROID
-  pthread_setname_np(thread.native_handle(), name.c_str());
-#endif
-  thread.detach();
-}
-
-AsyncQueue::~AsyncQueue() {
-  {
-    std::unique_lock<std::mutex> lock(state_->mutex);
-    state_->running = false;
-    state_->queue = {};
-  }
-  state_->cv.notify_all();
-}
-
-void AsyncQueue::push(std::function<void()> &&job) {
-  {
-    std::unique_lock<std::mutex> lock(state_->mutex);
-    state_->queue.emplace(job);
-  }
-  state_->cv.notify_one();
-}
-
-} // namespace worklets

package/harmony/reanimated/src/main/cpp/Common/cpp/worklets/Tools/AsyncQueue.h

@@ -1,35 +0,0 @@
-#pragma once
-
-#include <jsi/jsi.h>
-
-#include <atomic>
-#include <condition_variable>
-#include <memory>
-#include <queue>
-#include <string>
-#include <thread>
-#include <utility>
-#include <vector>
-
-namespace worklets {
-
-struct AsyncQueueState {
-  std::atomic_bool running{true};
-  std::mutex mutex;
-  std::condition_variable cv;
-  std::queue<std::function<void()>> queue;
-};
-
-class AsyncQueue {
- public:
-  explicit AsyncQueue(std::string name);
-
-  ~AsyncQueue();
-
-  void push(std::function<void()> &&job);
-
- private:
-  const std::shared_ptr<AsyncQueueState> state_;
-};
-
-} // namespace worklets

package/harmony/reanimated/src/main/cpp/Common/cpp/worklets/Tools/Defs.h

@@ -1,10 +0,0 @@
-#pragma once
-
-/*
-On Android JS_RUNTIME_HERMES is set in CMakeList.txt,
-but on iOS there is no simple way to defect if Hermes exists
-so we have to check if headers are available.
-*/
-#if __APPLE__ && __has_include(<hermes/hermes.h>)
-#define JS_RUNTIME_HERMES 1
-#endif

package/harmony/reanimated/src/main/cpp/Common/cpp/worklets/Tools/JSISerializer.cpp

@@ -1,342 +0,0 @@
-#include <worklets/Tools/JSISerializer.h>
-
-#include <cxxabi.h>
-#include <iostream>
-#include <sstream>
-
-namespace worklets {
-
-const std::vector<std::string> SUPPORTED_ERROR_TYPES = {
-    "Error",
-    "AggregateError",
-    "EvalError",
-    "RangeError",
-    "ReferenceError",
-    "SyntaxError",
-    "TypeError",
-    "URIError",
-    "InternalError"};
-
-const std::vector<std::string> SUPPORTED_INDEXED_COLLECTION_TYPES = {
-    "Int8Array",
-    "Uint8Array",
-    "Uint8ClampedArray",
-    "Int16Array",
-    "Uint16Array",
-    "Int32Array",
-    "Uint32Array",
-    "BigInt64Array",
-    "BigUint64Array",
-    "Float32Array",
-    "Float64Array",
-};
-
-const std::vector<std::string> SUPPORTED_STRUCTURED_DATA_TYPES = {
-    "ArrayBuffer",
-    "SharedArrayBuffer",
-    "DataView",
-    "Atomics",
-    "JSON",
-};
-
-const std::vector<std::string> SUPPORTED_MANAGING_MEMORY_TYPES = {
-    "WeakRef",
-    "FinalizationRegistry",
-};
-
-const std::vector<std::string> SUPPORTED_ABSTRACTION_OBJECT_TYPES = {
-    "Iterator",
-    "AsyncIterator",
-    "Promise",
-    "GeneratorFunction",
-    "AsyncGeneratorFunction",
-    "Generator",
-    "AsyncGenerator",
-    "AsyncFunction",
-};
-
-const std::vector<std::string> SUPPORTED_REFLECTION_TYPES = {
-    "Reflect",
-    "Proxy",
-};
-
-static inline std::string getObjectTypeName(
-    jsi::Runtime &rt,
-    const jsi::Object &object) {
-  return object.getPropertyAsObject(rt, "constructor")
-      .getProperty(rt, "name")
-      .toString(rt)
-      .utf8(rt);
-}
-
-static inline bool isInstanceOf(
-    jsi::Runtime &rt,
-    const jsi::Object &object,
-    const std::string &type) {
-  return getObjectTypeName(rt, object) == type;
-}
-
-static inline bool isInstanceOfAny(
-    jsi::Runtime &rt,
-    const jsi::Object &object,
-    const std::vector<std::string> &supportedTypes) {
-  auto instanceType = getObjectTypeName(rt, object);
-
-  return std::find(
-             supportedTypes.begin(), supportedTypes.end(), instanceType) !=
-      supportedTypes.end();
-}
-
-JSISerializer::JSISerializer(jsi::Runtime &rt)
-    : rt_(rt),
-      visitedNodes_(rt_.global()
-                        .getPropertyAsFunction(rt_, "Set")
-                        .callAsConstructor(rt_)
-                        .asObject(rt_)) {}
-
-std::string JSISerializer::stringifyWithName(const jsi::Object &object) {
-  std::stringstream ss;
-  ss << '[' << getObjectTypeName(rt_, object) << ']';
-
-  return ss.str();
-}
-
-std::string JSISerializer::stringifyArray(const jsi::Array &arr) {
-  std::stringstream ss;
-  ss << '[';
-
-  for (size_t i = 0, length = arr.size(rt_); i < length; i++) {
-    jsi::Value element = arr.getValueAtIndex(rt_, i);
-    ss << stringifyJSIValueRecursively(element);
-    if (i != length - 1) {
-      ss << ", ";
-    }
-  }
-
-  ss << ']';
-
-  return ss.str();
-}
-
-std::string JSISerializer::stringifyFunction(const jsi::Function &func) {
-  std::stringstream ss;
-  auto kind = (func.isHostFunction(rt_) ? "jsi::HostFunction" : "Function");
-  auto name = func.getProperty(rt_, "name").toString(rt_).utf8(rt_);
-  name = name.empty() ? "anonymous" : name;
-
-  ss << '[' << kind << ' ' << name << ']';
-  return ss.str();
-}
-
-std::string JSISerializer::stringifyHostObject(jsi::HostObject &hostObject) {
-  int status = -1;
-  char *hostObjClassName =
-      abi::__cxa_demangle(typeid(hostObject).name(), NULL, NULL, &status);
-  if (status != 0) {
-    return "[jsi::HostObject]";
-  }
-
-  std::stringstream ss;
-  ss << "[jsi::HostObject(" << hostObjClassName << ")";
-  std::free(hostObjClassName);
-
-  auto props = hostObject.getPropertyNames(rt_);
-  auto propsCount = props.size();
-
-  if (propsCount > 0) {
-    ss << " {";
-    auto lastKey = props.back().utf8(rt_);
-    for (const auto &key : props) {
-      auto formattedKey = key.utf8(rt_);
-      auto value = hostObject.get(rt_, key);
-      ss << '"' << formattedKey << '"' << ": "
-         << stringifyJSIValueRecursively(value);
-      if (formattedKey != lastKey) {
-        ss << ", ";
-      }
-    }
-    ss << '}';
-  }
-  ss << ']';
-
-  return ss.str();
-}
-
-std::string JSISerializer::stringifyObject(const jsi::Object &object) {
-  std::stringstream ss;
-  ss << '{';
-
-  auto props = object.getPropertyNames(rt_);
-
-  for (size_t i = 0, propsCount = props.size(rt_); i < propsCount; i++) {
-    jsi::String propName = props.getValueAtIndex(rt_, i).toString(rt_);
-    ss << '"' << propName.utf8(rt_) << '"' << ": "
-       << stringifyJSIValueRecursively(object.getProperty(rt_, propName));
-    if (i != propsCount - 1) {
-      ss << ", ";
-    }
-  }
-
-  ss << '}';
-
-  return ss.str();
-}
-
-std::string JSISerializer::stringifyError(const jsi::Object &object) {
-  std::stringstream ss;
-  ss << '[' << object.getProperty(rt_, "name").toString(rt_).utf8(rt_) << ": "
-     << object.getProperty(rt_, "message").toString(rt_).utf8(rt_) << ']';
-  return ss.str();
-}
-
-std::string JSISerializer::stringifySet(const jsi::Object &object) {
-  std::stringstream ss;
-  jsi::Function arrayFrom = rt_.global()
-                                .getPropertyAsObject(rt_, "Array")
-                                .getPropertyAsFunction(rt_, "from");
-  jsi::Object result = arrayFrom.call(rt_, object).asObject(rt_);
-
-  if (!result.isArray(rt_)) {
-    return "[Set]";
-  }
-
-  auto arr = result.asArray(rt_);
-  ss << "Set {";
-
-  for (size_t i = 0, length = arr.size(rt_); i < length; i++) {
-    ss << stringifyJSIValueRecursively(arr.getValueAtIndex(rt_, i));
-    if (i != length - 1) {
-      ss << ", ";
-    }
-  }
-
-  ss << '}';
-
-  return ss.str();
-}
-
-std::string JSISerializer::stringifyMap(const jsi::Object &object) {
-  std::stringstream ss;
-  jsi::Function arrayFrom = rt_.global()
-                                .getPropertyAsObject(rt_, "Array")
-                                .getPropertyAsFunction(rt_, "from");
-  jsi::Object result = arrayFrom.call(rt_, object).asObject(rt_);
-
-  if (!result.isArray(rt_)) {
-    return "[Map]";
-  }
-
-  auto arr = result.asArray(rt_);
-  ss << "Map {";
-
-  for (size_t i = 0, length = arr.size(rt_); i < length; i++) {
-    auto pair = arr.getValueAtIndex(rt_, i).asObject(rt_).getArray(rt_);
-    auto key = pair.getValueAtIndex(rt_, 0);
-    auto value = pair.getValueAtIndex(rt_, 1);
-    ss << stringifyJSIValueRecursively(key) << ": "
-       << stringifyJSIValueRecursively(value);
-    if (i != length - 1) {
-      ss << ", ";
-    }
-  }
-
-  ss << '}';
-
-  return ss.str();
-}
-
-std::string JSISerializer::stringifyRecursiveType(const jsi::Object &object) {
-  auto type = getObjectTypeName(rt_, object);
-
-  if (type == "Array") {
-    return "[...]";
-  }
-  if (type == "Object") {
-    return "{...}";
-  }
-  return "...";
-}
-
-std::string JSISerializer::stringifyWithToString(const jsi::Object &object) {
-  return object.getPropertyAsFunction(rt_, "toString")
-      .callWithThis(rt_, object)
-      .toString(rt_)
-      .utf8(rt_);
-}
-
-std::string JSISerializer::stringifyJSIValueRecursively(
-    const jsi::Value &value,
-    bool isTopLevel) {
-  if (value.isBool() || value.isNumber()) {
-    return value.toString(rt_).utf8(rt_);
-  }
-  if (value.isString()) {
-    return isTopLevel ? value.getString(rt_).utf8(rt_)
-                      : '"' + value.getString(rt_).utf8(rt_) + '"';
-  }
-  if (value.isSymbol()) {
-    return value.getSymbol(rt_).toString(rt_);
-  }
-  if (value.isBigInt()) {
-    return value.getBigInt(rt_).toString(rt_).utf8(rt_) + 'n';
-  }
-  if (value.isUndefined()) {
-    return "undefined";
-  }
-  if (value.isNull()) {
-    return "null";
-  }
-  if (value.isObject()) {
-    jsi::Object object = value.asObject(rt_);
-
-    if (hasBeenVisited(object)) {
-      return stringifyRecursiveType(object);
-    }
-    markAsVisited(object);
-
-    if (object.isArray(rt_)) {
-      return stringifyArray(object.getArray(rt_));
-    }
-    if (object.isFunction(rt_)) {
-      return stringifyFunction(object.getFunction(rt_));
-    }
-    if (object.isHostObject(rt_)) {
-      return stringifyHostObject(*object.getHostObject(rt_));
-    }
-    if (isInstanceOfAny(rt_, object, SUPPORTED_ERROR_TYPES)) {
-      return stringifyError(object);
-    }
-    if (isInstanceOfAny(rt_, object, SUPPORTED_INDEXED_COLLECTION_TYPES) ||
-        isInstanceOfAny(rt_, object, SUPPORTED_STRUCTURED_DATA_TYPES) ||
-        isInstanceOfAny(rt_, object, SUPPORTED_MANAGING_MEMORY_TYPES) ||
-        isInstanceOfAny(rt_, object, SUPPORTED_ABSTRACTION_OBJECT_TYPES) ||
-        isInstanceOfAny(rt_, object, SUPPORTED_REFLECTION_TYPES) ||
-        isInstanceOf(rt_, object, "Intl") ||
-        isInstanceOf(rt_, object, "WeakMap") ||
-        isInstanceOf(rt_, object, "WeakSet")) {
-      // TODO: Consider extending this log info
-      return stringifyWithName(object);
-    }
-    if (isInstanceOf(rt_, object, "Date") ||
-        isInstanceOf(rt_, object, "RegExp")) {
-      return stringifyWithToString(object);
-    }
-    if (isInstanceOf(rt_, object, "Map")) {
-      return stringifyMap(object);
-    }
-    if (isInstanceOf(rt_, object, "Set")) {
-      return stringifySet(object);
-    }
-    return stringifyObject(object);
-  }
-
-  throw std::runtime_error("[Reanimated] Unsupported value type.");
-}
-
-std::string stringifyJSIValue(jsi::Runtime &rt, const jsi::Value &value) {
-  JSISerializer serializer(rt);
-
-  return serializer.stringifyJSIValueRecursively(value, true);
-}
-
-} // namespace worklets

package/harmony/reanimated/src/main/cpp/Common/cpp/worklets/Tools/JSISerializer.h

@@ -1,47 +0,0 @@
-#pragma once
-
-#include <jsi/jsi.h>
-#include <string>
-#include <vector>
-
-using namespace facebook;
-
-namespace worklets {
-
-class JSISerializer {
- public:
-  explicit JSISerializer(jsi::Runtime &rt);
-  std::string stringifyJSIValueRecursively(
-      const jsi::Value &value,
-      bool isTopLevel = false);
-
- private:
-  std::string stringifyArray(const jsi::Array &arr);
-  std::string stringifyFunction(const jsi::Function &func);
-  std::string stringifyHostObject(jsi::HostObject &hostObject);
-  std::string stringifyObject(const jsi::Object &object);
-  std::string stringifyError(const jsi::Object &object);
-  std::string stringifySet(const jsi::Object &object);
-  std::string stringifyMap(const jsi::Object &object);
-  std::string stringifyWithName(const jsi::Object &object);
-  std::string stringifyWithToString(const jsi::Object &object);
-  std::string stringifyRecursiveType(const jsi::Object &object);
-
-  bool hasBeenVisited(const jsi::Object &object) {
-    return visitedNodes_.getPropertyAsFunction(rt_, "has")
-        .callWithThis(rt_, visitedNodes_, object)
-        .getBool();
-  }
-
-  void markAsVisited(const jsi::Object &object) {
-    visitedNodes_.getPropertyAsFunction(rt_, "add")
-        .callWithThis(rt_, visitedNodes_, object);
-  }
-
-  jsi::Runtime &rt_;
-  jsi::Object visitedNodes_;
-};
-
-std::string stringifyJSIValue(jsi::Runtime &rt, const jsi::Value &value);
-
-} // namespace worklets

package/harmony/reanimated/src/main/cpp/Common/cpp/worklets/Tools/JSLogger.cpp

@@ -1,16 +0,0 @@
-#include <worklets/Tools/JSLogger.h>
-#include <memory>
-
-namespace worklets {
-
-void JSLogger::warnOnJS(const std::string &warning) const {
-#ifndef NDEBUG
-  jsScheduler_->scheduleOnJS([warning](jsi::Runtime &rt) {
-    auto console = rt.global().getPropertyAsObject(rt, "console");
-    auto warn = console.getPropertyAsFunction(rt, "warn");
-    warn.call(rt, jsi::String::createFromUtf8(rt, warning));
-  });
-#endif // NDEBUG
-}
-
-} // namespace worklets

package/harmony/reanimated/src/main/cpp/Common/cpp/worklets/Tools/JSLogger.h

@@ -1,20 +0,0 @@
-#pragma once
-
-#include <worklets/Tools/JSScheduler.h>
-
-#include <memory>
-#include <string>
-
-namespace worklets {
-
-class JSLogger {
- public:
-  explicit JSLogger(const std::shared_ptr<JSScheduler> &jsScheduler)
-      : jsScheduler_(jsScheduler) {}
-  void warnOnJS(const std::string &warning) const;
-
- private:
-  const std::shared_ptr<JSScheduler> jsScheduler_;
-};
-
-} // namespace worklets

package/harmony/reanimated/src/main/cpp/Common/cpp/worklets/Tools/JSScheduler.cpp

@@ -1,20 +0,0 @@
-#include <worklets/Tools/JSScheduler.h>
-
-#include <utility>
-
-using namespace facebook;
-using namespace react;
-
-namespace worklets {
-
-JSScheduler::JSScheduler(
-    jsi::Runtime &rnRuntime,
-    const std::shared_ptr<CallInvoker> &jsCallInvoker)
-    : scheduleOnJS([&](Job job) {
-        jsCallInvoker_->invokeAsync(
-            [job = std::move(job), &rt = rnRuntime_] { job(rt); });
-      }),
-      rnRuntime_(rnRuntime),
-      jsCallInvoker_(jsCallInvoker) {}
-
-} // namespace worklets

package/harmony/reanimated/src/main/cpp/Common/cpp/worklets/Tools/JSScheduler.h

@@ -1,29 +0,0 @@
-#pragma once
-
-#include <ReactCommon/CallInvoker.h>
-#include <ReactCommon/RuntimeExecutor.h>
-#include <jsi/jsi.h>
-
-#include <memory>
-
-using namespace facebook;
-using namespace react;
-
-namespace worklets {
-
-class JSScheduler {
-  using Job = std::function<void(jsi::Runtime &rt)>;
-
- public:
-  explicit JSScheduler(
-      jsi::Runtime &rnRuntime,
-      const std::shared_ptr<CallInvoker> &jsCallInvoker);
-
-  const std::function<void(Job)> scheduleOnJS = nullptr;
-
- protected:
-  jsi::Runtime &rnRuntime_;
-  const std::shared_ptr<CallInvoker> jsCallInvoker_ = nullptr;
-};
-
-} // namespace worklets

package/harmony/reanimated/src/main/cpp/Common/cpp/worklets/Tools/PlatformLogger.h

@@ -1,16 +0,0 @@
-#pragma once
-
-#include <string>
-
-namespace worklets {
-
-class PlatformLogger {
- public:
-  static void log(const char *str);
-  static void log(const std::string &str);
-  static void log(const double d);
-  static void log(const int i);
-  static void log(const bool b);
-};
-
-} // namespace worklets

package/harmony/reanimated/src/main/cpp/Common/cpp/worklets/Tools/ReanimatedJSIUtils.cpp

@@ -1,26 +0,0 @@
-#include <worklets/Tools/ReanimatedJSIUtils.h>
-#include <vector>
-
-using namespace facebook;
-
-namespace worklets::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 (unsigned int i = 0; i < expectedSize; i++) {
-    matrix.setValueAtIndex(rt, i, transformMatrixList[i]);
-  }
-  return matrix;
-}
-
-} // namespace worklets::jsi_utils