react-native-windows 0.82.1 → 0.83.0-preview.0

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

@@ -24,35 +24,31 @@ 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) {
+  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)...);
+      facebook::jsi::Runtime &rt,
+      const T &array,
+      const std::shared_ptr<CallInvoker> &jsInvoker,
+      std::index_sequence<Index...> /*unused*/)
+  {
+    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) {
+  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) {
+    for (const auto &item : list) {
       result.setValueAtIndex(rt, index++, bridging::toJs(rt, item, jsInvoker));
     }
 
@@ -63,18 +59,15 @@ struct BridgingDynamic {
 } // namespace array_detail
 
 template <typename T, size_t N>
-struct Bridging<std::array<T, N>>
-    : array_detail::BridgingStatic<std::array<T, N>, N> {
-  static std::array<T, N> fromJs(
-      facebook::jsi::Runtime& rt,
-      const jsi::Array& array,
-      const std::shared_ptr<CallInvoker>& jsInvoker) {
+struct Bridging<std::array<T, N>> : array_detail::BridgingStatic<std::array<T, N>, N> {
+  static std::array<T, N>
+  fromJs(facebook::jsi::Runtime &rt, const jsi::Array &array, const std::shared_ptr<CallInvoker> &jsInvoker)
+  {
     size_t length = array.length(rt);
 
     std::array<T, N> result;
     for (size_t i = 0; i < length; i++) {
-      result[i] =
-          bridging::fromJs<T>(rt, array.getValueAtIndex(rt, i), jsInvoker);
+      result[i] = bridging::fromJs<T>(rt, array.getValueAtIndex(rt, i), jsInvoker);
     }
 
     return result;
@@ -82,12 +75,10 @@ struct Bridging<std::array<T, N>>
 };
 
 template <typename T1, typename T2>
-struct Bridging<std::pair<T1, T2>>
-    : array_detail::BridgingStatic<std::pair<T1, T2>, 2> {
-  static std::pair<T1, T1> fromJs(
-      facebook::jsi::Runtime& rt,
-      const jsi::Array& array,
-      const std::shared_ptr<CallInvoker>& jsInvoker) {
+struct Bridging<std::pair<T1, T2>> : array_detail::BridgingStatic<std::pair<T1, T2>, 2> {
+  static std::pair<T1, T1>
+  fromJs(facebook::jsi::Runtime &rt, const jsi::Array &array, const std::shared_ptr<CallInvoker> &jsInvoker)
+  {
     return std::make_pair(
         bridging::fromJs<T1>(rt, array.getValueAtIndex(rt, 0), jsInvoker),
         bridging::fromJs<T2>(rt, array.getValueAtIndex(rt, 1), jsInvoker));
@@ -95,35 +86,29 @@ struct Bridging<std::pair<T1, T2>>
 };
 
 template <typename... Types>
-struct Bridging<std::tuple<Types...>>
-    : array_detail::BridgingStatic<std::tuple<Types...>, sizeof...(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>> {
-};
+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>> {};
+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) {
+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));
+      vector.push_back(bridging::fromJs<T>(rt, array.getValueAtIndex(rt, i), jsInvoker));
     }
 
     return vector;
@@ -132,16 +117,14 @@ struct Bridging<std::vector<T>>
 
 template <typename T>
 struct Bridging<std::set<T>> : array_detail::BridgingDynamic<std::set<T>> {
-  static std::set<T> fromJs(
-      facebook::jsi::Runtime& rt,
-      const jsi::Array& array,
-      const std::shared_ptr<CallInvoker>& jsInvoker) {
+  static std::set<T>
+  fromJs(facebook::jsi::Runtime &rt, const jsi::Array &array, const std::shared_ptr<CallInvoker> &jsInvoker)
+  {
     size_t length = array.length(rt);
 
     std::set<T> set;
     for (size_t i = 0; i < length; i++) {
-      set.insert(
-          bridging::fromJs<T>(rt, array.getValueAtIndex(rt, i), jsInvoker));
+      set.insert(bridging::fromJs<T>(rt, array.getValueAtIndex(rt, i), jsInvoker));
     }
 
     return set;

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

@@ -24,7 +24,7 @@ struct Bridging;
 template <>
 struct Bridging<void> {
   // Highly generic code may result in "casting" to void.
-  static void fromJs(jsi::Runtime&, const jsi::Value&) {}
+  static void fromJs(jsi::Runtime & /*unused*/, const jsi::Value & /*unused*/) {}
 };
 
 namespace bridging {
@@ -51,9 +51,7 @@ struct bridging_wrapper {
 // 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())>>
+struct bridging_wrapper<T, std::void_t<decltype(&remove_cvref_t<T>::operator())>>
     : function_wrapper<decltype(&remove_cvref_t<T>::operator())> {};
 
 } // namespace detail
@@ -63,70 +61,45 @@ using bridging_t = typename detail::bridging_wrapper<T>::type;
 
 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)))))
+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))));
+  return static_cast<ReturnT>(std::move(convert(rt, std::forward<JSArgT>(value))));
 }
 
 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<JSArgT>(value)))) {
-  return Bridging<remove_cvref_t<ReturnT>>::fromJs(
-      rt, convert(rt, std::forward<JSArgT>(value)));
+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<JSArgT>(value))))
+{
+  return Bridging<remove_cvref_t<ReturnT>>::fromJs(rt, convert(rt, std::forward<JSArgT>(value)));
 }
 
 template <typename ReturnT, typename JSArgT>
