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

package/Microsoft.ReactNative/ReactHost/ReactInstanceWin.h

@@ -3,6 +3,8 @@
 
 #pragma once
 
+#include <JSI/ScriptStore.h>
+#include <tuple>
 #include "IReactDispatcher.h"
 #include "IReactInstanceInternal.h"
 #include "MsoReactContext.h"
@@ -16,7 +18,9 @@
 #include <Views/ExpressionAnimationStore.h>
 #endif
 
-#include <tuple>
+#ifdef USE_FABRIC
+#include <react/runtime/ReactInstance.h>
+#endif
 
 namespace winrt::Microsoft::ReactNative {
 class NativeModulesProvider;
@@ -95,6 +99,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;
@@ -105,9 +110,25 @@ class ReactInstanceWin final : public Mso::ActiveObject<IReactInstanceInternal>
   void InitJSMessageThread() noexcept;
   void InitNativeMessageThread() noexcept;
   void InitUIMessageThread() noexcept;
+  void SetupHMRClient() noexcept;
 #ifndef CORE_ABI
   void InitUIManager() noexcept;
 #endif
+
+#ifdef USE_FABRIC
+  void InitializeBridgeless() noexcept;
+  void LoadJSBundlesBridgeless(std::shared_ptr<facebook::react::DevSettings> devSettings) noexcept;
+#endif
+
+  void InitializeWithBridge() noexcept;
+  void InitUIQueue() noexcept;
+  void InitDevMenu() noexcept;
+  void InitUIDependentCalls() noexcept;
+  void FireInstanceCreatedCallback() noexcept;
+
+  std::shared_ptr<facebook::react::DevSettings> CreateDevSettings() noexcept;
+  std::unique_ptr<facebook::jsi::PreparedScriptStore> CreateHermesPreparedScriptStore() noexcept;
+
   std::string GetBytecodeFileName() noexcept;
   std::function<void()> GetLiveReloadCallback() noexcept;
   std::function<void(std::string)> GetErrorCallback() noexcept;
@@ -115,9 +136,13 @@ class ReactInstanceWin final : public Mso::ActiveObject<IReactInstanceInternal>
   std::shared_ptr<Mso::React::IRedBoxHandler> GetRedBoxHandler() noexcept;
   std::function<void()> GetWaitingForDebuggerCallback() noexcept;
   std::function<void()> GetDebuggerAttachCallback() noexcept;
+  bool IsBridgeless() noexcept;
 
   void OnError(const Mso::ErrorCode &errorcode) noexcept;
   void OnErrorWithMessage(const std::string &errorMessage) noexcept;
+#ifdef USE_FABRIC
+  void OnJSError(facebook::react::MapBuffer errorMap) noexcept;
+#endif
   void OnLiveReload() noexcept;
   void OnWaitingForDebugger() noexcept;
   void OnDebuggerAttach() noexcept;
@@ -136,8 +161,6 @@ class ReactInstanceWin final : public Mso::ActiveObject<IReactInstanceInternal>
     folly::dynamic Args;
   };
 
-  static std::string getApplicationTempFolder();
-
  private: // immutable fields
   const Mso::WeakPtr<IReactHost> m_weakReactHost;
   const ReactOptions m_options;
@@ -162,8 +185,8 @@ class ReactInstanceWin final : public Mso::ActiveObject<IReactInstanceInternal>
  private: // fields controlled by mutex
   mutable std::mutex m_mutex;
 
+  // !Bridgeless
   const Mso::ActiveReadableField<Mso::DispatchQueue> m_jsDispatchQueue{Queue(), m_mutex};
-
   const Mso::ActiveReadableField<std::shared_ptr<facebook::react::MessageQueueThread>> m_jsMessageThread{
       Queue(),
       m_mutex};
@@ -173,19 +196,23 @@ class ReactInstanceWin final : public Mso::ActiveObject<IReactInstanceInternal>
   const Mso::ActiveReadableField<std::shared_ptr<facebook::react::MessageQueueThread>> m_uiMessageThread{
       Queue(),
       m_mutex};
