react-native-windows 0.73.14 → 0.73.15

package/Microsoft.ReactNative/Microsoft.ReactNative.vcxproj

@@ -107,6 +107,7 @@
         $(ReactNativeWindowsDir)Microsoft.ReactNative\Views;
         $(ReactNativeWindowsDir);
         $(ReactNativeWindowsDir)codegen;
+        $(ReactNativeWindowsDir)codegen\react\components\rnwcore;
         $(ReactNativeWindowsDir)Common;
         $(ReactNativeWindowsDir)include;
         $(ReactNativeWindowsDir)Shared;
@@ -117,21 +118,25 @@
         $(GeneratedFilesDir);
         %(AdditionalIncludeDirectories)
       </AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>DISABLE_XAML_GENERATED_MAIN;FOLLY_NO_CONFIG;NOMINMAX;_HAS_AUTO_PTR_ETC;_USE_MATH_DEFINES;RN_EXPORT=;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <!--
         REACTWINDOWS_BUILD - building with REACTWINDOWS_API as dll exports
         OLD_CPPWINRT is a workaround to make target version to 19H1
       -->
       <PreprocessorDefinitions>
+        DISABLE_XAML_GENERATED_MAIN;
         REACTWINDOWS_BUILD;
         RN_PLATFORM=windows;
         NOMINMAX;
+        FOLLY_CFG_NO_COROUTINES;
         FOLLY_NO_CONFIG;
         RN_EXPORT=;
         JSI_EXPORT=;
         WIN32=0;
         WINRT=1;
         _HAS_AUTO_PTR_ETC;
+        _USE_MATH_DEFINES;
+        <!-- See https://cplusplus.github.io/LWG/issue3840 -->
+        _SILENCE_CXX20_U8PATH_DEPRECATION_WARNING;
         %(PreprocessorDefinitions)
       </PreprocessorDefinitions>
       <AdditionalUsingDirectories>$(WindowsSDK_WindowsMetadata);$(AdditionalUsingDirectories)</AdditionalUsingDirectories>

package/Microsoft.ReactNative/Modules/ExceptionsManager.cpp

