react-native-windows 0.82.3 → 0.83.0-preview.1

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

@@ -21,37 +21,34 @@ class SyncCallback;
 template <typename... Args>
 class AsyncCallback {
  public:
-  AsyncCallback(
-      jsi::Runtime& runtime,
-      jsi::Function function,
-      std::shared_ptr<CallInvoker> jsInvoker)
-      : callback_(std::make_shared<SyncCallback<void(Args...)>>(
-            runtime,
-            std::move(function),
-            std::move(jsInvoker))) {}
-
-  void operator()(Args... args) const noexcept {
+  AsyncCallback(jsi::Runtime &runtime, jsi::Function function, std::shared_ptr<CallInvoker> jsInvoker)
+      : callback_(std::make_shared<SyncCallback<void(Args...)>>(runtime, std::move(function), std::move(jsInvoker)))
+  {
+  }
+
+  void operator()(Args... args) const noexcept
+  {
     call(std::forward<Args>(args)...);
   }
 
-  void call(Args... args) const noexcept {
+  void call(Args... args) const noexcept
+  {
     callWithArgs(std::nullopt, std::forward<Args>(args)...);
   }
 
-  void callWithPriority(SchedulerPriority priority, Args... args)
-      const noexcept {
+  void callWithPriority(SchedulerPriority priority, Args... args) const noexcept
+  {
     callWithArgs(priority, std::forward<Args>(args)...);
   }
 
-  void call(std::function<void(jsi::Runtime&, jsi::Function&)>&& callImpl)
-      const noexcept {
+  void call(std::function<void(jsi::Runtime &, jsi::Function &)> &&callImpl) const noexcept
+  {
     callWithFunction(std::nullopt, std::move(callImpl));
   }
 
-  void callWithPriority(
-      SchedulerPriority priority,
-      std::function<void(jsi::Runtime&, jsi::Function&)>&& callImpl)
-      const noexcept {
+  void callWithPriority(SchedulerPriority priority, std::function<void(jsi::Runtime &, jsi::Function &)> &&callImpl)
+      const noexcept
+  {
     callWithFunction(priority, std::move(callImpl));
   }
 
@@ -60,15 +57,14 @@ class AsyncCallback {
 
   std::shared_ptr<SyncCallback<void(Args...)>> callback_;
 
-  void callWithArgs(std::optional<SchedulerPriority> priority, Args... args)
-      const noexcept {
+  void callWithArgs(std::optional<SchedulerPriority> priority, Args... args) const noexcept
+  {
     if (auto wrapper = callback_->wrapper_.lock()) {
       auto fn = [callback = callback_,
-                 argsPtr = std::make_shared<std::tuple<Args...>>(
-                     std::make_tuple(std::forward<Args>(args)...))](
-                    jsi::Runtime&) { callback->apply(std::move(*argsPtr)); };
+                 argsPtr = std::make_shared<std::tuple<Args...>>(std::make_tuple(std::forward<Args>(args)...))](
+                    jsi::Runtime &) { callback->apply(std::move(*argsPtr)); };
 
-      auto& jsInvoker = wrapper->jsInvoker();
+      auto &jsInvoker = wrapper->jsInvoker();
       if (priority) {
         jsInvoker.invokeAsync(*priority, std::move(fn));
       } else {
@@ -79,20 +75,19 @@ class AsyncCallback {
 
   void callWithFunction(
       std::optional<SchedulerPriority> priority,
-      std::function<void(jsi::Runtime&, jsi::Function&)>&& callImpl)
-      const noexcept {
+      std::function<void(jsi::Runtime &, jsi::Function &)> &&callImpl) const noexcept
+  {
     if (auto wrapper = callback_->wrapper_.lock()) {
       // Capture callback_ and not wrapper_. If callback_ is deallocated or the
       // JSVM is shutdown before the async task is scheduled, the underlying
       // function will have been deallocated.
-      auto fn = [callback = callback_,
-                 callImpl = std::move(callImpl)](jsi::Runtime& rt) {
+      auto fn = [callback = callback_, callImpl = std::move(callImpl)](jsi::Runtime &rt) {
         if (auto wrapper2 = callback->wrapper_.lock()) {
           callImpl(rt, wrapper2->callback());
         }
       };
 
-      auto& jsInvoker = wrapper->jsInvoker();
+      auto &jsInvoker = wrapper->jsInvoker();
       if (priority) {
         jsInvoker.invokeAsync(*priority, std::move(fn));
       } else {
@@ -108,40 +103,39 @@ class AsyncCallback {
 template <typename R, typename... Args>
 class SyncCallback<R(Args...)> {
  public:
-  SyncCallback(
-      jsi::Runtime& rt,
-      jsi::Function function,
-      std::shared_ptr<CallInvoker> jsInvoker)
-      : wrapper_(CallbackWrapper::createWeak(
-            std::move(function),
-            rt,
-            std::move(jsInvoker))) {}
+  SyncCallback(jsi::Runtime &rt, jsi::Function function, std::shared_ptr<CallInvoker> jsInvoker)
+      : wrapper_(CallbackWrapper::createWeak(std::move(function), rt, std::move(jsInvoker)))
+  {
+  }
 
   // Disallow copying, as we can no longer safely destroy the callback
   // from the destructor if there's multiple copies
-  SyncCallback(const SyncCallback&) = delete;
-  SyncCallback& operator=(const SyncCallback&) = delete;
+  SyncCallback(const SyncCallback &) = delete;
+  SyncCallback &operator=(const SyncCallback &) = delete;
 
   // Allow move
-  SyncCallback(SyncCallback&& other) noexcept
-      : wrapper_(std::move(other.wrapper_)) {}
+  SyncCallback(SyncCallback &&other) noexcept : wrapper_(std::move(other.wrapper_)) {}
 
-  SyncCallback& operator=(SyncCallback&& other) noexcept {
+  SyncCallback &operator=(SyncCallback &&other) noexcept
+  {
     wrapper_ = std::move(other.wrapper_);
     return *this;
   }
 
-  ~SyncCallback() {
+  ~SyncCallback()
+  {
     if (auto wrapper = wrapper_.lock()) {
       wrapper->destroy();
     }
   }
 
-  R operator()(Args... args) const {
+  R operator()(Args... args) const
+  {
     return call(std::forward<Args>(args)...);
   }
 
-  R call(Args... args) const {
+  R call(Args... args) const
+  {
     auto wrapper = wrapper_.lock();
 
     // If the wrapper has been deallocated, we can no longer provide a return
@@ -154,19 +148,15 @@ class SyncCallback<R(Args...)> {
       }
     }
 
-    auto& callback = wrapper->callback();
-    auto& rt = wrapper->runtime();
+    auto &callback = wrapper->callback();
+    auto &rt = wrapper->runtime();
     auto jsInvoker = wrapper->jsInvokerPtr();
 
     if constexpr (std::is_void_v<R>) {
-      callback.call(
-          rt, bridging::toJs(rt, std::forward<Args>(args), jsInvoker)...);
+      callback.call(rt, bridging::toJs(rt, std::forward<Args>(args), jsInvoker)...);
     } else {
       return bridging::fromJs<R>(
-          rt,
-          callback.call(
-              rt, bridging::toJs(rt, std::forward<Args>(args), jsInvoker)...),
-          jsInvoker);
+          rt, callback.call(rt, bridging::toJs(rt, std::forward<Args>(args), jsInvoker)...), jsInvoker);
     }
   }
 
@@ -174,12 +164,14 @@ class SyncCallback<R(Args...)> {
   friend AsyncCallback<Args...>;
   friend Bridging<SyncCallback>;
 
-  R apply(std::tuple<Args...>&& args) const {
+  R apply(std::tuple<Args...> &&args) const
+  {
     return apply(std::move(args), std::index_sequence_for<Args...>{});
   }
 
   template <size_t... Index>
-  R apply(std::tuple<Args...>&& args, std::index_sequence<Index...>) const {
+  R apply(std::tuple<Args...> &&args, std::index_sequence<Index...> /*unused*/) const
+  {
     return call(std::move(std::get<Index>(args))...);
   }
 
@@ -189,32 +181,28 @@ class SyncCallback<R(Args...)> {
 
 template <typename... Args>
 struct Bridging<AsyncCallback<Args...>> {
-  static AsyncCallback<Args...> fromJs(
-      jsi::Runtime& rt,
-      jsi::Function&& value,
-      const std::shared_ptr<CallInvoker>& jsInvoker) {
+  static AsyncCallback<Args...>
+  fromJs(jsi::Runtime &rt, jsi::Function &&value, const std::shared_ptr<CallInvoker> &jsInvoker)
+  {
     return AsyncCallback<Args...>(rt, std::move(value), jsInvoker);
   }
 
-  static jsi::Function toJs(
-      jsi::Runtime& rt,
-      const AsyncCallback<Args...>& value) {
+  static jsi::Function toJs(jsi::Runtime &rt, const AsyncCallback<Args...> &value)
+  {
     return value.callback_->function_.getFunction(rt);
   }
 };
 
 template <typename R, typename... Args>
 struct Bridging<SyncCallback<R(Args...)>> {
-  static SyncCallback<R(Args...)> fromJs(
-      jsi::Runtime& rt,
-      jsi::Function&& value,
-      const std::shared_ptr<CallInvoker>& jsInvoker) {
+  static SyncCallback<R(Args...)>
+  fromJs(jsi::Runtime &rt, jsi::Function &&value, const std::shared_ptr<CallInvoker> &jsInvoker)
+  {
     return SyncCallback<R(Args...)>(rt, std::move(value), jsInvoker);
   }
 
-  static jsi::Function toJs(
-      jsi::Runtime& rt,
-      const SyncCallback<R(Args...)>& value) {
+  static jsi::Function toJs(jsi::Runtime &rt, const SyncCallback<R(Args...)> &value)
+  {
     return value.function_.getFunction(rt);
   }
 };
@@ -226,19 +214,14 @@ struct Bridging<std::function<R(Args...)>> {
 
   static constexpr size_t kArgumentCount = sizeof...(Args);
 
-  static jsi::Function toJs(
-      jsi::Runtime& rt,
-      Func fn,
-      const std::shared_ptr<CallInvoker>& jsInvoker) {
+  static jsi::Function toJs(jsi::Runtime &rt, Func fn, const std::shared_ptr<CallInvoker> &jsInvoker)
+  {
     return jsi::Function::createFromHostFunction(
         rt,
         jsi::PropNameID::forAscii(rt, "BridgedFunction"),
         kArgumentCount,
         [fn = std::make_shared<Func>(std::move(fn)), jsInvoker](
-            jsi::Runtime& rt,
-            const jsi::Value&,
-            const jsi::Value* args,
-            size_t count) -> jsi::Value {
+            jsi::Runtime &rt, const jsi::Value &, const jsi::Value *args, size_t count) -> jsi::Value {
           if (count < kArgumentCount) {
             throw jsi::JSError(rt, "Incorrect number of arguments");
           }
@@ -247,10 +230,7 @@ struct Bridging<std::function<R(Args...)>> {
             callFromJs(*fn, rt, args, jsInvoker, IndexSequence{});
             return jsi::Value();
           } else {
-            return bridging::toJs(
-                rt,
-                callFromJs(*fn, rt, args, jsInvoker, IndexSequence{}),
-                jsInvoker);
+            return bridging::toJs(rt, callFromJs(*fn, rt, args, jsInvoker, IndexSequence{}), jsInvoker);
           }
         });
   }
@@ -258,11 +238,12 @@ struct Bridging<std::function<R(Args...)>> {
  private:
   template <size_t... Index>
   static R callFromJs(
-      Func& fn,
-      jsi::Runtime& rt,
-      const jsi::Value* args,
-      const std::shared_ptr<CallInvoker>& jsInvoker,
-      std::index_sequence<Index...>) {
+      Func &fn,
+      jsi::Runtime &rt,
+      const jsi::Value *args,
+      const std::shared_ptr<CallInvoker> &jsInvoker,
+      std::index_sequence<Index...> /*unused*/)
+  {
     return fn(bridging::fromJs<Args>(rt, args[Index], jsInvoker)...);
   }
 };
@@ -270,8 +251,7 @@ struct Bridging<std::function<R(Args...)>> {
 template <typename R, typename... Args>
 struct Bridging<
     std::function<R(Args...)>,
-    std::enable_if_t<
-        !std::is_same_v<std::function<R(Args...)>, std::function<R(Args...)>>>>
+    std::enable_if_t<!std::is_same_v<std::function<R(Args...)>, std::function<R(Args...)>>>>
     : Bridging<std::function<R(Args...)>> {};
 
 template <typename R, typename... Args>

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

@@ -14,26 +14,26 @@ namespace facebook::react {
 
 template <>
 struct Bridging<HighResTimeStamp> {
-  static HighResTimeStamp fromJs(
-      jsi::Runtime& /*rt*/,
-      const jsi::Value& jsiValue) {
+  static HighResTimeStamp fromJs(jsi::Runtime & /*rt*/, const jsi::Value &jsiValue)
+  {
     return HighResTimeStamp::fromDOMHighResTimeStamp(jsiValue.asNumber());
   }
 
-  static double toJs(jsi::Runtime& /*rt*/, const HighResTimeStamp& value) {
+  static double toJs(jsi::Runtime & /*rt*/, const HighResTimeStamp &value)
+  {
     return value.toDOMHighResTimeStamp();
   }
 };
 
 template <>
 struct Bridging<HighResDuration> {
-  static HighResDuration fromJs(
-      jsi::Runtime& /*rt*/,
-      const jsi::Value& jsiValue) {
+  static HighResDuration fromJs(jsi::Runtime & /*rt*/, const jsi::Value &jsiValue)
+  {
     return HighResDuration::fromDOMHighResTimeStamp(jsiValue.asNumber());
   }
 
-  static double toJs(jsi::Runtime& /*rt*/, const HighResDuration& value) {
+  static double toJs(jsi::Runtime & /*rt*/, const HighResDuration &value)
+  {
     return value.toDOMHighResTimeStamp();
   }
 };

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

@@ -32,9 +32,9 @@ class LongLivedObject {
   virtual void allowRelease();
 
  protected:
-  explicit LongLivedObject(jsi::Runtime& runtime) : runtime_(runtime) {}
+  explicit LongLivedObject(jsi::Runtime &runtime) : runtime_(runtime) {}
   virtual ~LongLivedObject() = default;
-  jsi::Runtime& runtime_;
+  jsi::Runtime &runtime_;
 };
 
 /**
@@ -42,14 +42,14 @@ class LongLivedObject {
  */
 class LongLivedObjectCollection {
  public:
-  static LongLivedObjectCollection& get(jsi::Runtime& runtime);
+  static LongLivedObjectCollection &get(jsi::Runtime &runtime);
 
   LongLivedObjectCollection() = default;
-  LongLivedObjectCollection(const LongLivedObjectCollection&) = delete;
-  void operator=(const LongLivedObjectCollection&) = delete;
+  LongLivedObjectCollection(const LongLivedObjectCollection &) = delete;
+  void operator=(const LongLivedObjectCollection &) = delete;
 
   void add(std::shared_ptr<LongLivedObject> o);
-  void remove(const LongLivedObject* o);
+  void remove(const LongLivedObject *o);
   void clear();
   size_t size() const;
 

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

@@ -13,44 +13,52 @@ namespace facebook::react {
 
 template <>
 struct Bridging<double> {
-  static double fromJs(jsi::Runtime& /*unused*/, const jsi::Value& value) {
+  static double fromJs(jsi::Runtime & /*unused*/, const jsi::Value &value)
+  {
     return value.asNumber();
   }
 
-  static double toJs(jsi::Runtime& /*unused*/, double value) {
+  static double toJs(jsi::Runtime & /*unused*/, double value)
+  {
     return value;
   }
 };
 
 template <>
 struct Bridging<float> {
-  static float fromJs(jsi::Runtime& /*unused*/, const jsi::Value& value) {
+  static float fromJs(jsi::Runtime & /*unused*/, const jsi::Value &value)
+  {
     return (float)value.asNumber();
   }
 
-  static float toJs(jsi::Runtime& /*unused*/, float value) {
+  static float toJs(jsi::Runtime & /*unused*/, float value)
+  {
     return value;
   }
 };
 
 template <>
 struct Bridging<int32_t> {
-  static int32_t fromJs(jsi::Runtime& /*unused*/, const jsi::Value& value) {
+  static int32_t fromJs(jsi::Runtime & /*unused*/, const jsi::Value &value)
+  {
     return (int32_t)value.asNumber();
   }
 
-  static int32_t toJs(jsi::Runtime& /*unused*/, int32_t value) {
+  static int32_t toJs(jsi::Runtime & /*unused*/, int32_t value)
+  {
     return value;
   }
 };
 
 template <>
 struct Bridging<uint32_t> {
-  static uint32_t fromJs(jsi::Runtime& /*unused*/, const jsi::Value& value) {
+  static uint32_t fromJs(jsi::Runtime & /*unused*/, const jsi::Value &value)
+  {
     return (uint32_t)value.asNumber();
   }
 
-  static jsi::Value toJs(jsi::Runtime& /*unused*/, uint32_t value) {
+  static jsi::Value toJs(jsi::Runtime & /*unused*/, uint32_t value)
+  {
     return double(value);
   }
 };

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

@@ -17,24 +17,26 @@ namespace facebook::react {
 
 template <>
 struct Bridging<jsi::WeakObject> {
-  static jsi::WeakObject fromJs(jsi::Runtime& rt, const jsi::Object& value) {
+  static jsi::WeakObject fromJs(jsi::Runtime &rt, const jsi::Object &value)
+  {
     return jsi::WeakObject(rt, value);
   }
 
-  static jsi::Value toJs(jsi::Runtime& rt, jsi::WeakObject& value) {
+  static jsi::Value toJs(jsi::Runtime &rt, jsi::WeakObject &value)
+  {
     return value.lock(rt);
   }
 };
 
 template <typename T>
-struct Bridging<
-    std::shared_ptr<T>,
-    std::enable_if_t<std::is_base_of_v<jsi::HostObject, T>>> {
-  static std::shared_ptr<T> fromJs(jsi::Runtime& rt, const jsi::Object& value) {
+struct Bridging<std::shared_ptr<T>, std::enable_if_t<std::is_base_of_v<jsi::HostObject, T>>> {
+  static std::shared_ptr<T> fromJs(jsi::Runtime &rt, const jsi::Object &value)
+  {
     return value.getHostObject<T>(rt);
   }
 
-  static jsi::Object toJs(jsi::Runtime& rt, std::shared_ptr<T> value) {
+  static jsi::Object toJs(jsi::Runtime &rt, std::shared_ptr<T> value)
+  {
     return jsi::Object::createFromHostObject(rt, std::move(value));
   }
 };
@@ -43,10 +45,8 @@ namespace map_detail {
 
 template <typename T>
 struct Bridging {
-  static T fromJs(
-      jsi::Runtime& rt,
-      const jsi::Object& value,
-      const std::shared_ptr<CallInvoker>& jsInvoker) {
+  static T fromJs(jsi::Runtime &rt, const jsi::Object &value, const std::shared_ptr<CallInvoker> &jsInvoker)
+  {
     T result;
     auto propertyNames = value.getPropertyNames(rt);
     auto length = propertyNames.length(rt);
@@ -56,24 +56,18 @@ struct Bridging {
 
       result.emplace(
           bridging::fromJs<std::string>(rt, propertyName, jsInvoker),
-          bridging::fromJs<typename T::mapped_type>(
-              rt, value.getProperty(rt, propertyName.asString(rt)), jsInvoker));
+          bridging::fromJs<typename T::mapped_type>(rt, value.getProperty(rt, propertyName.asString(rt)), jsInvoker));
     }
 
     return result;
   }
 
-  static jsi::Object toJs(
-      jsi::Runtime& rt,
-      const T& map,
-      const std::shared_ptr<CallInvoker>& jsInvoker) {
+  static jsi::Object toJs(jsi::Runtime &rt, const T &map, const std::shared_ptr<CallInvoker> &jsInvoker)
+  {
     auto resultObject = jsi::Object(rt);
 
-    for (const auto& [key, value] : map) {
-      resultObject.setProperty(
-          rt,
-          jsi::PropNameID::forUtf8(rt, key),
-          bridging::toJs(rt, value, jsInvoker));
+    for (const auto &[key, value] : map) {
+      resultObject.setProperty(rt, jsi::PropNameID::forUtf8(rt, key), bridging::toJs(rt, value, jsInvoker));
     }
 
     return resultObject;
@@ -83,8 +77,7 @@ struct Bridging {
 } // namespace map_detail
 
 template <typename... Args>
-struct Bridging<std::map<std::string, Args...>>
-    : map_detail::Bridging<std::map<std::string, Args...>> {};
+struct Bridging<std::map<std::string, Args...>> : map_detail::Bridging<std::map<std::string, Args...>> {};
 
 template <typename... Args>
 struct Bridging<std::unordered_map<std::string, Args...>>

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

@@ -18,13 +18,12 @@ namespace facebook::react {
 
 template <typename... T>
 class AsyncPromise {
-  static_assert(
-      sizeof...(T) <= 1,
-      "AsyncPromise must have at most one argument");
+  static_assert(sizeof...(T) <= 1, "AsyncPromise must have at most one argument");
 
  public:
-  AsyncPromise(jsi::Runtime& rt, const std::shared_ptr<CallInvoker>& jsInvoker)
-      : state_(std::make_shared<SharedState>()) {
+  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(
@@ -32,23 +31,21 @@ class AsyncPromise {
         bridging::toJs(
             rt,
             // Safe to capture this since this is called synchronously.
-            [this](
-                AsyncCallback<T...> resolve,
-                const AsyncCallback<Error>& reject) {
+            [this](AsyncCallback<T...> resolve, const AsyncCallback<Error> &reject) {
               state_->resolve = std::move(resolve);
               state_->reject = std::move(reject);
             },
             jsInvoker));
 
-    auto promiseHolder =
-        std::make_shared<PromiseHolder>(rt, promise.asObject(rt));
+    auto promiseHolder = std::make_shared<PromiseHolder>(rt, promise.asObject(rt));
     LongLivedObjectCollection::get(rt).add(promiseHolder);
 
     // The shared state can retain the promise holder weakly now.
     state_->promiseHolder = promiseHolder;
   }
 
-  void resolve(T... value) {
+  void resolve(T... value)
+  {
     std::lock_guard<std::mutex> lock(state_->mutex);
 
     if (state_->resolve) {
@@ -58,7 +55,8 @@ class AsyncPromise {
     }
   }
 
-  void reject(Error error) {
+  void reject(Error error)
+  {
     std::lock_guard<std::mutex> lock(state_->mutex);
 
     if (state_->reject) {
@@ -68,7 +66,8 @@ class AsyncPromise {
     }
   }
 
-  jsi::Object get(jsi::Runtime& rt) const {
+  jsi::Object get(jsi::Runtime &rt) const
+  {
     if (auto holder = state_->promiseHolder.lock()) {
       return jsi::Value(rt, holder->promise).asObject(rt);
     } else {
@@ -78,14 +77,14 @@ class AsyncPromise {
 
  private:
   struct PromiseHolder : LongLivedObject {
-    PromiseHolder(jsi::Runtime& runtime, jsi::Object p)
-        : LongLivedObject(runtime), promise(std::move(p)) {}
+    PromiseHolder(jsi::Runtime &runtime, jsi::Object p) : LongLivedObject(runtime), promise(std::move(p)) {}
 
     jsi::Object promise;
   };
 
   struct SharedState {
-    ~SharedState() {
+    ~SharedState()
+    {
       if (auto holder = promiseHolder.lock()) {
         holder->allowRelease();
       }
@@ -102,7 +101,8 @@ class AsyncPromise {
 
 template <typename... T>
 struct Bridging<AsyncPromise<T...>> {
-  static jsi::Object toJs(jsi::Runtime& rt, const AsyncPromise<T...>& promise) {
+  static jsi::Object toJs(jsi::Runtime &rt, const AsyncPromise<T...> &promise)
+  {
     return promise.get(rt);
   }
 };