react-native-windows 0.72.14 → 0.73.0-preview.1

package/Mso/compilerAdapters/compilerFeatures.h

@@ -20,7 +20,7 @@
 
 // Check if compiler supports UUID
 #ifndef COMPILER_SUPPORTS_UUID
-#if defined(__clang__) || defined(__GNUC__)
+#if (defined(__APPLE__) && defined(__clang__)) || defined(__GNUC__)
 #define COMPILER_SUPPORTS_UUID 0
 #elif defined(_MSC_VER)
 #define COMPILER_SUPPORTS_UUID 1

package/Mso/compilerAdapters/functionDecorations.h

@@ -91,13 +91,13 @@
 
   struct IBank
   {
-    // Generate mock_TryWithdrawlUint32
-    LIBLET_MOCKNAME("TryWithdrawlUint32")
-    virtual bool TryWithdrawl(uint32_t amount) = 0;
+    // Generate mock_TryWithdrawalUint32
+    LIBLET_MOCKNAME("TryWithdrawalUint32")
+    virtual bool TryWithdrawal(uint32_t amount) = 0;
 
-    // Generate mock_TryWithdrawlFloat
-    LIBLET_MOCKNAME("TryWithdrawlFloat")
-    virtual bool TryWithdrawl(float amount) = 0;
+    // Generate mock_TryWithdrawalFloat
+    LIBLET_MOCKNAME("TryWithdrawalFloat")
+    virtual bool TryWithdrawal(float amount) = 0;
   };
 */
 #if defined(__clangpluginrunner__)

package/Mso/debugAssertApi/debugAssertDetails.h

@@ -97,7 +97,7 @@ static
 
   Converts variable arguments into the arg list format
 
-  Use a lamba function to generate a unique function providing storage of
+  Use a lambda function to generate a unique function providing storage of
   _fIgnore_ (for in-proc based assert management) and unique break address.
 */
 #define MsoAssertSzTagProcInline2(dwTag, szFile, iLine, wzAnnotation, szFmt, ...)                               \

package/Mso/dispatchQueue/dispatchQueue.h