@@ -0,0 +1,110 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#include "pch.h"
+#include "ExceptionsManager.h"
+
+#include <DynamicWriter.h>
+#include <IRedBoxHandler.h>
+#include <JSValueWriter.h>
+
+namespace Microsoft::ReactNative {
+
+static const React::ReactPropertyId<React::ReactNonAbiValue<std::shared_ptr<Mso::React::IRedBoxHandler>>>
+    &RedBoxHandlerPropertyId() noexcept {
+  static const React::ReactPropertyId<React::ReactNonAbiValue<std::shared_ptr<Mso::React::IRedBoxHandler>>> prop{
+      L"ReactNative.ExceptionsManager", L"RedBoxHandler"};
+  return prop;
+}
+
+Mso::React::ErrorInfo CreateErrorInfo(
+    std::string message,
+    std::vector<ReactNativeSpecs::ExceptionsManagerSpec_StackFrame> const &stack,
+    double exceptionId) {
+  Mso::React::ErrorInfo errorInfo;
+  errorInfo.Message = message;
+  errorInfo.Id = static_cast<uint32_t>(exceptionId);
+  for (auto frame : stack) {
+    errorInfo.Callstack.push_back(Mso::React::ErrorFrameInfo{
+        frame.file.value_or(""),
+        frame.methodName,
+        static_cast<int>(frame.lineNumber.value_or(0)),
+        static_cast<int>(frame.column.value_or(0)),
+        frame.collapse.value_or(false)});
+  }
+  return errorInfo;
+};
+
+void ExceptionsManager::Initialize(winrt::Microsoft::ReactNative::ReactContext const &reactContext) noexcept {
+  m_reactContext = reactContext;
+  m_redboxHandler = *m_reactContext.Properties().Get(RedBoxHandlerPropertyId());
+}
+
+void ExceptionsManager::reportFatalException(
+    std::string message,
+    std::vector<ReactNativeSpecs::ExceptionsManagerSpec_StackFrame> const &stack,
+    double exceptionId) noexcept {
+  if (m_redboxHandler && m_redboxHandler->isDevSupportEnabled()) {
+    m_redboxHandler->showNewError(
+        std::move(CreateErrorInfo(message, stack, exceptionId)), Mso::React::ErrorType::JSFatal);
+  }
+}
+
+void ExceptionsManager::reportSoftException(
+    std::string message,
+    std::vector<ReactNativeSpecs::ExceptionsManagerSpec_StackFrame> const &stack,
+    double exceptionId) noexcept {
+  if (m_redboxHandler && m_redboxHandler->isDevSupportEnabled()) {
+    m_redboxHandler->showNewError(
+        std::move(CreateErrorInfo(message, stack, exceptionId)), Mso::React::ErrorType::JSSoft);
+  }
+}
+
+void ExceptionsManager::reportException(ReactNativeSpecs::ExceptionsManagerSpec_ExceptionData &&data) noexcept {
+  if (m_redboxHandler && m_redboxHandler->isDevSupportEnabled()) {
+    Mso::React::ErrorInfo errorInfo;
+    errorInfo.Message = data.message;
+    errorInfo.OriginalMessage = data.originalMessage.value_or("");
+    errorInfo.Name = data.name.value_or("");
+    errorInfo.ComponentStack = data.componentStack.value_or("");
+    errorInfo.Id = static_cast<uint32_t>(data.id);
+
+    auto writer = winrt::make_self<winrt::Microsoft::ReactNative::DynamicWriter>();
+    winrt::Microsoft::ReactNative::WriteValue(
+        writer.as<winrt::Microsoft::ReactNative::IJSValueWriter>(), data.extraData);
+    errorInfo.ExtraData = writer->TakeValue();
+
+    for (auto frame : data.stack) {
+      errorInfo.Callstack.push_back(Mso::React::ErrorFrameInfo{
+          frame.file.value_or(""),
+          frame.methodName,
+          static_cast<int>(frame.lineNumber.value_or(0)),
+          static_cast<int>(frame.column.value_or(0)),
+          frame.collapse.value_or(false)});
+    }
+    m_redboxHandler->showNewError(
+        std::move(errorInfo), data.isFatal ? Mso::React::ErrorType::JSFatal : Mso::React::ErrorType::JSSoft);
+  }
+}
+
+void ExceptionsManager::updateExceptionMessage(
+    std::string message,
+    std::vector<ReactNativeSpecs::ExceptionsManagerSpec_StackFrame> const &stack,
+    double exceptionId) noexcept {
+  if (m_redboxHandler && m_redboxHandler->isDevSupportEnabled()) {
+    m_redboxHandler->updateError(std::move(CreateErrorInfo(message, stack, exceptionId)));
+  }
+}
+
+void ExceptionsManager::dismissRedbox() noexcept {
+  if (m_redboxHandler)
+    m_redboxHandler->dismissRedbox();
+}
+
+void ExceptionsManager::SetRedBoxHander(
+    const winrt::Microsoft::ReactNative::ReactPropertyBag &properties,
+    std::shared_ptr<Mso::React::IRedBoxHandler> handler) noexcept {
+  properties.Set(RedBoxHandlerPropertyId(), handler);
+}
+
+} // namespace Microsoft::ReactNative

package/Microsoft.ReactNative/Modules/ExceptionsManager.h