-auto fromJs(
-    jsi::Runtime& rt,
-    JSArgT&& value,
-    const std::shared_ptr<CallInvoker>& jsInvoker)
-    -> decltype(Bridging<remove_cvref_t<ReturnT>>::fromJs(
-        rt,
-        convert(rt, std::forward<JSArgT>(value)),
-        jsInvoker)) {
-  return Bridging<remove_cvref_t<ReturnT>>::fromJs(
-      rt, convert(rt, std::forward<JSArgT>(value)), jsInvoker);
+auto fromJs(jsi::Runtime &rt, JSArgT &&value, const std::shared_ptr<CallInvoker> &jsInvoker)
+    -> decltype(Bridging<remove_cvref_t<ReturnT>>::fromJs(rt, convert(rt, std::forward<JSArgT>(value)), jsInvoker))
+{
+  return Bridging<remove_cvref_t<ReturnT>>::fromJs(rt, convert(rt, std::forward<JSArgT>(value)), jsInvoker);
 }
 
 template <typename T>
   requires is_jsi_v<T>
-auto toJs(
-    jsi::Runtime& rt,
-    T&& value,
-    const std::shared_ptr<CallInvoker>& = nullptr) -> remove_cvref_t<T> {
+auto toJs(jsi::Runtime &rt, T &&value, const std::shared_ptr<CallInvoker> & /*unused*/ = nullptr) -> remove_cvref_t<T>
+{
   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))) {
+auto toJs(jsi::Runtime &rt, T &&value, const std::shared_ptr<CallInvoker> & /*unused*/ = 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)) {
+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);
 }
 
@@ -137,19 +110,13 @@ template <typename T, typename Arg>
 inline constexpr bool supportsFromJs<
     T,
     Arg,
-    std::void_t<decltype(fromJs<T>(
-        std::declval<jsi::Runtime&>(),
-        std::declval<Arg>(),
-        nullptr))>> = true;
+    std::void_t<decltype(fromJs<T>(std::declval<jsi::Runtime &>(), std::declval<Arg>(), nullptr))>> = true;
 
 template <typename T>
 inline constexpr bool supportsFromJs<
     T,
     jsi::Value,
-    std::void_t<decltype(fromJs<T>(
-        std::declval<jsi::Runtime&>(),
-        std::declval<jsi::Value>(),
-        nullptr))>> = true;
+    std::void_t<decltype(fromJs<T>(std::declval<jsi::Runtime &>(), std::declval<jsi::Value>(), nullptr))>> = true;
 
 template <typename, typename = jsi::Value, typename = void>
 inline constexpr bool supportsToJs = false;
@@ -158,31 +125,15 @@ template <typename JSReturnT, typename ReturnT>
 inline constexpr bool supportsToJs<
     JSReturnT,
     ReturnT,
