react-native-windows 0.78.4 → 0.78.6

package/Microsoft.ReactNative/Fabric/platform/react/threading/TaskDispatchThread.cpp

@@ -0,0 +1,126 @@
+/*
+ * 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.
+ */
+
+// [Windows] Brought forward from react-native - switch to using react-native/ReactCxxPlatform/react/threading version
+// once we integrate that far
+
+#include "TaskDispatchThread.h"
+
+#include <folly/portability/SysResource.h>
+#include <folly/system/ThreadName.h>
+#include <chrono>
+#include <future>
+#include <utility>
+
+#include <glog/logging.h>
+
+#ifdef ANDROID
+#include <fbjni/fbjni.h>
+#include <sys/syscall.h>
+#endif
+
+namespace facebook::react {
+
+TaskDispatchThread::TaskDispatchThread(std::string threadName, int priorityOffset) noexcept
+    : threadName_(std::move(threadName)) {
+#ifdef ANDROID
+  // Attaches the thread to JVM just in case anything calls out to Java
+  thread_ = std::thread([&]() {
+    facebook::jni::ThreadScope::WithClassLoader([&]() {
+      int result = setpriority(PRIO_PROCESS, static_cast<pid_t>(::syscall(SYS_gettid)), priorityOffset);
+
+      if (result != 0) {
+        LOG(INFO) << " setCurrentThreadPriority failed with pri errno: " << errno;
+      }
+
+      loop();
+    });
+  });
+
+#else
+  thread_ = std::thread(&TaskDispatchThread::loop, this);
+#endif
+}
+
+TaskDispatchThread::~TaskDispatchThread() noexcept {
+  quit();
+}
+
+bool TaskDispatchThread::isOnThread() noexcept {
+  return std::this_thread::get_id() == thread_.get_id();
+}
+
+bool TaskDispatchThread::isRunning() noexcept {
+  return running_;
+}
+
+void TaskDispatchThread::runAsync(TaskFn &&task, std::chrono::milliseconds delayMs) noexcept {
+  if (!running_) {
+    return;
+  }
+  std::lock_guard<std::mutex> guard(queueLock_);
+  auto dispatchTime = std::chrono::system_clock::now() + delayMs;
+  queue_.emplace(dispatchTime, std::move(task));
+  loopCv_.notify_one();
+}
+
+void TaskDispatchThread::runSync(TaskFn &&task) noexcept {
+  std::promise<void> promise;
+  runAsync([&]() {
+    if (running_) {
+      task();
+    }
+    promise.set_value();
+  });
+  promise.get_future().wait();
+}
+
+void TaskDispatchThread::quit() noexcept {
+  if (!running_) {
+    return;
+  }
+  running_ = false;
+  loopCv_.notify_one();
+  if (thread_.joinable()) {
+    if (!isOnThread()) {
+      thread_.join();
+    } else {
+      thread_.detach();
+    }
+  }
+}
+
+void TaskDispatchThread::loop() noexcept {
+  if (!threadName_.empty()) {
+    folly::setThreadName(threadName_);
+  }
+  while (running_) {
+    std::unique_lock<std::mutex> lock(queueLock_);
+    loopCv_.wait(lock, [&]() { return !running_ || !queue_.empty(); });
+    while (!queue_.empty()) {
+      auto task = queue_.top();
+      auto now = std::chrono::system_clock::now();
+      if (task.dispatchTime > now) {
+        if (running_) {
+          loopCv_.wait_until(lock, task.dispatchTime);
+        } else {
+          // Shutting down, skip all the delayed tasks that are not to be
+          // executed yet
+          queue_.pop();
+        }
+        continue;
+      }
+
+      queue_.pop();
+      lock.unlock();
+      task.fn();
+      lock.lock();
+    }
+  }
+}
+
+} //  namespace facebook::react

package/Microsoft.ReactNative/Fabric/platform/react/threading/TaskDispatchThread.h

