react-native 0.68.1 → 0.69.0-rc.0

package/ReactCommon/react/bridging/Promise.h

@@ -0,0 +1,102 @@
+/*
+ * 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/Error.h>
+#include <react/bridging/Function.h>
+#include <react/bridging/LongLivedObject.h>
+
+#include <mutex>
+#include <optional>
+
+namespace facebook::react {
+
+template <typename T>
+class AsyncPromise {
+ public:
+  AsyncPromise(jsi::Runtime &rt, const std::shared_ptr<CallInvoker> &jsInvoker)
+      : state_(std::make_shared<SharedState>()) {
+    auto constructor = rt.global().getPropertyAsFunction(rt, "Promise");
+
+    auto promise = constructor.callAsConstructor(
+        rt,
+        bridging::toJs(
+            rt,
+            // Safe to capture this since this is called synchronously.
+            [this](AsyncCallback<T> resolve, AsyncCallback<Error> reject) {
+              state_->resolve = std::move(resolve);
+              state_->reject = std::move(reject);
+            },
+            jsInvoker));
+
+    auto promiseHolder = std::make_shared<PromiseHolder>(promise.asObject(rt));
+    LongLivedObjectCollection::get().add(promiseHolder);
+
+    // The shared state can retain the promise holder weakly now.
+    state_->promiseHolder = promiseHolder;
+  }
+
+  void resolve(T value) {
+    std::lock_guard<std::mutex> lock(state_->mutex);
+
+    if (state_->resolve) {
+      state_->resolve->call(std::move(value));
+      state_->resolve.reset();
+      state_->reject.reset();
+    }
+  }
+
+  void reject(Error error) {
+    std::lock_guard<std::mutex> lock(state_->mutex);
+
+    if (state_->reject) {
+      state_->reject->call(std::move(error));
+      state_->reject.reset();
+      state_->resolve.reset();
+    }
+  }
+
+  jsi::Object get(jsi::Runtime &rt) const {
+    if (auto holder = state_->promiseHolder.lock()) {
+      return jsi::Value(rt, holder->promise).asObject(rt);
+    } else {
+      throw jsi::JSError(rt, "Failed to get invalidated promise");
+    }
+  }
+
+ private:
+  struct PromiseHolder : LongLivedObject {
+    PromiseHolder(jsi::Object p) : promise(std::move(p)) {}
+
+    jsi::Object promise;
+  };
+
+  struct SharedState {
+    ~SharedState() {
+      if (auto holder = promiseHolder.lock()) {
+        holder->allowRelease();
+      }
+    }
+
+    std::mutex mutex;
+    std::weak_ptr<PromiseHolder> promiseHolder;
+    std::optional<AsyncCallback<T>> resolve;
+    std::optional<AsyncCallback<Error>> reject;
+  };
+
+  std::shared_ptr<SharedState> state_;
+};
+
+template <typename T>
+struct Bridging<AsyncPromise<T>> {
+  static jsi::Object toJs(jsi::Runtime &rt, const AsyncPromise<T> &promise) {
+    return promise.get(rt);
+  }
+};
+
+} // namespace facebook::react

package/ReactCommon/react/bridging/React-bridging.podspec

@@ -0,0 +1,41 @@
+# 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.
+
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "..", "..", "..", "package.json")))
+version = package['version']
+
+source = { :git => 'https://github.com/facebook/react-native.git' }
+if version == '1000.0.0'
+  # This is an unpublished version, use the latest commit hash of the react-native repo, which we’re presumably in.
+  source[:commit] = `git rev-parse HEAD`.strip if system("git rev-parse --git-dir > /dev/null 2>&1")
+else
+  source[:tag] = "v#{version}"
+end
+
+folly_compiler_flags = '-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1 -Wno-comma -Wno-shorten-64-to-32'
+folly_version = '2021.06.28.00-v2'
+
+Pod::Spec.new do |s|
+  s.name                   = "React-bridging"
+  s.version                = version
+  s.summary                = "-"  # TODO
+  s.homepage               = "https://reactnative.dev/"
+  s.license                = package["license"]
+  s.author                 = "Facebook, Inc. and its affiliates"
+  s.platforms              = { :ios => "12.4" }
+  s.source                 = source
+  s.source_files           = "**/*.{cpp,h}"
+  s.exclude_files          = "tests"
+  s.header_dir             = "react/bridging"
+  s.compiler_flags         = folly_compiler_flags
+  s.pod_target_xcconfig    = { "HEADER_SEARCH_PATHS" => "\"$(PODS_ROOT)/RCT-Folly\"",
+                               "USE_HEADERMAP" => "YES",
+                               "CLANG_CXX_LANGUAGE_STANDARD" => "c++17" }
+
+  s.dependency "RCT-Folly", folly_version
+  s.dependency "React-jsi", version
+end

