react-native 0.68.1 → 0.69.0-rc.1

package/ReactCommon/microprofiler/BUCK

@@ -12,12 +12,15 @@ cxx_library(
     compiler_flags = [
         "-Wall",
         "-Werror",
-        "-std=c++14",
+        "-std=c++17",
         "-fexceptions",
         "-fno-data-sections",
     ],
     force_static = True,
-    labels = ["supermodule:xplat/default/public.react_native.infra"],
+    labels = [
+        "pfh:ReactNative_CommonInfrastructurePlaceholder",
+        "supermodule:xplat/default/public.react_native.infra",
+    ],
     visibility = [
         "PUBLIC",
     ],

package/ReactCommon/react/bridging/AString.h

@@ -0,0 +1,42 @@
+/*
+ * 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 <string>
+#include <string_view>
+
+namespace facebook::react {
+
+template <>
+struct Bridging<std::string> {
+  static std::string fromJs(jsi::Runtime &rt, const jsi::String &value) {
+    return value.utf8(rt);
+  }
+
+  static jsi::String toJs(jsi::Runtime &rt, const std::string &value) {
+    return jsi::String::createFromUtf8(rt, value);
+  }
+};
+
+template <>
+struct Bridging<std::string_view> {
+  static jsi::String toJs(jsi::Runtime &rt, std::string_view value) {
+    return jsi::String::createFromUtf8(
+        rt, reinterpret_cast<const uint8_t *>(value.data()), value.length());
+  }
+};
+
+template <>
+struct Bridging<const char *> : Bridging<std::string_view> {};
+
+template <size_t N>
+struct Bridging<char[N]> : Bridging<std::string_view> {};
+
+} // namespace facebook::react

package/ReactCommon/react/bridging/Android.mk

@@ -0,0 +1,27 @@
+# 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.
+
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE := react_bridging
+
+LOCAL_SRC_FILES := $(wildcard $(LOCAL_PATH)/*.cpp)
+
+LOCAL_C_INCLUDES := $(LOCAL_PATH)
+LOCAL_EXPORT_C_INCLUDES := $(LOCAL_PATH)/../../
+
+LOCAL_CFLAGS += -fexceptions -frtti -std=c++17 -Wall
+
+LOCAL_STATIC_LIBRARIES :=
+
+LOCAL_SHARED_LIBRARIES := jsi
+
+include $(BUILD_STATIC_LIBRARY)
+
+$(call import-module,butter)
+$(call import-module,folly)
+$(call import-module,jsi)

package/ReactCommon/react/bridging/Array.h

@@ -0,0 +1,108 @@
+/*
+ * 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 <array>
+#include <deque>
+#include <initializer_list>
+#include <list>
+#include <tuple>
+#include <utility>
+#include <vector>
+
+namespace facebook::react {
+
+namespace array_detail {
+
+template <typename T, size_t N>
+struct BridgingStatic {
+  static jsi::Array toJs(
+      jsi::Runtime &rt,
+      const T &array,
+      const std::shared_ptr<CallInvoker> &jsInvoker) {
+    return toJs(rt, array, jsInvoker, std::make_index_sequence<N>{});
+  }
+
+ private:
+  template <size_t... Index>
+  static jsi::Array toJs(
+      facebook::jsi::Runtime &rt,
+      const T &array,
+      const std::shared_ptr<CallInvoker> &jsInvoker,
+      std::index_sequence<Index...>) {
+    return jsi::Array::createWithElements(
+        rt, bridging::toJs(rt, std::get<Index>(array), jsInvoker)...);
+  }
+};
+
+template <typename T>
+struct BridgingDynamic {
+  static jsi::Array toJs(
+      jsi::Runtime &rt,
+      const T &list,
+      const std::shared_ptr<CallInvoker> &jsInvoker) {
+    jsi::Array result(rt, list.size());
+    size_t index = 0;
+
+    for (const auto &item : list) {
+      result.setValueAtIndex(rt, index++, bridging::toJs(rt, item, jsInvoker));
+    }
+
+    return result;
+  }
+};
+
+} // namespace array_detail
+
+template <typename T, size_t N>
+struct Bridging<std::array<T, N>>
+    : array_detail::BridgingStatic<std::array<T, N>, N> {};
+
+template <typename T1, typename T2>
+struct Bridging<std::pair<T1, T2>>
+    : array_detail::BridgingStatic<std::pair<T1, T2>, 2> {};
+
+template <typename... Types>
+struct Bridging<std::tuple<Types...>>
+    : array_detail::BridgingStatic<std::tuple<Types...>, sizeof...(Types)> {};
+
+template <typename T>
+struct Bridging<std::deque<T>> : array_detail::BridgingDynamic<std::deque<T>> {
+};
+
+template <typename T>
+struct Bridging<std::initializer_list<T>>
+    : array_detail::BridgingDynamic<std::initializer_list<T>> {};
+
+template <typename T>
+struct Bridging<std::list<T>> : array_detail::BridgingDynamic<std::list<T>> {};
+
+template <typename T>
+struct Bridging<std::vector<T>>
+    : array_detail::BridgingDynamic<std::vector<T>> {
+  static std::vector<T> fromJs(
+      facebook::jsi::Runtime &rt,
+      const jsi::Array &array,
+      const std::shared_ptr<CallInvoker> &jsInvoker) {
+    size_t length = array.length(rt);
+
+    std::vector<T> vector;
+    vector.reserve(length);
+
+    for (size_t i = 0; i < length; i++) {
+      vector.push_back(
+          bridging::fromJs<T>(rt, array.getValueAtIndex(rt, i), jsInvoker));
+    }
+
+    return vector;
+  }
+};
+
+} // namespace facebook::react

package/ReactCommon/react/bridging/BUCK

@@ -0,0 +1,57 @@
+load("//tools/build_defs/oss:rn_defs.bzl", "ANDROID", "APPLE", "CXX", "IOS", "MACOSX", "fb_xplat_cxx_test", "react_native_xplat_shared_library_target", "react_native_xplat_target", "rn_xplat_cxx_library")
+
+rn_xplat_cxx_library(
+    name = "bridging",
+    srcs = glob(["*.cpp"]),
+    header_namespace = "react/bridging",
+    exported_headers = glob(["*.h"]),
+    compiler_flags_enable_exceptions = True,
+    compiler_flags_enable_rtti = True,
+    labels = [
+        "pfh:ReactNative_CommonInfrastructurePlaceholder",
+        "supermodule:xplat/default/public.react_native.infra",
+    ],
+    platforms = (ANDROID, APPLE, CXX),
+    tests = [":tests"],
+    visibility = ["PUBLIC"],
+    deps = [
+        "//xplat/folly:headers_only",
+    ],
+    exported_deps = [
+        react_native_xplat_target("butter:butter"),
+        react_native_xplat_target("callinvoker:callinvoker"),
+        react_native_xplat_shared_library_target("jsi:jsi"),
+    ],
+)
+
+rn_xplat_cxx_library(
+    name = "testlib",
+    header_namespace = "react/bridging",
+    exported_headers = glob(["tests/*.h"]),
+    platforms = (ANDROID, APPLE, CXX),
+    visibility = ["PUBLIC"],
+    exported_deps = [
+        ":bridging",
+        "//xplat/third-party/gmock:gtest",
+    ],
+)
+
+fb_xplat_cxx_test(
+    name = "tests",
+    srcs = glob(["tests/*.cpp"]),
+    headers = glob(["tests/*.h"]),
+    apple_sdks = (IOS, MACOSX),
+    compiler_flags = [
+        "-fexceptions",
+        "-frtti",
+        "-std=c++17",
+        "-Wall",
+    ],
+    contacts = ["oncall+react_native@xmail.facebook.com"],
+    platforms = (ANDROID, APPLE, CXX),
+    deps = [
+        ":bridging",
+        "//xplat/hermes/API:HermesAPI",
+        "//xplat/third-party/gmock:gtest",
+    ],
+)

package/ReactCommon/react/bridging/Base.h

@@ -0,0 +1,154 @@
+/*
+ * 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/Convert.h>
+
+#include <ReactCommon/CallInvoker.h>
+#include <folly/Function.h>
+#include <jsi/jsi.h>
+
+#include <cstdint>
+#include <memory>
+#include <type_traits>
+
+namespace facebook::react {
+
+template <typename T, typename = void>
+struct Bridging;
+
+template <>
+struct Bridging<void> {
+  // Highly generic code may result in "casting" to void.
+  static void fromJs(jsi::Runtime &, const jsi::Value &) {}
+};
+
+namespace bridging {
+namespace detail {
+
+template <typename F>
+struct function_wrapper;
+
+template <typename C, typename R, typename... Args>
+struct function_wrapper<R (C::*)(Args...)> {
+  using type = folly::Function<R(Args...)>;
+};
+
+template <typename C, typename R, typename... Args>
+struct function_wrapper<R (C::*)(Args...) const> {
+  using type = folly::Function<R(Args...)>;
+};
+
+template <typename T, typename = void>
+struct bridging_wrapper {
+  using type = remove_cvref_t<T>;
+};
+
+// Convert lambda types to move-only function types since we can't specialize
+// Bridging templates for arbitrary lambdas.
+template <typename T>
+struct bridging_wrapper<
+    T,
+    std::void_t<decltype(&remove_cvref_t<T>::operator())>>
+    : function_wrapper<decltype(&remove_cvref_t<T>::operator())> {};
+
+} // namespace detail
+
+template <typename T>
+using bridging_t = typename detail::bridging_wrapper<T>::type;
+
+template <typename R, typename T, std::enable_if_t<is_jsi_v<T>, int> = 0>
+auto fromJs(jsi::Runtime &rt, T &&value, const std::shared_ptr<CallInvoker> &)
+    -> decltype(static_cast<R>(convert(rt, std::forward<T>(value)))) {
+  return convert(rt, std::forward<T>(value));
+}
+
+template <typename R, typename T>
+auto fromJs(jsi::Runtime &rt, T &&value, const std::shared_ptr<CallInvoker> &)
+    -> decltype(Bridging<remove_cvref_t<R>>::fromJs(
+        rt,
+        convert(rt, std::forward<T>(value)))) {
+  return Bridging<remove_cvref_t<R>>::fromJs(
+      rt, convert(rt, std::forward<T>(value)));
+}
+
+template <typename R, typename T>
+auto fromJs(
+    jsi::Runtime &rt,
+    T &&value,
+    const std::shared_ptr<CallInvoker> &jsInvoker)
+    -> decltype(Bridging<remove_cvref_t<R>>::fromJs(
+        rt,
+        convert(rt, std::forward<T>(value)),
+        jsInvoker)) {
+  return Bridging<remove_cvref_t<R>>::fromJs(
+      rt, convert(rt, std::forward<T>(value)), jsInvoker);
+}
+
+template <typename T, std::enable_if_t<is_jsi_v<T>, int> = 0>
+auto toJs(
+    jsi::Runtime &rt,
+    T &&value,
+    const std::shared_ptr<CallInvoker> & = nullptr)
+    -> decltype(convert(rt, std::forward<T>(value))) {
+  return convert(rt, std::forward<T>(value));
+}
+
+template <typename T>
+auto toJs(
+    jsi::Runtime &rt,
+    T &&value,
+    const std::shared_ptr<CallInvoker> & = nullptr)
+    -> decltype(Bridging<bridging_t<T>>::toJs(rt, std::forward<T>(value))) {
+  return Bridging<bridging_t<T>>::toJs(rt, std::forward<T>(value));
+}
+
+template <typename T>
+auto toJs(
+    jsi::Runtime &rt,
+    T &&value,
+    const std::shared_ptr<CallInvoker> &jsInvoker)
+    -> decltype(Bridging<bridging_t<T>>::toJs(
+        rt,
+        std::forward<T>(value),
+        jsInvoker)) {
+  return Bridging<bridging_t<T>>::toJs(rt, std::forward<T>(value), jsInvoker);
+}
+
+template <typename, typename = jsi::Value, typename = void>
+inline constexpr bool supportsFromJs = false;
+
+template <typename T, typename Arg = jsi::Value>
+inline constexpr bool supportsFromJs<
+    T,
+    Arg,
+    std::void_t<decltype(fromJs<T>(
+        std::declval<jsi::Runtime &>(),
+        std::declval<Arg>(),
+        nullptr))>> = true;
+
+template <typename, typename = jsi::Value, typename = void>
+inline constexpr bool supportsToJs = false;
+
+template <typename T, typename Ret = jsi::Value>
+inline constexpr bool supportsToJs<
+    T,
+    Ret,
+    std::void_t<decltype(toJs(
+        std::declval<jsi::Runtime &>(),
+        std::declval<T>(),
+        nullptr))>> =
+    std::is_convertible_v<
+        decltype(toJs(
+            std::declval<jsi::Runtime &>(),
+            std::declval<T>(),
+            nullptr)),
+        Ret>;
+
+} // namespace bridging
+} // namespace facebook::react

package/ReactCommon/react/bridging/Bool.h

@@ -0,0 +1,25 @@
+/*
+ * 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<bool> {
+  static bool fromJs(jsi::Runtime &rt, const jsi::Value &value) {
+    return value.asBool();
+  }
+
+  static jsi::Value toJs(jsi::Runtime &, bool value) {
+    return value;
+  }
+};
+
+} // namespace facebook::react

package/ReactCommon/react/bridging/Bridging.h

@@ -0,0 +1,19 @@
+/*
+ * 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/Array.h>
+#include <react/bridging/Bool.h>
+#include <react/bridging/Class.h>
+#include <react/bridging/Error.h>
+#include <react/bridging/Function.h>
+#include <react/bridging/Number.h>
+#include <react/bridging/Object.h>
+#include <react/bridging/Promise.h>
+#include <react/bridging/Value.h>

package/ReactCommon/react/bridging/CMakeLists.txt

@@ -0,0 +1,17 @@
+# 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.
+
+cmake_minimum_required(VERSION 3.13)
+set(CMAKE_VERBOSE_MAKEFILE on)
+
+add_compile_options(-fexceptions -frtti -std=c++17 -Wall -DLOG_TAG=\"ReactNative\")
+
+file(GLOB react_bridging_SRC CONFIGURE_DEPENDS *.cpp)
+
+add_library(react_bridging STATIC ${react_bridging_SRC})
+
+target_include_directories(react_bridging PUBLIC ${REACT_COMMON_DIR})
+
+target_link_libraries(react_bridging jsi)

package/ReactCommon/react/bridging/CallbackWrapper.h

@@ -0,0 +1,103 @@
+/*
+ * 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 <react/bridging/LongLivedObject.h>
+
+#include <memory>
+
+namespace facebook {
+namespace react {
+
+// Helper for passing jsi::Function arg to other methods.
+class CallbackWrapper : public LongLivedObject {
+ private:
+  CallbackWrapper(
+      jsi::Function &&callback,
+      jsi::Runtime &runtime,
+      std::shared_ptr<CallInvoker> jsInvoker)
+      : longLivedObjectCollection_(),
+        callback_(std::move(callback)),
+        runtime_(runtime),
+        jsInvoker_(std::move(jsInvoker)) {}
+
+  CallbackWrapper(
+      std::shared_ptr<LongLivedObjectCollection> longLivedObjectCollection,
+      jsi::Function &&callback,
+      jsi::Runtime &runtime,
+      std::shared_ptr<CallInvoker> jsInvoker)
+      : longLivedObjectCollection_(longLivedObjectCollection),
+        callback_(std::move(callback)),
+        runtime_(runtime),
+        jsInvoker_(std::move(jsInvoker)) {}
+
+  // Use a weak_ptr to avoid a retain cycle: LongLivedObjectCollection owns all
+  // CallbackWrappers. So, CallbackWrapper cannot own its
+  // LongLivedObjectCollection.
+  std::weak_ptr<LongLivedObjectCollection> longLivedObjectCollection_;
+  jsi::Function callback_;
+  jsi::Runtime &runtime_;
+  std::shared_ptr<CallInvoker> jsInvoker_;
+
+ public:
+  static std::weak_ptr<CallbackWrapper> createWeak(
+      jsi::Function &&callback,
+      jsi::Runtime &runtime,
+      std::shared_ptr<CallInvoker> jsInvoker) {
+    auto wrapper = std::shared_ptr<CallbackWrapper>(
+        new CallbackWrapper(std::move(callback), runtime, jsInvoker));
+    LongLivedObjectCollection::get().add(wrapper);
+    return wrapper;
+  }
+
+  static std::weak_ptr<CallbackWrapper> createWeak(
+      std::shared_ptr<LongLivedObjectCollection> longLivedObjectCollection,
+      jsi::Function &&callback,
+      jsi::Runtime &runtime,
+      std::shared_ptr<CallInvoker> jsInvoker) {
+    auto wrapper = std::shared_ptr<CallbackWrapper>(new CallbackWrapper(
+        longLivedObjectCollection, std::move(callback), runtime, jsInvoker));
+    longLivedObjectCollection->add(wrapper);
+    return wrapper;
+  }
+
+  // Delete the enclosed jsi::Function
+  void destroy() {
+    allowRelease();
+  }
+
+  jsi::Function &callback() {
+    return callback_;
+  }
+
+  jsi::Runtime &runtime() {
+    return runtime_;
+  }
+
+  CallInvoker &jsInvoker() {
+    return *(jsInvoker_);
+  }
+
+  std::shared_ptr<CallInvoker> jsInvokerPtr() {
+    return jsInvoker_;
+  }
+
+  void allowRelease() override {
+    if (auto longLivedObjectCollection = longLivedObjectCollection_.lock()) {
+      if (longLivedObjectCollection != nullptr) {
+        longLivedObjectCollection->remove(this);
+        return;
+      }
+    }
+    LongLivedObject::allowRelease();
+  }
+};
+
+} // namespace react
+} // namespace facebook

package/ReactCommon/react/bridging/Class.h

@@ -0,0 +1,71 @@
+/*
+ * 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::bridging {
+
+template <
+    typename T,
+    typename C,
+    typename R,
+    typename... Args,
+    typename... JSArgs>
+T callFromJs(
+    jsi::Runtime &rt,
+    R (C::*method)(jsi::Runtime &, Args...),
+    const std::shared_ptr<CallInvoker> &jsInvoker,
+    C *instance,
+    JSArgs &&...args) {
+  static_assert(
+      sizeof...(Args) == sizeof...(JSArgs), "Incorrect arguments length");
+  static_assert(
+      (supportsFromJs<Args, JSArgs> && ...), "Incompatible arguments");
+
+  if constexpr (std::is_void_v<T>) {
+    (instance->*method)(
+        rt, fromJs<Args>(rt, std::forward<JSArgs>(args), jsInvoker)...);
+
+  } else if constexpr (std::is_void_v<R>) {
+    static_assert(
+        std::is_same_v<T, jsi::Value>,
+        "Void functions may only return undefined");
+
+    (instance->*method)(
+        rt, fromJs<Args>(rt, std::forward<JSArgs>(args), jsInvoker)...);
+    return jsi::Value();
+
+  } else if constexpr (is_jsi_v<T>) {
+    static_assert(supportsToJs<R, T>, "Incompatible return type");
+
+    return toJs(
+        rt,
+        (instance->*method)(
+            rt, fromJs<Args>(rt, std::forward<JSArgs>(args), jsInvoker)...),
+        jsInvoker);
+
+  } else {
+    static_assert(std::is_convertible_v<R, T>, "Incompatible return type");
+
+    return (instance->*method)(
+        rt, fromJs<Args>(rt, std::forward<JSArgs>(args), jsInvoker)...);
+  }
+}
+
+template <typename R, typename... Args>
+constexpr size_t getParameterCount(R (*)(Args...)) {
+  return sizeof...(Args);
+}
+
+template <typename C, typename R, typename... Args>
+constexpr size_t getParameterCount(R (C::*)(Args...)) {
+  return sizeof...(Args);
+}
+
+} // namespace facebook::react::bridging