react-native-windows 0.81.1 → 0.82.0-preview.1

package/Microsoft.ReactNative/RedBox.cpp

@@ -16,22 +16,14 @@
 
 #ifndef CORE_ABI
 
-#ifdef USE_FABRIC
 #include <ReactCoreInjection.h>
 #include <Shobjidl.h>
 #include <Utils/Helpers.h>
-#include <winrt/Windows.UI.Popups.h>
-#endif // USE_FABRIC
-#include <UI.Xaml.Controls.Primitives.h>
-#include <UI.Xaml.Controls.h>
-#include <UI.Xaml.Documents.h>
-#include <UI.Xaml.Input.h>
-#include <UI.Xaml.Markup.h>
-#include <UI.Xaml.Media.h>
 #include <winrt/Windows.ApplicationModel.Core.h>
 #include <winrt/Windows.Data.Json.h>
 #include <winrt/Windows.System.h>
 #include <winrt/Windows.UI.Core.h>
+#include <winrt/Windows.UI.Popups.h>
 #include <winrt/Windows.Web.Http.h>
 #include "CppWinRTIncludes.h"
 #include "Utils/Helpers.h"
@@ -56,28 +48,17 @@ struct RedBox : public std::enable_shared_from_this<RedBox> {
         m_onClosedCallback(std::move(onClosedCallback)),
         m_errorInfo(std::move(errorInfo)) {}
 
-  void Dismiss() noexcept {
-    if (m_popup) {
-      m_popup.IsOpen(false);
-    }
-  }
-
   void Reload() noexcept {
     if (auto reactHost = m_weakReactHost.GetStrongPtr()) {
       reactHost->ReloadInstance();
     }
   }
 
-  void WindowSizeChanged(winrt::Windows::UI::Core::WindowSizeChangedEventArgs const &args) noexcept {
-    if (m_redboxContent) {
-      m_redboxContent.MaxHeight(args.Size().Height);
-      m_redboxContent.Height(args.Size().Height);
-      m_redboxContent.MaxWidth(args.Size().Width);
-      m_redboxContent.Width(args.Size().Width);
-    }
+  void Dismiss() noexcept {
+    if (m_dialogAsync)
+      m_dialogAsync.Cancel();
   }
 
-#ifdef USE_FABRIC
   void ShowNewJsErrorUsingMessageDialog() noexcept {
     // Using MessageDialog is "easy", but it does mean we cannot update the message when symbols are resolved.
     // Ideally we'd have a dialog we could push UI updates to. -- Maybe we could load XAML and host the XAML dialog?
@@ -123,144 +104,24 @@ struct RedBox : public std::enable_shared_from_this<RedBox> {
         winrt::Microsoft::ReactNative::implementation::ReactCoreInjection::GetTopLevelWindowId(m_propBag.Handle()));
     auto initializeWithWindow{msg.as<::IInitializeWithWindow>()};
     initializeWithWindow->Initialize(hwnd);
-    msg.Commands().Append(
-        winrt::Windows::UI::Popups::UICommand(L"Dismiss", [](winrt::Windows::UI::Popups::IUICommand const &command){}));
+    msg.Commands().Append(winrt::Windows::UI::Popups::UICommand(
+        L"Dismiss", [](winrt::Windows::UI::Popups::IUICommand const &command) {}));
     msg.Commands().Append(winrt::Windows::UI::Popups::UICommand(
         L"Reload", [wkHost = m_weakReactHost](winrt::Windows::UI::Popups::IUICommand const &command) {
           if (auto reactHost = wkHost.GetStrongPtr()) {
             reactHost->ReloadInstance();
           }
         }));
-    msg.ShowAsync();
-  }
-#endif USE_FABRIC
-
-  void ShowNewJSErrorUsingXaml() noexcept {
-    m_popup = xaml::Controls::Primitives::Popup{};
-
-    const winrt::hstring xamlString =
-        LR"(
-        <Grid Background='#1A1A1A'
-          xmlns='http://schemas.microsoft.com/winfx/2006/xaml/presentation'
-          xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml'
-          RequestedTheme='Dark'>
-          <Grid.ColumnDefinitions>
-            <ColumnDefinition Width='*'/>
-            <ColumnDefinition Width='*'/>
-          </Grid.ColumnDefinitions>
-          <Grid.RowDefinitions>
-            <RowDefinition Height='*'/>
-            <RowDefinition Height='Auto'/>
-          </Grid.RowDefinitions>
-          <ScrollViewer Grid.Row='0' Grid.ColumnSpan='2' HorizontalAlignment='Stretch'>
-            <StackPanel HorizontalAlignment='Stretch'>
-              <StackPanel Background='#D01926' HorizontalAlignment='Stretch' Padding='15,35,15,15' x:Name='StackPanelUpper'>
-                <TextBlock x:Name='ErrorMessageText' FontSize='14' Foreground='White' IsTextSelectionEnabled='true' TextWrapping='Wrap'/>
-                <Border Padding='15,15,15,0'/>
-                <TextBlock x:Name='ErrorStackText' FontSize='12' FontFamily='Consolas' Foreground='White' IsTextSelectionEnabled='true' TextWrapping='Wrap'/>
-              </StackPanel>
-              <StackPanel HorizontalAlignment='Stretch' x:Name='StackPanel' Margin='15' />
-            </StackPanel>
-          </ScrollViewer>
-          <Button x:Name='DismissButton' Grid.Row='1' Grid.Column='0' HorizontalAlignment='Stretch' Margin='15' Style='{StaticResource ButtonRevealStyle}'>Dismiss</Button>
-          <Button x:Name='ReloadButton' Grid.Row='1' Grid.Column='2' HorizontalAlignment='Stretch' Margin='15' Style='{StaticResource ButtonRevealStyle}'>Reload</Button>
-        </Grid>)";
-
-    m_redboxContent = winrt::unbox_value<xaml::Controls::Grid>(xaml::Markup::XamlReader::Load(xamlString));
-    m_errorMessageText = m_redboxContent.FindName(L"ErrorMessageText").as<xaml::Controls::TextBlock>();
-    m_errorStackText = m_redboxContent.FindName(L"ErrorStackText").as<xaml::Controls::TextBlock>();
-    m_stackPanel = m_redboxContent.FindName(L"StackPanel").as<xaml::Controls::StackPanel>();
-    m_stackPanelUpper = m_redboxContent.FindName(L"StackPanelUpper").as<xaml::Controls::StackPanel>();
-    m_dismissButton = m_redboxContent.FindName(L"DismissButton").as<xaml::Controls::Button>();
-    m_reloadButton = m_redboxContent.FindName(L"ReloadButton").as<xaml::Controls::Button>();
-
-    m_tokenDismiss = m_dismissButton.Click(
-        [&](IInspectable const & /*sender*/, xaml::RoutedEventArgs const & /*args*/) noexcept { Dismiss(); });
-
-    m_tokenReload = m_reloadButton.Click([&](auto const & /*sender*/, xaml::RoutedEventArgs const & /*args*/) noexcept {
-      Dismiss();
-      Reload();
-    });
-
-    PopulateFrameStackUI();
-    UpdateErrorMessageUI();
-
-    xaml::FrameworkElement root{nullptr};
-
-    if (Microsoft::ReactNative::Is19H1OrHigher()) {
-      // XamlRoot added in 19H1
-      if (auto reactHost = m_weakReactHost.GetStrongPtr()) {
-        if (auto xamlRoot =
-                winrt::Microsoft::ReactNative::XamlUIService::GetXamlRoot(reactHost->Options().Properties)) {
-          m_popup.XamlRoot(xamlRoot);
-          root = xamlRoot.Content().as<xaml::FrameworkElement>();
-        }
-      }
-    }
-
-    if (!root) {
-      if (auto window = xaml::Window::Current()) {
-        root = window.Content().as<xaml::FrameworkElement>();
-      }
-    }
-
-    if (root) {
-      m_redboxContent.MaxHeight(root.ActualHeight());
-      m_redboxContent.Height(root.ActualHeight());
-      m_redboxContent.MaxWidth(root.ActualWidth());
-      m_redboxContent.Width(root.ActualWidth());
-
-      m_sizeChangedRevoker = root.SizeChanged(
-          winrt::auto_revoke,
-          [wkThis = weak_from_this()](auto const & /*sender*/, xaml::SizeChangedEventArgs const &args) {
-            if (auto strongThis = wkThis.lock()) {
-              strongThis->m_redboxContent.MaxHeight(args.NewSize().Height);
-              strongThis->m_redboxContent.Height(args.NewSize().Height);
-              strongThis->m_redboxContent.MaxWidth(args.NewSize().Width);
-              strongThis->m_redboxContent.Width(args.NewSize().Width);
-            }
-          });
-    }
-
-    m_tokenClosed = m_popup.Closed(
-        [wkThis = std::weak_ptr(shared_from_this())](auto const & /*sender*/, IInspectable const & /*args*/) noexcept {
-          if (auto pthis = wkThis.lock()) {
-            pthis->OnPopupClosed();
-          }
-        });
-
-    m_popup.Child(m_redboxContent);
-    m_popup.IsOpen(true);
+    m_dialogAsync = msg.ShowAsync();
   }
 
   void ShowNewJSError() noexcept {
     m_showing = true;
-
-#ifdef USE_FABRIC
-    if (Microsoft::ReactNative::IsFabricEnabled(m_propBag.Handle())) {
-      ShowNewJsErrorUsingMessageDialog();
-    } else
-#endif // USE_FABRIC
-    {
-      ShowNewJSErrorUsingXaml();
-    }
+    ShowNewJsErrorUsingMessageDialog();
   }
 
   void UpdateError(const ErrorInfo &&info) noexcept {
     m_errorInfo = std::move(info);
-    if (m_showing) {
-      PopulateFrameStackUI();
-    }
-  }
-
-  void OnPopupClosed() noexcept {
-    m_showing = false;
-    m_dismissButton.Click(m_tokenDismiss);
-    m_reloadButton.Click(m_tokenReload);
-    m_sizeChangedRevoker.revoke();
-    m_popup.Closed(m_tokenClosed);
-    m_redboxContent = nullptr;
-    m_onClosedCallback(GetId());
   }
 
   uint32_t GetId() const noexcept {
@@ -268,221 +129,7 @@ struct RedBox : public std::enable_shared_from_this<RedBox> {
   }
 
  private:
-  static bool IsMetroBundlerError(const std::string &message, const std::string &type) {
-    // This string must be kept in sync with the one in formatBundlingError in
-    // node_modules\metro\src\lib\formatBundlingError.js
-    if (message.find_first_of("Metro Bundler has encountered an error") != message.npos) {
-      return true;
-    }
-    return false;
-  }
-
-#define METRO_TROUBLESHOOTING_URL "http://aka.ms/RNWTroubleshootMetro"
-#define _MAKE_WIDE_STR(x) L##x
-#define MAKE_WIDE_STR(x) _MAKE_WIDE_STR(x)
-
-  void CreateWebView(xaml::Controls::Panel parent, const winrt::hstring &content) {
-#ifndef USE_WINUI3
-    xaml::Controls::WebView webView;
-#else
-    xaml::Controls::WebView2 webView;
-#endif
-
-    webView.HorizontalAlignment(xaml::HorizontalAlignment::Stretch);
-    webView.VerticalAlignment(xaml::VerticalAlignment::Stretch);
-    webView.MinWidth(400);
-    auto dispatcher = winrt::dispatching::DispatcherQueue::GetForCurrentThread();
-    // XAML doesn't currently provide a way to measure a WebView control,
-    // So we're going to tell the WebView to measure itself by running some javascript,
-    // and then we'll post a task back to XAML to set the XAML WebView minimum height.
-    // The HTML we get from Metro doesn't have any styling, so we'll take advantage of
-    // the fact that we're running javascript in the WebView, to set the
-    // foreground/background to match the rest of the RedBox.
-    // setProperty returns undefined so we continue the first expression with a comma
-    // whereas the height expression gets executed because of the ||
-    // (since the setProperty calls resulted in undefined).
-    // Finally, it's important to note that JS expressions of that are not of string type
-    // need to be manually converted to string for them to get marshaled properly back here.
-    webView.NavigationCompleted([=](IInspectable const &, auto const &) {
-      std::wstring jsExpression =
-          L"(document.body.style.setProperty('color', 'white'), "
-          L"document.body.style.setProperty('background', '#d01926')) "
-          L"|| document.documentElement.scrollHeight.toString()";
-
-#ifndef USE_WINUI3
-      auto async = webView.InvokeScriptAsync(L"eval", std::vector<winrt::hstring>{winrt::hstring { jsExpression }});
-#else
-      auto async = webView.ExecuteScriptAsync(std::wstring(L"eval(") + jsExpression + L")");
-#endif
-
-      async.Completed([=](IAsyncOperation<winrt::hstring> const &op, auto &&) {
-        auto result = op.GetResults();
-        int documentHeight = _wtoi(result.c_str());
-        dispatcher.TryEnqueue([=]() {
-          // Ensure the webview has a min height of the content it wants to show,
-          // and that the horizontal scrollbar that might exist, doesn't occlude the webview.
-          constexpr int horizontalScrollbarHeight = 12;
-          webView.MinHeight(documentHeight + horizontalScrollbarHeight);
-        });
-      });
-    });
-
-    m_stackPanel.Children().Clear();
-    m_stackPanel.Children().Append(webView);
-#ifdef USE_WINUI3
-    webView.EnsureCoreWebView2Async().Completed(
-        [content, webView](auto &&sender, auto &&args) { webView.NavigateToString(content); });
-#else
-    webView.NavigateToString(content);
-#endif
-  }
-
-  void UpdateErrorMessageUI() noexcept {
-    const std::regex colorsRegex(
-        "\\x1b\\[[0-9;]*m"); // strip out console colors which is often added to JS error messages
-    const std::string plain = std::regex_replace(m_errorInfo.Message, colorsRegex, "");
-
-    if (!plain.empty() && plain[0] == '{') {
-      try {
-        auto json = folly::parseJson(plain);
-        if (json.count("type") && json["type"] == "InternalError") {
-          auto message = json["message"].asString();
-          m_errorMessageText.Text(Microsoft::Common::Unicode::Utf8ToUtf16(message));
-
-          if (IsMetroBundlerError(message, json["type"].asString())) {
-            xaml::Documents::Hyperlink link;
-            link.NavigateUri(Uri(MAKE_WIDE_STR(METRO_TROUBLESHOOTING_URL)));
-            xaml::Documents::Run linkRun;
-
-            linkRun.Text(Microsoft::Common::Unicode::Utf8ToUtf16(METRO_TROUBLESHOOTING_URL));
-            link.Foreground(xaml::Media::SolidColorBrush(xaml::FromArgb(0xff, 0xff, 0xff, 0xff)));
-            link.Inlines().Append(linkRun);
-            xaml::Documents::Run normalRun;
-            normalRun.Text(Microsoft::Common::Unicode::Utf8ToUtf16(json["type"].asString() + (" ─ See ")));
-            m_errorStackText.Inlines().Append(normalRun);
-            m_errorStackText.Inlines().Append(link);
-          } else {
-            m_errorStackText.Text(Microsoft::Common::Unicode::Utf8ToUtf16(json["type"].asString()));
-          }
-          return;
-        } else if (json.count("name") && boost::ends_with(json["name"].asString(), "Error")) {
-          auto message = std::regex_replace(json["message"].asString(), colorsRegex, "");
-          const auto originalStack = std::regex_replace(json["stack"].asString(), colorsRegex, "");
-
-          const auto errorName = json["name"].asString();
-          std::string stack;
-
-          const auto prefix = errorName + ": " + message;
-          if (boost::starts_with(originalStack, prefix)) {
-            stack = originalStack.substr(prefix.length());
-          } else {
-            constexpr char startOfStackTrace[] = "\n    at ";
-            stack = originalStack.substr(originalStack.find(startOfStackTrace) + 1);
-          }
-
-          m_errorMessageText.Text(Microsoft::Common::Unicode::Utf8ToUtf16(message));
-          // Some messages (like SyntaxError) rely on fixed-width font to be properly formatted and indented.
-          m_errorMessageText.FontFamily(xaml::Media::FontFamily(L"Consolas"));
-
-          m_errorStackText.Text(Microsoft::Common::Unicode::Utf8ToUtf16(stack));
-          return;
-        }
-      } catch (...) {
-      }
-    }
-    std::string doctype = "<!DOCTYPE HTML>";
-    if (boost::istarts_with(plain, doctype)) {
-      winrt::hstring content(Microsoft::Common::Unicode::Utf8ToUtf16(plain.substr(doctype.length()).c_str()));
-
-      CreateWebView(m_stackPanel, content);
-
-      m_stackPanel.Margin(xaml::ThicknessHelper::FromUniformLength(0));
-      m_stackPanelUpper.Visibility(xaml::Visibility::Collapsed);
-
-      return;
-    }
-
-    // fall back to displaying the raw message string
-    m_errorMessageText.Text(Microsoft::Common::Unicode::Utf8ToUtf16(plain));
-    m_errorStackText.Text(L"");
-  }
-
-  void PopulateFrameStackUI() noexcept {
-    if (!m_stackPanel)
-      return;
-
-    m_stackPanel.Children().Clear();
-    for (const auto &frame : m_errorInfo.Callstack) {
-      const winrt::hstring xamlFrameString =
-          LR"(
-          <StackPanel Margin='0,5,0,5'
-            xmlns='http://schemas.microsoft.com/winfx/2006/xaml/presentation'
-            xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml'
-            >
-            <TextBlock x:Name='MethodText' FontSize='14' Foreground='White' TextWrapping='Wrap' FontFamily='Consolas'/>
-            <TextBlock x:Name='FrameText' FontSize='14' Foreground='Gray' TextWrapping='Wrap' FontFamily='Consolas'/>
-          </StackPanel>)";
-      auto frameContent =
-          winrt::unbox_value<xaml::Controls::StackPanel>(xaml::Markup::XamlReader::Load(xamlFrameString));
-      auto methodText = frameContent.FindName(L"MethodText").as<xaml::Controls::TextBlock>();
-      auto frameText = frameContent.FindName(L"FrameText").as<xaml::Controls::TextBlock>();
-      methodText.Text(Microsoft::Common::Unicode::Utf8ToUtf16(frame.Method));
-
-      // When the user taps on a stack frame, tell the bundler to load that source in the users editor of choice
-      frameContent.Tapped([weakReactHost = m_weakReactHost, f = frame](
-                              IInspectable const & /*sender*/, xaml::Input::TappedRoutedEventArgs const & /*e*/) {
-        if (auto reactHost = weakReactHost.GetStrongPtr()) {
-          auto devSettings = reactHost->Options().DeveloperSettings;
-          Uri uri{
-              Microsoft::Common::Unicode::Utf8ToUtf16(facebook::react::DevServerHelper::get_PackagerOpenStackFrameUrl(
-                  devSettings.SourceBundleHost, devSettings.SourceBundlePort))};
-          winrt::Windows::Web::Http::HttpClient httpClient{};
-          winrt::Windows::Data::Json::JsonObject payload{};
-
-          auto fileSanitized = f.File;
-          // Bundler will not launch filenames containing :'s, so strip off the <drive letter>:
-          if (fileSanitized[1] == ':') {
-            fileSanitized.erase(fileSanitized.begin());
-            fileSanitized.erase(fileSanitized.begin());
-          }
-          payload.SetNamedValue(
-              L"file",
-              winrt::Windows::Data::Json::JsonValue::CreateStringValue(
-                  Microsoft::Common::Unicode::Utf8ToUtf16(fileSanitized)));
-          payload.SetNamedValue(
-              L"methodName",
-              winrt::Windows::Data::Json::JsonValue::CreateStringValue(
-                  Microsoft::Common::Unicode::Utf8ToUtf16(f.Method)));
-          payload.SetNamedValue(L"lineNumber", winrt::Windows::Data::Json::JsonValue::CreateNumberValue(f.Line));
-          payload.SetNamedValue(L"column", winrt::Windows::Data::Json::JsonValue::CreateNumberValue(f.Column));
-          winrt::Windows::Web::Http::HttpStringContent content(
-              payload.ToString(),
-              winrt::Windows::Storage::Streams::UnicodeEncoding::Utf8,
-              L"application/json; charset=utf-8");
-          httpClient.TryPostAsync(uri, content);
-        }
-      });
-
-      std::stringstream stackFrameInfo;
-      stackFrameInfo << frame.File << ":" << frame.Line << ":" << frame.Column;
-      frameText.Text(Microsoft::Common::Unicode::Utf8ToUtf16(stackFrameInfo.str()));
-      m_stackPanel.Children().Append(frameContent);
-    }
-  }
-
-  xaml::Controls::StackPanel m_stackPanelUpper{nullptr};
-  xaml::Controls::StackPanel m_stackPanel{nullptr};
-  xaml::Controls::Primitives::Popup m_popup{nullptr};
-  xaml::Controls::Grid m_redboxContent{nullptr};
-  xaml::Controls::Button m_dismissButton{nullptr};
-  xaml::Controls::Button m_reloadButton{nullptr};
-  xaml::Controls::TextBlock m_errorMessageText{nullptr};
-  xaml::Controls::TextBlock m_errorStackText{nullptr};
-
-  xaml::FrameworkElement::SizeChanged_revoker m_sizeChangedRevoker;
-  winrt::event_token m_tokenClosed;
-  winrt::event_token m_tokenDismiss;
-  winrt::event_token m_tokenReload;
+  winrt::Windows::Foundation::IAsyncOperation<winrt::Windows::UI::Popups::IUICommand> m_dialogAsync{nullptr};
 
   winrt::Microsoft::ReactNative::ReactPropertyBag m_propBag;
   bool m_showing = false;

package/Microsoft.ReactNative/Theme.idl

@@ -50,9 +50,7 @@ namespace Microsoft.ReactNative.Composition
   runtimeclass Theme {
     Theme(Microsoft.ReactNative.IReactContext reactContext, ICustomResourceLoader resourceLoader);
 
-#ifdef USE_WINUI3
     Microsoft.UI.Composition.CompositionBrush PlatformBrush(String platformColor);
-#endif
 
     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.")

package/Microsoft.ReactNative/Timer.cpp

@@ -6,6 +6,7 @@
 #include "Timer.g.cpp"
 
 #include <CppWinRTIncludes.h>
+#include <winrt/Microsoft.UI.Dispatching.h>
 #include "ReactCoreInjection.h"
 
 namespace winrt::Microsoft::ReactNative::implementation {
@@ -13,7 +14,7 @@ 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();
+    const auto queue = winrt::Microsoft::UI::Dispatching::DispatcherQueue::GetForCurrentThread();
     m_dispatcherQueueTimer = queue.CreateTimer();
   }
 
@@ -42,7 +43,7 @@ struct ReactTimer : winrt::implements<ReactTimer, ITimer> {
   }
 
  private:
-  winrt::dispatching::DispatcherQueueTimer m_dispatcherQueueTimer{nullptr};
+  winrt::Microsoft::UI::Dispatching::DispatcherQueueTimer m_dispatcherQueueTimer{nullptr};
 };
 
 Timer::Timer() noexcept {}

package/Microsoft.ReactNative/Utils/Helpers.cpp

@@ -9,9 +9,7 @@
 #include <appmodel.h>
 #include <processthreadsapi.h>
 
-#ifdef USE_FABRIC
 #include <Fabric/Composition/CompositionUIService.h>
-#endif // USE_FABRIC
 
 namespace winrt {
 using namespace Windows::Foundation::Metadata;
@@ -32,14 +30,6 @@ bool IsAPIContractVxAvailable() {
   return isAPIContractVxAvailable;
 }
 
-bool IsAPIContractV5Available() {
-  return IsAPIContractVxAvailable<5>();
-}
-
-bool IsAPIContractV6Available() {
-  return IsAPIContractVxAvailable<6>();
-}
-
 bool IsAPIContractV7Available() {
   return IsAPIContractVxAvailable<7>();
 }
@@ -48,18 +38,6 @@ bool IsAPIContractV8Available() {
   return IsAPIContractVxAvailable<8>();
 }
 
-bool IsAPIContractV12Available() {
-  return IsAPIContractVxAvailable<12>();
-}
-
-bool IsRS3OrHigher() {
-  return IsAPIContractV5Available();
-}
-
-bool IsRS4OrHigher() {
-  return IsAPIContractV6Available();
-}
-
 bool IsRS5OrHigher() {
   return IsAPIContractV7Available();
 }
@@ -68,34 +46,9 @@ bool Is19H1OrHigher() {
   return IsAPIContractV8Available();
 }
 
-bool Is21H1OrHigher() {
-  return IsAPIContractV12Available();
-}
-
-bool IsXamlIsland() {
-  AppPolicyWindowingModel e;
-  if (FAILED(AppPolicyGetWindowingModel(GetCurrentThreadEffectiveToken(), &e)) ||
-      e == AppPolicyWindowingModel_ClassicDesktop) {
-    return true;
-  }
-  return false;
-}
-
-bool IsWinUI3Island() {
-#ifndef USE_WINUI3
-  return false;
-#else
-  return IsXamlIsland();
-#endif
-}
-
 bool IsFabricEnabled(winrt::Microsoft::ReactNative::IReactPropertyBag const &properties) {
-#ifdef USE_FABRIC
   return winrt::Microsoft::ReactNative::Composition::implementation::CompositionUIService::GetCompositionContext(
              properties) != nullptr;
-#else
-  return false;
-#endif
 }
 
 } // namespace Microsoft::ReactNative

package/Microsoft.ReactNative/Utils/Helpers.h

@@ -17,14 +17,9 @@ inline T asEnum(winrt::Microsoft::ReactNative::JSValue const &obj) {
   return static_cast<T>(obj.AsInt64());
 }
 
-bool IsRS3OrHigher();
-bool IsRS4OrHigher();
 bool IsRS5OrHigher();
 bool Is19H1OrHigher();
-bool Is21H1OrHigher();
 
-bool IsXamlIsland();
-bool IsWinUI3Island();
 bool IsFabricEnabled(winrt::Microsoft::ReactNative::IReactPropertyBag const &properties);
 
 } // namespace Microsoft::ReactNative

