react-native 0.68.2 → 0.69.0-rc.2

package/ReactCommon/react/bridging/Convert.h

@@ -0,0 +1,153 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <jsi/jsi.h>
+
+#include <optional>
+#include <type_traits>
+
+namespace facebook::react::bridging {
+
+// std::remove_cvref_t is not available until C++20.
+template <typename T>
+using remove_cvref_t = std::remove_cv_t<std::remove_reference_t<T>>;
+
+template <typename T>
+inline constexpr bool is_jsi_v =
+    std::is_same_v<jsi::Value, remove_cvref_t<T>> ||
+    std::is_same_v<jsi::String, remove_cvref_t<T>> ||
+    std::is_base_of_v<jsi::Object, remove_cvref_t<T>>;
+
+template <typename T>
+struct Converter;
+
+template <typename T>
+struct ConverterBase {
+  using BaseT = remove_cvref_t<T>;
+
+  ConverterBase(jsi::Runtime &rt, T &&value)
+      : rt_(rt), value_(std::forward<T>(value)) {}
+
+  operator BaseT() && {
+    if constexpr (std::is_lvalue_reference_v<T>) {
+      // Copy the reference into a Value that then can be moved from.
+      auto value = jsi::Value(rt_, value_);
+
+      if constexpr (std::is_same_v<BaseT, jsi::Value>) {
+        return std::move(value);
+      } else if constexpr (std::is_same_v<BaseT, jsi::String>) {
+        return std::move(value).getString(rt_);
+      } else if constexpr (std::is_same_v<BaseT, jsi::Object>) {
+        return std::move(value).getObject(rt_);
+      } else if constexpr (std::is_same_v<BaseT, jsi::Array>) {
+        return std::move(value).getObject(rt_).getArray(rt_);
+      } else if constexpr (std::is_same_v<BaseT, jsi::Function>) {
+        return std::move(value).getObject(rt_).getFunction(rt_);
+      }
+    } else {
+      return std::move(value_);
+    }
+  }
+
+  template <
+      typename U,
+      std::enable_if_t<
+          std::is_lvalue_reference_v<T> &&
+              // Ensure non-reference type can be converted to the desired type.
+              std::is_convertible_v<Converter<BaseT>, U>,
+          int> = 0>
+  operator U() && {
+    return Converter<BaseT>(rt_, std::move(*this).operator BaseT());
+  }
+
+  template <
+      typename U,
+      std::enable_if_t<is_jsi_v<T> && std::is_same_v<U, jsi::Value>, int> = 0>
+  operator U() && = delete; // Prevent unwanted upcasting of JSI values.
+
+ protected:
+  jsi::Runtime &rt_;
+  T value_;
+};
+
+template <typename T>
+struct Converter : public ConverterBase<T> {
+  using ConverterBase<T>::ConverterBase;
+};
+
+template <>
+struct Converter<jsi::Value> : public ConverterBase<jsi::Value> {
+  using ConverterBase<jsi::Value>::ConverterBase;
+
+  operator jsi::String() && {
+    return std::move(value_).asString(rt_);
+  }
+
+  operator jsi::Object() && {
+    return std::move(value_).asObject(rt_);
+  }
+
+  operator jsi::Array() && {
+    return std::move(value_).asObject(rt_).asArray(rt_);
+  }
+
+  operator jsi::Function() && {
+    return std::move(value_).asObject(rt_).asFunction(rt_);
+  }
+};
+
+template <>
+struct Converter<jsi::Object> : public ConverterBase<jsi::Object> {
+  using ConverterBase<jsi::Object>::ConverterBase;
+
+  operator jsi::Array() && {
+    return std::move(value_).asArray(rt_);
+  }
+
+  operator jsi::Function() && {
+    return std::move(value_).asFunction(rt_);
+  }
+};
+
+template <typename T>
+struct Converter<std::optional<T>> : public ConverterBase<jsi::Value> {
+  Converter(jsi::Runtime &rt, std::optional<T> value)
+      : ConverterBase(rt, value ? std::move(*value) : jsi::Value::null()) {}
+
+  operator std::optional<T>() && {
+    if (value_.isNull() || value_.isUndefined()) {
+      return {};
+    }
+    return std::move(value_);
+  }
+};
+
+template <typename T, std::enable_if_t<is_jsi_v<T>, int> = 0>
+auto convert(jsi::Runtime &rt, T &&value) {
+  return Converter<T>(rt, std::forward<T>(value));
+}
+
+template <
+    typename T,
+    std::enable_if_t<is_jsi_v<T> || std::is_scalar_v<T>, int> = 0>
+auto convert(jsi::Runtime &rt, std::optional<T> value) {
+  return Converter<std::optional<T>>(rt, std::move(value));
+}
+
+template <typename T, std::enable_if_t<std::is_scalar_v<T>, int> = 0>
+auto convert(jsi::Runtime &rt, T &&value) {
+  return value;
+}
+
+template <typename T>
+auto convert(jsi::Runtime &rt, Converter<T> &&converter) {
+  return std::move(converter);
+}
+
+} // namespace facebook::react::bridging