@@ -0,0 +1,73 @@
+/*
+ * 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.
+ */
+
+// [Windows] Brought forward from react-native - switch to using react-native/ReactCxxPlatform/react/threading version
+// once we integrate that far
+
+#pragma once
+
+#include <chrono>
+#include <condition_variable>
+#include <functional>
+#include <mutex>
+#include <queue>
+#include <thread>
+
+namespace facebook::react {
+
+/**
+ * Representation of a thread looper which can add tasks to a queue and handle
+ * the synchronization of callers.
+ */
+class TaskDispatchThread {
+ public:
+  using TaskFn = std::function<void()>;
+  using TimePoint = std::chrono::time_point<std::chrono::system_clock>;
+
+  TaskDispatchThread(std::string threadName = "", int priorityOffset = 0) noexcept;
+
+  ~TaskDispatchThread() noexcept;
+
+  /** Return true if the current thread is the same as this looper's thread. */
+  bool isOnThread() noexcept;
+
+  /** Return true until TaskDispatchThread.quit() is called  */
+  bool isRunning() noexcept;
+
+  /** Add task to the queue and return immediately. */
+  void runAsync(TaskFn &&task, std::chrono::milliseconds delayMs = std::chrono::milliseconds::zero()) noexcept;
+
+  /** Add task to the queue and wait until it has completed. */
+  void runSync(TaskFn &&task) noexcept;
+
+  /** Shut down and clean up the thread. */
+  void quit() noexcept;
+
+ protected:
+  struct Task {
+    TimePoint dispatchTime;
+    TaskFn fn;
+
+    Task(TimePoint dispatchTime, TaskFn &&fn) : dispatchTime(dispatchTime), fn(std::move(fn)) {}
+
+    bool operator<(const Task &other) const {
+      // Have the earliest tasks be at the front of the queue.
+      return dispatchTime > other.dispatchTime;
+    }
+  };
+
+  void loop() noexcept;
+
+  std::mutex queueLock_;
+  std::condition_variable loopCv_;
+  std::priority_queue<Task> queue_;
+  std::atomic<bool> running_{true};
+  std::string threadName_;
+  std::thread thread_;
+};
+
+} // namespace facebook::react

package/Microsoft.ReactNative/IReactContext.cpp

@@ -8,6 +8,9 @@
 #include "XamlUIService.h"
 #endif
 