@@ -0,0 +1,54 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+#pragma once
+
+#include "codegen/NativeExceptionsManagerSpec.g.h"
+#include <NativeModules.h>
+
+namespace Mso::React {
+struct IRedBoxHandler;
+}
+
+namespace Microsoft::ReactNative {
+
+REACT_MODULE(ExceptionsManager)
+struct ExceptionsManager {
+  using ModuleSpec = ReactNativeSpecs::ExceptionsManagerSpec;
+
+  REACT_INIT(Initialize)
+  void Initialize(winrt::Microsoft::ReactNative::ReactContext const &reactContext) noexcept;
+
+  REACT_METHOD(reportFatalException)
+  void reportFatalException(
+      std::string message,
+      std::vector<ReactNativeSpecs::ExceptionsManagerSpec_StackFrame> const &stack,
+      double exceptionId) noexcept;
+
+  REACT_METHOD(reportSoftException)
+  void reportSoftException(
+      std::string message,
+      std::vector<ReactNativeSpecs::ExceptionsManagerSpec_StackFrame> const &stack,
+      double exceptionId) noexcept;
+
+  REACT_METHOD(reportException)
+  void reportException(ReactNativeSpecs::ExceptionsManagerSpec_ExceptionData &&data) noexcept;
+
+  REACT_METHOD(updateExceptionMessage)
+  void updateExceptionMessage(
+      std::string message,
+      std::vector<ReactNativeSpecs::ExceptionsManagerSpec_StackFrame> const &stack,
+      double exceptionId) noexcept;
+
+  REACT_METHOD(dismissRedbox)
+  void dismissRedbox() noexcept;
+
+  static void SetRedBoxHander(
+      const winrt::Microsoft::ReactNative::ReactPropertyBag &properties,
+      std::shared_ptr<Mso::React::IRedBoxHandler> handler) noexcept;
+
+ private:
+  std::shared_ptr<Mso::React::IRedBoxHandler> m_redboxHandler;
+  winrt::Microsoft::ReactNative::ReactContext m_reactContext;
+};
+
+} // namespace Microsoft::ReactNative

package/Microsoft.ReactNative/Modules/PlatformConstantsWinModule.cpp

@@ -0,0 +1,43 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#include "pch.h"
+#include "PlatformConstantsWinModule.h"
+
+#include <VersionHelpers.h>
+#include <cxxreact/ReactNativeVersion.h>
+#include <winrt/Windows.Foundation.Metadata.h>
+
+namespace Microsoft::ReactNative {
+
+ReactNativeSpecs::PlatformConstantsWinSpec_PlatformConstantsWindows PlatformConstants::GetConstants() noexcept {
+  ReactNativeSpecs::PlatformConstantsWinSpec_PlatformConstantsWindows constants;
+
+  // We don't currently treat Native code differently in a test environment
+  constants.isTesting = false;
+
+  // Provide version information stamped into the compiled version of react-native
+  constants.reactNativeVersion.major = facebook::react::ReactNativeVersion.Major;
+  constants.reactNativeVersion.minor = facebook::react::ReactNativeVersion.Minor;
+  constants.reactNativeVersion.patch = facebook::react::ReactNativeVersion.Patch;
+  if (!facebook::react::ReactNativeVersion.Prerelease.empty()) {
+    constants.reactNativeVersion.prerelease = facebook::react::ReactNativeVersion.Prerelease;
+  }
+
+  // Provide the universal API contract as an OS version
+  if (!IsWindows10OrGreater()) {
+    constants.osVersion = -1;
+  } else {
+    for (uint16_t i = 1;; ++i) {
+      if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsApiContractPresent(
+              L"Windows.Foundation.UniversalApiContract", i)) {
+        constants.osVersion = i - 1;
+        break;
+      }
+    }
+  }
+
+  return constants;
+}
+
+} // namespace Microsoft::ReactNative

package/Microsoft.ReactNative/Modules/PlatformConstantsWinModule.h

@@ -0,0 +1,18 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+#pragma once
+
+#include "codegen/NativePlatformConstantsWinSpec.g.h"
+#include <NativeModules.h>
+
+namespace Microsoft::ReactNative {
+
+REACT_MODULE(PlatformConstants)
+struct PlatformConstants {
+  using ModuleSpec = ReactNativeSpecs::PlatformConstantsWinSpec;
+
+  REACT_GET_CONSTANTS(GetConstants)
+  ReactNativeSpecs::PlatformConstantsWinSpec_PlatformConstantsWindows GetConstants() noexcept;
+};
+
+} // namespace Microsoft::ReactNative

package/Microsoft.ReactNative/Modules/SourceCode.cpp