package/Microsoft.ReactNative/Utils/IcuUtils.cpp

@@ -0,0 +1,84 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#include "pch.h"
+#include "IcuUtils.h"
+#include <icu.h>
+
+namespace Microsoft::ReactNative::IcuUtils {
+
+void UBreakIteratorDeleter::operator()(void *ptr) const noexcept {
+  if (ptr) {
+    ubrk_close(static_cast<UBreakIterator *>(ptr));
+  }
+}
+
+WordBreakIterator::WordBreakIterator(const wchar_t *text, int32_t length) noexcept : m_length(length) {
+  UErrorCode status = U_ZERO_ERROR;
+  auto *iter = ubrk_open(UBRK_WORD, nullptr, reinterpret_cast<const UChar *>(text), length, &status);
+  if (U_SUCCESS(status)) {
+    m_breakIterator.reset(static_cast<void *>(iter));
+  }
+}
+
+bool WordBreakIterator::IsValid() const noexcept {
+  return m_breakIterator != nullptr;
+}
+
+bool WordBreakIterator::GetWordBoundaries(int32_t position, int32_t &outStart, int32_t &outEnd) const noexcept {
+  if (!m_breakIterator || position < 0 || position >= m_length) {
+    return false;
+  }
+
+  auto *iter = static_cast<UBreakIterator *>(m_breakIterator.get());
+
+  int32_t start = ubrk_preceding(iter, position + 1);
+  if (start == UBRK_DONE) {
+    start = 0;
+  }
+
+  int32_t end = ubrk_following(iter, position);
+  if (end == UBRK_DONE) {
+    end = m_length;
+  }
+
+  int32_t ruleStatus = ubrk_getRuleStatus(iter);
+  if (ruleStatus == UBRK_WORD_NONE) {
+    return false;
+  }
+
+  outStart = start;
+  outEnd = end;
+  return true;
+}
+
+bool IsAlphanumeric(UChar32 codePoint) noexcept {
+  return u_isalnum(codePoint) != 0;
+}
+
+UChar32 GetCodePointAt(const wchar_t *str, int32_t length, int32_t pos) noexcept {
+  if (!str || length <= 0 || pos < 0 || pos >= length) {
+    return 0;
+  }
+  UChar32 cp;
+  U16_GET(str, 0, pos, length, cp);
+  return cp;
+}
+
+int32_t MoveToPreviousCodePoint(const wchar_t *str, int32_t pos) noexcept {
+  if (!str || pos <= 0) {
+    return 0;
+  }
+  U16_BACK_1(str, 0, pos);
+  return pos;
+}
+
+int32_t MoveToNextCodePoint(const wchar_t *str, int32_t length, int32_t pos) noexcept {
+  if (!str || length <= 0 || pos >= length) {
+    return length;
+  }
+  U16_FWD_1(str, pos, length);
+  return pos;
+}
+
+} // namespace Microsoft::ReactNative::IcuUtils