-    std::void_t<decltype(toJs(
-        std::declval<jsi::Runtime&>(),
-        std::declval<JSReturnT>(),
-        nullptr))>> =
-    std::is_convertible_v<
-        decltype(toJs(
-            std::declval<jsi::Runtime&>(),
-            std::declval<JSReturnT>(),
-            nullptr)),
-        ReturnT>;
+    std::void_t<decltype(toJs(std::declval<jsi::Runtime &>(), std::declval<JSReturnT>(), nullptr))>> =
+    std::is_convertible_v<decltype(toJs(std::declval<jsi::Runtime &>(), std::declval<JSReturnT>(), nullptr)), ReturnT>;
 
 template <typename ReturnT>
 inline constexpr bool supportsToJs<
     ReturnT,
     jsi::Value,
-    std::void_t<decltype(toJs(
-        std::declval<jsi::Runtime&>(),
-        std::declval<ReturnT>(),
-        nullptr))>> =
-    std::is_convertible_v<
-        decltype(toJs(
-            std::declval<jsi::Runtime&>(),
-            std::declval<ReturnT>(),
-            nullptr)),
-        jsi::Value>;
+    std::void_t<decltype(toJs(std::declval<jsi::Runtime &>(), std::declval<ReturnT>(), nullptr))>> =
+    std::is_convertible_v<decltype(toJs(std::declval<jsi::Runtime &>(), std::declval<ReturnT>(), nullptr)), jsi::Value>;
 
 } // namespace bridging
 } // namespace facebook::react

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

@@ -13,11 +13,13 @@ namespace facebook::react {
 
 template <>
 struct Bridging<bool> {
-  static bool fromJs(jsi::Runtime&, const jsi::Value& value) {
+  static bool fromJs(jsi::Runtime & /*unused*/, const jsi::Value &value)
+  {
     return value.asBool();
   }
 
-  static bool toJs(jsi::Runtime& /*unused*/, bool value) {
+  static bool toJs(jsi::Runtime & /*unused*/, bool value)
+  {
     return value;
   }
 };

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

@@ -20,46 +20,47 @@ class CallInvoker;
 // 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)
-      : LongLivedObject(runtime),
-        callback_(std::move(callback)),
-        jsInvoker_(std::move(jsInvoker)) {}
+  CallbackWrapper(jsi::Function &&callback, jsi::Runtime &runtime, std::shared_ptr<CallInvoker> jsInvoker)
+      : LongLivedObject(runtime), callback_(std::move(callback)), jsInvoker_(std::move(jsInvoker))
+  {
+  }
 
   jsi::Function callback_;
   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, std::move(jsInvoker)));
+  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, std::move(jsInvoker)));
     LongLivedObjectCollection::get(runtime).add(wrapper);
     return wrapper;
   }
 
   // Delete the enclosed jsi::Function