@@ -0,0 +1,31 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#include "pch.h"
+#include "SourceCode.h"
+
+namespace Microsoft::ReactNative {
+
+static const React::ReactPropertyId<React::ReactNonAbiValue<std::string>> &ScriptUrlPropertyId() noexcept {
+  static const React::ReactPropertyId<React::ReactNonAbiValue<std::string>> prop{
+      L"ReactNative.SourceCode", L"ScriptUrl"};
+  return prop;
+}
+
+void SourceCode::Initialize(winrt::Microsoft::ReactNative::ReactContext const &reactContext) noexcept {
+  m_reactContext = reactContext;
+}
+
+ReactNativeSpecs::SourceCodeSpec_SourceCodeConstants SourceCode::GetConstants() noexcept {
+  ReactNativeSpecs::SourceCodeSpec_SourceCodeConstants constants;
+  constants.scriptURL = *m_reactContext.Properties().Get(ScriptUrlPropertyId());
+  return constants;
+}
+
+void SourceCode::SetScriptUrl(
+    const winrt::Microsoft::ReactNative::ReactPropertyBag &propertyBag,
+    const std::string &scriptUrl) noexcept {
+  propertyBag.Set(ScriptUrlPropertyId(), scriptUrl);
+}
+
+} // namespace Microsoft::ReactNative

package/Microsoft.ReactNative/Modules/SourceCode.h

@@ -0,0 +1,28 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+#pragma once
+
+#include "codegen/NativeSourceCodeSpec.g.h"
+#include <NativeModules.h>
+
+namespace Microsoft::ReactNative {
+
+REACT_MODULE(SourceCode)
+struct SourceCode {
+  using ModuleSpec = ReactNativeSpecs::SourceCodeSpec;
+
+  REACT_INIT(Initialize)
+  void Initialize(winrt::Microsoft::ReactNative::ReactContext const &reactContext) noexcept;
+
+  REACT_GET_CONSTANTS(GetConstants)
+  ReactNativeSpecs::SourceCodeSpec_SourceCodeConstants GetConstants() noexcept;
+
+  static void SetScriptUrl(
+      const winrt::Microsoft::ReactNative::ReactPropertyBag &propertyBag,
+      const std::string &scriptUrl) noexcept;
+
+ private:
+  winrt::Microsoft::ReactNative::ReactContext m_reactContext;
+};
+
+} // namespace Microsoft::ReactNative

package/Microsoft.ReactNative/Modules/StatusBarManager.h

@@ -0,0 +1,12 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+#pragma once
+
+#include <NativeModules.h>
+
+namespace Microsoft::ReactNative {
+
+REACT_MODULE(StatusBarManager)
+struct StatusBarManager {};
+
+} // namespace Microsoft::ReactNative

package/Microsoft.ReactNative/ReactHost/ReactInstanceWin.cpp

@@ -63,8 +63,14 @@
 #include "Modules/NativeUIManager.h"
 #include "Modules/PaperUIManagerModule.h"
 #include "Modules/TimingModule.h"
+#else
+#include "Modules/DesktopTimingModule.h"
 #endif
+#include "Modules/ExceptionsManager.h"
+#include "Modules/PlatformConstantsWinModule.h"
 #include "Modules/ReactRootViewTagGenerator.h"
+#include "Modules/SourceCode.h"
+#include "Modules/StatusBarManager.h"
 
 #ifndef CORE_ABI
 #include <Utils/UwpPreparedScriptStore.h>
