react-native-windows 0.79.5 → 0.80.0-preview.10

package/Microsoft.ReactNative/Fabric/Composition/UiaHelpers.cpp

@@ -166,6 +166,24 @@ void UpdateUiaProperty(winrt::IInspectable provider, PROPERTYID propId, bool old
   UiaRaiseAutomationPropertyChangedEvent(spProviderSimple.get(), propId, CComVariant(oldValue), CComVariant(newValue));
 }
 
+void UpdateUiaProperty(winrt::IInspectable provider, PROPERTYID propId, int oldValue, int newValue) noexcept {
+  auto spProviderSimple = provider.try_as<IRawElementProviderSimple>();
+
+  if (spProviderSimple == nullptr || oldValue == newValue || !WasUiaPropertyAdvised(spProviderSimple, propId))
+    return;
+
+  UiaRaiseAutomationPropertyChangedEvent(spProviderSimple.get(), propId, CComVariant(oldValue), CComVariant(newValue));
+}
+
+void UpdateUiaProperty(winrt::IInspectable provider, PROPERTYID propId, long oldValue, long newValue) noexcept {
+  auto spProviderSimple = provider.try_as<IRawElementProviderSimple>();
+
+  if (spProviderSimple == nullptr || oldValue == newValue || !WasUiaPropertyAdvised(spProviderSimple, propId))
+    return;
+
+  UiaRaiseAutomationPropertyChangedEvent(spProviderSimple.get(), propId, CComVariant(oldValue), CComVariant(newValue));
+}
+
 void UpdateUiaProperty(
     winrt::IInspectable provider,
     PROPERTYID propId,
@@ -190,6 +208,29 @@ void UpdateUiaProperty(
   UpdateUiaProperty(provider, propId, oldData, newData);
 }
 
+void UpdateUiaPropertiesForAnnotation(
+    winrt::IInspectable provider,
+    const std::optional<facebook::react::AccessibilityAnnotation> &oldAnnotation,
+    const std::optional<facebook::react::AccessibilityAnnotation> &newAnnotation) noexcept {
+  // if no value fall back to a default value.
+  const auto &old_annotation = oldAnnotation.value_or(facebook::react::AccessibilityAnnotation());
+  const auto &new_annotation = newAnnotation.value_or(facebook::react::AccessibilityAnnotation());
+
+  // Update all annotation properties
+  UpdateUiaProperty(
+      provider,
+      UIA_AnnotationAnnotationTypeIdPropertyId,
+      GetAnnotationTypeId(old_annotation.typeID),
+      GetAnnotationTypeId(new_annotation.typeID));
+
+  UpdateUiaProperty(
+      provider, UIA_AnnotationAnnotationTypeNamePropertyId, old_annotation.typeName, new_annotation.typeName);
+
+  UpdateUiaProperty(provider, UIA_AnnotationAuthorPropertyId, old_annotation.author, new_annotation.author);
+
+  UpdateUiaProperty(provider, UIA_AnnotationDateTimePropertyId, old_annotation.dateTime, new_annotation.dateTime);
+}
+
 long GetLiveSetting(const std::string &liveRegion) noexcept {
   if (liveRegion == "polite") {
     return LiveSetting::Polite;
@@ -250,6 +291,190 @@ long GetAnnotationTypeId(const std::string &annotationType) noexcept {
   return AnnotationType_Unknown;
 }
 
+long GetControlTypeFromString(const std::string &role) noexcept {
+  if (role == "adjustable") {
+    return UIA_SliderControlTypeId;
+  } else if (role == "group" || role == "search" || role == "radiogroup" || role == "timer" || role.empty()) {
+    return UIA_GroupControlTypeId;
+  } else if (role == "button" || role == "imagebutton" || role == "switch" || role == "togglebutton") {
+    return UIA_ButtonControlTypeId;
+  } else if (role == "checkbox") {
+    return UIA_CheckBoxControlTypeId;
+  } else if (role == "combobox") {
+    return UIA_ComboBoxControlTypeId;
+  } else if (role == "alert" || role == "header" || role == "summary" || role == "text") {
+    return UIA_TextControlTypeId;
+  } else if (role == "image") {
+    return UIA_ImageControlTypeId;
+  } else if (role == "keyboardkey") {
+    return UIA_CustomControlTypeId;
+  } else if (role == "link") {
+    return UIA_HyperlinkControlTypeId;
+  }
+  // list and listitem were added by RNW to better support UIA Control Types
+  else if (role == "list") {
+    return UIA_ListControlTypeId;
+  } else if (role == "listitem") {
+    return UIA_ListItemControlTypeId;
+  } else if (role == "menu") {
+    return UIA_MenuControlTypeId;
+  } else if (role == "menubar") {
+    return UIA_MenuBarControlTypeId;
+  } else if (role == "menuitem") {
+    return UIA_MenuItemControlTypeId;
+  }
+  // If role is "none", remove the element from the control tree
+  // and expose it as a plain element would in the raw tree.
+  else if (role == "none") {
+    return UIA_GroupControlTypeId;
+  } else if (role == "progressbar") {
+    return UIA_ProgressBarControlTypeId;
+  } else if (role == "radio") {
+    return UIA_RadioButtonControlTypeId;
+  } else if (role == "scrollbar") {
+    return UIA_ScrollBarControlTypeId;
+  } else if (role == "spinbutton") {
+    return UIA_SpinnerControlTypeId;
+  } else if (role == "splitbutton") {
+    return UIA_SplitButtonControlTypeId;
+  } else if (role == "tab") {
+    return UIA_TabItemControlTypeId;
+  } else if (role == "tablist") {
+    return UIA_TabControlTypeId;
+  } else if (role == "textinput" || role == "searchbox") {
+    return UIA_EditControlTypeId;
+  } else if (role == "toolbar") {
+    return UIA_ToolBarControlTypeId;
+  } else if (role == "tree") {
+    return UIA_TreeControlTypeId;
+  } else if (role == "treeitem") {
+    return UIA_TreeItemControlTypeId;
+  } else if (role == "pane") {
+    return UIA_PaneControlTypeId;
+  }
+  assert(false);
+  return UIA_GroupControlTypeId;
+}
+
+long GetControlTypeFromRole(const facebook::react::Role &role) noexcept {
+  switch (role) {
+    case facebook::react::Role::Alert:
+      return UIA_TextControlTypeId;
+    case facebook::react::Role::Application:
+      return UIA_WindowControlTypeId;
+    case facebook::react::Role::Button:
+      return UIA_ButtonControlTypeId;
+    case facebook::react::Role::Checkbox:
+      return UIA_CheckBoxControlTypeId;
+    case facebook::react::Role::Columnheader:
+      return UIA_HeaderControlTypeId;
+    case facebook::react::Role::Combobox:
+      return UIA_ComboBoxControlTypeId;
+    case facebook::react::Role::Document:
+      return UIA_DocumentControlTypeId;
+    case facebook::react::Role::Grid:
+      return UIA_GroupControlTypeId;
+    case facebook::react::Role::Group:
+      return UIA_GroupControlTypeId;
+    case facebook::react::Role::Heading:
+      return UIA_TextControlTypeId;
+    case facebook::react::Role::Img:
+      return UIA_ImageControlTypeId;
+    case facebook::react::Role::Link:
+      return UIA_HyperlinkControlTypeId;
+    case facebook::react::Role::List:
+      return UIA_ListControlTypeId;
+    case facebook::react::Role::Listitem:
+      return UIA_ListItemControlTypeId;
+    case facebook::react::Role::Menu:
+      return UIA_MenuControlTypeId;
+    case facebook::react::Role::Menubar:
+      return UIA_MenuBarControlTypeId;
+    case facebook::react::Role::Menuitem:
+      return UIA_MenuItemControlTypeId;
+    case facebook::react::Role::None:
+      return UIA_GroupControlTypeId;
+    case facebook::react::Role::Presentation:
+      return UIA_GroupControlTypeId;
+    case facebook::react::Role::Progressbar:
+      return UIA_ProgressBarControlTypeId;
+    case facebook::react::Role::Radio:
+      return UIA_RadioButtonControlTypeId;
+    case facebook::react::Role::Radiogroup:
+      return UIA_GroupControlTypeId;
+    case facebook::react::Role::Rowgroup:
+      return UIA_GroupControlTypeId;
+    case facebook::react::Role::Rowheader:
+      return UIA_HeaderControlTypeId;
+    case facebook::react::Role::Scrollbar:
+      return UIA_ScrollBarControlTypeId;
+    case facebook::react::Role::Searchbox:
+      return UIA_EditControlTypeId;
+    case facebook::react::Role::Separator:
+      return UIA_SeparatorControlTypeId;
+    case facebook::react::Role::Slider:
+      return UIA_SliderControlTypeId;
+    case facebook::react::Role::Spinbutton:
+      return UIA_SpinnerControlTypeId;
+    case facebook::react::Role::Status:
+      return UIA_StatusBarControlTypeId;
+    case facebook::react::Role::Summary:
+      return UIA_GroupControlTypeId;
+    case facebook::react::Role::Switch:
+      return UIA_ButtonControlTypeId;
+    case facebook::react::Role::Tab:
+      return UIA_TabItemControlTypeId;
+    case facebook::react::Role::Table:
+      return UIA_TableControlTypeId;
+    case facebook::react::Role::Tablist:
+      return UIA_TabControlTypeId;
+    case facebook::react::Role::Tabpanel:
+      return UIA_TabControlTypeId;
+    case facebook::react::Role::Timer:
+      return UIA_ButtonControlTypeId;
+    case facebook::react::Role::Toolbar:
+      return UIA_ToolBarControlTypeId;
+    case facebook::react::Role::Tooltip:
+      return UIA_ToolTipControlTypeId;
+    case facebook::react::Role::Tree:
+      return UIA_TreeControlTypeId;
+    case facebook::react::Role::Treegrid:
+      return UIA_TreeControlTypeId;
+    case facebook::react::Role::Treeitem:
+      return UIA_TreeItemControlTypeId;
+  }
+  return UIA_GroupControlTypeId;
+}
+
+long GetHeadingLevel(int headingLevel, const std::string &strRole, const facebook::react::Role &role) noexcept {
+  if (strRole != "header" && role != facebook::react::Role::Heading) {
+    return HeadingLevel_None;
+  }
+
+  switch (headingLevel) {
+    case 1:
+      return HeadingLevel1;
+    case 2:
+      return HeadingLevel2;
+    case 3:
+      return HeadingLevel3;
+    case 4:
+      return HeadingLevel4;
+    case 5:
+      return HeadingLevel5;
+    case 6:
+      return HeadingLevel6;
+    case 7:
+      return HeadingLevel7;
+    case 8:
+      return HeadingLevel8;
+    case 9:
+      return HeadingLevel9;
+    default:
+      return HeadingLevel_None;
+  }
+}
+
 bool accessibilityAnnotationHasValue(
     const std::optional<facebook::react::AccessibilityAnnotation> &annotation) noexcept {
   return annotation.has_value() &&

package/Microsoft.ReactNative/Fabric/Composition/UiaHelpers.h

@@ -29,6 +29,18 @@ void UpdateUiaProperty(
     bool oldValue,
     bool newValue) noexcept;
 
+void UpdateUiaProperty(
+    winrt::Windows::Foundation::IInspectable provider,
+    PROPERTYID propId,
+    int oldValue,
+    int newValue) noexcept;
+
+void UpdateUiaProperty(
+    winrt::Windows::Foundation::IInspectable provider,
+    PROPERTYID propId,
+    long oldValue,
+    long newValue) noexcept;
+
 void UpdateUiaProperty(
     winrt::Windows::Foundation::IInspectable provider,
     PROPERTYID propId,
@@ -41,10 +53,21 @@ void UpdateUiaProperty(
     const std::optional<std::string> &oldValue,
     const std::optional<std::string> &newValue) noexcept;
 
+void UpdateUiaPropertiesForAnnotation(
+    winrt::Windows::Foundation::IInspectable provider,
+    const std::optional<facebook::react::AccessibilityAnnotation> &oldAnnotation,
+    const std::optional<facebook::react::AccessibilityAnnotation> &newAnnotation) noexcept;
+
 long GetLiveSetting(const std::string &liveRegion) noexcept;
 
 long GetAnnotationTypeId(const std::string &annotationType) noexcept;
 
+long GetControlTypeFromRole(const facebook::react::Role &role) noexcept;
+
+long GetControlTypeFromString(const std::string &role) noexcept;
+
+long GetHeadingLevel(int headingLevel, const std::string &strRole, const facebook::react::Role &role) noexcept;
+
 bool accessibilityAnnotationHasValue(
     const std::optional<facebook::react::AccessibilityAnnotation> &annotation) noexcept;
 

package/Microsoft.ReactNative/Fabric/FabricUIManagerModule.cpp

@@ -66,7 +66,8 @@ FabricUIManager::~FabricUIManager() {
 void FabricUIManager::installFabricUIManager() noexcept {
   std::lock_guard<std::mutex> schedulerLock(m_schedulerMutex);
 
-  facebook::react::ContextContainer::Shared contextContainer = std::make_shared<facebook::react::ContextContainer>();
+  std::shared_ptr<const facebook::react::ContextContainer> contextContainer =
+      std::make_shared<facebook::react::ContextContainer>();
 
   // This allows access to our ReactContext from the contextContainer thats passed around the fabric codebase
   contextContainer->insert("MSRN.ReactContext", m_context);
@@ -97,8 +98,9 @@ void FabricUIManager::installFabricUIManager() noexcept {
       };
 
   toolbox.contextContainer = contextContainer;
-  toolbox.componentRegistryFactory = [](facebook::react::EventDispatcher::Weak const &eventDispatcher,
-                                        facebook::react::ContextContainer::Shared const &contextContainer)
+  toolbox.componentRegistryFactory =
+      [](facebook::react::EventDispatcher::Weak const &eventDispatcher,
+         std::shared_ptr<const facebook::react::ContextContainer> const &contextContainer)
       -> facebook::react::ComponentDescriptorRegistry::Shared {
     auto providerRegistry =
         WindowsComponentDescriptorRegistry::FromProperties(
@@ -465,6 +467,10 @@ void FabricUIManager::schedulerDidSetIsJSResponder(
     bool isJSResponder,
     bool blockNativeResponder) {}
 
+void FabricUIManager::schedulerShouldSynchronouslyUpdateViewOnUIThread(
+    facebook::react::Tag tag,
+    const folly::dynamic &props) {}
+
 void FabricUIManager::schedulerDidSendAccessibilityEvent(
     const facebook::react::ShadowView &shadowView,
     std::string const &eventType) {

package/Microsoft.ReactNative/Fabric/FabricUIManagerModule.h

@@ -99,6 +99,8 @@ struct FabricUIManager final : public std::enable_shared_from_this<FabricUIManag
       facebook::react::ShadowView const &shadowView,
       bool isJSResponder,
       bool blockNativeResponder) override;
+  virtual void schedulerShouldSynchronouslyUpdateViewOnUIThread(facebook::react::Tag tag, const folly::dynamic &props)
+      override;
   virtual void schedulerDidSendAccessibilityEvent(
       const facebook::react::ShadowView &shadowView,
       std::string const &eventType) override;

package/Microsoft.ReactNative/Fabric/ImageManager.cpp

@@ -9,7 +9,7 @@
 namespace facebook {
 namespace react {
 
-ImageManager::ImageManager(ContextContainer::Shared const &contextContainer) {
+ImageManager::ImageManager(std::shared_ptr<const ContextContainer> const &contextContainer) {
   auto reactContext = *contextContainer->find<winrt::Microsoft::ReactNative::ReactContext>("MSRN.ReactContext");
   self_ = new Microsoft::ReactNative::WindowsImageManager(reactContext);
 }

package/Microsoft.ReactNative/Fabric/platform/react/renderer/components/view/HostPlatformViewEventEmitter.cpp

@@ -64,4 +64,20 @@ void HostPlatformViewEventEmitter::onPressIn(GestureResponderEvent event) const
   });
 }
 
+void HostPlatformViewEventEmitter::onPressOut(GestureResponderEvent event) const {
+  dispatchEvent("pressOut", [event](jsi::Runtime &runtime) {
+    auto payload = jsi::Object(runtime);
+    auto nativeEvent = jsi::Object(runtime);
+    nativeEvent.setProperty(runtime, "target", static_cast<double>(event.target));
+    nativeEvent.setProperty(runtime, "pageX", event.pagePoint.x);
+    nativeEvent.setProperty(runtime, "pageY", event.pagePoint.y);
+    nativeEvent.setProperty(runtime, "locationX", event.offsetPoint.x);
+    nativeEvent.setProperty(runtime, "locationY", event.offsetPoint.y);
+    nativeEvent.setProperty(runtime, "timestamp", event.timestamp);
+    nativeEvent.setProperty(runtime, "identifier", event.identifier);
+    payload.setProperty(runtime, "nativeEvent", nativeEvent);
+    return payload;
+  });
+}
+
 } // namespace facebook::react

package/Microsoft.ReactNative/Fabric/platform/react/renderer/components/view/HostPlatformViewEventEmitter.h

@@ -39,6 +39,7 @@ class HostPlatformViewEventEmitter : public BaseViewEventEmitter {
 #pragma mark - Touch Events
 
   virtual void onPressIn(GestureResponderEvent event) const;
+  virtual void onPressOut(GestureResponderEvent event) const;
 };
 
 } // namespace facebook::react

package/Microsoft.ReactNative/Fabric/platform/react/renderer/components/view/HostPlatformViewProps.cpp

@@ -56,6 +56,14 @@ HostPlatformViewProps::HostPlatformViewProps(
           ReactNativeFeatureFlags::enableCppPropsIteratorSetter()
               ? sourceProps.accessibilityAccessKey
               : convertRawProp(context, rawProps, "accessibilityAccessKey", sourceProps.accessibilityAccessKey, {})),
+      accessibilityDescription(
+          ReactNativeFeatureFlags::enableCppPropsIteratorSetter() ? sourceProps.accessibilityDescription
+                                                                  : convertRawProp(
+                                                                        context,
+                                                                        rawProps,
+                                                                        "accessibilityDescription",
+                                                                        sourceProps.accessibilityDescription,
+                                                                        {})),
       accessibilityLiveRegion(
           ReactNativeFeatureFlags::enableCppPropsIteratorSetter() ? sourceProps.accessibilityLiveRegion
                                                                   : convertRawProp(
@@ -104,6 +112,7 @@ void HostPlatformViewProps::setProp(
     RAW_SET_PROP_SWITCH_CASE_BASIC(accessibilityLevel);
     RAW_SET_PROP_SWITCH_CASE_BASIC(accessibilityItemType);
     RAW_SET_PROP_SWITCH_CASE_BASIC(accessibilityAccessKey);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(accessibilityDescription);
     RAW_SET_PROP_SWITCH_CASE_BASIC(accessibilityLiveRegion);
     RAW_SET_PROP_SWITCH_CASE_BASIC(keyDownEvents);
     RAW_SET_PROP_SWITCH_CASE_BASIC(keyUpEvents);

package/Microsoft.ReactNative/Fabric/platform/react/renderer/components/view/HostPlatformViewProps.h

@@ -32,6 +32,7 @@ class HostPlatformViewProps : public BaseViewProps {
   std::optional<AccessibilityAnnotation> accessibilityAnnotation{};
   std::optional<std::string> accessibilityItemType{};
   std::optional<std::string> accessibilityAccessKey{};
+  std::optional<std::string> accessibilityDescription{};
 
   // std::optional<std::string> overflowAnchor{};
   std::optional<std::string> tooltip{};

package/Microsoft.ReactNative/Fabric/platform/react/renderer/components/view/HostPlatformViewTraitsInitializer.h

@@ -20,4 +20,8 @@ inline ShadowNodeTraits::Trait extraTraits() {
   return ShadowNodeTraits::Trait::None;
 }
 
+inline bool isKeyboardFocusable(const ViewProps &viewProps) {
+  return false;
+}
+
 } // namespace facebook::react::HostPlatformViewTraitsInitializer

package/Microsoft.ReactNative/Fabric/platform/react/renderer/graphics/PlatformColorUtils.cpp

@@ -3,11 +3,14 @@
 
 #include "PlatformColorUtils.h"
 #include <UI.Xaml.Media.h>
+#include <Utils/ThemeUtils.h>
 #include <Utils/ValueUtils.h>
 #ifndef CORE_ABI
 #include <XamlUtils.h>
 #endif // CORE_ABI
+#include <react/renderer/graphics/Color.h>
 #include <winrt/Windows.UI.ViewManagement.h>
+#include "HostPlatformColor.h"
 
 namespace facebook::react {
 
@@ -142,4 +145,65 @@ winrt::Windows::UI::Color ResolvePlatformColor(const std::vector<std::string> &s
   return {};
 }
 
+SharedColor GetTextInputPlaceholderColor(bool isFocused, const winrt::Windows::UI::Color &backgroundColor) {
+  // In high contrast mode, always use system GrayText for accessibility
+  auto accessibilitySettings{winrt::Windows::UI::ViewManagement::AccessibilitySettings()};
+  if (accessibilitySettings.HighContrast()) {
+    auto uiSettings{winrt::Windows::UI::ViewManagement::UISettings()};
+    auto grayText = uiSettings.UIElementColor(winrt::Windows::UI::ViewManagement::UIElementType::GrayText);
+    return hostPlatformColorFromRGBA(grayText.R, grayText.G, grayText.B, grayText.A);
+  }
+
+  // When no background color provided (transparent), use Windows system default
+  if (backgroundColor.A == 0) {
+    // Use system WindowText for default placeholder - matches RN Core behavior
+    auto uiSettings{winrt::Windows::UI::ViewManagement::UISettings()};
+    auto windowText = uiSettings.UIElementColor(winrt::Windows::UI::ViewManagement::UIElementType::WindowText);
+    // Make placeholder text lighter (60% opacity)
+    return hostPlatformColorFromRGBA(
+        windowText.R, windowText.G, windowText.B, static_cast<uint8_t>(windowText.A * 0.6f));
+  }
+
+  // Use ITU-R BT.601 luminance calculation to determine background brightness
+  bool isLightBackground = Microsoft::ReactNative::IsColorLight(backgroundColor);
+
+  // Use Windows 11 design system semantic colors for optimal contrast and consistency
+  // Light backgrounds: TextFillColorPrimary (darker) for focus, TextFillColorSecondary for unfocused
+  // Dark backgrounds: TextFillColorPrimary (lighter) for focus, TextFillColorSecondary for unfocused
+  if (isLightBackground) {
+    if (isFocused) {
+      auto color = ResolvePlatformColor({"TextFillColorPrimary"});
+      return hostPlatformColorFromRGBA(color.R, color.G, color.B, color.A);
+    } else {
+      auto color = ResolvePlatformColor({"TextFillColorSecondary"});
+      return hostPlatformColorFromRGBA(color.R, color.G, color.B, color.A);
+    }
+  } else {
+    if (isFocused) {
+      auto color = ResolvePlatformColor({"TextFillColorPrimary"});
+      return hostPlatformColorFromRGBA(color.R, color.G, color.B, color.A);
+    } else {
+      auto color = ResolvePlatformColor({"TextFillColorSecondary"});
+      return hostPlatformColorFromRGBA(color.R, color.G, color.B, color.A);
+    }
+  }
+}
+
+SharedColor GetDefaultTextColor() {
+  // In high contrast mode, always use system WindowText for accessibility
+  auto accessibilitySettings{winrt::Windows::UI::ViewManagement::AccessibilitySettings()};
+  if (accessibilitySettings.HighContrast()) {
+    auto uiSettings{winrt::Windows::UI::ViewManagement::UISettings()};
+    auto windowText = uiSettings.UIElementColor(winrt::Windows::UI::ViewManagement::UIElementType::WindowText);
+    return hostPlatformColorFromRGBA(windowText.R, windowText.G, windowText.B, windowText.A);
+  }
+
+  // Use Windows 11 design system semantic color TextFillColorPrimary
+  // This automatically adapts to light/dark mode themes:
+  // - Light mode: rgba(0, 0, 0, 0.894) - nearly black for good contrast
+  // - Dark mode: rgba(255, 255, 255, 1.0) - white for readability
+  auto color = ResolvePlatformColor({"TextFillColorPrimary"});
+  return hostPlatformColorFromRGBA(color.R, color.G, color.B, color.A);
+}
+
 } // namespace facebook::react

package/Microsoft.ReactNative/Fabric/platform/react/renderer/graphics/PlatformColorUtils.h

@@ -5,8 +5,19 @@
 
 #include <winrt/Windows.UI.h>
 
+// Forward declaration to avoid circular dependencies
+namespace facebook::react {
+class SharedColor;
+}
+
 namespace facebook::react {
 
 winrt::Windows::UI::Color ResolvePlatformColor(const std::vector<std::string> &semanticItems);
 
+// Get appropriate placeholder text color for TextInput based on focus state and background
+SharedColor GetTextInputPlaceholderColor(bool isFocused, const winrt::Windows::UI::Color &backgroundColor = {});
+
+// Get default text foreground color for Text component (theme-aware)
+SharedColor GetDefaultTextColor();
+
 } // namespace facebook::react

package/Microsoft.ReactNative/Fabric/platform/react/renderer/textlayoutmanager/WindowsTextLayoutManager.cpp

@@ -66,12 +66,10 @@ class AttachmentInlineObject : public winrt::implements<AttachmentInlineObject,
   float m_height;
 };
 
-TextLayoutManager::TextLayoutManager(const ContextContainer::Shared &contextContainer)
-    : contextContainer_(contextContainer),
-      textMeasureCache_(kSimpleThreadSafeCacheSizeCap),
-      lineMeasureCache_(kSimpleThreadSafeCacheSizeCap) {}
+TextLayoutManager::TextLayoutManager(const std::shared_ptr<const ContextContainer> &contextContainer)
+    : contextContainer_(contextContainer), textMeasureCache_(kSimpleThreadSafeCacheSizeCap) {}
 
-WindowsTextLayoutManager::WindowsTextLayoutManager(const ContextContainer::Shared &contextContainer)
+WindowsTextLayoutManager::WindowsTextLayoutManager(const std::shared_ptr<const ContextContainer> &contextContainer)
     : TextLayoutManager(contextContainer) {}
 
 void WindowsTextLayoutManager::GetTextLayout(
@@ -160,7 +158,6 @@ void WindowsTextLayoutManager::GetTextLayout(
 
   // Get text with Object Replacement Characters for attachments
   auto str = GetTransformedText(attributedStringBox);
-
   winrt::check_hresult(Microsoft::ReactNative::DWriteFactory()->CreateTextLayout(
       str.c_str(), // The string to be laid out and formatted.
       static_cast<UINT32>(str.size()), // The length of the string.
@@ -170,6 +167,39 @@ void WindowsTextLayoutManager::GetTextLayout(
       spTextLayout.put() // The IDWriteTextLayout interface pointer.
       ));
 
+  // Apply max width constraint and ellipsis trimming to ensure consistency with rendering
+  DWRITE_TEXT_METRICS metrics;
+  winrt::check_hresult(spTextLayout->GetMetrics(&metrics));
+
+  if (metrics.width > size.width) {
+    spTextLayout->SetMaxWidth(size.width);
+  }
+
+  // Apply DWRITE_TRIMMING for ellipsizeMode
+  DWRITE_TRIMMING trimming = {};
+  winrt::com_ptr<IDWriteInlineObject> ellipsisSign;
+
+  switch (paragraphAttributes.ellipsizeMode) {
+    case facebook::react::EllipsizeMode::Tail:
+      trimming.granularity = DWRITE_TRIMMING_GRANULARITY_CHARACTER;
+      break;
+    case facebook::react::EllipsizeMode::Clip:
+      trimming.granularity = DWRITE_TRIMMING_GRANULARITY_NONE;
+      break;
+    default:
+      trimming.granularity = DWRITE_TRIMMING_GRANULARITY_CHARACTER; // Default to tail behavior
+      break;
+  }
+
+  // Use DWriteFactory to create the ellipsis trimming sign
+  if (trimming.granularity != DWRITE_TRIMMING_GRANULARITY_NONE) {
+    auto dwriteFactory = Microsoft::ReactNative::DWriteFactory();
+    HRESULT hr = dwriteFactory->CreateEllipsisTrimmingSign(spTextLayout.get(), ellipsisSign.put());
+    if (SUCCEEDED(hr)) {
+      spTextLayout->SetTrimming(&trimming, ellipsisSign.get());
+    }
+  }
+
   // Calculate positions for attachments and set inline objects
   unsigned int position = 0;
   for (const auto &fragment : fragments) {
@@ -408,96 +438,6 @@ Microsoft::ReactNative::TextTransform ConvertTextTransform(std::optional<TextTra
   return Microsoft::ReactNative::TextTransform::Undefined;
 }
 
-LinesMeasurements TextLayoutManager::measureLines(
-    const AttributedStringBox &attributedStringBox,
-    const ParagraphAttributes &paragraphAttributes,
-    const Size &size) const {
-  LinesMeasurements lineMeasurements{};
-
-  winrt::com_ptr<IDWriteTextLayout> spTextLayout;
-  TextMeasurement::Attachments attachments;
-  WindowsTextLayoutManager::GetTextLayout(attributedStringBox, paragraphAttributes, size, spTextLayout, attachments);
-
-  if (spTextLayout) {
-    std::vector<DWRITE_LINE_METRICS> lineMetrics;
-    uint32_t actualLineCount;
-    spTextLayout->GetLineMetrics(nullptr, 0, &actualLineCount);
-    lineMetrics.resize(static_cast<size_t>(actualLineCount));
-    winrt::check_hresult(spTextLayout->GetLineMetrics(lineMetrics.data(), actualLineCount, &actualLineCount));
-    uint32_t startRange = 0;
-    const auto count = (paragraphAttributes.maximumNumberOfLines > 0)
-        ? std::min(static_cast<uint32_t>(paragraphAttributes.maximumNumberOfLines), actualLineCount)
-        : actualLineCount;
-    for (uint32_t i = 0; i < count; ++i) {
-      UINT32 actualHitTestCount = 0;
-      spTextLayout->HitTestTextRange(
-          startRange,
-          lineMetrics[i].length,
-          0, // x
-          0, // y
-          NULL,
-          0, // metrics count
-          &actualHitTestCount);
-
-      // Allocate enough room to return all hit-test metrics.
-      std::vector<DWRITE_HIT_TEST_METRICS> hitTestMetrics(actualHitTestCount);
-      spTextLayout->HitTestTextRange(
-          startRange,
-          lineMetrics[i].length,
-          0, // x
-          0, // y
-          &hitTestMetrics[0],
-          static_cast<UINT32>(hitTestMetrics.size()),
-          &actualHitTestCount);
-
-      float width = 0;
-      for (auto tm : hitTestMetrics) {
-        width += tm.width;
-      }
-
-      std::string str;
-      const auto &attributedString = attributedStringBox.getValue();
-      for (const auto &fragment : attributedString.getFragments()) {
-        str = str +
-            winrt::to_string(Microsoft::ReactNative::TransformableText::TransformText(
-                winrt::hstring{Microsoft::Common::Unicode::Utf8ToUtf16(fragment.string)},
-                ConvertTextTransform(fragment.textAttributes.textTransform)));
-      }
-
-      lineMeasurements.emplace_back(LineMeasurement(
-          str.substr(startRange, lineMetrics[i].length),
-          {{hitTestMetrics[0].left, hitTestMetrics[0].top}, // origin
-           {width, lineMetrics[i].height}},
-          0.0f, // TODO descender
-          0.0f, // TODO: capHeight
-          0.0f, // TODO ascender
-          0.0f // TODO: xHeight
-          ));
-
-      startRange += lineMetrics[i].length;
-    }
-  }
-
-  return lineMeasurements;
-}
-
-Float TextLayoutManager::baseline(
-    const AttributedStringBox &attributedStringBox,
-    const ParagraphAttributes &paragraphAttributes,
-    const Size &size) const {
-  winrt::com_ptr<IDWriteTextLayout> spTextLayout;
-  TextMeasurement::Attachments attachments;
-  WindowsTextLayoutManager::GetTextLayout(attributedStringBox, paragraphAttributes, size, spTextLayout, attachments);
-  if (!spTextLayout) {
-    return 0;
-  }
-
-  DWRITE_TEXT_METRICS metrics;
-  winrt::check_hresult(spTextLayout->GetMetrics(&metrics));
-  return metrics.height *
-      0.8f; // https://learn.microsoft.com/en-us/windows/win32/api/dwrite/nf-dwrite-idwritetextformat-getlinespacing
-}
-
 winrt::hstring WindowsTextLayoutManager::GetTransformedText(const AttributedStringBox &attributedStringBox) {
   winrt::hstring result{};
   const auto &attributedString = attributedStringBox.getValue();