react-native-windows 0.72.19 → 0.72.20

package/Directory.Build.props

@@ -19,8 +19,8 @@
     <FollyVersion>2022.11.28.00</FollyVersion>
     <FollyCommitHash>6ed36117cdc4831f3a3951e013ae76b405e88e15</FollyCommitHash>
     <!-- When bumping the fmt version, be sure to bump the git hash of that version's commit and build fmt.vcxproj (to update its cgmanifest.json) too. -->
-    <FmtVersion>8.0.0</FmtVersion>
-    <FmtCommitHash>9e8b86fd2d9806672cc73133d21780dd182bfd24</FmtCommitHash>
+    <FmtVersion>10.1.0</FmtVersion>
+    <FmtCommitHash>ca2e3685b160617d3d95fcd9e789c4e06ca88</FmtCommitHash>
     <!-- Commit hash for https://github.com/microsoft/node-api-jsi code. -->
     <NodeApiJsiCommitHash>53b897b03c1c7e57c3372acc6234447a44e150d6</NodeApiJsiCommitHash>
   </PropertyGroup>

package/Microsoft.ReactNative/JSDispatcherWriter.cpp

@@ -33,6 +33,12 @@ JSDispatcherWriter::JSDispatcherWriter(
     std::weak_ptr<LongLivedJsiRuntime> jsiRuntimeHolder) noexcept
     : m_jsDispatcher(jsDispatcher), m_jsiRuntimeHolder(std::move(jsiRuntimeHolder)) {}
 
+JSDispatcherWriter::~JSDispatcherWriter() {
+  if (auto jsiRuntimeHolder = m_jsiRuntimeHolder.lock()) {
+    jsiRuntimeHolder->allowRelease();
+  }
+}
+
 void JSDispatcherWriter::WithResultArgs(
     Mso::Functor<void(facebook::jsi::Runtime &rt, facebook::jsi::Value const *args, size_t argCount)>
         handler) noexcept {
@@ -49,17 +55,18 @@ void JSDispatcherWriter::WithResultArgs(
     VerifyElseCrash(!m_jsiWriter);
     folly::dynamic dynValue = m_dynamicWriter->TakeValue();
     VerifyElseCrash(dynValue.isArray());
-    m_jsDispatcher.Post([handler, dynValue = std::move(dynValue), weakJsiRuntimeHolder = m_jsiRuntimeHolder]() {
-      if (auto jsiRuntimeHolder = weakJsiRuntimeHolder.lock()) {
-        std::vector<facebook::jsi::Value> args;
-        args.reserve(dynValue.size());
-        auto &runtime = jsiRuntimeHolder->Runtime();
-        for (auto const &item : dynValue) {
-          args.emplace_back(facebook::jsi::valueFromDynamic(runtime, item));
-        }
-        handler(runtime, args.data(), args.size());
-      }
-    });
+    m_jsDispatcher.Post(
+        [handler, dynValue = std::move(dynValue), weakJsiRuntimeHolder = m_jsiRuntimeHolder, self = get_strong()]() {
+          if (auto jsiRuntimeHolder = weakJsiRuntimeHolder.lock()) {
+            std::vector<facebook::jsi::Value> args;
+            args.reserve(dynValue.size());
+            auto &runtime = jsiRuntimeHolder->Runtime();
+            for (auto const &item : dynValue) {
+              args.emplace_back(facebook::jsi::valueFromDynamic(runtime, item));
+            }
+            handler(runtime, args.data(), args.size());
+          }
+        });
   }
 }
 

package/Microsoft.ReactNative/JSDispatcherWriter.h