package/ReactCommon/react/bridging/Error.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <react/bridging/Base.h>
+
+namespace facebook::react {
+
+class Error {
+ public:
+  // TODO (T114055466): Retain stack trace (at least caller location)
+  Error(std::string message) : message_(std::move(message)) {}
+
+  Error(const char *message) : Error(std::string(message)) {}
+
+  const std::string &message() const {
+    return message_;
+  }
+
+ private:
+  std::string message_;
+};
+
+template <>
+struct Bridging<jsi::JSError> {
+  static jsi::JSError fromJs(jsi::Runtime &rt, const jsi::Value &value) {
+    return jsi::JSError(rt, jsi::Value(rt, value));
+  }
+
+  static jsi::JSError fromJs(jsi::Runtime &rt, jsi::Value &&value) {
+    return jsi::JSError(rt, std::move(value));
+  }
+
+  static jsi::Value toJs(jsi::Runtime &rt, std::string message) {
+    return jsi::Value(rt, jsi::JSError(rt, std::move(message)).value());
+  }
+};
+
+template <>
+struct Bridging<Error> {
+  static jsi::Value toJs(jsi::Runtime &rt, const Error &error) {
+    return jsi::Value(rt, jsi::JSError(rt, error.message()).value());
+  }
+};
+
+} // namespace facebook::react

package/ReactCommon/react/bridging/Function.h

