react-native-windows 0.80.1 → 0.81.0-preview.1

package/Microsoft.ReactNative.Cxx/JSI/jsi.h

@@ -28,7 +28,7 @@
 
 #ifndef JSI_VERSION
 // Use the latest version by default
-#define JSI_VERSION 19
+#define JSI_VERSION 20
 #endif
 
 #if JSI_VERSION >= 3
@@ -65,6 +65,109 @@ class FBJSRuntime;
 namespace facebook {
 namespace jsi {
 
+#if JSI_VERSION >= 20
+/// UUID version 1 implementation. This should be constructed with constant
+/// arguments to identify fixed UUIDs.
+class JSI_EXPORT UUID {
+ public:
+  // Construct from raw parts
+  constexpr UUID(
+      uint32_t timeLow,
+      uint16_t timeMid,
+      uint16_t timeHighAndVersion,
+      uint16_t variantAndClockSeq,
+      uint64_t node)
+      : high(
+            ((uint64_t)(timeLow) << 32) | ((uint64_t)(timeMid) << 16) |
+            ((uint64_t)(timeHighAndVersion))),
+        low(((uint64_t)(variantAndClockSeq) << 48) | node) {}
+
+  // Default constructor (zero UUID)
+  constexpr UUID() : high(0), low(0) {}
+
+  constexpr UUID(const UUID&) = default;
+  constexpr UUID& operator=(const UUID&) = default;
+
+  constexpr bool operator==(const UUID& other) const {
+    return high == other.high && low == other.low;
+  }
+  constexpr bool operator!=(const UUID& other) const {
+    return !(*this == other);
+  }
+
+  // Ordering (for std::map, sorting, etc.)
+  constexpr bool operator<(const UUID& other) const {
+    return (high < other.high) || (high == other.high && low < other.low);
+  }
+
+  // Hash support for UUID (for unordered_map compatibility)
+  struct Hash {
+    std::size_t operator()(const UUID& uuid) const noexcept {
+      return std::hash<uint64_t>{}(uuid.high) ^
+          (std::hash<uint64_t>{}(uuid.low) << 1);
+    }
+  };
+
+  // UUID format: 8-4-4-4-12
+  std::string toString() const {
+    std::string buffer(36, ' ');
+    std::snprintf(
+        buffer.data(),
+        buffer.size() + 1,
+        "%08x-%04x-%04x-%04x-%012llx",
+        getTimeLow(),
+        getTimeMid(),
+        getTimeHighAndVersion(),
+        getVariantAndClockSeq(),
+        (unsigned long long)getNode());
+    return buffer;
+  }
+
+  constexpr uint32_t getTimeLow() const {
+    return (uint32_t)(high >> 32);
+  }
+
+  constexpr uint16_t getTimeMid() const {
+    return (uint16_t)(high >> 16);
+  }
+
+  constexpr uint16_t getTimeHighAndVersion() const {
+    return (uint16_t)high;
+  }
+
+  constexpr uint16_t getVariantAndClockSeq() const {
+    return (uint16_t)(low >> 48);
+  }
+
+  constexpr uint64_t getNode() const {
+    return low & 0xFFFFFFFFFFFF;
+  }
+
+ private:
+  uint64_t high;
+  uint64_t low;
+};
+
+/// Base interface that all JSI interfaces inherit from. Users should not try to
+/// manipulate this base type directly, and should use castInterface to get the
+/// appropriate subtype.
+struct JSI_EXPORT ICast {
+  /// If the current object can be cast into the interface specified by \p
+  /// interfaceUUID, return a pointer to the object. Otherwise, return a null
+  /// pointer.
+  /// The returned interface has the same lifetime as the underlying object. It
+  /// does not need to be released when not needed.
+  virtual ICast* castInterface(const UUID& interfaceUUID) = 0;
+
+ protected:
+  /// Interfaces are not destructible, thus the destructor is intentionally
+  /// protected to prevent delete calls on the interface.
+  /// Additionally, the destructor is non-virtual to reduce the vtable
+  /// complexity from inheritance.
+  ~ICast() = default;
+};
+#endif
+
 /// Base class for buffers of data or bytecode that need to be passed to the
 /// runtime. The buffer is expected to be fully immutable, so the result of
 /// size(), data(), and the contents of the pointer returned by data() must not
@@ -209,10 +312,18 @@ class JSI_EXPORT NativeState {
 /// in a non-Runtime-managed object, and not clean it up before the Runtime
 /// is shut down.  If your lifecycle is such that avoiding this is hard,
 /// you will probably need to do use your own locks.
+#if JSI_VERSION >= 20
+class JSI_EXPORT Runtime : public ICast {
+#else
 class JSI_EXPORT Runtime {
+#endif
  public:
   virtual ~Runtime();
 
+  #if JSI_VERSION >= 20
+  ICast* castInterface(const UUID& interfaceUUID) override;
+  #endif
+
   /// Evaluates the given JavaScript \c buffer.  \c sourceURL is used
   /// to annotate the stack trace if there is an exception.  The
   /// contents may be utf8-encoded JS source code, or binary bytecode
@@ -310,6 +421,18 @@ class JSI_EXPORT Runtime {
   /// implementation of this function returns an \c Instrumentation instance
   /// which returns no metrics.
   virtual Instrumentation& instrumentation();
+  
+  #if JSI_VERSION >= 20
+  /// Stores the pointer \p data with the \p uuid in the runtime. This can be
+  /// used to store some custom data within the runtime. When the runtime is
+  /// destroyed, or if an entry at an existing key is overwritten, the runtime
+  /// will release its ownership of the held object.
+  void setRuntimeData(const UUID& uuid, const std::shared_ptr<void>& data);
+
+  /// Returns the data associated with the \p uuid in the runtime. If there's no
+  /// data associated with the uuid, return a null pointer.
+  std::shared_ptr<void> getRuntimeData(const UUID& uuid);
+  #endif
 
  protected:
   friend class Pointer;
@@ -327,6 +450,21 @@ class JSI_EXPORT Runtime {
   friend class Value;
   friend class Scope;
   friend class JSError;
+  
+  #if JSI_VERSION >= 20
+  /// Stores the pointer \p data with the \p uuid in the runtime. This can be
+  /// used to store some custom data within the runtime. When the runtime is
+  /// destroyed, or if an entry at an existing key is overwritten, the runtime
+  /// will release its ownership by calling \p deleter.
+  virtual void setRuntimeDataImpl(
+      const UUID& uuid,
+      const void* data,
+      void (*deleter)(const void* data));
+
+  /// Returns the data associated with the \p uuid in the runtime. If there's no
+  /// data associated with the uuid, return a null pointer.
+  virtual const void* getRuntimeDataImpl(const UUID& uuid);
+  #endif
 
   // Potential optimization: avoid the cloneFoo() virtual dispatch,
   // and instead just fix the number of fields, and copy them, since
@@ -1793,6 +1931,34 @@ class JSI_EXPORT JSError : public JSIException {
   std::string stack_;
 };
 
+/// Helper function to cast the object pointed to by \p ptr into an interface
+/// specified by \c U. If cast is successful, return a pointer to the object
+/// as a raw pointer of \c U. Otherwise, return nullptr.
+/// The returned interface same lifetime as the object referenced by \p ptr.
+#if JSI_VERSION >= 20
+template <typename U, typename T>
+U* castInterface(T* ptr) {
+  if (ptr) {
+    return static_cast<U*>(ptr->castInterface(U::uuid));
+  }
+  return nullptr;
+};
+
+/// Helper function to cast the object managed by the shared_ptr \p ptr into an
+/// interface specified by \c U. If the cast is successful, return a shared_ptr
+/// of type \c U to the object. Otherwise, return an empty pointer.
+/// The returned shared_ptr shares ownership of the object with \p ptr.
+template <typename U, typename T>
+std::shared_ptr<U> dynamicInterfaceCast(T&& ptr) {
+  auto* p = ptr->castInterface(U::uuid);
+  U* res = static_cast<U*>(p);
+  if (res) {
+    return std::shared_ptr<U>(std::forward<T>(ptr), res);
+  }
+  return nullptr;
+}
+#endif
+
 } // namespace jsi
 } // namespace facebook
 

package/Microsoft.ReactNative.Cxx/Microsoft.ReactNative.Cxx.vcxitems

@@ -14,7 +14,7 @@
     <!-- If your project is using glog, then GLog_IncludeDir could be set to include the actual location of glog -->
     <GLog_IncludeDir Condition="'$(GLog_IncludeDir)' == '' AND Exists('$(MSBuildThisFileDirectory)stubs\glog\logging.h')">$(MSBuildThisFileDirectory)stubs</GLog_IncludeDir>
 
-    <NodeApiJsiCommitHash>980cb60d7911237d0f647fc566543ef627adac70</NodeApiJsiCommitHash>
+    <NodeApiJsiCommitHash>21b47f08b762b21b1d4d970940ab23f59f43249c</NodeApiJsiCommitHash>
     <NodeApiJsiLocal Condition="Exists('$(MSBuildThisFileDirectory)NodeApiJsiRuntime.cpp')">true</NodeApiJsiLocal>
     <NodeApiJsiDir Condition="'$(NodeApiJsiDir)' == '' AND '$(NodeApiJsiLocal)' == 'true'">$(MSBuildThisFileDirectory)</NodeApiJsiDir>
     <NodeApiJsiDir Condition="'$(NodeApiJsiDir)' == '' AND '$(ReactNativeDir)' != ''">$(ReactNativeDir)\..\..\node_modules\.node-api-jsi\node-api-jsi-$(NodeApiJsiCommitHash)\</NodeApiJsiDir>
@@ -35,7 +35,7 @@
         $(NodeApiJsiSrcDir);
         %(AdditionalIncludeDirectories)
       </AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>JSI_VERSION=19;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>JSI_VERSION=20;%(PreprocessorDefinitions)</PreprocessorDefinitions>
     </ClCompile>
     <Midl>
       <AdditionalIncludeDirectories>$(MSBuildThisFileDirectory);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

package/Microsoft.ReactNative.Cxx/NodeApiJsiRuntime.cpp

@@ -44,12 +44,21 @@ using namespace std::string_view_literals;
 // We use macros to report errors.
 // Macros provide more flexibility to show assert and provide failure context.
 
+#if defined(__clang__) || defined(__GNUC__)
+#define CRASH_NOW() __builtin_trap()
+#elif defined(_MSC_VER)
+#include <intrin.h>
+#define CRASH_NOW() __fastfail(/*FAST_FAIL_FATAL_APP_EXIT*/ 7)
+#else
+#define CRASH_NOW() *((volatile int *)0) = 1
+#endif
+
 // Check condition and crash process if it fails.
 #define CHECK_ELSE_CRASH(condition, message)               \
   do {                                                     \
     if (!(condition)) {                                    \
       assert(false && "Failed: " #condition && (message)); \
-      *((int *)0) = 1;                                     \
+      CRASH_NOW();                                         \
     }                                                      \
   } while (false)
 
@@ -286,7 +295,7 @@ class NodeApiJsiRuntime : public jsi::Runtime {
   jsi::Array createArray(size_t length) override;
 #if JSI_VERSION >= 9
   jsi::ArrayBuffer createArrayBuffer(
-      std::shared_ptr<jsi::MutableBuffer> buffer);
+      std::shared_ptr<jsi::MutableBuffer> buffer) override;
 #endif
   size_t size(const jsi::Array &arr) override;
   size_t size(const jsi::ArrayBuffer &arrBuf) override;
@@ -1628,8 +1637,8 @@ jsi::Object NodeApiJsiRuntime::createObject(
   // access to the hostObject's get, set, and getPropertyNames methods. There is
   // a special symbol property ID, 'hostObjectSymbol', used to access the
   // hostObjectWrapper from the Proxy.
-  napi_value hostObjectHolder =
-      createExternalObject(std::make_unique<std::shared_ptr<jsi::HostObject>>(
+  napi_value hostObjectHolder = createExternalObject(
+      std::make_unique<std::shared_ptr<jsi::HostObject>>(
           std::move(hostObject)));
   napi_value obj = createNodeApiObject();
   setProperty(
@@ -2420,31 +2429,89 @@ jsi::JSError NodeApiJsiRuntime::makeJSError(Args &&...args) {
   return jsi::JSError(*this, errorStream.str());
 }
 
-// Throws jsi::JSError or jsi::JSINativeException from Node-API error.
 [[noreturn]] void NodeApiJsiRuntime::throwJSException(
     napi_status status) const {
+  auto formatStatusError = [](napi_status status) -> std::string {
+    // TODO: (vmoroz) use a more sophisticated error formatting.
+    std::ostringstream errorStream;
+    errorStream << "A call to Node-API returned error code 0x" << std::hex
+                << static_cast<int>(status) << '.';
+    return errorStream.str();
+  };
+
+  NodeApiScope scope{*this};
+  // Retrieve the exception value and clear as we will rethrow it as a C++
+  // exception.
   napi_value jsError{};
   CHECK_NAPI_ELSE_CRASH(
       jsrApi_->napi_get_and_clear_last_exception(env_, &jsError));
   napi_valuetype jsErrorType;
   CHECK_NAPI_ELSE_CRASH(jsrApi_->napi_typeof(env_, jsError, &jsErrorType));
+  if (jsErrorType == napi_undefined) {
+    throw jsi::JSINativeException(formatStatusError(status).c_str());
+  }
+  jsi::Value jsiJSError = toJsiValue(jsError);
+
+  std::string msg = "No message";
+  std::string stack = "No stack";
+  if (jsErrorType == napi_string) {
+    // If the exception is a string, use it as the message.
+    msg = stringToStdString(jsError);
+  } else if (jsErrorType == napi_object) {
+    // If the exception is an object try to retrieve its message and stack
+    // properties.
+
+    /// Attempt to retrieve a string property \p sym from \c jsError and store
+    /// it in \p out. Ignore any catchable errors and non-string properties.
+    auto getStrProp = [this, jsError](const char *sym, std::string &out) {
+      napi_value value{};
+      napi_status propStatus =
+          jsrApi_->napi_get_named_property(env_, jsError, sym, &value);
+      if (propStatus != napi_ok) {
+        // An exception was thrown while retrieving the property, if it is
+        // catchable, suppress it. Otherwise, rethrow this exception without
+        // trying to invoke any more JavaScript.
+        napi_value newJSError{};
+        CHECK_NAPI_ELSE_CRASH(
+            jsrApi_->napi_get_and_clear_last_exception(env_, &newJSError));
+        napi_valuetype newJSErrorType;
+        CHECK_NAPI_ELSE_CRASH(
+            jsrApi_->napi_typeof(env_, newJSError, &newJSErrorType));
+
+        if (propStatus != napi_cannot_run_js)
+          return;
 
-  if (!hasPendingJSError_ &&
-      (status == napi_pending_exception || jsErrorType != napi_undefined)) {
-    AutoRestore<bool> setValue(
-        const_cast<NodeApiJsiRuntime *>(this)->hasPendingJSError_, true);
-    if (jsErrorType == napi_object &&
-        instanceOf(jsError, getNodeApiValue(cachedValue_.Error))) {
-      rewriteErrorMessage(jsError);
-    }
-    throw jsi::JSError(
-        *const_cast<NodeApiJsiRuntime *>(this), toJsiValue(jsError));
-  } else {
-    std::ostringstream errorStream;
-    errorStream << "A call to Node-API returned error code 0x" << std::hex
-                << status << '.';
-    throw jsi::JSINativeException(errorStream.str().c_str());
+        // An uncatchable error occurred, it is unsafe to do anything that
+        // might execute more JavaScript.
+        if (newJSErrorType != napi_undefined) {
+          throw jsi::JSError(
+              toJsiValue(newJSError),
+              "Uncatchable exception thrown while creating error",
+              "No stack");
+        } else {
+          std::ostringstream errorStream;
+          errorStream << "A call to Node-API returned error code 0x" << std::hex
+                      << propStatus << '.';
+          throw jsi::JSINativeException(errorStream.str().c_str());
+        }
+      }
+
+      // If the property is a string, update out. Otherwise ignore it.
+      napi_valuetype valueType;
+      CHECK_NAPI_ELSE_CRASH(jsrApi_->napi_typeof(env_, value, &valueType));
+      if (valueType == napi_string) {
+        out = stringToStdString(value);
+      }
+    };
+
+    getStrProp("message", msg);
+    getStrProp("stack", stack);
   }
+
+  // Use the constructor of jsi::JSError that cannot run additional
+  // JS, since that may then result in additional exceptions and infinite
+  // recursion.
+  throw jsi::JSError(std::move(jsiJSError), msg, stack);
 }
 
 // Throws jsi::JSINativeException with a message.
@@ -2467,7 +2534,9 @@ void NodeApiJsiRuntime::rewriteErrorMessage(napi_value jsError) const {
     jsrApi_->napi_get_and_clear_last_exception(env_, &ignoreJSError);
   } else if (typeOf(message) == napi_string) {
     // JSI unit tests expect V8- or JSC-like messages for the stack overflow.
-    if (stringToStdString(message) == "Out of stack space") {
+    std::string messageStr = stringToStdString(message);
+    if (messageStr == "Out of stack space" ||
+        messageStr.find("Maximum call stack") != std::string::npos) {
       setProperty(
           jsError,
           getNodeApiValue(propertyId_.message),
@@ -2594,7 +2663,7 @@ napi_value NodeApiJsiRuntime::getBoolean(bool value) const {
 
 // Gets value of the Boolean napi_value.
 bool NodeApiJsiRuntime::getValueBool(napi_value value) const {
-  bool result{nullptr};
+  bool result{false};
   CHECK_NAPI(jsrApi_->napi_get_value_bool(env_, value, &result));
   return result;
 }
@@ -2848,13 +2917,14 @@ void NodeApiJsiRuntime::setElement(
     napi_callback_info info) noexcept {
   HostFunctionWrapper *hostFuncWrapper{};
   size_t argc{};
-  CHECK_NAPI_ELSE_CRASH(JSRuntimeApi::current()->napi_get_cb_info(
-      env,
-      info,
-      &argc,
-      nullptr,
-      nullptr,
-      reinterpret_cast<void **>(&hostFuncWrapper)));
+  CHECK_NAPI_ELSE_CRASH(
+      JSRuntimeApi::current()->napi_get_cb_info(
+          env,
+          info,
+          &argc,
+          nullptr,
+          nullptr,
+          reinterpret_cast<void **>(&hostFuncWrapper)));
   CHECK_ELSE_CRASH(hostFuncWrapper, "Cannot find the host function");
   NodeApiJsiRuntime &runtime = hostFuncWrapper->runtime();
   NodeApiPointerValueScope scope{runtime};
@@ -2863,8 +2933,9 @@ void NodeApiJsiRuntime::setElement(
       [&env, &info, &argc, &runtime, &hostFuncWrapper]() {
         SmallBuffer<napi_value, MaxStackArgCount> napiArgs(argc);
         napi_value thisArg{};
-        CHECK_NAPI_ELSE_CRASH(JSRuntimeApi::current()->napi_get_cb_info(
-            env, info, &argc, napiArgs.data(), &thisArg, nullptr));
+        CHECK_NAPI_ELSE_CRASH(
+            JSRuntimeApi::current()->napi_get_cb_info(
+                env, info, &argc, napiArgs.data(), &thisArg, nullptr));
         CHECK_ELSE_CRASH(napiArgs.size() == argc, "Wrong argument count");
         const JsiValueView jsiThisArg{&runtime, thisArg};
         JsiValueViewArgs jsiArgs(
@@ -2986,13 +3057,14 @@ void NodeApiJsiRuntime::setProxyTrap(
     NodeApiJsiRuntime *runtime{};
     napi_value args[argCount]{};
     size_t actualArgCount{argCount};
-    CHECK_NAPI_ELSE_CRASH(JSRuntimeApi::current()->napi_get_cb_info(
-        env,
-        info,
-        &actualArgCount,
-        args,
-        nullptr,
-        reinterpret_cast<void **>(&runtime)));
+    CHECK_NAPI_ELSE_CRASH(
+        JSRuntimeApi::current()->napi_get_cb_info(
+            env,
+            info,
+            &actualArgCount,
+            args,
+            nullptr,
+            reinterpret_cast<void **>(&runtime)));
     CHECK_ELSE_CRASH(
         actualArgCount == argCount, "proxy trap requires argCount arguments.");
     NodeApiPointerValueScope scope{*runtime};

package/Microsoft.ReactNative.Cxx/ReactCommon/CallInvoker.h

@@ -7,11 +7,11 @@
 
 #pragma once
 
-#include <functional>
-#include <memory>
-
 #include "SchedulerPriority.h"
 
+#include <functional>
+#include <string>
+
 namespace facebook::jsi {
 class Runtime;
 }
@@ -45,7 +45,7 @@ class CallInvoker {
     invokeSync([func](jsi::Runtime&) { func(); });
   }
 
-  virtual ~CallInvoker() {}
+  virtual ~CallInvoker() = default;
 };
 
 using NativeMethodCallFunc = std::function<void()>;
@@ -58,7 +58,7 @@ class NativeMethodCallInvoker {
   virtual void invokeSync(
       const std::string& methodName,
       NativeMethodCallFunc&& func) = 0;
-  virtual ~NativeMethodCallInvoker() {}
+  virtual ~NativeMethodCallInvoker() = default;
 };
 
 } // namespace facebook::react

package/Microsoft.ReactNative.Cxx/ReactCommon/SchedulerPriority.h

@@ -7,8 +7,6 @@
 
 #pragma once
 
-#include <chrono>
-
 namespace facebook::react {
 
 enum class SchedulerPriority : int {

package/Microsoft.ReactNative.Cxx/ReactCommon/TurboModuleUtils.h

@@ -35,23 +35,4 @@ jsi::Value createPromiseAsJSIValue(
     jsi::Runtime& rt,
     PromiseSetupFunctionType&& func);
 
-// Deprecated. Use AsyncCallback instead.
-class RAIICallbackWrapperDestroyer {
- public:
-  RAIICallbackWrapperDestroyer(std::weak_ptr<CallbackWrapper> callbackWrapper)
-      : callbackWrapper_(callbackWrapper) {}
-
-  ~RAIICallbackWrapperDestroyer() {
-    auto strongWrapper = callbackWrapper_.lock();
-    if (!strongWrapper) {
-      return;
-    }
-
-    strongWrapper->destroy();
-  }
-
- private:
-  std::weak_ptr<CallbackWrapper> callbackWrapper_;
-};
-
 } // namespace facebook::react

package/Microsoft.ReactNative.Cxx/ReactCommon/react/bridging/Base.h

@@ -33,14 +33,14 @@ namespace detail {
 template <typename F>
 struct function_wrapper;
 
-template <typename C, typename R, typename... Args>
-struct function_wrapper<R (C::*)(Args...)> {
-  using type = std::function<R(Args...)>;
+template <typename ClassT, typename ReturnT, typename... ArgsT>
+struct function_wrapper<ReturnT (ClassT::*)(ArgsT...)> {
+  using type = std::function<ReturnT(ArgsT...)>;
 };
 
-template <typename C, typename R, typename... Args>
-struct function_wrapper<R (C::*)(Args...) const> {
-  using type = std::function<R(Args...)>;
+template <typename ClassT, typename ReturnT, typename... ArgsT>
+struct function_wrapper<ReturnT (ClassT::*)(ArgsT...) const> {
+  using type = std::function<ReturnT(ArgsT...)>;
 };
 
 template <typename T, typename = void>
@@ -61,36 +61,47 @@ struct bridging_wrapper<
 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>(
-        std::move(convert(rt, std::forward<T>(value))))) {
-  return static_cast<R>(std::move(convert(rt, std::forward<T>(value))));
+template <typename ReturnT, typename JSArgT>
+  requires is_jsi_v<JSArgT>
+auto fromJs(
+    jsi::Runtime& rt,
+    JSArgT&& value,
+    const std::shared_ptr<CallInvoker>& /*unused*/)
+    -> decltype(static_cast<ReturnT>(
+        std::move(convert(rt, std::forward<JSArgT>(value)))))
+
+{
+  return static_cast<ReturnT>(
+      std::move(convert(rt, std::forward<JSArgT>(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(
+template <typename ReturnT, typename JSArgT>
+auto fromJs(
+    jsi::Runtime& rt,
+    JSArgT&& value,
+    const std::shared_ptr<CallInvoker>& /*unused*/)
+    -> decltype(Bridging<remove_cvref_t<ReturnT>>::fromJs(
         rt,
-        convert(rt, std::forward<T>(value)))) {
-  return Bridging<remove_cvref_t<R>>::fromJs(
-      rt, convert(rt, std::forward<T>(value)));
+        convert(rt, std::forward<JSArgT>(value)))) {
+  return Bridging<remove_cvref_t<ReturnT>>::fromJs(
+      rt, convert(rt, std::forward<JSArgT>(value)));
 }
 
-template <typename R, typename T>
+template <typename ReturnT, typename JSArgT>
 auto fromJs(
     jsi::Runtime& rt,
-    T&& value,
+    JSArgT&& value,
     const std::shared_ptr<CallInvoker>& jsInvoker)
-    -> decltype(Bridging<remove_cvref_t<R>>::fromJs(
+    -> decltype(Bridging<remove_cvref_t<ReturnT>>::fromJs(
         rt,
-        convert(rt, std::forward<T>(value)),
+        convert(rt, std::forward<JSArgT>(value)),
         jsInvoker)) {
-  return Bridging<remove_cvref_t<R>>::fromJs(
-      rt, convert(rt, std::forward<T>(value)), jsInvoker);
+  return Bridging<remove_cvref_t<ReturnT>>::fromJs(
+      rt, convert(rt, std::forward<JSArgT>(value)), jsInvoker);
 }
 
-template <typename T, std::enable_if_t<is_jsi_v<T>, int> = 0>
+template <typename T>
+  requires is_jsi_v<T>
 auto toJs(
     jsi::Runtime& rt,
     T&& value,
@@ -143,33 +154,33 @@ inline constexpr bool supportsFromJs<
 template <typename, typename = jsi::Value, typename = void>
 inline constexpr bool supportsToJs = false;
 
-template <typename T, typename Ret>
+template <typename JSReturnT, typename ReturnT>
 inline constexpr bool supportsToJs<
-    T,
-    Ret,
+    JSReturnT,
+    ReturnT,
     std::void_t<decltype(toJs(
         std::declval<jsi::Runtime&>(),
-        std::declval<T>(),
+        std::declval<JSReturnT>(),
         nullptr))>> =
     std::is_convertible_v<
         decltype(toJs(
             std::declval<jsi::Runtime&>(),
-            std::declval<T>(),
+            std::declval<JSReturnT>(),
             nullptr)),
-        Ret>;
+        ReturnT>;
 
-template <typename T>
+template <typename ReturnT>
 inline constexpr bool supportsToJs<
-    T,
+    ReturnT,
     jsi::Value,
     std::void_t<decltype(toJs(
         std::declval<jsi::Runtime&>(),
-        std::declval<T>(),
+        std::declval<ReturnT>(),
         nullptr))>> =
     std::is_convertible_v<
         decltype(toJs(
             std::declval<jsi::Runtime&>(),
-            std::declval<T>(),
+            std::declval<ReturnT>(),
             nullptr)),
         jsi::Value>;
 

package/Microsoft.ReactNative.Cxx/ReactCommon/react/bridging/Bool.h

@@ -17,7 +17,7 @@ struct Bridging<bool> {
     return value.asBool();
   }
 
-  static jsi::Value toJs(jsi::Runtime&, bool value) {
+  static bool toJs(jsi::Runtime& /*unused*/, bool value) {
     return value;
   }
 };

package/Microsoft.ReactNative.Cxx/ReactCommon/react/bridging/Bridging.h

@@ -15,6 +15,7 @@
 #include <react/bridging/Error.h>
 #include <react/bridging/EventEmitter.h>
 #include <react/bridging/Function.h>
+#include <react/bridging/HighResTimeStamp.h>
 #include <react/bridging/Number.h>
 #include <react/bridging/Object.h>
 #include <react/bridging/Promise.h>