react-native-windows 0.73.11 → 0.74.0-preview.1

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/ImageViewManagerModule.h

@@ -4,7 +4,6 @@
 #pragma once
 
 #include "codegen/NativeImageLoaderIOSSpec.g.h"
-#include <NativeImageLoaderIOSSpec.g.h>
 #include <NativeModules.h>
 #include <winrt/Windows.ApplicationModel.h>
 #include <winrt/Windows.Foundation.h>
@@ -17,33 +16,35 @@ struct ImageLoader {
   using ModuleSpec = ReactNativeSpecs::ImageLoaderIOSSpec;
 
   REACT_INIT(Initialize)
-  void Initialize(React::ReactContext const &reactContext) noexcept;
+  void Initialize(winrt::Microsoft::ReactNative::ReactContext const &reactContext) noexcept;
 
   REACT_METHOD(getSize)
-  void getSize(std::string uri, React::ReactPromise<std::vector<double>> &&result) noexcept;
+  void getSize(std::string uri, winrt::Microsoft::ReactNative::ReactPromise<std::vector<double>> &&result) noexcept;
 
   REACT_METHOD(getSizeWithHeaders)
   void getSizeWithHeaders(
       std::string uri,
-      React::JSValue &&headers,
-      React::ReactPromise<Microsoft::ReactNativeSpecs::ImageLoaderIOSSpec_getSizeWithHeaders_returnType>
-          &&result) noexcept;
+      winrt::Microsoft::ReactNative::JSValue &&headers,
+      winrt::Microsoft::ReactNative::ReactPromise<
+          Microsoft::ReactNativeSpecs::ImageLoaderIOSSpec_getSizeWithHeaders_returnType> &&result) noexcept;
 
   REACT_METHOD(prefetchImage)
-  void prefetchImage(std::string uri, React::ReactPromise<bool> &&result) noexcept;
+  void prefetchImage(std::string uri, winrt::Microsoft::ReactNative::ReactPromise<bool> &&result) noexcept;
 
   REACT_METHOD(prefetchImageWithMetadata)
   void prefetchImageWithMetadata(
       std::string uri,
       std::string queryRootName,
       double rootTag,
-      React::ReactPromise<bool> &&result) noexcept;
+      winrt::Microsoft::ReactNative::ReactPromise<bool> &&result) noexcept;
 
   REACT_METHOD(queryCache)
-  void queryCache(std::vector<std::string> const &uris, React::ReactPromise<React::JSValue> &&result) noexcept;
+  void queryCache(
+      std::vector<std::string> const &uris,
+      winrt::Microsoft::ReactNative::ReactPromise<winrt::Microsoft::ReactNative::JSValue> &&result) noexcept;
 
  private:
-  React::ReactContext m_context;
+  winrt::Microsoft::ReactNative::ReactContext m_context;
 };
 
 } // namespace Microsoft::ReactNative

package/Microsoft.ReactNative/Modules/LinkingManagerModule.h