@@ -0,0 +1,214 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <react/bridging/Base.h>
+#include <react/bridging/CallbackWrapper.h>
+
+#include <folly/Function.h>
+
+namespace facebook::react {
+
+template <typename F>
+class SyncCallback;
+
+template <typename... Args>
+class AsyncCallback {
+ public:
+  AsyncCallback(
+      jsi::Runtime &runtime,
+      jsi::Function function,
+      std::shared_ptr<CallInvoker> jsInvoker)
+      : callback_(std::make_shared<SyncCallback<void(Args...)>>(
+            runtime,
+            std::move(function),
+            std::move(jsInvoker))) {}
+
+  AsyncCallback(const AsyncCallback &) = default;
+  AsyncCallback &operator=(const AsyncCallback &) = default;
+
+  void operator()(Args... args) const {
+    call(std::forward<Args>(args)...);
+  }
+
+  void call(Args... args) const {
+    auto wrapper = callback_->wrapper_.lock();
+    if (!wrapper) {
+      throw std::runtime_error("Failed to call invalidated async callback");
+    }
+
+    auto argsTuple = std::make_tuple(std::forward<Args>(args)...);
+
+    wrapper->jsInvoker().invokeAsync(
+        [callback = callback_,
+         argsPtr = std::make_shared<decltype(argsTuple)>(
+             std::move(argsTuple))] { callback->apply(std::move(*argsPtr)); });
+  }
+
+ private:
+  friend Bridging<AsyncCallback>;
+
+  std::shared_ptr<SyncCallback<void(Args...)>> callback_;
+};
+
+template <typename R, typename... Args>
+class SyncCallback<R(Args...)> {
+ public:
+  SyncCallback(
+      jsi::Runtime &rt,
+      jsi::Function function,
+      std::shared_ptr<CallInvoker> jsInvoker)
+      : wrapper_(CallbackWrapper::createWeak(
+            std::move(function),
+            rt,
+            std::move(jsInvoker))) {}
+
+  // Disallow moving to prevent function from get called on another thread.
+  SyncCallback(SyncCallback &&) = delete;
+  SyncCallback &operator=(SyncCallback &&) = delete;
+
+  ~SyncCallback() {
+    if (auto wrapper = wrapper_.lock()) {
+      wrapper->destroy();
+    }
+  }
+
+  R operator()(Args... args) const {
+    return call(std::forward<Args>(args)...);
+  }
+
+  R call(Args... args) const {
+    auto wrapper = wrapper_.lock();
+    if (!wrapper) {
+      throw std::runtime_error("Failed to call invalidated sync callback");
+    }
+
+    auto &callback = wrapper->callback();
+    auto &rt = wrapper->runtime();
+    auto jsInvoker = wrapper->jsInvokerPtr();
+
+    if constexpr (std::is_void_v<R>) {
+      callback.call(
+          rt, bridging::toJs(rt, std::forward<Args>(args), jsInvoker)...);
+    } else {
+      return bridging::fromJs<R>(
+          rt,
+          callback.call(
+              rt, bridging::toJs(rt, std::forward<Args>(args), jsInvoker)...),
+          jsInvoker);
+    }
+  }
+
+ private:
+  friend AsyncCallback<Args...>;
+  friend Bridging<SyncCallback>;
+
+  R apply(std::tuple<Args...> &&args) const {
+    return apply(std::move(args), std::index_sequence_for<Args...>{});
+  }
+
+  template <size_t... Index>
+  R apply(std::tuple<Args...> &&args, std::index_sequence<Index...>) const {
+    return call(std::move(std::get<Index>(args))...);
+  }
+
+  // Held weakly so lifetime is managed by LongLivedObjectCollection.
+  std::weak_ptr<CallbackWrapper> wrapper_;
+};
+
+template <typename... Args>
+struct Bridging<AsyncCallback<Args...>> {
+  static AsyncCallback<Args...> fromJs(
+      jsi::Runtime &rt,
+      jsi::Function &&value,
+      const std::shared_ptr<CallInvoker> &jsInvoker) {
+    return AsyncCallback<Args...>(rt, std::move(value), jsInvoker);
+  }
+
+  static jsi::Function toJs(
+      jsi::Runtime &rt,
+      const AsyncCallback<Args...> &value) {
+    return value.callback_->function_.getFunction(rt);
+  }
+};
+
+template <typename R, typename... Args>
+struct Bridging<SyncCallback<R(Args...)>> {
+  static SyncCallback<R(Args...)> fromJs(
+      jsi::Runtime &rt,
+      jsi::Function &&value,
+      const std::shared_ptr<CallInvoker> &jsInvoker) {
+    return SyncCallback<R(Args...)>(rt, std::move(value), jsInvoker);
+  }
+
+  static jsi::Function toJs(
+      jsi::Runtime &rt,
+      const SyncCallback<R(Args...)> &value) {
+    return value.function_.getFunction(rt);
+  }
+};
+
+template <typename R, typename... Args>
+struct Bridging<folly::Function<R(Args...)>> {
+  using Func = folly::Function<R(Args...)>;
+  using IndexSequence = std::index_sequence_for<Args...>;
+
+  static constexpr size_t kArgumentCount = sizeof...(Args);
+
+  static jsi::Function toJs(
+      jsi::Runtime &rt,
+      Func fn,
+      const std::shared_ptr<CallInvoker> &jsInvoker) {
+    return jsi::Function::createFromHostFunction(
+        rt,
+        jsi::PropNameID::forAscii(rt, "BridgedFunction"),
+        kArgumentCount,
+        [fn = std::make_shared<Func>(std::move(fn)), jsInvoker](
+            jsi::Runtime &rt,
+            const jsi::Value &,
+            const jsi::Value *args,
+            size_t count) -> jsi::Value {
+          if (count < kArgumentCount) {
+            throw jsi::JSError(rt, "Incorrect number of arguments");
+          }
+
+          if constexpr (std::is_void_v<R>) {
+            callFromJs(*fn, rt, args, jsInvoker, IndexSequence{});
+            return jsi::Value();
+          } else {
+            return bridging::toJs(
+                rt,
+                callFromJs(*fn, rt, args, jsInvoker, IndexSequence{}),
+                jsInvoker);
+          }
+        });
+  }
+
+ private:
+  template <size_t... Index>
+  static R callFromJs(
+      Func &fn,
+      jsi::Runtime &rt,
+      const jsi::Value *args,
+      const std::shared_ptr<CallInvoker> &jsInvoker,
+      std::index_sequence<Index...>) {
+    return fn(bridging::fromJs<Args>(rt, args[Index], jsInvoker)...);
+  }
+};
+
+template <typename R, typename... Args>
+struct Bridging<std::function<R(Args...)>>
+    : Bridging<folly::Function<R(Args...)>> {};
+
+template <typename R, typename... Args>
+struct Bridging<R(Args...)> : Bridging<folly::Function<R(Args...)>> {};
+
+template <typename R, typename... Args>
+struct Bridging<R (*)(Args...)> : Bridging<folly::Function<R(Args...)>> {};
+
+} // namespace facebook::react