+#include "CallInvoker.h"
+#include "Utils/Helpers.h"
+
 namespace winrt::Microsoft::ReactNative::implementation {
 
 //=============================================================================
@@ -97,10 +100,24 @@ IReactDispatcher ReactContext::UIDispatcher() noexcept {
 }
 
 IReactDispatcher ReactContext::JSDispatcher() noexcept {
+#if defined(DEBUG) && defined(USE_FABRIC)
+  VerifyElseCrashSz(
+      !::Microsoft::ReactNative::IsFabricEnabled(Properties()),
+      "ReactContext.JSRuntime is not supported on new arch, use ReactContext.CallInvoker instead.");
+#endif
   return Properties().Get(ReactDispatcherHelper::JSDispatcherProperty()).try_as<IReactDispatcher>();
 }
 
+winrt::Microsoft::ReactNative::CallInvoker ReactContext::CallInvoker() noexcept {
+  return winrt::Microsoft::ReactNative::implementation::CallInvoker::FromProperties(ReactPropertyBag(Properties()));
+}
+
 winrt::Windows::Foundation::IInspectable ReactContext::JSRuntime() noexcept {
+#if defined(DEBUG) && defined(USE_FABRIC)
+  VerifyElseCrashSz(
+      !::Microsoft::ReactNative::IsFabricEnabled(Properties()),
+      "ReactContext.JSRuntime is not supported on new arch, use ReactContext.CallInvoker instead.");
+#endif
   return m_context->JsiRuntime();
 }
 

package/Microsoft.ReactNative/IReactContext.h

@@ -43,6 +43,7 @@ struct ReactContext : winrt::implements<ReactContext, IReactContext> {
   IReactNotificationService Notifications() noexcept;
   IReactDispatcher UIDispatcher() noexcept;
   IReactDispatcher JSDispatcher() noexcept;
+  winrt::Microsoft::ReactNative::CallInvoker CallInvoker() noexcept;
   IInspectable JSRuntime() noexcept;
   LoadingState LoadingState() noexcept;
 

package/Microsoft.ReactNative/IReactContext.idl

@@ -14,6 +14,18 @@ import "IReactPropertyBag.idl";
 namespace Microsoft.ReactNative
 {
 
+  DOC_STRING("Function that acts on a JsiRuntime, provided as the argument to the function.  ABI safe version of facebook::react::CallFunc in CallInvoker.h. Most direct usage of this should be avoided by using ReactContext.CallInvoker.")
+  delegate void CallFunc(Object runtime);
+
+  [webhosthidden]
+  [default_interface]
+  DOC_STRING("CallInvoker used to access the jsi runtime. Most direct usage of this should be avoided by using ReactContext.CallInvoker.")
+  runtimeclass CallInvoker
+  {
+    void InvokeAsync(CallFunc func);
+    void InvokeSync(CallFunc func);
+  };
+
   DOC_STRING(
     "Used to represent the state of the React Native JavaScript instance")
   enum LoadingState
@@ -173,6 +185,7 @@ namespace Microsoft.ReactNative
       "It is a shortcut for the @ReactDispatcherHelper.UIDispatcherProperty from the @.Properties property bag.")
     IReactDispatcher UIDispatcher { get; };
 
+    [deprecated("Use @IReactContext.CallInvoker instead", deprecate, 1)]
     DOC_STRING(
       "Gets the JavaScript engine thread dispatcher.\n"
       "It is a shortcut for the @ReactDispatcherHelper.JSDispatcherProperty from the @.Properties property bag.")
@@ -182,9 +195,13 @@ namespace Microsoft.ReactNative
       "Gets the JavaScript runtime for the running React instance.\n"
       "It can be null if Web debugging is used.\n"
       "**Note: do not use this property directly. "
-      "It is an experimental property that may be removed or changed in a future version.")
+      "It is an experimental property will be removed in a future version.\n"
+      "Deprecated for new Arch: Use @IReactContext.CallInvoker instead.")
     Object JSRuntime { get; };
 
+    DOC_STRING("used to schedule work on the JS runtime. Most direct usage of this should be avoided by using ReactContext.CallInvoker.")
+    CallInvoker CallInvoker { get; };
+
 #if !defined(CORE_ABI) && !defined(USE_FABRIC)
     [deprecated("Use @XamlUIService.DispatchEvent instead", deprecate, 1)]
     DOC_STRING("Deprecated property. Use @XamlUIService.DispatchEvent instead. It will be removed in a future version.")

package/Microsoft.ReactNative/IReactDispatcher.idl

@@ -48,6 +48,7 @@ namespace Microsoft.ReactNative
       "a specific React instance.")
     static IReactPropertyName UIDispatcherProperty { get; };
 
+    [deprecated("Use @IReactContext.CallInvoker instead", deprecate, 1)]
     DOC_STRING(
       "Gets name of the `JSDispatcher` property for the @IReactPropertyBag.\n"
       "Generally you can use @IReactContext.JSDispatcher to get the value of this property for "

package/Microsoft.ReactNative/IReactModuleBuilder.cpp

@@ -3,6 +3,7 @@
 
 #include "pch.h"
 #include "IReactModuleBuilder.h"
+#include <IReactContext.h>
 #include <strsafe.h>
 #include "DynamicWriter.h"
 #include "ReactHost/MsoUtils.h"
@@ -74,6 +75,10 @@ void ReactModuleBuilder::AddInitializer(InitializerDelegate const &initializer)
   m_initializers.push_back(initializer);
 }
 