@@ -255,6 +261,7 @@ ReactInstanceWin::ReactInstanceWin(
   m_whenDestroyedResult =
       m_whenDestroyed.AsFuture().Then<Mso::Executors::Inline>([whenLoaded = m_whenLoaded,
                                                                onDestroyed = m_options.OnInstanceDestroyed,
+                                                               // If the ReactHost has been released, this
                                                                // instance might be the only thing keeping
                                                                // the propertyBag alive.
                                                                // We want it to remain alive for the
@@ -316,6 +323,7 @@ void ReactInstanceWin::InstanceCrashHandler(int fileDescriptor) noexcept {
 }
 
 void ReactInstanceWin::LoadModules(
+    const std::shared_ptr<facebook::react::DevSettings> &devSettings,
     const std::shared_ptr<winrt::Microsoft::ReactNative::NativeModulesProvider> &nativeModulesProvider,
     const std::shared_ptr<winrt::Microsoft::ReactNative::TurboModulesProvider> &turboModulesProvider) noexcept {
   auto registerTurboModule = [this, &nativeModulesProvider, &turboModulesProvider](
@@ -385,6 +393,45 @@ void ReactInstanceWin::LoadModules(
   }
 #endif
 
+  if (devSettings->useTurboModulesOnly) {
+    ::Microsoft::ReactNative::ExceptionsManager::SetRedBoxHander(
+        winrt::Microsoft::ReactNative::ReactPropertyBag(m_reactContext->Properties()), m_redboxHandler);
+    registerTurboModule(
+        L"ExceptionsManager",
+        winrt::Microsoft::ReactNative::MakeTurboModuleProvider<::Microsoft::ReactNative::ExceptionsManager>());
+
+    registerTurboModule(
+        L"StatusBarManager",
+        winrt::Microsoft::ReactNative::MakeModuleProvider<::Microsoft::ReactNative::StatusBarManager>());
+
+    registerTurboModule(
+        L"PlatformConstants",
+        winrt::Microsoft::ReactNative::MakeTurboModuleProvider<::Microsoft::ReactNative::PlatformConstants>());
+
+    uint32_t hermesBytecodeVersion = 0;
+#if defined(USE_HERMES) && defined(ENABLE_DEVSERVER_HBCBUNDLES)
+    hermesBytecodeVersion = ::hermes::hbc::BYTECODE_VERSION;
+#endif
+
+    std::string bundleUrl = (devSettings->useWebDebugger || devSettings->liveReloadCallback)
+        ? facebook::react::DevServerHelper::get_BundleUrl(
+              devSettings->sourceBundleHost,
+              devSettings->sourceBundlePort,
+              devSettings->debugBundlePath,
+              devSettings->platformName,
+              devSettings->bundleAppId,
+              devSettings->devBundle,
+              devSettings->useFastRefresh,
+              devSettings->inlineSourceMap,
+              hermesBytecodeVersion)
+        : devSettings->bundleRootPath;
+    ::Microsoft::ReactNative::SourceCode::SetScriptUrl(
+        winrt::Microsoft::ReactNative::ReactPropertyBag(m_reactContext->Properties()), bundleUrl);
+
+    registerTurboModule(
+        L"SourceCode", winrt::Microsoft::ReactNative::MakeTurboModuleProvider<::Microsoft::ReactNative::SourceCode>());
+  }
+
   registerTurboModule(
       L"DevSettings", winrt::Microsoft::ReactNative::MakeTurboModuleProvider<::Microsoft::ReactNative::DevSettings>());
 
@@ -396,8 +443,9 @@ void ReactInstanceWin::LoadModules(
       L"LinkingManager",
       winrt::Microsoft::ReactNative::MakeTurboModuleProvider<::Microsoft::ReactNative::LinkingManager>());
 
-  registerTurboModule(
-      L"Timing", winrt::Microsoft::ReactNative::MakeTurboModuleProvider<::Microsoft::ReactNative::Timing>());
+  registerTurboModule(L"Timing", winrt::Microsoft::ReactNative::MakeModuleProvider<::Microsoft::ReactNative::Timing>());
+#else
+  registerTurboModule(L"Timing", winrt::Microsoft::ReactNative::MakeModuleProvider<::facebook::react::Timing>());
 #endif
 
   registerTurboModule(
@@ -439,13 +487,10 @@ void ReactInstanceWin::Initialize() noexcept {
           winrt::Microsoft::ReactNative::ReactPropertyBag(strongThis->Options().Properties));
       Microsoft::ReactNative::Appearance::InitOnUIThread(strongThis->GetReactContext());
       Microsoft::ReactNative::DeviceInfoHolder::InitDeviceInfoHolder(strongThis->GetReactContext());
-
 #endif // CORE_ABI
 
       strongThis->Queue().Post([this, weakThis]() noexcept {
         if (auto strongThis = weakThis.GetStrongPtr()) {
-          // auto cxxModulesProviders = GetCxxModuleProviders();
-
           auto devSettings = std::make_shared<facebook::react::DevSettings>();
           devSettings->useJITCompilation = m_options.EnableJITCompilation;
           devSettings->sourceBundleHost = SourceBundleHost();
@@ -478,10 +523,21 @@ void ReactInstanceWin::Initialize() noexcept {
             }
           };
 
+          auto getBoolProperty = [properties = ReactPropertyBag{m_options.Properties}](
+                                     const wchar_t *ns, const wchar_t *name, bool defaultValue) noexcept -> bool {
+            ReactPropertyId<bool> propId{ns == nullptr ? ReactPropertyNamespace() : ReactPropertyNamespace(ns), name};
+            std::optional<bool> propValue = properties.Get(propId);
+            return propValue.value_or(defaultValue);
+          };
+
+          devSettings->omitNetworkingCxxModules = getBoolProperty(nullptr, L"OmitNetworkingCxxModules", false);
+          devSettings->useWebSocketTurboModule = getBoolProperty(nullptr, L"UseWebSocketTurboModule", false);
+          devSettings->useTurboModulesOnly = getBoolProperty(L"DevSettings", L"UseTurboModulesOnly", false);
+
           std::vector<facebook::react::NativeModuleDescription> cxxModules;
           auto nmp = std::make_shared<winrt::Microsoft::ReactNative::NativeModulesProvider>();
 
-          LoadModules(nmp, m_options.TurboModuleProvider);
+          LoadModules(devSettings, nmp, m_options.TurboModuleProvider);
 
           auto modules = nmp->GetModules(m_reactContext, m_jsMessageThread.Load());
           cxxModules.insert(
@@ -569,12 +625,7 @@ void ReactInstanceWin::Initialize() noexcept {
             // We need to keep the instance wrapper alive as its destruction shuts down the native queue.
             m_options.TurboModuleProvider->SetReactContext(
                 winrt::make<implementation::ReactContext>(Mso::Copy(m_reactContext)));
-            auto omitNetCxxPropName = ReactPropertyBagHelper::GetName(nullptr, L"OmitNetworkingCxxModules");
-            auto omitNetCxxPropValue = m_options.Properties.Get(omitNetCxxPropName);
-            devSettings->omitNetworkingCxxModules = winrt::unbox_value_or(omitNetCxxPropValue, false);
-            auto useWebSocketTurboModulePropName = ReactPropertyBagHelper::GetName(nullptr, L"UseWebSocketTurboModule");
-            auto useWebSocketTurboModulePropValue = m_options.Properties.Get(useWebSocketTurboModulePropName);
-            devSettings->useWebSocketTurboModule = winrt::unbox_value_or(useWebSocketTurboModulePropValue, false);
+
             auto bundleRootPath = devSettings->bundleRootPath;
             auto instanceWrapper = facebook::react::CreateReactInstance(
                 std::shared_ptr<facebook::react::Instance>(strongThis->m_instance.Load()),

package/Microsoft.ReactNative/ReactHost/ReactInstanceWin.h

@@ -95,6 +95,7 @@ class ReactInstanceWin final : public Mso::ActiveObject<IReactInstanceInternal>
       Mso::Promise<void> &&whenLoaded,
       Mso::VoidFunctor &&updateUI) noexcept;
   void LoadModules(
+      const std::shared_ptr<facebook::react::DevSettings> &devSettings,
       const std::shared_ptr<winrt::Microsoft::ReactNative::NativeModulesProvider> &nativeModulesProvider,
       const std::shared_ptr<winrt::Microsoft::ReactNative::TurboModulesProvider> &turboModulesProvider) noexcept;
   void Initialize() noexcept override;

package/PropertySheets/Generated/PackageVersion.g.props

@@ -10,11 +10,11 @@
 -->
 <Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <PropertyGroup>
-    <ReactNativeWindowsVersion>0.73.14</ReactNativeWindowsVersion>
+    <ReactNativeWindowsVersion>0.73.15</ReactNativeWindowsVersion>
     <ReactNativeWindowsMajor>0</ReactNativeWindowsMajor>
     <ReactNativeWindowsMinor>73</ReactNativeWindowsMinor>
-    <ReactNativeWindowsPatch>14</ReactNativeWindowsPatch>
+    <ReactNativeWindowsPatch>15</ReactNativeWindowsPatch>
     <ReactNativeWindowsCanary>false</ReactNativeWindowsCanary>
-    <ReactNativeWindowsCommitId>0e1b8e1d5fec5a25b43234733ebcf621bde8c04e</ReactNativeWindowsCommitId>
+    <ReactNativeWindowsCommitId>7cb849542746286f1fb7758306cdf152c89db1aa</ReactNativeWindowsCommitId>
   </PropertyGroup>
 </Project>

package/Shared/DevSettings.h

@@ -105,6 +105,9 @@ struct DevSettings {
 
   // OC:8368383 - Memory leak under investigation.
   bool useWebSocketTurboModule{false};
+
+  // If true, then use only Turbo Modules instead of CxxModules.
+  bool useTurboModulesOnly{false};
 };
 
 } // namespace react

package/Shared/OInstance.cpp

@@ -549,6 +549,10 @@ InstanceImpl::~InstanceImpl() {
 std::vector<std::unique_ptr<NativeModule>> InstanceImpl::GetDefaultNativeModules(
     std::shared_ptr<MessageQueueThread> nativeQueue) {
   std::vector<std::unique_ptr<NativeModule>> modules;
+  if (m_devSettings->useTurboModulesOnly) {
+    return modules;
+  }
+
   auto transitionalProps{ReactPropertyBagHelper::CreatePropertyBag()};
 
   // These modules are instantiated separately in MSRN (Universal Windows).
@@ -566,9 +570,9 @@ std::vector<std::unique_ptr<NativeModule>> InstanceImpl::GetDefaultNativeModules
         nativeQueue));
   }
 
-  // Applications using the Windows ABI feature should loade the networking TurboModule variants instead.
+  // Applications using the Windows ABI feature should load the networking TurboModule variants instead.
   if (!m_devSettings->omitNetworkingCxxModules) {
-    // Use in case the host app provides its a non-Blob-compatilbe HTTP module.
+    // Use in case the host app provides its a non-Blob-compatible HTTP module.
     if (!Microsoft::React::GetRuntimeOptionBool("Blob.DisableModule")) {
       modules.push_back(std::make_unique<CxxNativeModule>(
           m_innerInstance,

package/Shared/Shared.vcxitems

@@ -403,6 +403,9 @@
     <ClInclude Include="$(MSBuildThisFileDirectory)WebSocketJSExecutorFactory.h" />
     <ClCompile Include="$(ReactNativeWindowsDir)Microsoft.ReactNative\Modules\DevSettingsModule.cpp" />
     <ClCompile Include="$(ReactNativeWindowsDir)Microsoft.ReactNative\Modules\ReactRootViewTagGenerator.cpp" />
+    <ClCompile Include="$(ReactNativeWindowsDir)Microsoft.ReactNative\Modules\PlatformConstantsWinModule.cpp" />
+    <ClCompile Include="$(ReactNativeWindowsDir)Microsoft.ReactNative\Modules\ExceptionsManager.cpp" />
+    <ClCompile Include="$(ReactNativeWindowsDir)Microsoft.ReactNative\Modules\SourceCode.cpp" />
     <ClCompile Include="$(ReactNativeWindowsDir)Microsoft.ReactNative\NativeModulesProvider.cpp" />
     <ClCompile Include="$(ReactNativeWindowsDir)Microsoft.ReactNative\ReactHost\AsyncActionQueue.cpp" />
     <ClCompile Include="$(ReactNativeWindowsDir)Microsoft.ReactNative\ReactHost\CrashManager.cpp" />

package/Shared/Shared.vcxitems.filters

@@ -279,6 +279,9 @@
     </ClCompile>
     <ClCompile Include="$(MSBuildThisFileDirectory)..\Microsoft.ReactNative\Fabric\platform\react\renderer\components\view\HostPlatformViewProps.cpp" />
     <ClCompile Include="$(MSBuildThisFileDirectory)..\Microsoft.ReactNative\Fabric\platform\react\renderer\components\view\HostPlatformViewEventEmitter.cpp" />
+    <ClCompile Include="$(ReactNativeWindowsDir)Microsoft.ReactNative\Modules\PlatformConstantsWinModule.cpp" />
+    <ClCompile Include="$(ReactNativeWindowsDir)Microsoft.ReactNative\Modules\ExceptionsManager.cpp" />
+    <ClCompile Include="$(ReactNativeWindowsDir)Microsoft.ReactNative\Modules\SourceCode.cpp" />
   </ItemGroup>
   <ItemGroup>
     <Filter Include="Source Files">

package/package.json

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