@depup/react-native-worklets 0.11.3-depup.0

package/Common/cpp/worklets/Tools/JSISerializer.cpp

@@ -0,0 +1,312 @@
+#include <worklets/Tools/JSISerializer.h>
+
+#include <cxxabi.h>
+
+#include <memory>
+#include <sstream>
+#include <string>
+#include <vector>
+
+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;
+  std::unique_ptr<char, decltype(&std::free)> hostObjClassName(
+      abi::__cxa_demangle(typeid(hostObject).name(), nullptr, nullptr, &status), std::free);
+  if (status != 0) {
+    return "[jsi::HostObject]";
+  }
+
+  std::stringstream ss;
+  ss << "[jsi::HostObject(" << hostObjClassName.get() << ")";
+
+  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("[Worklets] Unsupported value type.");
+}
+
+std::string stringifyJSIValue(jsi::Runtime &rt, const jsi::Value &value) {
+  JSISerializer serializer(rt);
+
+  return serializer.stringifyJSIValueRecursively(value, true);
+}
+
+} // namespace worklets

package/Common/cpp/worklets/Tools/JSISerializer.h

@@ -0,0 +1,42 @@
+#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/Common/cpp/worklets/Tools/JSLogger.cpp

@@ -0,0 +1,92 @@
+#include <worklets/Tools/JSLogger.h>
+
+#include <memory>
+#include <string>
+#include <utility>
+
+namespace worklets {
+
+void JSLogger::warnOnJS(const std::string &warning) const {
+#ifndef NDEBUG
+  jsScheduler_->scheduleOnJS([warning](jsi::Runtime &rnRuntime) {
+    auto console = rnRuntime.global().getPropertyAsObject(rnRuntime, "console");
+    auto warn = console.getPropertyAsFunction(rnRuntime, "warn");
+    warn.call(rnRuntime, jsi::String::createFromUtf8(rnRuntime, warning));
+  });
+#endif // NDEBUG
+}
+
+void JSLogger::reportFatalErrorOnJS(
+    const std::shared_ptr<JSScheduler> &jsScheduler,
+    JSErrorData &&jsErrorData,
+    bool force) {
+  auto job = [jsErrorData = std::move(jsErrorData), force](jsi::Runtime &rnRuntime) {
+    reportFatalErrorOnJS(rnRuntime, jsErrorData, force);
+  };
+  if (jsScheduler->canInvokeSyncOnJS()) {
+    jsScheduler->invokeSyncOnJS(job);
+  } else {
+    jsScheduler->scheduleOnJS(job);
+  }
+}
+
+void JSLogger::reportFatalErrorOnJS(jsi::Runtime &rnRuntime, const JSErrorData &jsErrorData, bool force) {
+  const auto &global = rnRuntime.global();
+  const auto errorInstance =
+      rnRuntime.global().getPropertyAsFunction(rnRuntime, "Error").callAsConstructor(rnRuntime).asObject(rnRuntime);
+
+  errorInstance.setProperty(rnRuntime, "message", jsi::String::createFromUtf8(rnRuntime, jsErrorData.message));
+
+  errorInstance.setProperty(rnRuntime, "stack", jsi::String::createFromUtf8(rnRuntime, jsErrorData.stack));
+
+  errorInstance.setProperty(rnRuntime, "name", jsi::String::createFromUtf8(rnRuntime, jsErrorData.name));
+
+  const auto &reportFatalErrorFunction = global.getPropertyAsFunction(rnRuntime, "__reportFatalRemoteError");
+  reportFatalErrorFunction.call(rnRuntime, errorInstance, force);
+}
+
+#ifndef NDEBUG
+static std::string labelStackFrames(const std::string &rawStack, const std::string &label) {
+  static const std::string sep = "\n    at";
+  std::string result;
+  size_t pos = rawStack.find(sep);
+  while (pos != std::string::npos) {
+    size_t next = rawStack.find(sep, pos + sep.size());
+    size_t end = (next == std::string::npos) ? rawStack.size() : next;
+    result += "\n    at [" + label + "]:" + rawStack.substr(pos + sep.size(), end - (pos + sep.size()));
+    pos = next;
+  }
+  return result;
+}
+
+void JSLogger::handleJSError(
+    const std::shared_ptr<JSScheduler> &jsScheduler,
+    jsi::Runtime &workletRuntime,
+    const std::string &runtimeName,
+    jsi::JSError &error,
+    const std::optional<std::string> &scheduleStack) {
+  std::string name = "WorkletsError";
+  const auto &errVal = error.value();
+  if (errVal.isObject()) {
+    auto errObj = errVal.asObject(workletRuntime);
+    if (errObj.hasProperty(workletRuntime, "name")) {
+      auto nameVal = errObj.getProperty(workletRuntime, "name");
+      if (nameVal.isString()) {
+        name = nameVal.asString(workletRuntime).utf8(workletRuntime);
+      }
+    }
+  }
+
+  const auto &message = error.getMessage();
+  std::string combined = message + labelStackFrames(error.getStack(), runtimeName);
+  if (scheduleStack.has_value()) {
+    auto pos = scheduleStack->find("\n    at");
+    if (pos != std::string::npos) {
+      combined += scheduleStack->substr(pos);
+    }
+  }
+  reportFatalErrorOnJS(jsScheduler, JSErrorData{.message = message, .stack = combined, .name = name});
+}
+#endif // NDEBUG
+
+} // namespace worklets

package/Common/cpp/worklets/Tools/JSLogger.h