@@ -308,7 +308,7 @@ struct IDispatchQueue : IUnknown {
 MSO_GUID(IDispatchQueueScheduler, "fd98f3c9-1343-4cbe-8758-a0322ffd253a")
 struct IDispatchQueueScheduler : IUnknown {
   //! Initializes scheduler by providing the dispatch queue service.
-  virtual void IntializeScheduler(Mso::WeakPtr<IDispatchQueueService> &&queue) noexcept = 0;
+  virtual void InitializeScheduler(Mso::WeakPtr<IDispatchQueueService> &&queue) noexcept = 0;
 
   //! True if the scheduler does processing in a serial order.
   virtual bool IsSerial() noexcept = 0;
@@ -376,8 +376,8 @@ struct IDispatchQueueService : IUnknown {
   virtual void UnlockLocalValue(void **tlsValue) noexcept = 0;
 
   //! Suspend task invocation and increment internal suspend count by one.
-  //! Note that we do not expose IsSuspeneded() method because the Suspend/Resume
-  //! methods can be called from different threads and using IsSuspeneded()
+  //! Note that we do not expose IsSuspended() method because the Suspend/Resume
+  //! methods can be called from different threads and using IsSuspended()
   //! could lead to errors because the status can be changed any time right after the check.
   virtual void Suspend() noexcept = 0;
 

package/Mso/motifCpp/motifCppTest.h

@@ -203,7 +203,7 @@ inline uint32_t FilterCrashExceptions(uint32_t exceptionCode) noexcept {
 }
 
 #pragma warning(push)
-#pragma warning(disable : 4702) // unreachable code might be hit if the linker determines the lambda is quaranteed to
+#pragma warning(disable : 4702) // unreachable code might be hit if the linker determines the lambda is guaranteed to
                                 // throw an exception
 template <class TLambda>
 inline bool ExpectCrashCore(TLambda const &lambda) {

package/Mso/motifCpp/testCheck.h

@@ -73,7 +73,7 @@
 // It is useful to check when a noexcept function throws, or std::terminate is called directly.
 // The implementation uses setjmp and longjmp which stops the termination sequence.
 // In case if TestCheckTerminate succeeds we may end up with leaked memory because
-// the call stack is not unwinded correctly.
+// the call stack is not unwound correctly.
 // You should disable memory leak detection in tests that use TestCheckTerminate.
 //=============================================================================
 #define TestCheckTerminateAtInternal(file, line, expr, exprStr, ...) \

package/Mso/oacr/oacr.h

@@ -98,7 +98,7 @@
 #endif // _Intl_deprecated_
 
 #if !defined(_Oleo_deprecated_)
-// Office specifix annotation used by the OLEO effort
+// Office specific annotation used by the OLEO effort
 #define _Oleo_deprecated_(NewFunctionName) __oacr_oleo_deprecated(NewFunctionName)
 #endif // _Oleo_deprecated_
 

package/Mso/smartPtr/smartPointerBase.h

@@ -74,7 +74,7 @@ class THolder {
   } // equivalent to std::string::clear()
   void reset() noexcept {
     this->Clear();
-  } // equivalent to std::unique_ptr::reset(), excpet for not supporting (yet) passing a new pointer in (like Attach
+  } // equivalent to std::unique_ptr::reset(), except for not supporting (yet) passing a new pointer in (like Attach
     // here).
 
   /**

package/Mso/src/dispatchQueue/looperScheduler.cpp

@@ -14,7 +14,7 @@ struct LooperScheduler : Mso::UnknownObject<Mso::RefCountStrategy::WeakRef, IDis
   static void RunLoop(const Mso::WeakPtr<LooperScheduler> &weakSelf) noexcept;
 
  public: // IDispatchQueueScheduler
-  void IntializeScheduler(Mso::WeakPtr<IDispatchQueueService> &&queue) noexcept override;
+  void InitializeScheduler(Mso::WeakPtr<IDispatchQueueService> &&queue) noexcept override;
   bool HasThreadAccess() noexcept override;
   bool IsSerial() noexcept override;
   void Post() noexcept override;
@@ -88,7 +88,7 @@ LooperScheduler::~LooperScheduler() noexcept {
   }
 }
 
-void LooperScheduler::IntializeScheduler(Mso::WeakPtr<IDispatchQueueService> &&queue) noexcept {
+void LooperScheduler::InitializeScheduler(Mso::WeakPtr<IDispatchQueueService> &&queue) noexcept {
   m_queue = std::move(queue);
 }
 

package/Mso/src/dispatchQueue/queueService.cpp

@@ -13,7 +13,7 @@ namespace Mso {
 
 QueueService::QueueService(Mso::CntPtr<IDispatchQueueScheduler> &&scheduler) noexcept
     : m_scheduler{std::move(scheduler)} {
-  m_scheduler->IntializeScheduler(this);
+  m_scheduler->InitializeScheduler(this);
 }
 
 QueueService::~QueueService() noexcept {

package/Mso/src/dispatchQueue/taskQueue.h

@@ -52,7 +52,7 @@ struct TaskQueue {
   std::vector<DispatchTask> m_writeBuffer; // To enqueue items.
   TaskReadBuffer m_readBuffer; // To dequeue items.
   Mso::WeakPtr<IUnknown> m_weakOwnerPtr;
-  Mso::CntPtr<IUnknown> m_strongOwnerPtr; // Keep strong reference to the owner when queu is not empty;
+  Mso::CntPtr<IUnknown> m_strongOwnerPtr; // Keep strong reference to the owner when queue is not empty;
 };
 
 } // namespace Mso

package/Mso/src/dispatchQueue/threadPoolScheduler_win.cpp

@@ -23,7 +23,7 @@ struct ThreadPoolSchedulerWin : Mso::UnknownObject<IDispatchQueueScheduler> {
       _Inout_ PTP_WORK work);
 
  public: // IDispatchQueueScheduler
-  void IntializeScheduler(Mso::WeakPtr<IDispatchQueueService> &&queue) noexcept override;
+  void InitializeScheduler(Mso::WeakPtr<IDispatchQueueService> &&queue) noexcept override;
   bool HasThreadAccess() noexcept override;
   bool IsSerial() noexcept override;
   void Post() noexcept override;
@@ -131,7 +131,7 @@ ThreadPoolSchedulerWin::~ThreadPoolSchedulerWin() noexcept {
   }
 }
 
-void ThreadPoolSchedulerWin::IntializeScheduler(Mso::WeakPtr<IDispatchQueueService> &&queue) noexcept {
+void ThreadPoolSchedulerWin::InitializeScheduler(Mso::WeakPtr<IDispatchQueueService> &&queue) noexcept {
   m_queue = std::move(queue);
 }
 

package/Mso/src/dispatchQueue/uiScheduler_winrt.cpp

@@ -9,12 +9,10 @@
 
 using namespace winrt;
 using namespace Windows::Foundation;
-#ifndef USE_WINUI3
 #include "winrt/Windows.System.h"
-using namespace Windows::System;
-#else
+
+#ifdef USE_WINUI3
 #include "winrt/Microsoft.UI.Dispatching.h"
-using namespace Microsoft::UI::Dispatching;
 #endif
 
 namespace Mso {
@@ -67,29 +65,68 @@ struct ThreadSafeMap {
 
 } // namespace
 
+template <typename TDispatcherTraits>
 struct UISchedulerWinRT;
 
+template <typename TDispatcherTraits>
+struct DispatcherTraits {};
+
+template <typename TDispatcherTraits>
+struct TaskDispatcherHandler;
+
+struct WindowsTypeTag;
+using WindowsTaskDispatcherHandler = TaskDispatcherHandler<DispatcherTraits<WindowsTypeTag>>;
+
+template <>
+struct DispatcherTraits<WindowsTypeTag> {
+  using DispatcherQueueHandler = Windows::System::DispatcherQueueHandler;
+  using DispatcherQueue = Windows::System::DispatcherQueue;
+  using DispatcherQueue_ShutdownCompleted_revoker = Windows::System::DispatcherQueue::ShutdownCompleted_revoker;
+  using TaskDispatcherHandler = WindowsTaskDispatcherHandler;
+};
+using WindowsDispatcherTraits = DispatcherTraits<WindowsTypeTag>;
+
+#ifdef USE_WINUI3
+struct MicrosoftTypeTag;
+using MicrosoftTaskDispatcherHandler = TaskDispatcherHandler<DispatcherTraits<MicrosoftTypeTag>>;
+
+template <>
+struct DispatcherTraits<MicrosoftTypeTag> {
+  using DispatcherQueueHandler = Microsoft::UI::Dispatching::DispatcherQueueHandler;
+  using DispatcherQueue = Microsoft::UI::Dispatching::DispatcherQueue;
+  using DispatcherQueue_ShutdownCompleted_revoker =
+      Microsoft::UI::Dispatching::DispatcherQueue::ShutdownCompleted_revoker;
+  using TaskDispatcherHandler = MicrosoftTaskDispatcherHandler;
+};
+using MicrosoftDispatcherTraits = DispatcherTraits<MicrosoftTypeTag>;
+
+#endif
+
 //! TaskDispatcherHandler is a DispatcherQueueHandler delegate that we pass to DispatcherQueue.
 //! We use custom ref counting to avoid extra memory allocations and to handle reference to DispatchTask.
-struct TaskDispatcherHandler final : impl::abi_t<DispatcherQueueHandler> {
-  TaskDispatcherHandler(UISchedulerWinRT *scheduler) noexcept;
+template <typename TDispatcherTraits>
+struct TaskDispatcherHandler final : impl::abi_t<typename TDispatcherTraits::DispatcherQueueHandler> {
+  TaskDispatcherHandler(UISchedulerWinRT<TDispatcherTraits> *scheduler) noexcept;
   int32_t __stdcall QueryInterface(guid const &id, void **result) noexcept final;
   uint32_t __stdcall AddRef() noexcept final;
   uint32_t __stdcall Release() noexcept final;
   int32_t __stdcall Invoke() noexcept final;
 
  private:
-  UISchedulerWinRT *m_scheduler;
+  UISchedulerWinRT<TDispatcherTraits> *m_scheduler;
 };
 
+using WindowsTaskDispatcherHandler = TaskDispatcherHandler<DispatcherTraits<WindowsTypeTag>>;
+
+template <typename TDispatcherTraits>
 struct UISchedulerWinRT : Mso::UnknownObject<Mso::RefCountStrategy::WeakRef, IDispatchQueueScheduler> {
-  UISchedulerWinRT(DispatcherQueue &&dispatcher) noexcept;
+  UISchedulerWinRT(typename TDispatcherTraits::DispatcherQueue &&dispatcher) noexcept;
   ~UISchedulerWinRT() noexcept override;
 
   uint32_t AddHandlerRef() noexcept;
   uint32_t ReleaseHandlerRef() noexcept;
 
-  DispatcherQueueHandler MakeDispatcherQueueHandler() noexcept;
+  typename TDispatcherTraits::DispatcherQueueHandler MakeDispatcherQueueHandler() noexcept;
   bool TryTakeTask(Mso::CntPtr<IDispatchQueueService> &queue, DispatchTask &task) noexcept;
 
   static DispatchQueue GetOrCreateUIThreadQueue() noexcept;
@@ -97,7 +134,7 @@ struct UISchedulerWinRT : Mso::UnknownObject<Mso::RefCountStrategy::WeakRef, IDi
   static DispatchQueueRegistry &GetDispatchQueueRegistry() noexcept;
 
  public: // IDispatchQueueScheduler
-  void IntializeScheduler(Mso::WeakPtr<IDispatchQueueService> &&queue) noexcept override;
+  void InitializeScheduler(Mso::WeakPtr<IDispatchQueueService> &&queue) noexcept override;
   bool HasThreadAccess() noexcept override;
   bool IsSerial() noexcept override;
   void Post() noexcept override;
@@ -120,8 +157,8 @@ struct UISchedulerWinRT : Mso::UnknownObject<Mso::RefCountStrategy::WeakRef, IDi
   };
 
  private:
-  DispatcherQueue m_dispatcher{nullptr};
-  TaskDispatcherHandler m_dispatcherHandler{this};
+  typename TDispatcherTraits::DispatcherQueue m_dispatcher{nullptr};
+  typename TDispatcherTraits::TaskDispatcherHandler m_dispatcherHandler{this};
   ManualResetEvent m_terminationEvent;
   ThreadMutex m_mutex;
   Mso::WeakPtr<IDispatchQueueService> m_queue;
@@ -130,19 +167,22 @@ struct UISchedulerWinRT : Mso::UnknownObject<Mso::RefCountStrategy::WeakRef, IDi
   uint32_t m_taskCount{0};
   bool m_isShutdown{false};
   std::thread::id m_threadId{std::this_thread::get_id()};
-  DispatcherQueue::ShutdownCompleted_revoker m_shutdownCompletedRevoker;
+  typename TDispatcherTraits::DispatcherQueue_ShutdownCompleted_revoker m_shutdownCompletedRevoker;
 };
 
 //=============================================================================
 // TaskDispatcherHandler implementation
 //=============================================================================
 
-TaskDispatcherHandler::TaskDispatcherHandler(UISchedulerWinRT *scheduler) noexcept : m_scheduler{scheduler} {}
+template <typename TDispatcherTraits>
+TaskDispatcherHandler<TDispatcherTraits>::TaskDispatcherHandler(UISchedulerWinRT<TDispatcherTraits> *scheduler) noexcept
+    : m_scheduler{scheduler} {}
 
-int32_t __stdcall TaskDispatcherHandler::QueryInterface(guid const &id, void **result) noexcept {
-  if (is_guid_of<DispatcherQueueHandler>(id) || is_guid_of<Windows::Foundation::IUnknown>(id) ||
-      is_guid_of<IAgileObject>(id)) {
-    *result = static_cast<impl::abi_t<DispatcherQueueHandler> *>(this);
+template <typename TDispatcherTraits>
+int32_t __stdcall TaskDispatcherHandler<TDispatcherTraits>::QueryInterface(guid const &id, void **result) noexcept {
+  if (is_guid_of<typename TDispatcherTraits::DispatcherQueueHandler>(id) ||
+      is_guid_of<Windows::Foundation::IUnknown>(id) || is_guid_of<IAgileObject>(id)) {
+    *result = static_cast<impl::abi_t<typename TDispatcherTraits::DispatcherQueueHandler> *>(this);
     AddRef();
     return impl::error_ok;
   }
@@ -155,15 +195,18 @@ int32_t __stdcall TaskDispatcherHandler::QueryInterface(guid const &id, void **r
   return impl::error_no_interface;
 }
 
-uint32_t __stdcall TaskDispatcherHandler::AddRef() noexcept {
+template <typename TDispatcherTraits>
+uint32_t __stdcall TaskDispatcherHandler<TDispatcherTraits>::AddRef() noexcept {
   return m_scheduler->AddHandlerRef();
 }
 
-uint32_t __stdcall TaskDispatcherHandler::Release() noexcept {
+template <typename TDispatcherTraits>
+uint32_t __stdcall TaskDispatcherHandler<TDispatcherTraits>::Release() noexcept {
   return m_scheduler->ReleaseHandlerRef();
 }
 
-int32_t __stdcall TaskDispatcherHandler::Invoke() noexcept {
+template <typename TDispatcherTraits>
+int32_t __stdcall TaskDispatcherHandler<TDispatcherTraits>::Invoke() noexcept {
   Mso::CntPtr<IDispatchQueueService> queue;
   DispatchTask task;
   if (m_scheduler->TryTakeTask(queue, task)) {
@@ -177,24 +220,29 @@ int32_t __stdcall TaskDispatcherHandler::Invoke() noexcept {
 // UISchedulerWinRT implementation
 //=============================================================================
 
-UISchedulerWinRT::UISchedulerWinRT(DispatcherQueue &&dispatcher) noexcept : m_dispatcher{std::move(dispatcher)} {
-  m_shutdownCompletedRevoker =
-      m_dispatcher.ShutdownCompleted(winrt::auto_revoke, [](DispatcherQueue const &, IInspectable const &) noexcept {
+template <typename TDispatcherTraits>
+UISchedulerWinRT<TDispatcherTraits>::UISchedulerWinRT(typename TDispatcherTraits::DispatcherQueue &&dispatcher) noexcept
+    : m_dispatcher{std::move(dispatcher)} {
+  m_shutdownCompletedRevoker = m_dispatcher.ShutdownCompleted(
+      winrt::auto_revoke, [](typename TDispatcherTraits::DispatcherQueue const &, IInspectable const &) noexcept {
         GetDispatchQueueRegistry().Remove(std::this_thread::get_id());
       });
 }
 
-UISchedulerWinRT::~UISchedulerWinRT() noexcept {
+template <typename TDispatcherTraits>
+UISchedulerWinRT<TDispatcherTraits>::~UISchedulerWinRT() noexcept {
   GetDispatchQueueRegistry().Remove(m_threadId);
   AwaitTermination();
 }
 
-uint32_t UISchedulerWinRT::AddHandlerRef() noexcept {
+template <typename TDispatcherTraits>
+uint32_t UISchedulerWinRT<TDispatcherTraits>::AddHandlerRef() noexcept {
   std::lock_guard lock{m_mutex};
   return ++m_handlerRefCount;
 }
 
-uint32_t UISchedulerWinRT::ReleaseHandlerRef() noexcept {
+template <typename TDispatcherTraits>
+uint32_t UISchedulerWinRT<TDispatcherTraits>::ReleaseHandlerRef() noexcept {
   Mso::CntPtr<UISchedulerWinRT> self;
   CleanupContext context{this};
 
@@ -213,7 +261,10 @@ uint32_t UISchedulerWinRT::ReleaseHandlerRef() noexcept {
   }
 }
 
-bool UISchedulerWinRT::TryTakeTask(Mso::CntPtr<IDispatchQueueService> &queue, DispatchTask &task) noexcept {
+template <typename TDispatcherTraits>
+bool UISchedulerWinRT<TDispatcherTraits>::TryTakeTask(
+    Mso::CntPtr<IDispatchQueueService> &queue,
+    DispatchTask &task) noexcept {
   {
     std::lock_guard lock{m_mutex};
     VerifyElseCrashSz(m_taskCount, "Task count cannot be negative");
@@ -227,7 +278,9 @@ bool UISchedulerWinRT::TryTakeTask(Mso::CntPtr<IDispatchQueueService> &queue, Di
   return false;
 }
 
-DispatcherQueueHandler UISchedulerWinRT::MakeDispatcherQueueHandler() noexcept {
+template <typename TDispatcherTraits>
+typename TDispatcherTraits::DispatcherQueueHandler
+UISchedulerWinRT<TDispatcherTraits>::MakeDispatcherQueueHandler() noexcept {
   VerifyElseCrash(m_mutex.IsLockedByMe());
 
   if (m_handlerRefCount == 0) {
@@ -238,22 +291,26 @@ DispatcherQueueHandler UISchedulerWinRT::MakeDispatcherQueueHandler() noexcept {
   return {static_cast<void *>(&m_dispatcherHandler), take_ownership_from_abi};
 }
 
-void UISchedulerWinRT::IntializeScheduler(Mso::WeakPtr<IDispatchQueueService> &&queue) noexcept {
+template <typename TDispatcherTraits>
+void UISchedulerWinRT<TDispatcherTraits>::InitializeScheduler(Mso::WeakPtr<IDispatchQueueService> &&queue) noexcept {
   m_queue = std::move(queue);
 }
 
-bool UISchedulerWinRT::HasThreadAccess() noexcept {
+template <typename TDispatcherTraits>
+bool UISchedulerWinRT<TDispatcherTraits>::HasThreadAccess() noexcept {
   // m_dispatcher.HasThreadAccess() is implemented only in Windows 19H1.
   // We must use an alternative implementation.
   return m_threadId == std::this_thread::get_id();
 }
 
-bool UISchedulerWinRT::IsSerial() noexcept {
+template <typename TDispatcherTraits>
+bool UISchedulerWinRT<TDispatcherTraits>::IsSerial() noexcept {
   return true;
 }
 
-void UISchedulerWinRT::Post() noexcept {
-  DispatcherQueueHandler handler;
+template <typename TDispatcherTraits>
+void UISchedulerWinRT<TDispatcherTraits>::Post() noexcept {
+  typename TDispatcherTraits::DispatcherQueueHandler handler;
   {
     std::lock_guard lock{m_mutex};
     if (!m_isShutdown) {
@@ -267,7 +324,8 @@ void UISchedulerWinRT::Post() noexcept {
   }
 }
 
-void UISchedulerWinRT::Shutdown() noexcept {
+template <typename TDispatcherTraits>
+void UISchedulerWinRT<TDispatcherTraits>::Shutdown() noexcept {
   CleanupContext context{this};
   {
     std::lock_guard lock{m_mutex};
@@ -276,12 +334,14 @@ void UISchedulerWinRT::Shutdown() noexcept {
   }
 }
 
-void UISchedulerWinRT::AwaitTermination() noexcept {
+template <typename TDispatcherTraits>
+void UISchedulerWinRT<TDispatcherTraits>::AwaitTermination() noexcept {
   Shutdown();
   m_terminationEvent.Wait();
 }
 
-/*static*/ DispatchQueue UISchedulerWinRT::GetOrCreateUIThreadQueue() noexcept {
+template <typename TDispatcherTraits>
+/*static*/ DispatchQueue UISchedulerWinRT<TDispatcherTraits>::GetOrCreateUIThreadQueue() noexcept {
   std::thread::id threadId{std::this_thread::get_id()};
   std::optional<Mso::WeakPtr<IDispatchQueueService>> weakQueue = GetDispatchQueueRegistry().Get(threadId);
   DispatchQueue queue{weakQueue.value_or(nullptr).GetStrongPtr()};
@@ -289,9 +349,9 @@ void UISchedulerWinRT::AwaitTermination() noexcept {
     return queue;
   }
 
-  decltype(DispatcherQueue::GetForCurrentThread()) dispatcher{nullptr};
+  decltype(TDispatcherTraits::DispatcherQueue::GetForCurrentThread()) dispatcher{nullptr};
   try {
-    dispatcher = DispatcherQueue::GetForCurrentThread();
+    dispatcher = TDispatcherTraits::DispatcherQueue::GetForCurrentThread();
   } catch (winrt::hresult_error const &) {
   }
 
@@ -305,7 +365,9 @@ void UISchedulerWinRT::AwaitTermination() noexcept {
   return queue;
 }
 
-/*static*/ UISchedulerWinRT::DispatchQueueRegistry &UISchedulerWinRT::GetDispatchQueueRegistry() noexcept {
+template <typename TDispatcherTraits>
+/*static*/ typename UISchedulerWinRT<TDispatcherTraits>::DispatchQueueRegistry &
+UISchedulerWinRT<TDispatcherTraits>::GetDispatchQueueRegistry() noexcept {
   static std::recursive_mutex mutex;
   static DispatchQueueRegistry registry{mutex};
   return registry;
@@ -315,9 +377,13 @@ void UISchedulerWinRT::AwaitTermination() noexcept {
 // UISchedulerWinRT::CleanupContext implementation
 //=============================================================================
 
-UISchedulerWinRT::CleanupContext::CleanupContext(UISchedulerWinRT *scheduler) noexcept : m_scheduler{scheduler} {}
+template <typename TDispatcherTraits>
+UISchedulerWinRT<TDispatcherTraits>::CleanupContext::CleanupContext(
+    UISchedulerWinRT<TDispatcherTraits> *scheduler) noexcept
+    : m_scheduler{scheduler} {}
 
-UISchedulerWinRT::CleanupContext::~CleanupContext() noexcept {
+template <typename TDispatcherTraits>
+UISchedulerWinRT<TDispatcherTraits>::CleanupContext::~CleanupContext() noexcept {
   if (m_isTerminated) {
     m_scheduler->m_terminationEvent.Set();
   }
@@ -329,7 +395,8 @@ UISchedulerWinRT::CleanupContext::~CleanupContext() noexcept {
   }
 }
 
-void UISchedulerWinRT::CleanupContext::CheckShutdown() noexcept {
+template <typename TDispatcherTraits>
+void UISchedulerWinRT<TDispatcherTraits>::CleanupContext::CheckShutdown() noexcept {
   // See if dispatcher queue released all handlers without invoking them.
   if (m_scheduler->m_taskCount != 0 && m_scheduler->m_handlerRefCount == 0) {
     m_isShutdown = true;
@@ -338,7 +405,8 @@ void UISchedulerWinRT::CleanupContext::CheckShutdown() noexcept {
   }
 }
 
-void UISchedulerWinRT::CleanupContext::CheckTermination() noexcept {
+template <typename TDispatcherTraits>
+void UISchedulerWinRT<TDispatcherTraits>::CleanupContext::CheckTermination() noexcept {
   m_isTerminated = m_scheduler->m_isShutdown && (m_scheduler->m_handlerRefCount == 0);
 }
 
@@ -347,7 +415,16 @@ void UISchedulerWinRT::CleanupContext::CheckTermination() noexcept {
 //=============================================================================
 
 DispatchQueue DispatchQueueStatic::GetCurrentUIThreadQueue() noexcept {
-  return UISchedulerWinRT::GetOrCreateUIThreadQueue();
+  DispatchQueue queue{nullptr};
+#if USE_WINUI3
+  queue = UISchedulerWinRT<MicrosoftDispatcherTraits>::GetOrCreateUIThreadQueue();
+  if (!queue) {
+#endif
+    queue = UISchedulerWinRT<WindowsDispatcherTraits>::GetOrCreateUIThreadQueue();
+#if USE_WINUI3
+  }
+#endif
+  return queue;
 }
 
 } // namespace Mso

package/Mso/src/eventWaitHandle/eventWaitHandleImpl_win.cpp

@@ -53,12 +53,12 @@ struct ConditionVariable {
 
     // For the very first time here we use duration provided by user.
     // If we get here again, then it means that the condition_variable was woken up
-    // due to sporatic wakeups, and we have to recalculate the wait duration.
+    // due to sporadic wakeups, and we have to recalculate the wait duration.
     if (waitTimePoint.ShouldUpdateWaitDuration) {
       using namespace std::chrono;
       auto timeLeft = duration_cast<milliseconds>(waitTimePoint.WaitUntil - system_clock::now());
       // Make sure that we do not have negative duration because we waited beyond the target time point,
-      // or because system_clock::now() gave inacccurate time due to internal implementation.
+      // or because system_clock::now() gave inaccurate time due to internal implementation.
       waitTimePoint.WaitDuration = std::max(timeLeft, milliseconds{0});
     }
 

package/Mso/src/future/futureImpl.cpp

@@ -144,7 +144,7 @@ bool FuturePackedData::IsDone() const noexcept {
   return (state == FutureState::Succeeded || state == FutureState::Failed);
 }
 
-bool FuturePackedData::IsSucceded() const noexcept {
+bool FuturePackedData::IsSucceeded() const noexcept {
   return (GetState() == FutureState::Succeeded);
 }
 
@@ -218,7 +218,7 @@ FutureImpl::~FutureImpl() noexcept {
   }
 
   // Destroy value if it was set. The value exists only if future succeeded.
-  if (m_traits.ValueDestroy && data.IsSucceded()) {
+  if (m_traits.ValueDestroy && data.IsSucceeded()) {
     m_traits.ValueDestroy(GetValueInternal());
   }
 
@@ -291,7 +291,7 @@ const FutureTraits &FutureImpl::GetTraits() const noexcept {
 
 ByteArrayView FutureImpl::GetValue() noexcept {
   FuturePackedData data = m_stateAndContinuation.load(std::memory_order_acquire);
-  if (data.IsSucceded()) {
+  if (data.IsSucceeded()) {
     if (IsSet(m_traits.Options, FutureOptions::UseParentValue)) {
       return m_link->GetValue();
     }
@@ -352,7 +352,7 @@ void FutureImpl::AddContinuation(Mso::CntPtr<IFuture> &&continuation) noexcept {
       // Do not change ref count when assigning previous continuation. It could be already deleted by now.
       // So, we treat it just as a raw pointer until compare_exchange_weak succeeds.
       // Initially it is owned by this FutureImpl instance, and if compare_exchange_weak succeeds then the
-      // ownership is transfered to the new continuation contFuture. No ref count should be changed during that
+      // ownership is transferred to the new continuation contFuture. No ref count should be changed during that
       // ownership transition.
       //
       contFuture->m_link = Mso::CntPtr<FutureImpl>{currentContinuation, AttachTag};
@@ -809,7 +809,7 @@ bool FutureImpl::IsDone() const noexcept {
 }
 
 bool FutureImpl::IsSucceeded() const noexcept {
-  return m_stateAndContinuation.load(std::memory_order_acquire).IsSucceded();
+  return m_stateAndContinuation.load(std::memory_order_acquire).IsSucceeded();
 }
 
 bool FutureImpl::IsFailed() const noexcept {

package/Mso/src/future/futureImpl.h

@@ -159,7 +159,7 @@ struct FuturePackedData {
   FutureState GetState() const noexcept;
   FutureImpl *GetContinuation() noexcept;
   bool IsDone() const noexcept;
-  bool IsSucceded() const noexcept;
+  bool IsSucceeded() const noexcept;
   bool IsFailed() const noexcept;
 
   static FuturePackedData Make(FutureState state) noexcept;

package/PropertySheets/External/Microsoft.ReactNative.Common.props

@@ -36,6 +36,9 @@
     <ProjectDir Condition="'$(ProjectDir)' == ''">$(MSBuildProjectDirectory)\</ProjectDir>
     <UseExperimentalNuget Condition="'$(UseExperimentalNuget)' == ''">false</UseExperimentalNuget>
     <HermesNoDLLCopy Condition="'$(UseHermes)' != 'true'">true</HermesNoDLLCopy>
+
+    <RestorePackagesWithLockFile Condition="'$(RestorePackagesWithLockFile)' == ''">true</RestorePackagesWithLockFile>
+    <RestoreForceEvaluate Condition="'$(RestoreForceEvaluate)' == ''">false</RestoreForceEvaluate>
   </PropertyGroup>
 
   <Import Project="$(ReactNativeWindowsDir)\PropertySheets\NewAPIDeclarations.props" />

package/PropertySheets/External/{Microsoft.ReactNative.WinAppSDK.Common.props → Microsoft.ReactNative.Composition.Common.props}

@@ -3,10 +3,10 @@
   Copyright (c) Microsoft Corporation. All rights reserved.
   Licensed under the MIT License.
 
-  This file will be consumed by ALL WinAppSDK app and module projects (both inside
+  This file will be consumed by ALL Win32 app and module projects (both inside
   and outside of this repo) that build on top of Microsoft.ReactNative.
   Do not make any changes here unless it applies to ALL such projects.
 -->
 <Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <Import Project="$(MSBuildThisFileDirectory)Microsoft.ReactNative.Common.props" />
-</Project>
+</Project>

package/PropertySheets/External/{Microsoft.ReactNative.WinAppSDK.CSharpApp.props → Microsoft.ReactNative.Composition.CppApp.props}

@@ -3,7 +3,7 @@
   Copyright (c) Microsoft Corporation.
   Licensed under the MIT License.
 
-  This file will be consumed by ALL WinAppSDK C# app projects (both inside
+  This file will be consumed by ALL Win32 C++ app projects (both inside
   and outside of this repo) that build on top of Microsoft.ReactNative.
   Do not make any changes here unless it applies to ALL such projects.
 -->
@@ -13,16 +13,13 @@
   <Import Project="$(ProjectDir)\AutolinkedNativeModules.g.props"
           Condition="Exists('$(ProjectDir)\AutolinkedNativeModules.g.props')" />
 
-  <PropertyGroup>
-    <!--https://github.com/microsoft/react-native-windows/pull/9177#discussion_r827643823-->
-    <UseDocString>false</UseDocString>
-    <ReactNativeCodeGenEnabled Condition="'$(ReactNativeCodeGenEnabled)' == ''">true</ReactNativeCodeGenEnabled>
-  </PropertyGroup>
-
-  <Import Project="$(MSBuildThisFileDirectory)Microsoft.ReactNative.WinAppSDK.Common.props" />
+  <Import Project="$(MSBuildThisFileDirectory)Microsoft.ReactNative.Composition.Common.props" />
   <Import Project="$(ReactNativeWindowsDir)\PropertySheets\Appx.props" />
   <Import Project="$(ReactNativeWindowsDir)\PropertySheets\Autolink.props" />
   <Import Project="$(ReactNativeWindowsDir)\PropertySheets\Codegen.props" />
-  <Import Project="$(ReactNativeWindowsDir)\PropertySheets\NuGet.CSharp.props" />
+  <Import Project="$(ReactNativeWindowsDir)\PropertySheets\HybridCRT.props" Condition="'$(UseWinUI3)'=='true'"/>
+  <Import Project="$(ReactNativeWindowsDir)\PropertySheets\NuGet.Cpp.props" />
   <Import Project="$(ReactNativeWindowsDir)\PropertySheets\WinUI.props" />
-</Project>
+  <Import Project="$(ReactNativeWindowsDir)\PropertySheets\CppAppConsumeCSharpModule.props" />
+  <Import Project="$(ReactNativeWindowsDir)\PropertySheets\PackageVersionDefinitions.props" />
+</Project>