@@ -14,6 +14,7 @@ namespace winrt::Microsoft::ReactNative {
 // In case if writing is done outside of JSDispatcher, it uses DynamicWriter to create
 // folly::dynamic which then is written to JsiWriter in JSDispatcher.
 struct JSDispatcherWriter : winrt::implements<JSDispatcherWriter, IJSValueWriter> {
+  ~JSDispatcherWriter();
   JSDispatcherWriter(
       IReactDispatcher const &jsDispatcher,
       std::weak_ptr<LongLivedJsiRuntime> jsiRuntimeHolder) noexcept;

package/Microsoft.ReactNative/TurboModulesProvider.cpp

@@ -221,11 +221,46 @@ class TurboModuleImpl : public facebook::react::TurboModule {
                   VerifyElseCrash(argCount > 1);
                   if (auto strongLongLivedObjectCollection = longLivedObjectCollection.lock()) {
                     auto jsiRuntimeHolder = LongLivedJsiRuntime::CreateWeak(strongLongLivedObjectCollection, rt);
+                    auto weakCallback1 = LongLivedJsiFunction::CreateWeak(
+                        strongLongLivedObjectCollection, rt, args[argCount - 2].getObject(rt).getFunction(rt));
+                    auto weakCallback2 = LongLivedJsiFunction::CreateWeak(
+                        strongLongLivedObjectCollection, rt, args[argCount - 1].getObject(rt).getFunction(rt));
+
                     method(
                         winrt::make<JsiReader>(rt, args, argCount - 2),
                         winrt::make<JSDispatcherWriter>(jsDispatcher, jsiRuntimeHolder),
-                        MakeCallback(rt, strongLongLivedObjectCollection, args[argCount - 2]),
-                        MakeCallback(rt, strongLongLivedObjectCollection, args[argCount - 1]));
+                        [weakCallback1, weakCallback2, jsiRuntimeHolder](const IJSValueWriter &writer) noexcept {
+                          writer.as<JSDispatcherWriter>()->WithResultArgs(
+                              [weakCallback1, weakCallback2, jsiRuntimeHolder](
+                                  facebook::jsi::Runtime &rt, facebook::jsi::Value const *args, size_t count) {
+                                if (auto callback1 = weakCallback1.lock()) {
+                                  callback1->Value().call(rt, args, count);
+                                  callback1->allowRelease();
+                                }
+                                if (auto callback2 = weakCallback2.lock()) {
+                                  callback2->allowRelease();
+                                }
+                                if (auto runtimeHolder = jsiRuntimeHolder.lock()) {
+                                  runtimeHolder->allowRelease();
+                                }
+                              });
+                        },
+                        [weakCallback1, weakCallback2, jsiRuntimeHolder](const IJSValueWriter &writer) noexcept {
+                          writer.as<JSDispatcherWriter>()->WithResultArgs(
+                              [weakCallback1, weakCallback2, jsiRuntimeHolder](
+                                  facebook::jsi::Runtime &rt, facebook::jsi::Value const *args, size_t count) {
+                                if (auto callback2 = weakCallback2.lock()) {
+                                  callback2->Value().call(rt, args, count);
+                                  callback2->allowRelease();
+                                }
+                                if (auto callback1 = weakCallback1.lock()) {
+                                  callback1->allowRelease();
+                                }
+                                if (auto runtimeHolder = jsiRuntimeHolder.lock()) {
+                                  runtimeHolder->allowRelease();
+                                }
+                              });
+                        });
                   }
                   return facebook::jsi::Value::undefined();
                 });