package/ReactCommon/react/bridging/Value.h

@@ -0,0 +1,107 @@
+/*
+ * 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 <memory>
+#include <optional>
+
+namespace facebook::react {
+
+template <>
+struct Bridging<std::nullptr_t> {
+  static std::nullptr_t fromJs(jsi::Runtime &rt, const jsi::Value &value) {
+    if (value.isNull() || value.isUndefined()) {
+      return nullptr;
+    } else {
+      throw jsi::JSError(rt, "Cannot convert value to nullptr");
+    }
+  }
+
+  static std::nullptr_t toJs(jsi::Runtime &, std::nullptr_t) {
+    return nullptr;
+  }
+};
+
+template <typename T>
+struct Bridging<std::optional<T>> {
+  static std::optional<T> fromJs(
+      jsi::Runtime &rt,
+      const jsi::Value &value,
+      const std::shared_ptr<CallInvoker> &jsInvoker) {
+    if (value.isNull() || value.isUndefined()) {
+      return {};
+    }
+    return bridging::fromJs<T>(rt, value, jsInvoker);
+  }
+
+  template <typename U>
+  static std::optional<T> fromJs(
+      jsi::Runtime &rt,
+      const std::optional<U> &value,
+      const std::shared_ptr<CallInvoker> &jsInvoker) {
+    if (value) {
+      return bridging::fromJs<T>(rt, *value, jsInvoker);
+    }
+    return {};
+  }
+
+  static jsi::Value toJs(
+      jsi::Runtime &rt,
+      const std::optional<T> &value,
+      const std::shared_ptr<CallInvoker> &jsInvoker) {
+    if (value) {
+      return bridging::toJs(rt, *value, jsInvoker);
+    }
+    return jsi::Value::null();
+  }
+};
+
+template <typename T>
+struct Bridging<
+    std::shared_ptr<T>,
+    std::enable_if_t<!std::is_base_of_v<jsi::HostObject, T>>> {
+  static jsi::Value toJs(
+      jsi::Runtime &rt,
+      const std::shared_ptr<T> &ptr,
+      const std::shared_ptr<CallInvoker> &jsInvoker) {
+    if (ptr) {
+      return bridging::toJs(rt, *ptr, jsInvoker);
+    }
+    return jsi::Value::null();
+  }
+};
+
+template <typename T>
+struct Bridging<std::unique_ptr<T>> {
+  static jsi::Value toJs(
+      jsi::Runtime &rt,
+      const std::unique_ptr<T> &ptr,
+      const std::shared_ptr<CallInvoker> &jsInvoker) {
+    if (ptr) {
+      return bridging::toJs(rt, *ptr, jsInvoker);
+    }
+    return jsi::Value::null();
+  }
+};
+
+template <typename T>
+struct Bridging<std::weak_ptr<T>> {
+  static jsi::Value toJs(
+      jsi::Runtime &rt,
+      const std::weak_ptr<T> &weakPtr,
+      const std::shared_ptr<CallInvoker> &jsInvoker) {
+    if (auto ptr = weakPtr.lock()) {
+      return bridging::toJs(rt, *ptr, jsInvoker);
+    }
+    return jsi::Value::null();
+  }
+};
+
+} // namespace facebook::react

package/ReactCommon/react/bridging/tests/BridgingTest.cpp

@@ -0,0 +1,407 @@
+/*
+ * 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.
+ */
+
+#include "BridgingTest.h"
+
+namespace facebook::react {
+
+using namespace std::literals;
+
+TEST_F(BridgingTest, jsiTest) {
+  jsi::Value value = true;
+  jsi::Value string = jsi::String::createFromAscii(rt, "hello");
+  jsi::Value object = jsi::Object(rt);
+  jsi::Value array = jsi::Array::createWithElements(rt, value, object);
+  jsi::Value func = function("() => {}");
+
+  // The bridging mechanism needs to know how to copy and downcast values.
+  EXPECT_NO_THROW(bridging::fromJs<jsi::Value>(rt, value, invoker));
+  EXPECT_NO_THROW(bridging::fromJs<jsi::String>(rt, string, invoker));
+  EXPECT_NO_THROW(bridging::fromJs<jsi::Object>(rt, object, invoker));
+  EXPECT_NO_THROW(bridging::fromJs<jsi::Array>(rt, array, invoker));
+  EXPECT_NO_THROW(bridging::fromJs<jsi::Function>(rt, func, invoker));
+
+  // Should throw when attempting an invalid cast.
+  EXPECT_JSI_THROW(bridging::fromJs<jsi::Object>(rt, value, invoker));
+  EXPECT_JSI_THROW(bridging::fromJs<jsi::String>(rt, array, invoker));
+  EXPECT_JSI_THROW(bridging::fromJs<jsi::Array>(rt, object, invoker));
+  EXPECT_JSI_THROW(bridging::fromJs<jsi::Array>(rt, string, invoker));
+  EXPECT_JSI_THROW(bridging::fromJs<jsi::Array>(rt, func, invoker));
+
+  // Should be able to generically no-op convert JSI.
+  EXPECT_NO_THROW(bridging::toJs(rt, value, invoker));
+  EXPECT_NO_THROW(bridging::toJs(rt, string.asString(rt), invoker));
+  EXPECT_NO_THROW(bridging::toJs(rt, object.asObject(rt), invoker));
+  EXPECT_NO_THROW(bridging::toJs(rt, array.asObject(rt).asArray(rt), invoker));
+  EXPECT_NO_THROW(
+      bridging::toJs(rt, func.asObject(rt).asFunction(rt), invoker));
+}
+
+TEST_F(BridgingTest, boolTest) {
+  EXPECT_TRUE(bridging::fromJs<bool>(rt, jsi::Value(true), invoker));
+  EXPECT_FALSE(bridging::fromJs<bool>(rt, jsi::Value(false), invoker));
+  EXPECT_JSI_THROW(bridging::fromJs<bool>(rt, jsi::Value(1), invoker));
+
+  EXPECT_TRUE(bridging::toJs(rt, true).asBool());
+  EXPECT_FALSE(bridging::toJs(rt, false).asBool());
+}
+
+TEST_F(BridgingTest, numberTest) {
+  EXPECT_EQ(1, bridging::fromJs<int>(rt, jsi::Value(1), invoker));
+  EXPECT_FLOAT_EQ(1.2f, bridging::fromJs<float>(rt, jsi::Value(1.2), invoker));
+  EXPECT_DOUBLE_EQ(1.2, bridging::fromJs<double>(rt, jsi::Value(1.2), invoker));
+  EXPECT_JSI_THROW(bridging::fromJs<double>(rt, jsi::Value(true), invoker));
+
+  EXPECT_EQ(1, static_cast<int>(bridging::toJs(rt, 1).asNumber()));
+  EXPECT_FLOAT_EQ(
+      1.2f, static_cast<float>(bridging::toJs(rt, 1.2f).asNumber()));
+  EXPECT_DOUBLE_EQ(1.2, bridging::toJs(rt, 1.2).asNumber());
+}
+
+TEST_F(BridgingTest, stringTest) {
+  auto string = jsi::String::createFromAscii(rt, "hello");
+
+  EXPECT_EQ("hello"s, bridging::fromJs<std::string>(rt, string, invoker));
+  EXPECT_JSI_THROW(bridging::fromJs<std::string>(rt, jsi::Value(1), invoker));
+
+  EXPECT_TRUE(
+      jsi::String::strictEquals(rt, string, bridging::toJs(rt, "hello")));
+  EXPECT_TRUE(
+      jsi::String::strictEquals(rt, string, bridging::toJs(rt, "hello"s)));
+  EXPECT_TRUE(
+      jsi::String::strictEquals(rt, string, bridging::toJs(rt, "hello"sv)));
+}
+
+TEST_F(BridgingTest, objectTest) {
+  auto object = jsi::Object(rt);
+  object.setProperty(rt, "foo", "bar");
+
+  auto omap =
+      bridging::fromJs<std::map<std::string, std::string>>(rt, object, invoker);
+  auto umap = bridging::fromJs<std::unordered_map<std::string, std::string>>(
+      rt, object, invoker);
+  auto bmap = bridging::fromJs<butter::map<std::string, std::string>>(
+      rt, object, invoker);
+
+  EXPECT_EQ(1, omap.size());
+  EXPECT_EQ(1, umap.size());
+  EXPECT_EQ(1, bmap.size());
+  EXPECT_EQ("bar"s, omap["foo"]);
+  EXPECT_EQ("bar"s, umap["foo"]);
+  EXPECT_EQ("bar"s, bmap["foo"]);
+
+  EXPECT_EQ(
+      "bar"s,
+      bridging::toJs(rt, omap, invoker)
+          .getProperty(rt, "foo")
+          .asString(rt)
+          .utf8(rt));
+  EXPECT_EQ(
+      "bar"s,
+      bridging::toJs(rt, umap, invoker)
+          .getProperty(rt, "foo")
+          .asString(rt)
+          .utf8(rt));
+  EXPECT_EQ(
+      "bar"s,
+      bridging::toJs(rt, bmap, invoker)
+          .getProperty(rt, "foo")
+          .asString(rt)
+          .utf8(rt));
+}
+
+TEST_F(BridgingTest, hostObjectTest) {
+  struct TestHostObject : public jsi::HostObject {
+    jsi::Value get(jsi::Runtime &rt, const jsi::PropNameID &name) override {
+      if (name.utf8(rt) == "test") {
+        return jsi::Value(1);
+      }
+      return jsi::Value::undefined();
+    }
+  };
+
+  auto hostobject = std::make_shared<TestHostObject>();
+  auto object = bridging::toJs(rt, hostobject);
+
+  EXPECT_EQ(1, object.getProperty(rt, "test").asNumber());
+  EXPECT_EQ(
+      hostobject, bridging::fromJs<decltype(hostobject)>(rt, object, invoker));
+}
+
+TEST_F(BridgingTest, weakbjectTest) {
+  auto object = jsi::Object(rt);
+  auto weakobject = jsi::WeakObject(rt, object);
+
+  EXPECT_TRUE(jsi::Object::strictEquals(
+      rt,
+      object,
+      bridging::fromJs<jsi::WeakObject>(rt, object, invoker)
+          .lock(rt)
+          .asObject(rt)));
+
+  EXPECT_TRUE(jsi::Object::strictEquals(
+      rt, object, bridging::toJs(rt, weakobject).asObject(rt)));
+}
+
+TEST_F(BridgingTest, arrayTest) {
+  auto vec = std::vector({"foo"s, "bar"s});
+  auto array = jsi::Array::createWithElements(rt, "foo", "bar");
+
+  EXPECT_EQ(
+      vec, bridging::fromJs<std::vector<std::string>>(rt, array, invoker));
+
+  EXPECT_EQ(vec.size(), bridging::toJs(rt, vec, invoker).size(rt));
+  for (size_t i = 0; i < vec.size(); i++) {
+    EXPECT_EQ(
+        vec[i],
+        bridging::toJs(rt, vec, invoker)
+            .getValueAtIndex(rt, i)
+            .asString(rt)
+            .utf8(rt));
+  }
+
+  EXPECT_EQ(2, bridging::toJs(rt, std::make_pair(1, "2"), invoker).size(rt));
+  EXPECT_EQ(2, bridging::toJs(rt, std::make_tuple(1, "2"), invoker).size(rt));
+  EXPECT_EQ(2, bridging::toJs(rt, std::array<int, 2>{1, 2}, invoker).size(rt));
+  EXPECT_EQ(2, bridging::toJs(rt, std::deque<int>{1, 2}, invoker).size(rt));
+  EXPECT_EQ(2, bridging::toJs(rt, std::list<int>{1, 2}, invoker).size(rt));
+  EXPECT_EQ(
+      2,
+      bridging::toJs(rt, std::initializer_list<int>{1, 2}, invoker).size(rt));
+}
+
+TEST_F(BridgingTest, functionTest) {
+  auto object = jsi::Object(rt);
+  object.setProperty(rt, "foo", "bar");
+
+  auto lambda = [](std::map<std::string, std::string> map, std::string key) {
+    return map[key];
+  };
+
+  auto func = bridging::toJs(rt, lambda, invoker);
+
+  EXPECT_EQ(
+      "bar"s,
+      func.call(rt, object, jsi::String::createFromAscii(rt, "foo"))
+          .asString(rt)
+          .utf8(rt));
+
+  // Should throw if not enough arguments are passed or are the wrong types.
+  EXPECT_JSI_THROW(func.call(rt, object));
+  EXPECT_JSI_THROW(func.call(rt, object, jsi::Value(1)));
+
+  // Test with non-capturing lambda converted to function pointer.
+  func = bridging::toJs(rt, +lambda, invoker);
+
+  EXPECT_EQ(
+      "bar"s,
+      func.call(rt, object, jsi::String::createFromAscii(rt, "foo"))
+          .asString(rt)
+          .utf8(rt));
+}
+
+TEST_F(BridgingTest, syncCallbackTest) {
+  auto fn = function("(a, b) => a + b");
+  auto cb = bridging::fromJs<SyncCallback<std::string(std::string, int)>>(
+      rt, fn, invoker);
+  auto foo = "foo"s;
+
+  EXPECT_EQ("foo1"s, cb(foo, 1)); // Tests lvalue string
+  EXPECT_EQ("bar2", cb("bar", 2)); // Tests rvalue C string
+  EXPECT_TRUE(fn.isFunction(rt)); // Ensure the function wasn't invalidated.
+}
+
+TEST_F(BridgingTest, asyncCallbackTest) {
+  std::string output;
+
+  auto func = std::function<void(std::string)>([&](auto str) { output = str; });
+
+  auto cb = bridging::fromJs<AsyncCallback<decltype(func), std::string>>(
+      rt, function("(func, str) => func(str)"), invoker);
+
+  cb(func, "hello");
+
+  flushQueue(); // Run scheduled async work
+
+  EXPECT_EQ("hello"s, output);
+}
+
+TEST_F(BridgingTest, promiseTest) {
+  auto func = function(
+      "(promise, obj) => {"
+      "  promise.then("
+      "    (res) => { obj.res = res; },"
+      "    (err) => { obj.err = err; }"
+      "  )"
+      "}");
+
+  auto promise = AsyncPromise<std::vector<std::string>>(rt, invoker);
+  auto output = jsi::Object(rt);
+
+  func.call(rt, bridging::toJs(rt, promise, invoker), output);
+  promise.resolve({"foo"s, "bar"s});
+  flushQueue();
+
+  EXPECT_EQ(1, output.getPropertyNames(rt).size(rt));
+  EXPECT_EQ(2, output.getProperty(rt, "res").asObject(rt).asArray(rt).size(rt));
+  EXPECT_NO_THROW(promise.resolve({"ignored"}));
+  EXPECT_NO_THROW(promise.reject("ignored"));
+
+  promise = AsyncPromise<std::vector<std::string>>(rt, invoker);
+  output = jsi::Object(rt);
+
+  func.call(rt, bridging::toJs(rt, promise, invoker), output);
+  promise.reject("fail");
+  flushQueue();
+
+  EXPECT_EQ(1, output.getPropertyNames(rt).size(rt));
+  EXPECT_EQ(
+      "fail"s,
+      output.getProperty(rt, "err")
+          .asObject(rt)
+          .getProperty(rt, "message")
+          .asString(rt)
+          .utf8(rt));
+  EXPECT_NO_THROW(promise.resolve({"ignored"}));
+  EXPECT_NO_THROW(promise.reject("ignored"));
+}
+
+TEST_F(BridgingTest, optionalTest) {
+  EXPECT_EQ(
+      1, bridging::fromJs<std::optional<int>>(rt, jsi::Value(1), invoker));
+  EXPECT_EQ(
+      1,
+      bridging::fromJs<std::optional<int>>(
+          rt, std::make_optional(jsi::Value(1)), invoker));
+  EXPECT_EQ(
+      "hi"s,
+      bridging::fromJs<std::optional<std::string>>(
+          rt,
+          std::make_optional(jsi::String::createFromAscii(rt, "hi")),
+          invoker));
+  EXPECT_FALSE(
+      bridging::fromJs<std::optional<int>>(rt, jsi::Value::undefined(), invoker)
+          .has_value());
+  EXPECT_FALSE(
+      bridging::fromJs<std::optional<int>>(rt, jsi::Value::null(), invoker)
+          .has_value());
+
+  EXPECT_TRUE(bridging::toJs(rt, std::optional<int>(), invoker).isNull());
+  EXPECT_EQ(1, bridging::toJs(rt, std::optional<int>(1), invoker).asNumber());
+}
+
+TEST_F(BridgingTest, pointerTest) {
+  auto str = "hi"s;
+  auto unique = std::make_unique<std::string>(str);
+  auto shared = std::make_shared<std::string>(str);
+  auto weak = std::weak_ptr(shared);
+
+  EXPECT_EQ(str, bridging::toJs(rt, unique, invoker).asString(rt).utf8(rt));
+  EXPECT_EQ(str, bridging::toJs(rt, shared, invoker).asString(rt).utf8(rt));
+  EXPECT_EQ(str, bridging::toJs(rt, weak, invoker).asString(rt).utf8(rt));
+
+  shared.reset();
+
+  EXPECT_TRUE(bridging::toJs(rt, weak, invoker).isNull());
+}
+
+TEST_F(BridgingTest, supportTest) {
+  // Ensure sure can convert some basic types, including primitives that can be
+  // trivially converted to JSI values.
+  EXPECT_TRUE((bridging::supportsFromJs<bool>));
+  EXPECT_TRUE((bridging::supportsFromJs<bool, bool>));
+  EXPECT_TRUE((bridging::supportsFromJs<bool, jsi::Value &>));
+  EXPECT_TRUE((bridging::supportsFromJs<int>));
+  EXPECT_TRUE((bridging::supportsFromJs<int, int>));
+  EXPECT_TRUE((bridging::supportsFromJs<int, jsi::Value &>));
+  EXPECT_TRUE((bridging::supportsFromJs<double>));
+  EXPECT_TRUE((bridging::supportsFromJs<double, double>));
+  EXPECT_TRUE((bridging::supportsFromJs<double, jsi::Value &>));
+  EXPECT_TRUE((bridging::supportsFromJs<std::string>));
+  EXPECT_TRUE((bridging::supportsFromJs<std::string, jsi::String>));
+  EXPECT_TRUE((bridging::supportsFromJs<std::string, jsi::String &>));
+  EXPECT_TRUE((bridging::supportsFromJs<std::vector<int>, jsi::Array>));
+  EXPECT_TRUE((bridging::supportsFromJs<std::vector<int>, jsi::Array &>));
+  EXPECT_TRUE(
+      (bridging::supportsFromJs<std::map<std::string, int>, jsi::Object>));
+  EXPECT_TRUE(
+      (bridging::supportsFromJs<std::map<std::string, int>, jsi::Object &>));
+
+  // Ensure incompatible conversions will fail.
+  EXPECT_FALSE((bridging::supportsFromJs<bool, jsi::String>));
+  EXPECT_FALSE((bridging::supportsFromJs<bool, jsi::String &>));
+  EXPECT_FALSE((bridging::supportsFromJs<int, jsi::String>));
+  EXPECT_FALSE((bridging::supportsFromJs<int, jsi::String &>));
+  EXPECT_FALSE((bridging::supportsFromJs<double, jsi::String>));
+  EXPECT_FALSE((bridging::supportsFromJs<double, jsi::String &>));
+  EXPECT_FALSE((bridging::supportsFromJs<bool, jsi::Object>));
+  EXPECT_FALSE((bridging::supportsFromJs<bool, jsi::Object &>));
+  EXPECT_FALSE((bridging::supportsFromJs<int, jsi::Object>));
+  EXPECT_FALSE((bridging::supportsFromJs<int, jsi::Object &>));
+  EXPECT_FALSE((bridging::supportsFromJs<double, jsi::Object>));
+  EXPECT_FALSE((bridging::supportsFromJs<double, jsi::Object &>));
+  EXPECT_FALSE((bridging::supportsFromJs<std::string, jsi::Object>));
+  EXPECT_FALSE((bridging::supportsFromJs<std::string, jsi::Object &>));
+  EXPECT_FALSE((bridging::supportsFromJs<std::vector<int>, jsi::String>));
+  EXPECT_FALSE((bridging::supportsFromJs<std::vector<int>, jsi::String &>));
+
+  // Ensure copying and up/down casting JSI values is also supported.
+  EXPECT_TRUE((bridging::supportsFromJs<jsi::Value>));
+  EXPECT_TRUE((bridging::supportsFromJs<jsi::Value, jsi::Value &>));
+  EXPECT_TRUE((bridging::supportsFromJs<jsi::Value, jsi::Object>));
+  EXPECT_TRUE((bridging::supportsFromJs<jsi::Value, jsi::Object &>));
+  EXPECT_TRUE((bridging::supportsFromJs<jsi::String>));
+  EXPECT_TRUE((bridging::supportsFromJs<jsi::String, jsi::String>));
+  EXPECT_TRUE((bridging::supportsFromJs<jsi::String, jsi::String &>));
+  EXPECT_TRUE((bridging::supportsFromJs<jsi::Object>));
+  EXPECT_TRUE((bridging::supportsFromJs<jsi::Object, jsi::Object>));
+  EXPECT_TRUE((bridging::supportsFromJs<jsi::Object, jsi::Object &>));
+  EXPECT_TRUE((bridging::supportsFromJs<jsi::Object, jsi::Array>));
+  EXPECT_TRUE((bridging::supportsFromJs<jsi::Object, jsi::Array &>));
+  EXPECT_TRUE((bridging::supportsFromJs<jsi::Object, jsi::Function>));
+  EXPECT_TRUE((bridging::supportsFromJs<jsi::Object, jsi::Function &>));
+  EXPECT_TRUE((bridging::supportsFromJs<jsi::Array>));
+  EXPECT_TRUE((bridging::supportsFromJs<jsi::Array, jsi::Array>));
+  EXPECT_TRUE((bridging::supportsFromJs<jsi::Array, jsi::Array &>));
+  EXPECT_TRUE((bridging::supportsFromJs<jsi::Array, jsi::Object>));
+  EXPECT_TRUE((bridging::supportsFromJs<jsi::Array, jsi::Object &>));
+  EXPECT_TRUE((bridging::supportsFromJs<jsi::Function>));
+  EXPECT_TRUE((bridging::supportsFromJs<jsi::Function, jsi::Function>));
+  EXPECT_TRUE((bridging::supportsFromJs<jsi::Function, jsi::Function &>));
+  EXPECT_TRUE((bridging::supportsFromJs<jsi::Function, jsi::Object>));
+  EXPECT_TRUE((bridging::supportsFromJs<jsi::Function, jsi::Object &>));
+
+  // Ensure incorrect casts will fail.
+  EXPECT_FALSE((bridging::supportsFromJs<jsi::Array, jsi::Function>));
+  EXPECT_FALSE((bridging::supportsFromJs<jsi::Array, jsi::Function &>));
+  EXPECT_FALSE((bridging::supportsFromJs<jsi::Function, jsi::Array>));
+  EXPECT_FALSE((bridging::supportsFromJs<jsi::Function, jsi::Array &>));
+
+  // Ensure we can convert some basic types to JSI values.
+  EXPECT_TRUE((bridging::supportsToJs<bool>));
+  EXPECT_TRUE((bridging::supportsToJs<int>));
+  EXPECT_TRUE((bridging::supportsToJs<double>));
+  EXPECT_TRUE((bridging::supportsToJs<std::string>));
+  EXPECT_TRUE((bridging::supportsToJs<std::string, jsi::String>));
+  EXPECT_TRUE((bridging::supportsToJs<std::vector<int>>));
+  EXPECT_TRUE((bridging::supportsToJs<std::vector<int>, jsi::Array>));
+  EXPECT_TRUE((bridging::supportsToJs<std::map<std::string, int>>));
+  EXPECT_TRUE(
+      (bridging::supportsToJs<std::map<std::string, int>, jsi::Object>));
+  EXPECT_TRUE((bridging::supportsToJs<void (*)()>));
+  EXPECT_TRUE((bridging::supportsToJs<void (*)(), jsi::Function>));
+
+  // Ensure invalid conversions to JSI values are not supported.
+  EXPECT_FALSE((bridging::supportsToJs<void *>));
+  EXPECT_FALSE((bridging::supportsToJs<bool, jsi::Object>));
+  EXPECT_FALSE((bridging::supportsToJs<int, jsi::Object>));
+  EXPECT_FALSE((bridging::supportsToJs<double, jsi::Object>));
+  EXPECT_FALSE((bridging::supportsToJs<std::string, jsi::Object>));
+  EXPECT_FALSE((bridging::supportsToJs<std::vector<int>, jsi::Function>));
+}
+
+} // namespace facebook::react