@@ -0,0 +1,48 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <worklets/Tools/JSScheduler.h>
+
+#include <memory>
+#include <optional>
+#include <string>
+
+namespace worklets {
+
+struct JSErrorData {
+  std::string message;
+  std::string stack;
+  std::string name;
+};
+
+class JSLogger {
+ public:
+  explicit JSLogger(const std::shared_ptr<JSScheduler> &jsScheduler) : jsScheduler_(jsScheduler) {}
+  void warnOnJS(const std::string &warning) const;
+
+  static void
+  reportFatalErrorOnJS(const std::shared_ptr<JSScheduler> &jsScheduler, JSErrorData &&jsErrorData, bool force = false);
+
+#ifndef NDEBUG
+  /**
+   * Forwards a `jsi::JSError` raised on a worklet runtime to the RN runtime so
+   * RN's LogBox can display it. The reported stack is rewritten to label each
+   * frame with `runtimeName` and, when present, the `scheduleStack` is appended
+   * so users can trace the error back to the JS call site that scheduled the
+   * worklet.
+   */
+  static void handleJSError(
+      const std::shared_ptr<JSScheduler> &jsScheduler,
+      facebook::jsi::Runtime &workletRuntime,
+      const std::string &runtimeName,
+      facebook::jsi::JSError &error,
+      const std::optional<std::string> &scheduleStack);
+#endif // NDEBUG
+
+ private:
+  static void reportFatalErrorOnJS(jsi::Runtime &rnRuntime, const JSErrorData &jsErrorData, bool force = false);
+
+  const std::shared_ptr<JSScheduler> jsScheduler_;
+};
+
+} // namespace worklets

package/Common/cpp/worklets/Tools/JSScheduler.cpp

@@ -0,0 +1,21 @@
+#include <react/debug/react_native_assert.h>
+#include <worklets/Tools/JSScheduler.h>
+
+#include <utility>
+
+namespace worklets {
+
+void JSScheduler::scheduleOnJS(Job job) {
+  jsCallInvoker_->invokeAsync([job = std::move(job), &rt = rnRuntime_] { job(rt); });
+}
+
+bool JSScheduler::canInvokeSyncOnJS() {
+  return isJavaScriptQueue_();
+}
+
+void JSScheduler::invokeSyncOnJS(const Job &job) {
+  react_native_assert(canInvokeSyncOnJS() && "JSScheduler::invokeSyncOnJS should only be called from the JS thread");
+  job(rnRuntime_);
+}
+
+} // namespace worklets

package/Common/cpp/worklets/Tools/JSScheduler.h

@@ -0,0 +1,35 @@
+#pragma once
+
+#include <ReactCommon/CallInvoker.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,
+      std::function<bool()> &&isJavaScriptQueue)
+      : rnRuntime_(rnRuntime), jsCallInvoker_(jsCallInvoker), isJavaScriptQueue_(isJavaScriptQueue) {}
+
+  void scheduleOnJS(std::function<void(jsi::Runtime &rt)> job);
+
+  void invokeSyncOnJS(const std::function<void(jsi::Runtime &rt)> &job);
+
+  bool canInvokeSyncOnJS();
+
+ protected:
+  jsi::Runtime &rnRuntime_;
+  const std::shared_ptr<CallInvoker> jsCallInvoker_;
+  const std::function<bool()> isJavaScriptQueue_;
+};
+
+} // namespace worklets

package/Common/cpp/worklets/Tools/PlatformLogger.h

@@ -0,0 +1,16 @@
+#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/Common/cpp/worklets/Tools/RNRuntimeStatus.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include <shared_mutex>
+#include <utility>
+
+namespace worklets {
+
+class RNRuntimeStatus {
+ public:
+  void setDead() {
+    std::lock_guard<std::shared_mutex> lock(mutex_);
+    isDead_ = true;
+  }
+
+  template <typename TFn>
+  void runWhileLocked(TFn &&fn) {
+    std::shared_lock<std::shared_mutex> lock(mutex_);
+    const bool isDead = isDead_;
+    std::forward<TFn>(fn)(isDead);
+  }
+
+ private:
+  bool isDead_ = false;
+  std::shared_mutex mutex_;
+};
+
+} // namespace worklets

package/Common/cpp/worklets/Tools/ScriptBuffer.h

@@ -0,0 +1,56 @@
+#pragma once
+
+#include <cxxreact/ReactNativeVersion.h>
+#include <jsi/jsi.h>
+
+#if REACT_NATIVE_VERSION_MINOR >= 84
+#include <cxxreact/JSBigString.h>
+#else
+#include <jsireact/JSIExecutor.h>
+#endif
+
+#include <memory>
+#include <utility>
+
+namespace worklets {
+
+using namespace facebook;
+using namespace facebook::react;
+
+/**
+ * Our custom copyable structure that is accepted by
+ * Hermes Runtime for evaluation.
+ */
+class ScriptBuffer : public jsi::Buffer {
+ public:
+  explicit ScriptBuffer(std::shared_ptr<const JSBigString> script) : script_(std::move(script)) {}
+
+  size_t size() const override {
+    return script_->size();
+  }
+
+  const uint8_t *data() const override {
+    return reinterpret_cast<const uint8_t *>(script_->c_str());
+  }
+
+ private:
+  std::shared_ptr<const JSBigString> script_;
+};
+
+class BytecodeBuffer : public jsi::Buffer {
+ public:
+  explicit BytecodeBuffer(const std::vector<uint8_t> &bytecode) : bytecode_(bytecode) {}
+
+  size_t size() const override {
+    return bytecode_.size();
+  }
+
+  const uint8_t *data() const override {
+    return bytecode_.data();
+  }
+
+ private:
+  std::vector<uint8_t> bytecode_;
+};
+
+} // namespace worklets