-
   const Mso::ActiveReadableField<std::shared_ptr<facebook::react::InstanceWrapper>> m_instanceWrapper{Queue(), m_mutex};
   const Mso::ActiveReadableField<std::shared_ptr<facebook::react::Instance>> m_instance{Queue(), m_mutex};
+  std::deque<JSCallEntry> m_jsCallQueue;
+  winrt::Microsoft::ReactNative::JsiRuntime m_jsiRuntime{nullptr};
+  std::shared_ptr<Microsoft::JSI::RuntimeHolderLazyInit> m_jsiRuntimeHolder;
+
+#ifdef USE_FABRIC
+  // Bridgeless
+  std::unique_ptr<facebook::react::ReactInstance> m_bridgelessReactInstance;
+#endif
+
   std::atomic<ReactInstanceState> m_state{ReactInstanceState::Loading};
 
   std::shared_ptr<facebook::react::MessageQueueThread> m_batchingUIThread;
 
   std::shared_ptr<IRedBoxHandler> m_redboxHandler;
   Mso::CntPtr<Mso::React::IDispatchQueue2> m_uiQueue;
-  std::deque<JSCallEntry> m_jsCallQueue;
-
-  std::shared_ptr<Microsoft::JSI::RuntimeHolderLazyInit> m_jsiRuntimeHolder;
-  winrt::Microsoft::ReactNative::JsiRuntime m_jsiRuntime{nullptr};
 
   static std::mutex s_registryMutex; // protects access to s_instanceRegistry
   static std::vector<ReactInstanceWin *> s_instanceRegistry;

package/Microsoft.ReactNative/ReactInstanceSettings.idl

@@ -119,6 +119,9 @@ namespace Microsoft.ReactNative
       "Controls whether the instance JavaScript runs in a remote environment such as within a browser.\n"
       "By default, this is using a browser navigated to http://localhost:8081/debugger-ui served by Metro/Haul.\n"
       "Debugging will start as soon as the react native instance is loaded.")
+    [deprecated(
+      "Debugging should be done using DirectDebugging rather than WebDebugger.  Web debugging changes the app behavior "
+      "and will be removed in a future version.", deprecate, 1)]
     Boolean UseWebDebugger { get; set; };
 
     DOC_STRING(

package/Microsoft.ReactNative/ReactPointerEventArgs.cpp

@@ -39,6 +39,14 @@ void ReactPointerEventArgs::Target(winrt::IInspectable const &target) noexcept {
   m_target = target;
 }
 
+bool ReactPointerEventArgs::AllowUncaptured() const noexcept {
+  return m_allowUncaptured;
+}
+
+void ReactPointerEventArgs::AllowUncaptured(bool allowUncaptured) noexcept {
+  m_allowUncaptured = allowUncaptured;
+}
+
 ReactPointerEventArgs::ReactPointerEventArgs(
     PointerEventKind kind,
     xaml::Input::PointerRoutedEventArgs const &args) noexcept

package/Microsoft.ReactNative/ReactPointerEventArgs.h

@@ -16,6 +16,9 @@ struct ReactPointerEventArgs : ReactPointerEventArgsT<ReactPointerEventArgs> {
   winrt::IInspectable Target() const noexcept;
   void Target(winrt::IInspectable const &target) noexcept;
 
+  bool AllowUncaptured() const noexcept;
+  void AllowUncaptured(bool allowUncaptured) noexcept;
+
   // Internal use
   ReactPointerEventArgs(PointerEventKind kind, xaml::Input::PointerRoutedEventArgs const &args) noexcept;
 
@@ -23,6 +26,7 @@ struct ReactPointerEventArgs : ReactPointerEventArgsT<ReactPointerEventArgs> {
   PointerEventKind m_kind;
   xaml::Input::PointerRoutedEventArgs const &m_args;
   winrt::IInspectable m_target{nullptr};
+  bool m_allowUncaptured{false};
 };
 
 } // namespace winrt::Microsoft::ReactNative::implementation

package/Microsoft.ReactNative/ReactPointerEventArgs.idl

@@ -63,5 +63,17 @@ namespace Microsoft.ReactNative {
       get;
       set;
     };
+    DOC_STRING(
+      "Gets or sets a flag that allows the ReactRootView to handle pointer "
+      "events even when it does not capture the pointer. This is particularly "
+      "useful for view managers that seek to capture the pointer to handle "
+      "move events for a gesture (e.g., dragging), but conditionally may "
+      "allow the ReactRootView to emit events (e.g., if the "
+      "@PointerEventKind.End event is received before a drag threshold is hit."
+    )
+    Boolean AllowUncaptured {
+      get;
+      set;
+    };
   }
 } // namespace Microsoft.ReactNative