package/ReactCommon/react/{nativemodule/core/ReactCommon → bridging}/LongLivedObject.cpp

@@ -41,6 +41,11 @@ void LongLivedObjectCollection::clear() const {
   collection_.clear();
 }
 
+size_t LongLivedObjectCollection::size() const {
+  std::lock_guard<std::mutex> lock(collectionMutex_);
+  return collection_.size();
+}
+
 // LongLivedObject
 LongLivedObject::LongLivedObject() {}
 LongLivedObject::~LongLivedObject() {}

package/ReactCommon/react/bridging/LongLivedObject.h

@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <memory>
+#include <mutex>
+#include <unordered_set>
+
+namespace facebook {
+namespace react {
+
+/**
+ * A simple wrapper class that can be registered to a collection that keep it
+ * alive for extended period of time. This object can be removed from the
+ * collection when needed.
+ *
+ * The subclass of this class must be created using std::make_shared<T>().
+ * After creation, add it to the `LongLivedObjectCollection`.
+ * When done with the object, call `allowRelease()` to allow the OS to release
+ * it.
+ */
+class LongLivedObject {
+ public:
+  virtual void allowRelease();
+
+ protected:
+  LongLivedObject();
+  virtual ~LongLivedObject();
+};
+
+/**
+ * A singleton, thread-safe, write-only collection for the `LongLivedObject`s.
+ */
+class LongLivedObjectCollection {
+ public:
+  static LongLivedObjectCollection &get();
+
+  LongLivedObjectCollection();
+  LongLivedObjectCollection(LongLivedObjectCollection const &) = delete;
+  void operator=(LongLivedObjectCollection const &) = delete;
+
+  void add(std::shared_ptr<LongLivedObject> o) const;
+  void remove(const LongLivedObject *o) const;
+  void clear() const;
+  size_t size() const;
+
+ private:
+  mutable std::unordered_set<std::shared_ptr<LongLivedObject>> collection_;
+  mutable std::mutex collectionMutex_;
+};
+
+} // namespace react
+} // namespace facebook

package/ReactCommon/react/bridging/Number.h