+void ReactModuleBuilder::AddJsiInitializer(JsiInitializerDelegate const &initializer) noexcept {
+  m_jsiinitializers.push_back(initializer);
+}
+
 void ReactModuleBuilder::AddConstantProvider(ConstantProviderDelegate const &constantProvider) noexcept {
   m_constantProviders.push_back(constantProvider);
 }
@@ -155,6 +160,13 @@ std::unique_ptr<CxxModule> ReactModuleBuilder::MakeCxxModule(
   for (auto &initializer : m_initializers) {
     initializer(m_reactContext);
   }
+  for (auto &initializer : m_jsiinitializers) {
+    initializer(
+        m_reactContext,
+        winrt::get_self<winrt::Microsoft::ReactNative::implementation::ReactContext>(m_reactContext)
+            ->GetInner()
+            .JsiRuntime());
+  }
   return std::make_unique<ABICxxModule>(
       nativeModule, Mso::Copy(name), Mso::Copy(m_constantProviders), Mso::Copy(m_methods));
 }

package/Microsoft.ReactNative/IReactModuleBuilder.h

@@ -12,6 +12,7 @@ struct ReactModuleBuilder : winrt::implements<ReactModuleBuilder, IReactModuleBu
 
  public: // IReactModuleBuilder
   void AddInitializer(InitializerDelegate const &initializer) noexcept;
+  void AddJsiInitializer(JsiInitializerDelegate const &initializer) noexcept;
   void AddConstantProvider(ConstantProviderDelegate const &constantProvider) noexcept;
   void AddMethod(hstring const &name, MethodReturnType returnType, MethodDelegate const &method) noexcept;
   void AddSyncMethod(hstring const &name, SyncMethodDelegate const &method) noexcept;
@@ -29,6 +30,7 @@ struct ReactModuleBuilder : winrt::implements<ReactModuleBuilder, IReactModuleBu
  private:
   IReactContext m_reactContext;
   std::vector<InitializerDelegate> m_initializers;
+  std::vector<JsiInitializerDelegate> m_jsiinitializers;
   std::vector<ConstantProviderDelegate> m_constantProviders;
   std::vector<facebook::xplat::module::CxxModule::Method> m_methods;
 };

package/Microsoft.ReactNative/IReactModuleBuilder.idl

@@ -15,6 +15,12 @@ namespace Microsoft.ReactNative
     "Experimental code uses it to initialize TurboModule `CallInvoker`.")
   delegate void InitializerDelegate(IReactContext reactContext);
 
+  DOC_STRING(
+    "A delegate that sets `reactContext` for a module.\n"
+    "We use it for a stand-alone initialize method, strongly typed JS events and functions.\n"
+    "Experimental code uses it to initialize TurboModule `CallInvoker`.")
+  delegate void JsiInitializerDelegate(IReactContext reactContext, Object runtimeHandle);
+
   DOC_STRING("Native method return type.")
   enum MethodReturnType
   {
@@ -59,6 +65,8 @@ namespace Microsoft.ReactNative
       "There can be multiple initializer methods which are called in the order they were registered.")
     void AddInitializer(InitializerDelegate initializer);
 
+    void AddJsiInitializer(JsiInitializerDelegate initializer);
+
     DOC_STRING(
       "Adds a constant provider method to define constants for the native module. See @ConstantProviderDelegate.")
     void AddConstantProvider(ConstantProviderDelegate constantProvider);

package/Microsoft.ReactNative/JsiApi.cpp