package/Microsoft.ReactNative/SchedulerSettings.cpp

@@ -48,4 +48,27 @@ facebook::react::RuntimeExecutor &GetRuntimeExecutor(
   return properties.Get(RuntimeExecutorProperty()).Value();
 }
 
+winrt::Microsoft::ReactNative::ReactPropertyId<
+    winrt::Microsoft::ReactNative::ReactNonAbiValue<std::shared_ptr<facebook::react::RuntimeScheduler>>>
+RuntimeSchedulerProperty() noexcept {
+  winrt::Microsoft::ReactNative::ReactPropertyId<
+      winrt::Microsoft::ReactNative::ReactNonAbiValue<std::shared_ptr<facebook::react::RuntimeScheduler>>>
+      propId{L"ReactNative", L"RuntimeScheduler"};
+  return propId;
+}
+
+void SetRuntimeScheduler(
+    winrt::Microsoft::ReactNative::ReactPropertyBag properties,
+    const std::shared_ptr<facebook::react::RuntimeScheduler> &runtimeScheduler) noexcept {
+  properties.Set(RuntimeSchedulerProperty(), runtimeScheduler);
+}
+
+std::shared_ptr<facebook::react::RuntimeScheduler> RuntimeSchedulerFromProperties(
+    winrt::Microsoft::ReactNative::ReactPropertyBag properties) noexcept {
+  auto runtimeScheduler = properties.Get(RuntimeSchedulerProperty());
+  if (!runtimeScheduler)
+    return nullptr;
+  return runtimeScheduler.Value();
+}
+
 } // namespace Microsoft::ReactNative::SchedulerSettings

package/Microsoft.ReactNative/SchedulerSettings.h