@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <react/bridging/Base.h>
+
+namespace facebook::react {
+
+template <>
+struct Bridging<double> {
+  static double fromJs(jsi::Runtime &, const jsi::Value &value) {
+    return value.asNumber();
+  }
+
+  static jsi::Value toJs(jsi::Runtime &, double value) {
+    return value;
+  }
+};
+
+template <>
+struct Bridging<float> {
+  static float fromJs(jsi::Runtime &, const jsi::Value &value) {
+    return (float)value.asNumber();
+  }
+
+  static jsi::Value toJs(jsi::Runtime &, float value) {
+    return (double)value;
+  }
+};
+
+template <>
+struct Bridging<int32_t> {
+  static int32_t fromJs(jsi::Runtime &, const jsi::Value &value) {
+    return (int32_t)value.asNumber();
+  }
+
+  static jsi::Value toJs(jsi::Runtime &, int32_t value) {
+    return value;
+  }
+};
+
+} // namespace facebook::react

package/ReactCommon/react/bridging/Object.h

@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <react/bridging/AString.h>
+#include <react/bridging/Base.h>
+
+#include <butter/map.h>
+#include <map>
+#include <unordered_map>
+
+namespace facebook::react {
+
+template <>
+struct Bridging<jsi::WeakObject> {
+  static jsi::WeakObject fromJs(jsi::Runtime &rt, const jsi::Object &value) {
+    return jsi::WeakObject(rt, value);
+  }
+
+  static jsi::Value toJs(jsi::Runtime &rt, jsi::WeakObject &value) {
+    return value.lock(rt);
+  }
+};
+
+template <typename T>
+struct Bridging<
+    std::shared_ptr<T>,
+    std::enable_if_t<std::is_base_of_v<jsi::HostObject, T>>> {
+  static std::shared_ptr<T> fromJs(jsi::Runtime &rt, const jsi::Object &value) {
+    return value.asHostObject<T>(rt);
+  }
+
+  static jsi::Object toJs(jsi::Runtime &rt, std::shared_ptr<T> value) {
+    return jsi::Object::createFromHostObject(rt, std::move(value));
+  }
+};
+
+namespace map_detail {
+
+template <typename T>
+struct Bridging {
+  static T fromJs(
+      jsi::Runtime &rt,
+      const jsi::Object &value,
+      const std::shared_ptr<CallInvoker> &jsInvoker) {
+    T result;
+    auto propertyNames = value.getPropertyNames(rt);
+    auto length = propertyNames.length(rt);
+
+    for (size_t i = 0; i < length; i++) {
+      auto propertyName = propertyNames.getValueAtIndex(rt, i);
+
+      result.emplace(
+          bridging::fromJs<std::string>(rt, propertyName, jsInvoker),
+          bridging::fromJs<typename T::mapped_type>(
+              rt, value.getProperty(rt, propertyName.asString(rt)), jsInvoker));
+    }
+
+    return result;
+  }
+
+  static jsi::Object toJs(
+      jsi::Runtime &rt,
+      const T &map,
+      const std::shared_ptr<CallInvoker> &jsInvoker) {
+    auto resultObject = jsi::Object(rt);
+
+    for (const auto &[key, value] : map) {
+      resultObject.setProperty(
+          rt,
+          jsi::PropNameID::forUtf8(rt, key),
+          bridging::toJs(rt, value, jsInvoker));
+    }
+
+    return resultObject;
+  }
+};
+
+} // namespace map_detail
+
+#ifdef BUTTER_USE_FOLLY_CONTAINERS
+template <typename... Args>
+struct Bridging<butter::map<std::string, Args...>>
+    : map_detail::Bridging<butter::map<std::string, Args...>> {};
+#endif
+
+template <typename... Args>
+struct Bridging<std::map<std::string, Args...>>
+    : map_detail::Bridging<std::map<std::string, Args...>> {};
+
+template <typename... Args>
+struct Bridging<std::unordered_map<std::string, Args...>>
+    : map_detail::Bridging<std::unordered_map<std::string, Args...>> {};
+
+} // namespace facebook::react