@@ -482,8 +482,8 @@ facebook::jsi::JSError const &jsError) {                             \
   jsiRuntime->evaluateJavaScript(jsiPalBuffer, "Form_JSI_API_not_a_real_file");
   ReactNative::JsiRuntime abiJsiResult{make<JsiRuntime>(Mso::Copy(jsiRuntimeHolder), Mso::Copy(jsiRuntime))};
   std::scoped_lock lock{s_mutex};
-  s_jsiRuntimeMap.try_emplace(reinterpret_cast<uintptr_t>(jsiRuntime.get()), abiJsiResult);
-  return abiJsiResult;
+  auto it = s_jsiRuntimeMap.try_emplace(reinterpret_cast<uintptr_t>(jsiRuntime.get()), abiJsiResult);
+  return it.first->second.get();
 }
 
 ReactNative::JsiRuntime JsiRuntime::MakeChakraRuntime() {
@@ -553,6 +553,14 @@ bool JsiRuntime::DrainMicrotasks(int32_t maxMicrotasksHint) try {
   throw;
 }
 
+void JsiRuntime::QueueMicrotask(JsiObjectRef callback) try {
+  auto funcPtr = RuntimeAccessor::AsPointerValue(callback);
+  auto const &jsiFunc = RuntimeAccessor::AsFunction(&funcPtr);
+  m_runtimeAccessor->queueMicrotask(jsiFunc);
+} catch (JSI_SET_ERROR) {
+  throw;
+}
+
 JsiObjectRef JsiRuntime::Global() try {
   return PointerAccessor::MakeJsiObjectData(m_runtimeAccessor->global());
 } catch (JSI_SET_ERROR) {

package/Microsoft.ReactNative/JsiApi.h

@@ -77,6 +77,7 @@ struct JsiRuntime : JsiRuntimeT<JsiRuntime> {
   ReactNative::JsiPreparedJavaScript PrepareJavaScript(IJsiByteBuffer const &buffer, hstring const &sourceUrl);
   JsiValueRef EvaluatePreparedJavaScript(ReactNative::JsiPreparedJavaScript const &js);
   bool DrainMicrotasks(int32_t maxMicrotasksHint);
+  void QueueMicrotask(JsiObjectRef callback);
   JsiObjectRef Global();
   hstring Description();
   bool IsInspectable();

package/Microsoft.ReactNative/JsiApi.idl

@@ -249,6 +249,7 @@ namespace Microsoft.ReactNative
     JsiPreparedJavaScript PrepareJavaScript(IJsiByteBuffer buffer, String sourceUrl);
     JsiValueRef EvaluatePreparedJavaScript(JsiPreparedJavaScript js);
     Boolean DrainMicrotasks(Int32 maxMicrotasksHint);
+    void QueueMicrotask(JsiObjectRef callback);
     JsiObjectRef Global { get; };
     String Description { get; };
     Boolean IsInspectable { get; };

package/Microsoft.ReactNative/Microsoft.ReactNative.vcxproj

@@ -200,9 +200,6 @@
     <ClInclude Include="DynamicWriter.h">
       <DependentUpon>IJSValueWriter.idl</DependentUpon>
     </ClInclude>
-    <ClInclude Include="JSDispatcherWriter.h">
-      <DependentUpon>IJSValueWriter.idl</DependentUpon>
-    </ClInclude>
     <ClInclude Include="HResult.h" />
     <ClInclude Include="IReactDispatcher.h">
       <DependentUpon>IReactDispatcher.idl</DependentUpon>

package/Microsoft.ReactNative/Modules/AccessibilityInfoModule.cpp

@@ -22,12 +22,11 @@ void AccessibilityInfo::Initialize(winrt::Microsoft::ReactNative::ReactContext c
 }
 
 void AccessibilityInfo::isReduceMotionEnabled(std::function<void(bool)> const &onSuccess) noexcept {
-  auto jsDispatcher = m_context.JSDispatcher();
-  m_context.UIDispatcher().Post([weakThis = weak_from_this(), jsDispatcher, onSuccess] {
+  m_context.UIDispatcher().Post([weakThis = weak_from_this(), onSuccess] {
     if (auto strongThis = weakThis.lock()) {
       winrt::Windows::UI::ViewManagement::UISettings uiSettings;
       auto animationsEnabled = uiSettings.AnimationsEnabled();
-      jsDispatcher.Post([animationsEnabled, onSuccess] { onSuccess(!animationsEnabled); });
+      onSuccess(!animationsEnabled);
     }
   });
 }

package/Microsoft.ReactNative/Modules/AlertModule.cpp

@@ -44,7 +44,6 @@ void Alert::ProcessPendingAlertRequestsXaml() noexcept {
   const auto &pendingAlert = pendingAlerts.front();
   const auto &args = pendingAlert.args;
   const auto &result = pendingAlert.result;
-  auto jsDispatcher = m_context.JSDispatcher();
 
   xaml::Controls::ContentDialog dialog{};
   xaml::Controls::TextBlock titleTextBlock;
@@ -110,7 +109,7 @@ void Alert::ProcessPendingAlertRequestsXaml() noexcept {
     } else if (IsXamlIsland()) {
       // We cannot show a ContentDialog in a XAML Island unless it is assigned a
       // XamlRoot instance. In such cases, we just treat the alert as dismissed.
-      jsDispatcher.Post([result, this] { result(m_constants.dismissed, m_constants.buttonNeutral); });
+      result(m_constants.dismissed, m_constants.buttonNeutral);
       pendingAlerts.pop();
       ProcessPendingAlertRequests();
       return;
@@ -138,19 +137,17 @@ void Alert::ProcessPendingAlertRequestsXaml() noexcept {
   const auto hasCloseButton = dialog.CloseButtonText().size() > 0;
   auto asyncOp = dialog.ShowAsync();
   asyncOp.Completed(
-      [hasCloseButton, jsDispatcher, result, this](
+      [hasCloseButton, result, this](
           const winrt::IAsyncOperation<xaml::Controls::ContentDialogResult> &asyncOp, winrt::AsyncStatus status) {
         switch (asyncOp.GetResults()) {
           case xaml::Controls::ContentDialogResult::Primary:
-            jsDispatcher.Post([result, this] { result(m_constants.buttonClicked, m_constants.buttonPositive); });
+            result(m_constants.buttonClicked, m_constants.buttonPositive);
             break;
           case xaml::Controls::ContentDialogResult::Secondary:
-            jsDispatcher.Post([result, this] { result(m_constants.buttonClicked, m_constants.buttonNegative); });
+            result(m_constants.buttonClicked, m_constants.buttonNegative);
             break;
           case xaml::Controls::ContentDialogResult::None:
-            jsDispatcher.Post([hasCloseButton, result, this] {
-              result(hasCloseButton ? m_constants.buttonClicked : m_constants.dismissed, m_constants.buttonNeutral);
-            });
+            result(hasCloseButton ? m_constants.buttonClicked : m_constants.dismissed, m_constants.buttonNeutral);
             break;
           default:
             break;
@@ -164,7 +161,6 @@ void Alert::ProcessPendingAlertRequestsMessageDialog() noexcept {
   const auto &pendingAlert = pendingAlerts.front();
   const auto &args = pendingAlert.args;
   const auto &result = pendingAlert.result;
-  auto jsDispatcher = m_context.JSDispatcher();
 
   auto cancelable = args.cancelable.value_or(true);
   auto messageDialog = winrt::Windows::UI::Popups::MessageDialog(
@@ -208,11 +204,10 @@ void Alert::ProcessPendingAlertRequestsMessageDialog() noexcept {
 
   auto asyncOp = messageDialog.ShowAsync();
   asyncOp.Completed(
-      [jsDispatcher, result, this](
+      [result, this](
           const winrt::IAsyncOperation<winrt::Windows::UI::Popups::IUICommand> &asyncOp, winrt::AsyncStatus status) {
         auto uicommand = asyncOp.GetResults();
-        jsDispatcher.Post(
-            [id = uicommand.Id(), result, this] { result(m_constants.buttonClicked, winrt::unbox_value<int>(id)); });
+        result(m_constants.buttonClicked, winrt::unbox_value<int>(uicommand.Id()));
         pendingAlerts.pop();
         ProcessPendingAlertRequests();
       });

package/Microsoft.ReactNative/Modules/Animated/AnimationDriver.cpp

@@ -50,7 +50,6 @@ void AnimationDriver::StartAnimation() {
     animatedValue->PropertySet().StartAnimation(ValueAnimatedNode::s_valueName, animation);
     animatedValue->AddActiveAnimation(m_id);
   }
-  scopedBatch.End();
 
   m_scopedBatchCompletedToken = scopedBatch.Completed(
       [weakSelf = weak_from_this(), weakManager = m_manager, id = m_id, tag = m_animatedValueTag](auto sender, auto) {
@@ -74,6 +73,8 @@ void AnimationDriver::StartAnimation() {
         }
       });
 
+  scopedBatch.End();
+
   m_animation = animation;
   m_scopedBatch = scopedBatch;
 }

package/Microsoft.ReactNative/Modules/Animated/NativeAnimatedModule.cpp

@@ -56,9 +56,7 @@ void NativeAnimatedModule::getValue(double tag, std::function<void(double)> cons
        callback = std::move(saveValueCallback)]() {
         if (auto pThis = wkThis.lock()) {
           pThis->m_nodesManager->GetValue(
-              tag, [context = pThis->m_context, callback = std::move(callback)](double value) {
-                context.JSDispatcher().Post([callback = std::move(callback), value]() { callback(value); });
-              });
+              tag, [context = pThis->m_context, callback = std::move(callback)](double value) { callback(value); });
         }
       });
 }
@@ -131,11 +129,9 @@ void NativeAnimatedModule::startAnimatingNode(
               nodeTag,
               animationConfig.AsObject(),
               [context = pThis->m_context, endCallback = std::move(endCallback)](bool finished) {
-                context.JSDispatcher().Post([finished, endCallback = std::move(endCallback)]() {
-                  ReactNativeSpecs::AnimatedModuleSpec_EndResult result;
-                  result.finished = finished;
-                  endCallback(std::move(result));
-                });
+                ReactNativeSpecs::AnimatedModuleSpec_EndResult result;
+                result.finished = finished;
+                endCallback(std::move(result));
               },
               pThis->m_nodesManager);
         }

package/Microsoft.ReactNative/Modules/AppStateModule.cpp

@@ -96,13 +96,13 @@ void AppState::SetDeactivated(bool deactivated) noexcept {
   if (winrt::Microsoft::ReactNative::implementation::QuirkSettings::GetMapWindowDeactivatedToAppStateInactive(
           m_context.Properties())) {
     m_deactivated = deactivated;
-    m_context.JSDispatcher().Post([this]() { AppStateDidChange({GetAppState()}); });
+    AppStateDidChange({GetAppState()});
   }
 }
 
 void AppState::SetEnteredBackground(bool enteredBackground) noexcept {
   m_enteredBackground = enteredBackground;
-  m_context.JSDispatcher().Post([this]() { AppStateDidChange({GetAppState()}); });
+  AppStateDidChange({GetAppState()});
 }
 
 std::string AppState::GetAppState() noexcept {

package/Microsoft.ReactNative/Modules/ClipboardModule.cpp

@@ -16,27 +16,25 @@ void Clipboard::Initialize(winrt::Microsoft::ReactNative::ReactContext const &re
 }
 
 void Clipboard::getString(React::ReactPromise<std::string> result) noexcept {
-  auto jsDispatcher = m_reactContext.JSDispatcher();
-  m_reactContext.UIDispatcher().Post([jsDispatcher, result] {
+  m_reactContext.UIDispatcher().Post([result] {
     auto data = DataTransfer::Clipboard::GetContent();
     auto asyncOp = data.GetTextAsync();
     // unfortunately, lambda captures doesn't work well with winrt::fire_and_forget and co_await here
     // call asyncOp.Completed explicitly
-    asyncOp.Completed([jsDispatcher, result](const IAsyncOperation<winrt::hstring> &asyncOp, AsyncStatus status) {
+    asyncOp.Completed([result](const IAsyncOperation<winrt::hstring> &asyncOp, AsyncStatus status) {
       switch (status) {
         case AsyncStatus::Completed: {
           auto text = std::wstring(asyncOp.GetResults());
-          jsDispatcher.Post(
-              [result, text] { result.Resolve(std::string{Microsoft::Common::Unicode::Utf16ToUtf8(text)}); });
+          result.Resolve(std::string{Microsoft::Common::Unicode::Utf16ToUtf8(text)});
           break;
         }
         case AsyncStatus::Canceled: {
-          jsDispatcher.Post([result] { result.Reject(React::ReactError()); });
+          result.Reject(React::ReactError());
           break;
         }
         case AsyncStatus::Error: {
           auto message = std::wstring(winrt::hresult_error(asyncOp.ErrorCode()).message());
-          jsDispatcher.Post([result, message] { result.Reject(message.c_str()); });
+          result.Reject(message.c_str());
           break;
         }
         case AsyncStatus::Started: {
@@ -48,7 +46,7 @@ void Clipboard::getString(React::ReactPromise<std::string> result) noexcept {
   );
 }
 
-void Clipboard::setString(std::wstring content) noexcept {
+void Clipboard::setString(winrt::hstring content) noexcept {
   m_reactContext.UIDispatcher().Post([=] {
     DataTransfer::DataPackage data;
     data.SetText(content);

package/Microsoft.ReactNative/Modules/ClipboardModule.h

@@ -18,7 +18,7 @@ struct Clipboard {
   void getString(winrt::Microsoft::ReactNative::ReactPromise<std::string> result) noexcept;
 
   REACT_METHOD(setString)
-  void setString(std::wstring content) noexcept;
+  void setString(winrt::hstring content) noexcept;
 
   winrt::Microsoft::ReactNative::ReactContext m_reactContext;
 };

package/Microsoft.ReactNative/Modules/ImageViewManagerModule.cpp

@@ -109,14 +109,10 @@ void ImageLoader::getSize(std::string uri, React::ReactPromise<std::vector<doubl
             context.Properties().Handle(),
             std::move(uri),
             {},
-            [result, context](double width, double height) noexcept {
-              context.JSDispatcher().Post([result = std::move(result), width, height]() noexcept {
-                result.Resolve(std::vector<double>{width, height});
-              });
+            [result](double width, double height) noexcept {
+              result.Resolve(std::vector<double>{width, height});
             },
-            [result, context]() noexcept {
-              context.JSDispatcher().Post([result = std::move(result)]() noexcept { result.Reject("Failed"); });
-            }
+            [result]() noexcept { result.Reject("Failed"); }
 #ifdef USE_FABRIC
             ,
             IsFabricEnabled(context.Properties().Handle())
@@ -138,15 +134,10 @@ void ImageLoader::getSizeWithHeaders(
         context.Properties().Handle(),
         std::move(uri),
         std::move(headers),
-        [result, context](double width, double height) noexcept {
-          context.JSDispatcher().Post([result = std::move(result), width, height]() noexcept {
-            result.Resolve(
-                Microsoft::ReactNativeSpecs::ImageLoaderIOSSpec_getSizeWithHeaders_returnType{width, height});
-          });
+        [result](double width, double height) noexcept {
+          result.Resolve(Microsoft::ReactNativeSpecs::ImageLoaderIOSSpec_getSizeWithHeaders_returnType{width, height});
         },
-        [result, context]() noexcept {
-          context.JSDispatcher().Post([result = std::move(result)]() noexcept { result.Reject("Failed"); });
-        }
+        [result]() noexcept { result.Reject("Failed"); }
 #ifdef USE_FABRIC
         ,
         IsFabricEnabled(context.Properties().Handle())