package/Microsoft.ReactNative/Utils/IcuUtils.h

@@ -0,0 +1,42 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include <cstdint>
+#include <memory>
+
+// ICU utilities wrapped in a namespace to avoid UChar naming conflicts with Folly's FBString.
+// Folly has a template parameter named 'UChar' which conflicts with ICU's global UChar typedef.
+namespace Microsoft::ReactNative::IcuUtils {
+
+using UChar32 = int32_t;
+
+struct UBreakIteratorDeleter {
+  void operator()(void *ptr) const noexcept;
+};
+
+class WordBreakIterator {
+ public:
+  WordBreakIterator(const wchar_t *text, int32_t length) noexcept;
+
+  WordBreakIterator(const WordBreakIterator &) = delete;
+  WordBreakIterator &operator=(const WordBreakIterator &) = delete;
+  WordBreakIterator(WordBreakIterator &&) = default;
+  WordBreakIterator &operator=(WordBreakIterator &&) = default;
+
+  bool IsValid() const noexcept;
+
+  bool GetWordBoundaries(int32_t position, int32_t &outStart, int32_t &outEnd) const noexcept;
+
+ private:
+  std::unique_ptr<void, UBreakIteratorDeleter> m_breakIterator{nullptr};
+  int32_t m_length = 0;
+};
+
+bool IsAlphanumeric(UChar32 codePoint) noexcept;
+UChar32 GetCodePointAt(const wchar_t *str, int32_t length, int32_t pos) noexcept;
+int32_t MoveToPreviousCodePoint(const wchar_t *str, int32_t pos) noexcept;
+int32_t MoveToNextCodePoint(const wchar_t *str, int32_t length, int32_t pos) noexcept;
+
+} // namespace Microsoft::ReactNative::IcuUtils