@@ -19,16 +19,18 @@ struct LinkingManager {
   using ModuleSpec = ReactNativeSpecs::LinkingManagerSpec;
 
   REACT_INIT(Initialize)
-  void Initialize(React::ReactContext const &reactContext) noexcept;
+  void Initialize(winrt::Microsoft::ReactNative::ReactContext const &reactContext) noexcept;
 
   REACT_METHOD(canOpenURL)
-  static winrt::fire_and_forget canOpenURL(std::wstring url, ::React::ReactPromise<bool> result) noexcept;
+  static winrt::fire_and_forget canOpenURL(
+      std::wstring url,
+      winrt::Microsoft::ReactNative::ReactPromise<bool> result) noexcept;
 
   REACT_METHOD(openURL)
-  void openURL(std::wstring &&url, ::React::ReactPromise<void> &&result) noexcept;
+  void openURL(std::wstring &&url, winrt::Microsoft::ReactNative::ReactPromise<void> &&result) noexcept;
 
   REACT_METHOD(openSettings)
-  static void openSettings(::React::ReactPromise<void> &&result) noexcept;
+  static void openSettings(winrt::Microsoft::ReactNative::ReactPromise<void> &&result) noexcept;
 
   REACT_METHOD(addListener)
   static void addListener(std::string eventName) noexcept;
@@ -37,7 +39,7 @@ struct LinkingManager {
   static void removeListeners(double count) noexcept;
 
   REACT_METHOD(getInitialURL)
-  static void getInitialURL(::React::ReactPromise<std::string> &&result) noexcept;
+  static void getInitialURL(winrt::Microsoft::ReactNative::ReactPromise<std::string> &&result) noexcept;
 
   static void OpenUri(winrt::Windows::Foundation::Uri const &uri) noexcept;
 
@@ -45,7 +47,7 @@ struct LinkingManager {
   void HandleOpenUri(winrt::hstring const &uri) noexcept;
 
   static std::mutex s_mutex;
-  React::ReactContext m_context;
+  winrt::Microsoft::ReactNative::ReactContext m_context;
   static winrt::Windows::Foundation::Uri s_initialUri;
   static std::vector<LinkingManager *> s_linkingModules;
 };

package/Microsoft.ReactNative/Modules/LogBoxModule.h

@@ -15,7 +15,7 @@ struct LogBox : public std::enable_shared_from_this<LogBox> {
   using ModuleSpec = ReactNativeSpecs::LogBoxSpec;
 
   REACT_INIT(Initialize)
-  void Initialize(React::ReactContext const &reactContext) noexcept;
+  void Initialize(winrt::Microsoft::ReactNative::ReactContext const &reactContext) noexcept;
 
   REACT_METHOD(Show, L"show") void Show() noexcept;
   REACT_METHOD(Hide, L"hide") void Hide() noexcept;
@@ -27,12 +27,12 @@ struct LogBox : public std::enable_shared_from_this<LogBox> {
   void ShowOnUIThread() noexcept;
   void HideOnUIThread() noexcept;
 
-  React::ReactContext m_context;
+  winrt::Microsoft::ReactNative::ReactContext m_context;
 #ifdef USE_FABRIC
   HWND m_hwnd{nullptr};
 #endif // USE_FABRIC
   xaml::Controls::Primitives::Popup m_popup{nullptr};
-  React::ReactRootView m_logBoxContent{nullptr};
+  winrt::Microsoft::ReactNative::ReactRootView m_logBoxContent{nullptr};
   xaml::FrameworkElement::SizeChanged_revoker m_sizeChangedRevoker;
   winrt::event_token m_tokenClosed;
 };

package/Microsoft.ReactNative/Modules/NativeUIManager.cpp

@@ -163,7 +163,7 @@ NativeUIManager::NativeUIManager(winrt::Microsoft::ReactNative::ReactContext con
   // To Debug Yoga layout, uncomment the following line.
   // YGConfigSetPrintTreeFlag(m_yogaConfig, true);
 
-  // Additional logging can be enabled editing yoga.cpp (e.g. gPrintChanges,
+  // Additional logging can be enabled editing CalculateLayout.cpp (e.g. gPrintChanges,
   // gPrintSkips)
 #endif
 }
@@ -999,34 +999,11 @@ void NativeUIManager::measure(
     return;
   }
 
-  // Traverse up the react node tree to find any windowed popups.
-  // If there are none, then we use the top-level root provided by our caller.
-  xaml::FrameworkElement feRootView = nullptr;
-  int64_t rootTag = shadowNode.m_tag;
-  int64_t childTag = rootTag;
-  while (true) {
-    auto &currNode = m_host->GetShadowNodeForTag(rootTag);
-    if (currNode.m_parent == InvalidTag)
-      break;
-    ShadowNodeBase &rootNode = static_cast<ShadowNodeBase &>(currNode);
-    if (rootNode.IsWindowed()) {
-      ShadowNodeBase &childNode = static_cast<ShadowNodeBase &>(m_host->GetShadowNodeForTag(childTag));
-      feRootView = childNode.GetView().try_as<xaml::FrameworkElement>();
-      break;
-    }
-    childTag = currNode.m_tag;
-    rootTag = currNode.m_parent;
-  }
-
+  // Retrieve the XAML element for the root view containing this view
+  auto feRootView = static_cast<ShadowNodeBase &>(shadowRoot).GetView().try_as<xaml::FrameworkElement>();
   if (feRootView == nullptr) {
-    // Retrieve the XAML element for the root view containing this view
-    if (auto xamlRootView = static_cast<ShadowNodeBase &>(shadowRoot).GetView()) {
-      feRootView = xamlRootView.as<xaml::FrameworkElement>();
-    }
-    if (feRootView == nullptr) {
-      m_context.JSDispatcher().Post([callback = std::move(callback)]() { callback(0, 0, 0, 0, 0, 0); });
-      return;
-    }
+    m_context.JSDispatcher().Post([callback = std::move(callback)]() { callback(0, 0, 0, 0, 0, 0); });
+    return;
   }
 
   winrt::Rect rectInParentCoords = GetRectOfElementInParentCoords(feView, feRootView);

package/Microsoft.ReactNative/Modules/NativeUIManager.h

@@ -8,7 +8,7 @@
 #include <Views/ViewManagerBase.h>
 
 #include <folly/dynamic.h>
-#include <yoga/yoga.h>
+#include <yoga/Yoga.h>
 
 #include <ReactHost/React.h>
 #include <ReactRootView.h>

package/Microsoft.ReactNative/Modules/PaperUIManagerModule.cpp

@@ -11,6 +11,7 @@
 #include <Views/ViewManager.h>
 #include <XamlUtils.h>
 #include <cxxreact/SystraceSection.h>
+#include <glog/logging.h>
 #include "ShadowNodeBase.h"
 #include "Unicode.h"
 #include "XamlUIService.h"
@@ -110,8 +111,11 @@ class UIManagerModule : public std::enable_shared_from_this<UIManagerModule>, pu
     m_nativeUIManager->setHost(this);
   }
 
-  React::JSValueObject getConstantsForViewManager(std::string &&viewManagerName) noexcept {
+  React::JSValue getConstantsForViewManager(std::string &&viewManagerName) noexcept {
     const IViewManager *vm = GetViewManager(viewManagerName);
+    if (vm == nullptr) {
+      return {};
+    }
 
     auto writer = winrt::Microsoft::ReactNative::MakeJSValueTreeWriter();
     writer.WriteObjectBegin();
@@ -542,11 +546,11 @@ void UIManager::Initialize(winrt::Microsoft::ReactNative::ReactContext const &re
   m_module->Initialize(reactContext);
 }
 
-React::JSValueObject UIManager::getConstantsForViewManager(std::string viewManagerName) noexcept {
+React::JSValue UIManager::getConstantsForViewManager(std::string viewManagerName) noexcept {
   return m_module->getConstantsForViewManager(std::move(viewManagerName));
 }
 
-React::JSValueObject UIManager::getViewManagerConfig(std::string viewManagerName) noexcept {
+React::JSValue UIManager::getViewManagerConfig(std::string viewManagerName) noexcept {
   return getConstantsForViewManager(std::move(viewManagerName));
 }
 
@@ -561,8 +565,7 @@ React::JSValueArray UIManager::getDefaultEventTypes() noexcept {
   return {};
 }
 
-React::JSValueObject UIManager::lazilyLoadView(std::string name) noexcept {
-  assert(false);
+React::JSValue UIManager::lazilyLoadView(std::string name) noexcept {
   // TODO
   return {};
 }

package/Microsoft.ReactNative/Modules/PaperUIManagerModule.h

@@ -54,17 +54,17 @@ struct UIManager final {
   void ConstantsViaConstantsProvider(winrt::Microsoft::ReactNative::ReactConstantProvider &constants) noexcept;
 
   REACT_SYNC_METHOD(getConstantsForViewManager)
-  winrt::Microsoft::ReactNative::JSValueObject getConstantsForViewManager(std::string viewManagerName) noexcept;
+  winrt::Microsoft::ReactNative::JSValue getConstantsForViewManager(std::string viewManagerName) noexcept;
 
   // Not part of the spec, but core polyfils this on the JS side.
   REACT_SYNC_METHOD(getViewManagerConfig)
-  winrt::Microsoft::ReactNative::JSValueObject getViewManagerConfig(std::string viewManagerName) noexcept;
+  winrt::Microsoft::ReactNative::JSValue getViewManagerConfig(std::string viewManagerName) noexcept;
 
   REACT_SYNC_METHOD(getDefaultEventTypes)
   winrt::Microsoft::ReactNative::JSValueArray getDefaultEventTypes() noexcept;
 
   REACT_SYNC_METHOD(lazilyLoadView)
-  winrt::Microsoft::ReactNative::JSValueObject lazilyLoadView(std::string name) noexcept;
+  winrt::Microsoft::ReactNative::JSValue lazilyLoadView(std::string name) noexcept;
 
   REACT_METHOD(createView)
   void createView(

package/Microsoft.ReactNative/Modules/PlatformConstantsWinModule.cpp

@@ -0,0 +1,49 @@
+// 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 version information for react-native-windows -- which is independent of
+  // the version of react-native we are built from
+  constants.reactNativeWindowsVersion.major = RNW_MAJOR;
+  constants.reactNativeWindowsVersion.minor = RNW_MINOR;
+  constants.reactNativeWindowsVersion.patch = RNW_PATCH;
+
+  // 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