@@ -8,7 +8,8 @@
 
 namespace facebook::react {
 class MessageQueueThread;
-}
+class RuntimeScheduler;
+} // namespace facebook::react
 
 namespace Microsoft::ReactNative::SchedulerSettings {
 
@@ -24,4 +25,11 @@ void SetRuntimeExecutor(
 facebook::react::RuntimeExecutor &GetRuntimeExecutor(
     winrt::Microsoft::ReactNative::ReactPropertyBag properties) noexcept;
 
+void SetRuntimeScheduler(
+    winrt::Microsoft::ReactNative::ReactPropertyBag properties,
+    const std::shared_ptr<facebook::react::RuntimeScheduler> &runtimeScheduler) noexcept;
+
+std::shared_ptr<facebook::react::RuntimeScheduler> RuntimeSchedulerFromProperties(
+    winrt::Microsoft::ReactNative::ReactPropertyBag properties) noexcept;
+
 } // namespace Microsoft::ReactNative::SchedulerSettings

package/Microsoft.ReactNative/SynchronousEventBeat.cpp

@@ -0,0 +1,41 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#include "SynchronousEventBeat.h"
+
+namespace Microsoft::ReactNative {
+
+SynchronousEventBeat::SynchronousEventBeat(
+    facebook::react::EventBeat::SharedOwnerBox const &ownerBox,
+    const winrt::Microsoft::ReactNative::ReactContext &context,
+    facebook::react::RuntimeExecutor runtimeExecutor,
+    std::shared_ptr<facebook::react::RuntimeScheduler> runtimeScheduler)
+    : EventBeat(ownerBox),
+      m_context(context),
+      m_runtimeExecutor(runtimeExecutor),
+      m_runtimeScheduler(std::move(runtimeScheduler)) {}
+
+void SynchronousEventBeat::induce() const {
+  if (!isRequested_) {
+    return;
+  }
+
+  if (m_context.JSDispatcher().HasThreadAccess()) {
+    lockExecutorAndBeat();
+  }
+}
+
+void SynchronousEventBeat::lockExecutorAndBeat() const {
+  if (!this->isRequested_) {
+    return;
+  }
+
+  if (m_runtimeScheduler) {
+    m_runtimeScheduler->executeNowOnTheSameThread([this](facebook::jsi::Runtime &runtime) { beat(runtime); });
+  } else {
+    facebook::react::executeSynchronouslyOnSameThread_CAN_DEADLOCK(
+        m_runtimeExecutor, [this](facebook::jsi::Runtime &runtime) { beat(runtime); });
+  }
+}
+
+} // namespace Microsoft::ReactNative

package/Microsoft.ReactNative/SynchronousEventBeat.h

@@ -0,0 +1,29 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#include <NativeModules.h>
+#include <ReactCommon/RuntimeExecutor.h>
+#include <react/renderer/core/EventBeat.h>
+#include <react/renderer/runtimescheduler/RuntimeScheduler.h>
+
+namespace Microsoft::ReactNative {
+
+class SynchronousEventBeat final : public facebook::react::EventBeat {
+ public:
+  SynchronousEventBeat(
+      facebook::react::EventBeat::SharedOwnerBox const &ownerBox,
+      const winrt::Microsoft::ReactNative::ReactContext &context,
+      facebook::react::RuntimeExecutor runtimeExecutor,
+      std::shared_ptr<facebook::react::RuntimeScheduler> runtimeScheduler);
+
+  void induce() const override;
+
+  void lockExecutorAndBeat() const;
+
+ private:
+  winrt::Microsoft::ReactNative::ReactContext m_context;
+  facebook::react::RuntimeExecutor m_runtimeExecutor;
+  std::shared_ptr<facebook::react::RuntimeScheduler> m_runtimeScheduler;
+};
+
+} // namespace Microsoft::ReactNative

package/Microsoft.ReactNative/Theme.idl

@@ -0,0 +1,57 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#include "DocString.h"
+import "CompositionSwitcher.idl";
+import "IReactContext.idl";
+import "IReactPropertyBag.idl";
+import "ReactInstanceSettings.idl";
+
+namespace Microsoft.ReactNative.Composition
+{
+  [experimental]
+  [webhosthidden]
+  enum ResourceType {
+    DOC_STRING("Resource type for a @Windows.UI.Color")
+    Color
+  };
+
+  [webhosthidden]
+  [experimental]
+  runtimeclass CustomResourceResult {
+    Object Resource;
+    DOC_STRING("The value of this resource should resolve to the value of another ResourceId")
+    String AlternateResourceId;
+  };
+
+  [webhosthidden]
+  [experimental]
+  DOC_STRING("Applications can implement this interface to provide custom values for native platform colors.")
+  interface ICustomResourceLoader {
+    DOC_STRING("Called when a theme is queried for a specific resource. "
+    "resourceId will be the name of the platform color. "
+    "Implementations should return an empty result if the resource is not being overridden.")
+    void GetResource(String resourceId, ResourceType resourceType, CustomResourceResult result);
+
+    DOC_STRING("Implementations should raise this event if the platform colors will return new values")
+    event Windows.Foundation.EventHandler<Object> ResourcesChanged;
+  };
+
+  [webhosthidden]
+  [experimental]
+  runtimeclass Theme {
+    Theme(Microsoft.ReactNative.IReactContext reactContext, ICustomResourceLoader resourceLoader);
+
+    Microsoft.ReactNative.Composition.IBrush PlatformBrush(String platformColor);
+    Boolean TryGetPlatformColor(String platformColor, out Windows.UI.Color color);
+    DOC_STRING("An empty theme is used when the final theme is not yet known.  It will generally return transparent colors.")
+    Boolean IsEmpty { get; };
+
+    event Windows.Foundation.EventHandler<Object> ThemeChanged;
+
+    static Theme GetDefaultTheme(Microsoft.ReactNative.IReactContext context);
+    static void SetDefaultTheme(Microsoft.ReactNative.ReactInstanceSettings settings, Theme theme);
+    static Microsoft.ReactNative.IReactPropertyName ThemeChangedEventName { get; };
+  };
+
+} // namespace Microsoft.ReactNative

package/Microsoft.ReactNative/Timer.cpp

@@ -0,0 +1,63 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#include "pch.h"
+#include "Timer.h"
+#include "Timer.g.cpp"
+
+#include <CppWinRTIncludes.h>
+#include "ReactCoreInjection.h"
+
+namespace winrt::Microsoft::ReactNative::implementation {
+
+// Implementation of ITimer based on Windows' DispatcherQueue
+struct ReactTimer : winrt::implements<ReactTimer, ITimer> {
+  ReactTimer(const IReactPropertyBag &properties) {
+    const auto queue = winrt::dispatching::DispatcherQueue::GetForCurrentThread();
+    m_dispatcherQueueTimer = queue.CreateTimer();
+  }
+
+  winrt::Windows::Foundation::TimeSpan Interval() noexcept {
+    return m_dispatcherQueueTimer.Interval();
+  }
+
+  void Interval(winrt::Windows::Foundation::TimeSpan value) noexcept {
+    m_dispatcherQueueTimer.Interval(value);
+  }
+
+  void Start() noexcept {
+    return m_dispatcherQueueTimer.Start();
+  }
+
+  void Stop() noexcept {
+    return m_dispatcherQueueTimer.Stop();
+  }
+
+  winrt::event_token Tick(const winrt::Windows::Foundation::EventHandler<IInspectable> &handler) {
+    return m_dispatcherQueueTimer.Tick([handler](auto sender, auto args) { handler(sender, args); });
+  }
+
+  void Tick(winrt::event_token const &token) {
+    m_dispatcherQueueTimer.Tick(token);
+  }
+
+ private:
+  winrt::dispatching::DispatcherQueueTimer m_dispatcherQueueTimer{nullptr};
+};
+
+Timer::Timer() noexcept {}
+
+ITimer Timer::Create(const IReactPropertyBag &properties) {
+  auto dispatcher = properties.Get(ReactDispatcherHelper::UIDispatcherProperty()).try_as<IReactDispatcher>();
+  if (!dispatcher.HasThreadAccess()) {
+    throw winrt::hresult_wrong_thread();
+  }
+
+  if (auto customTimerFactory = implementation::ReactCoreInjection::GetTimerFactory(properties)) {
+    return customTimerFactory();
+  } else {
+    return winrt::make<ReactTimer>(properties);
+  }
+}
+
+} // namespace winrt::Microsoft::ReactNative::implementation

package/Microsoft.ReactNative/{CoreAppPage.h → Timer.h}

@@ -1,15 +1,22 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
+
 #pragma once
-#include "CoreAppPage.g.h"
-#include <UI.Xaml.Markup.h>
+
+#include "Timer.g.h"
+
+#include "winrt/Microsoft.ReactNative.h"
 
 namespace winrt::Microsoft::ReactNative::implementation {
-struct CoreAppPage : CoreAppPageT<CoreAppPage> {
-  CoreAppPage();
+
+struct Timer : TimerT<Timer> {
+  Timer() noexcept;
+
+  static ITimer Create(const IReactPropertyBag &properties);
 };
+
 } // namespace winrt::Microsoft::ReactNative::implementation
 
 namespace winrt::Microsoft::ReactNative::factory_implementation {
-struct CoreAppPage : CoreAppPageT<CoreAppPage, implementation::CoreAppPage> {};
+struct Timer : TimerT<Timer, implementation::Timer> {};
 } // namespace winrt::Microsoft::ReactNative::factory_implementation

package/Microsoft.ReactNative/Timer.idl

@@ -0,0 +1,34 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#include "DocString.h"
+import "IJSValueReader.idl";
+import "IJSValueWriter.idl";
+import "Theme.idl";
+
+namespace Microsoft.ReactNative {
+
+  [webhosthidden]
+  interface ITimer
+  {
+    Windows.Foundation.TimeSpan Interval;
+    void Start();
+    void Stop();
+
+    event Windows.Foundation.EventHandler<Object> Tick;
+  }
+
+  [default_interface]
+  [webhosthidden]
+  DOC_STRING(
+    "Used to create timers.")
+  runtimeclass Timer
+  {
+    DOC_STRING(
+      "Creates a UI timer.  Must be called on the UI thread.  Using this rather than "
+      "System/Windows.DispatcherQueue.CreateTimer works when applications have provided "
+      "custom Timer implementations using @ReactCoreInjection.SetTimerFactory")
+    static ITimer Create(IReactPropertyBag properties);
+  }
+
+} // namespace Microsoft.ReactNative

package/Microsoft.ReactNative/TurboModulesProvider.cpp

@@ -436,6 +436,10 @@ std::vector<std::string> TurboModulesProvider::getEagerInitModuleNames() noexcep
   if (it != m_moduleProviders.end()) {
     eagerModules.push_back("UIManager");
   }
+  it = m_moduleProviders.find("FabricUIManagerBinding");
+  if (it != m_moduleProviders.end()) {
+    eagerModules.push_back("FabricUIManagerBinding");
+  }
   return eagerModules;
 }
 

package/Microsoft.ReactNative/Utils/ImageUtils.cpp

@@ -23,13 +23,47 @@ winrt::IAsyncOperation<winrt::IRandomAccessStream> GetImageStreamAsync(ReactImag
   try {
     co_await winrt::resume_background();
 
-    auto httpMethod{
-        source.method.empty() ? winrt::HttpMethod::Get() : winrt::HttpMethod{winrt::to_hstring(source.method)}};
-
     winrt::Uri uri = UriTryCreate(winrt::to_hstring(source.uri));
     if (!uri) {
       co_return nullptr;
     }
+
+    bool isFile = (uri.SchemeName() == L"file");
+    bool isAppx = (uri.SchemeName() == L"ms-appx");
+
+    if (isFile || isAppx) {
+      winrt::Windows::Foundation::IAsyncOperation<winrt::Windows::Storage::StorageFile> getFileSync{nullptr};
+
+      if (isFile) {
+        getFileSync = winrt::Windows::Storage::StorageFile::GetFileFromPathAsync(uri.AbsoluteCanonicalUri());
+      } else {
+        getFileSync = winrt::Windows::Storage::StorageFile::GetFileFromApplicationUriAsync(uri);
+      }
+
+      co_await lessthrow_await_adapter<
+          winrt::Windows::Foundation::IAsyncOperation<winrt::Windows::Storage::StorageFile>>{getFileSync};
+
+      if (FAILED(getFileSync.ErrorCode())) {
+        co_return nullptr;
+      }
+
+      winrt::Windows::Storage::StorageFile file{getFileSync.GetResults()};
+
+      auto openReadAsync = file.OpenReadAsync();
+      co_await lessthrow_await_adapter<winrt::Windows::Foundation::IAsyncOperation<
+          winrt::Windows::Storage::Streams::IRandomAccessStreamWithContentType>>{openReadAsync};
+
+      if (FAILED(openReadAsync.ErrorCode())) {
+        co_return nullptr;
+      }
+
+      winrt::Windows::Storage::Streams::IRandomAccessStreamWithContentType stream{openReadAsync.GetResults()};
+      co_return stream;
+    }
+
+    auto httpMethod{
+        source.method.empty() ? winrt::HttpMethod::Get() : winrt::HttpMethod{winrt::to_hstring(source.method)}};
+
     winrt::HttpRequestMessage request{httpMethod, uri};
 
     if (!source.headers.empty()) {

package/Microsoft.ReactNative/Utils/ImageUtils.h

@@ -13,7 +13,6 @@ enum class ImageSourceFormat { Bitmap = 0, Svg = 1 };
 struct ReactImageSource {
   std::string uri;
   std::string method;
-  std::string bundleRootPath;
   std::vector<std::pair<std::string, std::string>> headers;
   double width = 0;
   double height = 0;

package/Microsoft.ReactNative/Utils/LocalBundleReader.cpp

@@ -15,8 +15,7 @@
 
 namespace Microsoft::ReactNative {
 
-std::string GetBundleFromEmbeddedResource(winrt::hstring str) {
-  winrt::Windows::Foundation::Uri uri(str);
+std::string GetBundleFromEmbeddedResource(const winrt::Windows::Foundation::Uri &uri) {
   auto moduleName = uri.Host();
   auto path = uri.Path();
   // skip past the leading / slash
@@ -54,21 +53,21 @@ std::string GetBundleFromEmbeddedResource(winrt::hstring str) {
   return std::string(start, start + size);
 }
 
-std::future<std::string> LocalBundleReader::LoadBundleAsync(const std::string &bundleUri) {
-  winrt::hstring str(Microsoft::Common::Unicode::Utf8ToUtf16(bundleUri));
-
+std::future<std::string> LocalBundleReader::LoadBundleAsync(const std::wstring bundleUri) {
   co_await winrt::resume_background();
 
   winrt::Windows::Storage::StorageFile file{nullptr};
 
   // Supports "ms-appx://" or "ms-appdata://"
-  if (bundleUri._Starts_with("ms-app")) {
-    winrt::Windows::Foundation::Uri uri(str);
+  // TODO: Replace call to private string function with C++ 20 `starts_with`
+  if (bundleUri._Starts_with(L"ms-app")) {
+    winrt::Windows::Foundation::Uri uri(bundleUri);
     file = co_await winrt::Windows::Storage::StorageFile::GetFileFromApplicationUriAsync(uri);
-  } else if (bundleUri._Starts_with("resource://")) {
-    co_return GetBundleFromEmbeddedResource(str);
+  } else if (bundleUri._Starts_with(L"resource://")) {
+    winrt::Windows::Foundation::Uri uri(bundleUri);
+    co_return GetBundleFromEmbeddedResource(uri);
   } else {
-    file = co_await winrt::Windows::Storage::StorageFile::GetFileFromPathAsync(str);
+    file = co_await winrt::Windows::Storage::StorageFile::GetFileFromPathAsync(bundleUri);
   }
 
   // Read the buffer manually to avoid a Utf8 -> Utf16 -> Utf8 encoding
@@ -90,11 +89,11 @@ std::future<std::string> LocalBundleReader::LoadBundleAsync(const std::string &b
   co_return script;
 }
 
-std::string LocalBundleReader::LoadBundle(const std::string &bundlePath) {
+std::string LocalBundleReader::LoadBundle(const std::wstring &bundlePath) {
   return LoadBundleAsync(bundlePath).get();
 }
 
-StorageFileBigString::StorageFileBigString(const std::string &path) {
+StorageFileBigString::StorageFileBigString(const std::wstring &path) {
   m_futureBuffer = LocalBundleReader::LoadBundleAsync(path);
 }
 

package/Microsoft.ReactNative/Utils/LocalBundleReader.h

@@ -10,13 +10,13 @@ namespace Microsoft::ReactNative {
 
 class LocalBundleReader {
  public:
-  static std::future<std::string> LoadBundleAsync(const std::string &bundlePath);
-  static std::string LoadBundle(const std::string &bundlePath);
+  static std::future<std::string> LoadBundleAsync(const std::wstring bundlePath);
+  static std::string LoadBundle(const std::wstring &bundlePath);
 };
 
 class StorageFileBigString : public facebook::react::JSBigString {
  public:
-  StorageFileBigString(const std::string &path);
+  StorageFileBigString(const std::wstring &path);
   bool isAscii() const override;
   const char *c_str() const override;
   size_t size() const override;

package/Microsoft.ReactNative/Utils/ThemeUtils.cpp

@@ -0,0 +1,33 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#include "pch.h"
+#include <Utils/ThemeUtils.h>
+
+#include <winuser.h>
+
+namespace Microsoft::ReactNative {
+
+bool IsColorLight(const winrt::Windows::UI::Color &clr) noexcept {
+  return (((5 * clr.G) + (2 * clr.R) + clr.B) > (8 * 128));
+}
+
+bool IsInHighContrastWin32() noexcept {
+  BOOL fResult;
+  HIGHCONTRAST info;
+
+  fResult = SystemParametersInfo(
+      SPI_GETHIGHCONTRAST, // Get contrast information
+      0, // Not used
+      &info, // Holds contrast information
+      0); // Not used
+
+  // Double it.
+  if (fResult) {
+    return !!(info.dwFlags & HCF_HIGHCONTRASTON);
+  }
+
+  return false;
+}
+
+} // namespace Microsoft::ReactNative