@@ -247,49 +282,65 @@ class TurboModuleImpl : public facebook::react::TurboModule {
                     auto argWriter = winrt::make<JSDispatcherWriter>(jsDispatcher, jsiRuntimeHolder);
                     return facebook::react::createPromiseAsJSIValue(
                         rt,
-                        [method, argReader, argWriter, strongLongLivedObjectCollection](
+                        [method, argReader, argWriter, strongLongLivedObjectCollection, jsiRuntimeHolder](
                             facebook::jsi::Runtime &runtime, std::shared_ptr<facebook::react::Promise> promise) {
+                          auto weakResolve = LongLivedJsiFunction::CreateWeak(
+                              strongLongLivedObjectCollection, runtime, std::move(promise->resolve_));
+                          auto weakReject = LongLivedJsiFunction::CreateWeak(
+                              strongLongLivedObjectCollection, runtime, std::move(promise->reject_));
                           method(
                               argReader,
                               argWriter,
-                              [weakResolve = LongLivedJsiFunction::CreateWeak(
-                                   strongLongLivedObjectCollection, runtime, std::move(promise->resolve_))](
-                                  const IJSValueWriter &writer) {
-                                writer.as<JSDispatcherWriter>()->WithResultArgs([weakResolve](
-                                                                                    facebook::jsi::Runtime &runtime,
-                                                                                    facebook::jsi::Value const *args,
-                                                                                    size_t argCount) {
-                                  VerifyElseCrash(argCount == 1);
-                                  if (auto resolveHolder = weakResolve.lock()) {
-                                    resolveHolder->Value().call(runtime, args[0]);
-                                  }
-                                });
+                              [weakResolve, weakReject, jsiRuntimeHolder](const IJSValueWriter &writer) {
+                                writer.as<JSDispatcherWriter>()->WithResultArgs(
+                                    [weakResolve, weakReject, jsiRuntimeHolder](
+                                        facebook::jsi::Runtime &runtime,
+                                        facebook::jsi::Value const *args,
+                                        size_t argCount) {
+                                      VerifyElseCrash(argCount == 1);
+                                      if (auto resolveHolder = weakResolve.lock()) {
+                                        resolveHolder->Value().call(runtime, args[0]);
+                                        resolveHolder->allowRelease();
+                                      }
+                                      if (auto rejectHolder = weakReject.lock()) {
+                                        rejectHolder->allowRelease();
+                                      }
+                                      if (auto runtimeHolder = jsiRuntimeHolder.lock()) {
+                                        runtimeHolder->allowRelease();
+                                      }
+                                    });
                               },
-                              [weakReject = LongLivedJsiFunction::CreateWeak(
-                                   strongLongLivedObjectCollection, runtime, std::move(promise->reject_))](
-                                  const IJSValueWriter &writer) {
-                                writer.as<JSDispatcherWriter>()->WithResultArgs([weakReject](
-                                                                                    facebook::jsi::Runtime &runtime,
-                                                                                    facebook::jsi::Value const *args,
-                                                                                    size_t argCount) {
-                                  VerifyElseCrash(argCount == 1);
-                                  if (auto rejectHolder = weakReject.lock()) {
-                                    // To match the Android and iOS TurboModule behavior we create the Error object for
-                                    // the Promise rejection the same way as in updateErrorWithErrorData method.
-                                    // See react-native/Libraries/BatchedBridge/NativeModules.js for details.
-                                    auto error = runtime.global()
-                                                     .getPropertyAsFunction(runtime, "Error")
-                                                     .callAsConstructor(runtime, {});
-                                    auto &errorData = args[0];
-                                    if (errorData.isObject()) {
-                                      runtime.global()
-                                          .getPropertyAsObject(runtime, "Object")
-                                          .getPropertyAsFunction(runtime, "assign")
-                                          .call(runtime, error, errorData.getObject(runtime));
-                                    }
-                                    rejectHolder->Value().call(runtime, args[0]);
-                                  }
-                                });
+                              [weakResolve, weakReject, jsiRuntimeHolder](const IJSValueWriter &writer) {
+                                writer.as<JSDispatcherWriter>()->WithResultArgs(
+                                    [weakResolve, weakReject, jsiRuntimeHolder](
+                                        facebook::jsi::Runtime &runtime,
+                                        facebook::jsi::Value const *args,
+                                        size_t argCount) {
+                                      VerifyElseCrash(argCount == 1);
+                                      if (auto rejectHolder = weakReject.lock()) {
+                                        // To match the Android and iOS TurboModule behavior we create the Error object
+                                        // for the Promise rejection the same way as in updateErrorWithErrorData method.
+                                        // See react-native/Libraries/BatchedBridge/NativeModules.js for details.
+                                        auto error = runtime.global()
+                                                         .getPropertyAsFunction(runtime, "Error")
+                                                         .callAsConstructor(runtime, {});
+                                        auto &errorData = args[0];
+                                        if (errorData.isObject()) {
+                                          runtime.global()
+                                              .getPropertyAsObject(runtime, "Object")
+                                              .getPropertyAsFunction(runtime, "assign")
+                                              .call(runtime, error, errorData.getObject(runtime));
+                                        }
+                                        rejectHolder->Value().call(runtime, args[0]);
+                                        rejectHolder->allowRelease();
+                                      }
+                                      if (auto resolveHolder = weakResolve.lock()) {
+                                        resolveHolder->allowRelease();
+                                      }
+                                      if (auto runtimeHolder = jsiRuntimeHolder.lock()) {
+                                        runtimeHolder->allowRelease();
+                                      }
+                                    });
                               });
                         });
                   }
@@ -347,6 +398,7 @@ class TurboModuleImpl : public facebook::react::TurboModule {
           [weakCallback](facebook::jsi::Runtime &rt, facebook::jsi::Value const *args, size_t count) {
             if (auto callback = weakCallback.lock()) {
               callback->Value().call(rt, args, count);
+              callback->allowRelease();
             }
           });
     };

package/PropertySheets/Generated/PackageVersion.g.props

@@ -10,11 +10,11 @@
 -->
 <Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <PropertyGroup>
-    <ReactNativeWindowsVersion>0.72.19</ReactNativeWindowsVersion>
+    <ReactNativeWindowsVersion>0.72.20</ReactNativeWindowsVersion>
     <ReactNativeWindowsMajor>0</ReactNativeWindowsMajor>
     <ReactNativeWindowsMinor>72</ReactNativeWindowsMinor>
-    <ReactNativeWindowsPatch>19</ReactNativeWindowsPatch>
+    <ReactNativeWindowsPatch>20</ReactNativeWindowsPatch>
     <ReactNativeWindowsCanary>false</ReactNativeWindowsCanary>
-    <ReactNativeWindowsCommitId>318d6227643ae6c9d080a1e3000c903104afa59b</ReactNativeWindowsCommitId>
+    <ReactNativeWindowsCommitId>aecc90b632a5bc36341543318bb178b2054ea1dd</ReactNativeWindowsCommitId>
   </PropertyGroup>
 </Project>

package/PropertySheets/JSEngine.props

@@ -14,7 +14,7 @@
     <!-- Enabling this will (1) Include hermes glues in the Microsoft.ReactNative binaries AND (2) Make hermes the default engine -->
     <UseHermes Condition="'$(UseHermes)' == ''">false</UseHermes>
     <!-- This will be true if (1) the client want to use hermes by setting UseHermes to true OR (2) We are building for UWP where dynamic switching is enabled -->
-    <HermesVersion Condition="'$(HermesVersion)' == ''">0.1.15</HermesVersion>
+    <HermesVersion Condition="'$(HermesVersion)' == ''">0.1.18</HermesVersion>
     <HermesPackage Condition="'$(HermesPackage)' == '' And Exists('$(PkgMicrosoft_JavaScript_Hermes)')">$(PkgMicrosoft_JavaScript_Hermes)</HermesPackage>
     <HermesPackage Condition="'$(HermesPackage)' == ''">$(NuGetPackageRoot)\Microsoft.JavaScript.Hermes\$(HermesVersion)</HermesPackage>
     <EnableHermesInspectorInReleaseFlavor Condition="'$(EnableHermesInspectorInReleaseFlavor)' == ''">false</EnableHermesInspectorInReleaseFlavor>

package/Shared/Networking/DefaultBlobResource.cpp

@@ -140,15 +140,19 @@ void DefaultBlobResource::Release(string &&blobId) noexcept /*override*/ {
 void DefaultBlobResource::AddNetworkingHandler() noexcept /*override*/ {
   auto propId = msrn::ReactPropertyId<msrn::ReactNonAbiValue<weak_ptr<IHttpModuleProxy>>>{L"HttpModule.Proxy"};
 
+  bool handlerAdded = false;
   if (auto prop = m_propertyBag.Get(propId)) {
     if (auto httpHandler = prop.Value().lock()) {
       httpHandler->AddRequestBodyHandler(m_requestBodyHandler);
       httpHandler->AddResponseHandler(m_responseHandler);
+      handlerAdded = true;
     }
-  } else {
-    // #11439 - The absence of HttpModule.Proxy may be caused by a module initialization race condition.
-    // Best-effort approach to set up the request/response handlers by exposing this interface to dependents
-    // (i.e. IHttpResource).
+  }
+
+  // #11439 - The absence of HttpModule.Proxy may be caused by a module initialization race condition.
+  // Best-effort approach to set up the request/response handlers by exposing this interface to dependents
+  // (i.e. IHttpResource).
+  if (!handlerAdded) {
     auto propId = msrn::ReactPropertyId<msrn::ReactNonAbiValue<weak_ptr<IBlobResource>>>{L"Blob.Resource"};
     m_propertyBag.Set(propId, weak_ptr<IBlobResource>(shared_from_this()));
   }

package/Shared/Networking/WinRTHttpResource.cpp

@@ -545,7 +545,7 @@ WinRTHttpResource::PerformSendRequest(HttpMethod &&method, Uri &&rtUri, IInspect
           if (self->m_onComplete) {
             self->m_onComplete(reqArgs->RequestId);
           }
-          co_return;
+          co_return self->UntrackResponse(reqArgs->RequestId);
         }
       }
 

package/fmt/cgmanifest.json

@@ -6,7 +6,7 @@
                 "Type": "git",
                 "Git": {
                   "RepositoryUrl": "https://github.com/fmtlib/fmt",
-                  "CommitHash": "9e8b86fd2d9806672cc73133d21780dd182bfd24"
+                  "CommitHash": "ca2e3685b160617d3d95fcd9e789c4e06ca88"
                 }
             },
             "DevelopmentDependency": false

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-windows",
-  "version": "0.72.19",
+  "version": "0.72.20",
   "license": "MIT",
   "repository": {
     "type": "git",