-  void destroy() {
+  void destroy()
+  {
     allowRelease();
   }
 
-  jsi::Function& callback() noexcept {
+  jsi::Function &callback() noexcept
+  {
     return callback_;
   }
 
-  jsi::Runtime& runtime() noexcept {
+  jsi::Runtime &runtime() noexcept
+  {
     return runtime_;
   }
 
-  CallInvoker& jsInvoker() noexcept {
+  CallInvoker &jsInvoker() noexcept
+  {
     return *(jsInvoker_);
   }
 
-  std::shared_ptr<CallInvoker> jsInvokerPtr() noexcept {
+  std::shared_ptr<CallInvoker> jsInvokerPtr() noexcept
+  {
     return jsInvoker_;
   }
 };

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

@@ -11,64 +11,41 @@
 
 namespace facebook::react::bridging {
 
-template <
-    typename JSReturnT,
-    typename ClassT,
-    typename ReturnT,
-    typename... ArgsT,
-    typename... JSArgsT>
+template <typename JSReturnT, typename ClassT, typename ReturnT, typename... ArgsT, typename... JSArgsT>
 JSReturnT callFromJs(
-    jsi::Runtime& rt,
-    ReturnT (ClassT::*method)(jsi::Runtime&, ArgsT...),
-    const std::shared_ptr<CallInvoker>& jsInvoker,
-    ClassT* instance,
-    JSArgsT&&... args) {
-  static_assert(
-      sizeof...(ArgsT) == sizeof...(JSArgsT), "Incorrect arguments length");
-  static_assert(
-      (supportsFromJs<ArgsT, JSArgsT> && ...), "Incompatible arguments");
+    jsi::Runtime &rt,
+    ReturnT (ClassT::*method)(jsi::Runtime &, ArgsT...),
+    const std::shared_ptr<CallInvoker> &jsInvoker,
+    ClassT *instance,
+    JSArgsT &&...args)
+{
+  static_assert(sizeof...(ArgsT) == sizeof...(JSArgsT), "Incorrect arguments length");
+  static_assert((supportsFromJs<ArgsT, JSArgsT> && ...), "Incompatible arguments");
   if constexpr (std::is_void_v<JSReturnT>) {
-    static_assert(
-        std::is_void_v<ReturnT>,
-        "Method must return void when JSReturnT is void");
+    static_assert(std::is_void_v<ReturnT>, "Method must return void when JSReturnT is void");
   }
 
   if constexpr (std::is_void_v<JSReturnT>) {
-    (instance->*method)(
-        rt, fromJs<ArgsT>(rt, std::forward<JSArgsT>(args), jsInvoker)...);
+    (instance->*method)(rt, fromJs<ArgsT>(rt, std::forward<JSArgsT>(args), jsInvoker)...);
 
   } else if constexpr (std::is_void_v<ReturnT>) {
-    static_assert(
-        std::is_same_v<JSReturnT, jsi::Value>,
-        "Void functions may only return undefined");
+    static_assert(std::is_same_v<JSReturnT, jsi::Value>, "Void functions may only return undefined");
 
-    (instance->*method)(
-        rt, fromJs<ArgsT>(rt, std::forward<JSArgsT>(args), jsInvoker)...);
+    (instance->*method)(rt, fromJs<ArgsT>(rt, std::forward<JSArgsT>(args), jsInvoker)...);
     return jsi::Value();
 
-  } else if constexpr (
-      is_jsi_v<JSReturnT> || supportsToJs<ReturnT, JSReturnT>) {
+  } else if constexpr (is_jsi_v<JSReturnT> || supportsToJs<ReturnT, JSReturnT>) {
     static_assert(supportsToJs<ReturnT, JSReturnT>, "Incompatible return type");
 
-    return toJs(
-        rt,
-        (instance->*method)(
-            rt, fromJs<ArgsT>(rt, std::forward<JSArgsT>(args), jsInvoker)...),
-        jsInvoker);
+    return toJs(rt, (instance->*method)(rt, fromJs<ArgsT>(rt, std::forward<JSArgsT>(args), jsInvoker)...), jsInvoker);
   } else if constexpr (is_optional_jsi_v<JSReturnT>) {
     static_assert(
-        is_optional_v<ReturnT>
-            ? supportsToJs<
-                  typename ReturnT::value_type,
-                  typename JSReturnT::value_type>
-            : supportsToJs<ReturnT, typename JSReturnT::value_type>,
+        is_optional_v<ReturnT> ? supportsToJs<typename ReturnT::value_type, typename JSReturnT::value_type>
+                               : supportsToJs<ReturnT, typename JSReturnT::value_type>,
         "Incompatible return type");
 
-    auto result = toJs(
-        rt,
-        (instance->*method)(
-            rt, fromJs<ArgsT>(rt, std::forward<JSArgsT>(args), jsInvoker)...),
-        jsInvoker);
+    auto result =
+        toJs(rt, (instance->*method)(rt, fromJs<ArgsT>(rt, std::forward<JSArgsT>(args), jsInvoker)...), jsInvoker);
 
     if constexpr (std::is_same_v<decltype(result), jsi::Value>) {
       if (result.isNull() || result.isUndefined()) {
@@ -78,20 +55,20 @@ JSReturnT callFromJs(
 
     return convert(rt, std::move(result));
   } else {
-    static_assert(
-        std::is_convertible_v<ReturnT, JSReturnT>, "Incompatible return type");
-    return (instance->*method)(
-        rt, fromJs<ArgsT>(rt, std::forward<JSArgsT>(args), jsInvoker)...);
+    static_assert(std::is_convertible_v<ReturnT, JSReturnT>, "Incompatible return type");
+    return (instance->*method)(rt, fromJs<ArgsT>(rt, std::forward<JSArgsT>(args), jsInvoker)...);
   }
 }
 
 template <typename ReturnT, typename... ArgsT>
-constexpr size_t getParameterCount(ReturnT (*)(ArgsT...)) {
+constexpr size_t getParameterCount(ReturnT (* /*unused*/)(ArgsT...))
+{
   return sizeof...(ArgsT);
 }
 
 template <typename Class, typename ReturnT, typename... ArgsT>
-constexpr size_t getParameterCount(ReturnT (Class::*)(ArgsT...)) {
+constexpr size_t getParameterCount(ReturnT (Class::* /*unused*/)(ArgsT...))
+{
   return sizeof...(ArgsT);
 }
 

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

@@ -19,10 +19,8 @@ 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>>;
+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>
 struct is_optional : std::false_type {};
@@ -37,9 +35,8 @@ template <typename T, typename = void>
 inline constexpr bool is_optional_jsi_v = false;
 
 template <typename T>
-inline constexpr bool
-    is_optional_jsi_v<T, typename std::enable_if_t<is_optional_v<T>>> =
-        is_jsi_v<typename T::value_type>;
+inline constexpr bool is_optional_jsi_v<T, typename std::enable_if_t<is_optional_v<T>>> =
+    is_jsi_v<typename T::value_type>;
 
 template <typename T>
 struct Converter;
@@ -48,10 +45,10 @@ template <typename T>
 struct ConverterBase {
   using BaseT = remove_cvref_t<T>;
 
-  ConverterBase(jsi::Runtime& rt, T&& value)
-      : rt_(rt), value_(std::forward<T>(value)) {}
+  ConverterBase(jsi::Runtime &rt, T &&value) : rt_(rt), value_(std::forward<T>(value)) {}
 
-  operator BaseT() && {
+  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_);
@@ -79,17 +76,16 @@ struct ConverterBase {
               // Ensure non-reference type can be converted to the desired type.
               std::is_convertible_v<Converter<BaseT>, U>,
           int> = 0>
-  operator U() && {
+  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>
+  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_;
+  jsi::Runtime &rt_;
   T value_;
 };
 
@@ -102,19 +98,23 @@ template <>
 struct Converter<jsi::Value> : public ConverterBase<jsi::Value> {
   using ConverterBase<jsi::Value>::ConverterBase;
 
-  operator jsi::String() && {
+  operator jsi::String() &&
+  {
     return std::move(value_).asString(rt_);
   }
 
-  operator jsi::Object() && {
+  operator jsi::Object() &&
+  {
     return std::move(value_).asObject(rt_);
   }
 
-  operator jsi::Array() && {
+  operator jsi::Array() &&
+  {
     return std::move(value_).asObject(rt_).asArray(rt_);
   }
 
-  operator jsi::Function() && {
+  operator jsi::Function() &&
+  {
     return std::move(value_).asObject(rt_).asFunction(rt_);
   }
 };
@@ -123,21 +123,26 @@ template <>
 struct Converter<jsi::Object> : public ConverterBase<jsi::Object> {
   using ConverterBase<jsi::Object>::ConverterBase;
 
-  operator jsi::Array() && {
+  operator jsi::Array() &&
+  {
     return std::move(value_).asArray(rt_);
   }
 
-  operator jsi::Function() && {
+  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()) {}
+  Converter(jsi::Runtime &rt, std::optional<T> value)
+      : ConverterBase(rt, value ? std::move(*value) : jsi::Value::null())
+  {
+  }
 
-  operator std::optional<T>() && {
+  operator std::optional<T>() &&
+  {
     if (value_.isNull() || value_.isUndefined()) {
       return {};
     }
@@ -146,24 +151,26 @@ struct Converter<std::optional<T>> : public ConverterBase<jsi::Value> {
 };
 
 template <typename T, std::enable_if_t<is_jsi_v<T>, int> = 0>
-auto convert(jsi::Runtime& rt, T&& value) {
+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) {
+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) {
+auto convert(jsi::Runtime & /*rt*/, T &&value)
+{
   return value;
 }
 
 template <typename T>
-auto convert(jsi::Runtime& /*rt*/, Converter<T>&& converter) {
+auto convert(jsi::Runtime & /*rt*/, Converter<T> &&converter)
+{
   return std::move(converter);
 }