react-native-windows 0.74.46 → 0.74.48

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

@@ -64,6 +64,14 @@ void ParagraphComponentView::updateProps(
     updateTextAlignment(newViewProps.textAttributes.alignment);
   }
 
+  if (oldViewProps.paragraphAttributes.ellipsizeMode != newViewProps.paragraphAttributes.ellipsizeMode) {
+    m_textLayout = nullptr;
+  }
+
+  if (oldViewProps.paragraphAttributes.adjustsFontSizeToFit != newViewProps.paragraphAttributes.adjustsFontSizeToFit) {
+    m_textLayout = nullptr;
+  }
+
   Super::updateProps(props, oldProps);
 }
 
@@ -73,7 +81,7 @@ void ParagraphComponentView::updateState(
   const auto &newState = *std::static_pointer_cast<facebook::react::ParagraphShadowNode::ConcreteState const>(state);
 
   m_attributedStringBox = facebook::react::AttributedStringBox(newState.getData().attributedString);
-  m_paragraphAttributes = {}; // TODO
+  m_paragraphAttributes = facebook::react::ParagraphAttributes(newState.getData().paragraphAttributes);
 
   m_textLayout = nullptr;
 }
@@ -97,7 +105,7 @@ void ParagraphComponentView::FinalizeUpdates(
 
 facebook::react::SharedViewEventEmitter ParagraphComponentView::eventEmitterAtPoint(
     facebook::react::Point pt) noexcept {
-  if (m_attributedStringBox.getValue().getFragments().size()) {
+  if (m_attributedStringBox.getValue().getFragments().size() && m_textLayout) {
     BOOL isTrailingHit = false;
     BOOL isInside = false;
     DWRITE_HIT_TEST_METRICS metrics;
@@ -120,35 +128,8 @@ facebook::react::SharedViewEventEmitter ParagraphComponentView::eventEmitterAtPo
 
 void ParagraphComponentView::updateTextAlignment(
     const std::optional<facebook::react::TextAlignment> &fbAlignment) noexcept {
+  // Reset text layout to force recreation with new alignment
   m_textLayout = nullptr;
-  if (!m_textLayout)
-    return;
-
-  DWRITE_TEXT_ALIGNMENT alignment = DWRITE_TEXT_ALIGNMENT_LEADING;
-  if (fbAlignment) {
-    switch (*fbAlignment) {
-      case facebook::react::TextAlignment::Center:
-        alignment = DWRITE_TEXT_ALIGNMENT_CENTER;
-        break;
-      case facebook::react::TextAlignment::Justified:
-        alignment = DWRITE_TEXT_ALIGNMENT_JUSTIFIED;
-        break;
-      case facebook::react::TextAlignment::Left:
-        alignment = DWRITE_TEXT_ALIGNMENT_LEADING;
-        break;
-      case facebook::react::TextAlignment::Right:
-        alignment = DWRITE_TEXT_ALIGNMENT_TRAILING;
-        break;
-      // TODO use LTR values
-      case facebook::react::TextAlignment::Natural:
-        alignment = DWRITE_TEXT_ALIGNMENT_LEADING;
-        break;
-      default:
-        assert(false);
-    }
-  }
-  // TODO
-  // m_textFormat->SetTextAlignment(alignment);
 }
 
 void ParagraphComponentView::OnRenderingDeviceLost() noexcept {
@@ -160,7 +141,6 @@ void ParagraphComponentView::updateVisualBrush() noexcept {
 
   // TODO
   // updateTextAlignment(paragraphProps.textAttributes.alignment);
-
   if (!m_textLayout) {
     facebook::react::LayoutConstraints constraints;
     constraints.maximumSize.width =
@@ -168,7 +148,38 @@ void ParagraphComponentView::updateVisualBrush() noexcept {
     constraints.maximumSize.height =
         m_layoutMetrics.frame.size.height - m_layoutMetrics.contentInsets.top - m_layoutMetrics.contentInsets.bottom;
 
-    facebook::react::TextLayoutManager::GetTextLayout(m_attributedStringBox, {} /*TODO*/, constraints, m_textLayout);
+    facebook::react::TextLayoutManager::GetTextLayout(
+        m_attributedStringBox, m_paragraphAttributes, constraints, m_textLayout);
+
+    // Apply text alignment after creating the text layout
+    if (m_textLayout) {
+      const auto &props = paragraphProps();
+      DWRITE_TEXT_ALIGNMENT alignment = DWRITE_TEXT_ALIGNMENT_LEADING;
+      if (props.textAttributes.alignment) {
+        switch (*props.textAttributes.alignment) {
+          case facebook::react::TextAlignment::Center:
+            alignment = DWRITE_TEXT_ALIGNMENT_CENTER;
+            break;
+          case facebook::react::TextAlignment::Justified:
+            alignment = DWRITE_TEXT_ALIGNMENT_JUSTIFIED;
+            break;
+          case facebook::react::TextAlignment::Left:
+            alignment = DWRITE_TEXT_ALIGNMENT_LEADING;
+            break;
+          case facebook::react::TextAlignment::Right:
+            alignment = DWRITE_TEXT_ALIGNMENT_TRAILING;
+            break;
+          case facebook::react::TextAlignment::Natural:
+            alignment = DWRITE_TEXT_ALIGNMENT_LEADING;
+            break;
+          default:
+            alignment = DWRITE_TEXT_ALIGNMENT_LEADING;
+            break;
+        }
+      }
+      winrt::check_hresult(m_textLayout->SetTextAlignment(alignment));
+    }
+
     requireNewBrush = true;
   }
 
@@ -270,9 +281,7 @@ void ParagraphComponentView::DrawText() noexcept {
       d2dDeviceContext->Clear(
           viewProps()->backgroundColor ? theme()->D2DColor(*viewProps()->backgroundColor)
                                        : D2D1::ColorF(D2D1::ColorF::Black, 0.0f));
-
       const auto &props = paragraphProps();
-
       RenderText(
           *d2dDeviceContext,
           *m_textLayout,

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

@@ -88,6 +88,8 @@ void RootComponentView::SetFocusedComponent(
         ->onLostFocus(args);
   }
 
+  m_focusedComponent = value;
+
   if (value) {
     if (auto rootView = m_wkRootView.get()) {
       winrt::get_self<winrt::Microsoft::ReactNative::implementation::ReactNativeIsland>(rootView)->TrySetFocus();
@@ -95,8 +97,6 @@ void RootComponentView::SetFocusedComponent(
     auto args = winrt::make<winrt::Microsoft::ReactNative::implementation::GotFocusEventArgs>(value, direction);
     winrt::get_self<winrt::Microsoft::ReactNative::implementation::ComponentView>(value)->onGotFocus(args);
   }
-
-  m_focusedComponent = value;
 }
 
 bool RootComponentView::NavigateFocus(const winrt::Microsoft::ReactNative::FocusNavigationRequest &request) noexcept {

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

@@ -9,6 +9,7 @@
 #include <Fabric/AbiViewProps.h>
 #include "CompositionDynamicAutomationProvider.h"
 #include "RootComponentView.h"
+#include "UiaHelpers.h"
 
 namespace winrt::Microsoft::ReactNative::Composition::implementation {
 
@@ -80,6 +81,16 @@ void SwitchComponentView::updateProps(
     m_visualUpdateRequired = true;
   }
 
+  if (oldViewProps.value != newViewProps.value) {
+    if (UiaClientsAreListening()) {
+      winrt::Microsoft::ReactNative::implementation::UpdateUiaProperty(
+          EnsureUiaProvider(),
+          UIA_ToggleToggleStatePropertyId,
+          oldViewProps.value ? ToggleState_On : ToggleState_Off,
+          newViewProps.value ? ToggleState_On : ToggleState_Off);
+    }
+  }
+
   Super::updateProps(props, oldProps);
 }
 

package/Microsoft.ReactNative/Fabric/Composition/TextInput/WindowsTextInputComponentView.cpp

@@ -14,6 +14,7 @@
 #include <winrt/Microsoft.UI.Input.h>
 #include <winrt/Windows.System.h>
 #include <winrt/Windows.UI.h>
+#include "../Composition.Input.h"
 #include "../CompositionHelpers.h"
 #include "../RootComponentView.h"
 #include "JSValueReader.h"
@@ -212,15 +213,14 @@ struct CompTextHost : public winrt::implements<CompTextHost, ITextHost> {
 
   //@cmember Get mouse capture
   void TxSetCapture(BOOL fCapture) override {
-    // assert(false);
-    // TODO capture?
-    /*
+    auto mousePointer = winrt::make<winrt::Microsoft::ReactNative::Composition::Input::implementation::Pointer>(
+        winrt::Microsoft::ReactNative::Composition::Input::PointerDeviceType::Mouse, 1 /* 1 is Mouse PointerId*/);
+
     if (fCapture) {
-      ::SetCapture(m_hwndHost);
+      m_outer->CapturePointer(mousePointer);
     } else {
-      ::ReleaseCapture();
+      m_outer->ReleasePointerCapture(mousePointer);
     }
-    */
   }
 
   //@cmember Set the focus to the text window
@@ -319,20 +319,30 @@ struct CompTextHost : public winrt::implements<CompTextHost, ITextHost> {
           return (*m_outer->windowsTextInputProps().textAttributes.foregroundColor).AsColorRefNoAlpha();
         // cr = 0x000000FF;
         break;
-
       case COLOR_WINDOW:
         if (m_outer->viewProps()->backgroundColor)
           return (*m_outer->viewProps()->backgroundColor).AsColorRefNoAlpha();
         break;
-        // case COLOR_HIGHLIGHT:
-        // cr = RGB(0, 0, 255);
-        // cr = 0x0000ffFF;
-        //          break;
 
-        // case COLOR_HIGHLIGHTTEXT:
-        // cr = RGB(255, 0, 0);
-        // cr = 0xFFFFFFFF;
-        //          break;
+      case COLOR_HIGHLIGHT:
+        if (m_outer->windowsTextInputProps().selectionColor)
+          return (*m_outer->windowsTextInputProps().selectionColor).AsColorRefNoAlpha();
+        break;
+
+      case COLOR_HIGHLIGHTTEXT:
+        // For selected text color, we use the same color as the selection background
+        // or the text color if selection color is not specified
+        if (m_outer->windowsTextInputProps().selectionColor) {
+          // Calculate appropriate text color based on selection background
+          auto selectionColor = (*m_outer->windowsTextInputProps().selectionColor).AsColorRefNoAlpha();
+          // Use white text for dark selection, black text for light selection
+          int r = GetRValue(selectionColor);
+          int g = GetGValue(selectionColor);
+          int b = GetBValue(selectionColor);
+          int brightness = (r * 299 + g * 587 + b * 114) / 1000;
+          return brightness > 125 ? RGB(0, 0, 0) : RGB(255, 255, 255);
+        }
+        break;
 
         // case COLOR_GRAYTEXT:
         // cr = RGB(128, 128, 128);
@@ -463,6 +473,13 @@ struct CompTextHost : public winrt::implements<CompTextHost, ITextHost> {
   WindowsTextInputComponentView *m_outer;
 };
 
+int WINAPI
+AutoCorrectOffCallback(LANGID langid, const WCHAR *pszBefore, WCHAR *pszAfter, LONG cchAfter, LONG *pcchReplaced) {
+  wcsncpy_s(pszAfter, cchAfter, pszBefore, _TRUNCATE);
+  *pcchReplaced = static_cast<LONG>(wcslen(pszAfter));
+  return ATP_CHANGE;
+}
+
 facebook::react::AttributedString WindowsTextInputComponentView::getAttributedString() const {
   // Use BaseTextShadowNode to get attributed string from children
 
@@ -986,7 +1003,10 @@ void WindowsTextInputComponentView::updateProps(
   if (!facebook::react::floatEquality(
           oldTextInputProps.textAttributes.fontSize, newTextInputProps.textAttributes.fontSize) ||
       (oldTextInputProps.textAttributes.allowFontScaling != newTextInputProps.textAttributes.allowFontScaling) ||
-      oldTextInputProps.textAttributes.fontWeight != newTextInputProps.textAttributes.fontWeight) {
+      oldTextInputProps.textAttributes.fontWeight != newTextInputProps.textAttributes.fontWeight ||
+      !facebook::react::floatEquality(
+          oldTextInputProps.textAttributes.letterSpacing, newTextInputProps.textAttributes.letterSpacing) ||
+      oldTextInputProps.textAttributes.fontFamily != newTextInputProps.textAttributes.fontFamily) {
     m_propBitsMask |= TXTBIT_CHARFORMATCHANGE;
     m_propBits |= TXTBIT_CHARFORMATCHANGE;
   }
@@ -1051,6 +1071,23 @@ void WindowsTextInputComponentView::updateProps(
     m_propBits |= TXTBIT_PARAFORMATCHANGE;
   }
 
+  // Please note: spellcheck performs both red lines and autocorrect as per windows behaviour
+  bool shouldUpdateSpellCheck =
+      (!oldProps || (oldTextInputProps.spellCheck != newTextInputProps.spellCheck) ||
+       (oldTextInputProps.autoCorrect != newTextInputProps.autoCorrect));
+
+  if (shouldUpdateSpellCheck) {
+    bool effectiveSpellCheck = newTextInputProps.spellCheck || newTextInputProps.autoCorrect;
+    updateSpellCheck(effectiveSpellCheck);
+  }
+  if (!oldProps || oldTextInputProps.autoCorrect != newTextInputProps.autoCorrect) {
+    updateAutoCorrect(newTextInputProps.autoCorrect);
+  }
+
+  if (oldTextInputProps.selectionColor != newTextInputProps.selectionColor) {
+    m_needsRedraw = true;
+  }
+
   UpdatePropertyBits();
 }
 
@@ -1136,6 +1173,49 @@ void WindowsTextInputComponentView::updateLayoutMetrics(
   m_imgHeight = newHeight;
 }
 
+std::pair<float, float> WindowsTextInputComponentView::GetContentSize() const noexcept {
+  if (!m_textServices)
+    return {0.0f, 0.0f};
+
+  // Get a device context for measurement
+  HDC hdc = GetDC(nullptr);
+  if (!hdc)
+    return {0.0f, 0.0f};
+
+  // Use the layout width as the constraint (always multiline)
+  float availableWidth = m_layoutMetrics.frame.size.width;
+  float scale = m_layoutMetrics.pointScaleFactor;
+  float dpi = m_layoutMetrics.pointScaleFactor * GetDpiForSystem();
+  constexpr float HIMETRIC_PER_INCH = 2540.0f;
+
+  SIZE extentHimetric = {
+      static_cast<LONG>(availableWidth * scale * HIMETRIC_PER_INCH / dpi),
+      static_cast<LONG>(std::numeric_limits<LONG>::max() * HIMETRIC_PER_INCH / dpi)};
+
+  SIZE naturalSize = {0, 0};
+
+  HRESULT hr = m_textServices->TxGetNaturalSize(
+      DVASPECT_CONTENT,
+      hdc,
+      nullptr,
+      nullptr,
+      static_cast<DWORD>(TXTNS_FITTOCONTENTWSP),
+      reinterpret_cast<SIZEL *>(&extentHimetric),
+      &naturalSize.cx,
+      &naturalSize.cy);
+
+  ReleaseDC(nullptr, hdc);
+
+  if (FAILED(hr)) {
+    return {0.0f, 0.0f};
+  }
+
+  float contentWidth = static_cast<float>(naturalSize.cx) / scale;
+  float contentHeight = static_cast<float>(naturalSize.cy) / scale;
+
+  return {contentWidth, contentHeight};
+}
+
 // When we are notified by RichEdit that the text changed, we need to notify JS
 void WindowsTextInputComponentView::OnTextUpdated() noexcept {
   auto data = m_state->getData();
@@ -1154,6 +1234,13 @@ void WindowsTextInputComponentView::OnTextUpdated() noexcept {
     onChangeArgs.text = GetTextFromRichEdit();
     onChangeArgs.eventCount = ++m_nativeEventCount;
     emitter->onChange(onChangeArgs);
+    if (windowsTextInputProps().multiline) {
+      auto [contentWidth, contentHeight] = GetContentSize();
+      facebook::react::WindowsTextInputEventEmitter::OnContentSizeChange onContentSizeChangeArgs;
+      onContentSizeChangeArgs.contentSize.width = contentWidth;
+      onContentSizeChangeArgs.contentSize.height = contentHeight;
+      emitter->onContentSizeChange(onContentSizeChangeArgs);
+    }
   }
 
   if (m_uiaProvider) {
@@ -1228,6 +1315,13 @@ void WindowsTextInputComponentView::onMounted() noexcept {
     m_propBits |= TXTBIT_CHARFORMATCHANGE;
   }
   InternalFinalize();
+
+  // Handle autoFocus property - focus the component when mounted if autoFocus is true
+  if (windowsTextInputProps().autoFocus) {
+    if (auto root = rootComponentView()) {
+      root->TrySetFocusedComponent(*get_strong(), winrt::Microsoft::ReactNative::FocusNavigationDirection::None);
+    }
+  }
 }
 
 std::optional<std::string> WindowsTextInputComponentView::getAccessiblityValue() noexcept {
@@ -1272,9 +1366,12 @@ void WindowsTextInputComponentView::UpdateCharFormat() noexcept {
 
   // set font size -- 15 to convert twips to pt
   const auto &props = windowsTextInputProps();
-  float fontSize = m_fontSizeMultiplier *
+  float fontSize =
       (std::isnan(props.textAttributes.fontSize) ? facebook::react::TextAttributes::defaultTextAttributes().fontSize
                                                  : props.textAttributes.fontSize);
+
+  fontSize *= m_fontSizeMultiplier;
+
   // TODO get fontSize from props.textAttributes, or defaultTextAttributes, or fragment?
   cfNew.dwMask |= CFM_SIZE;
   cfNew.yHeight = static_cast<LONG>(fontSize * 15);
@@ -1495,6 +1592,9 @@ WindowsTextInputComponentView::createVisual() noexcept {
   LRESULT res;
   winrt::check_hresult(m_textServices->TxSendMessage(EM_SETTEXTMODE, TM_PLAINTEXT, 0, &res));
 
+  // Enable TSF support
+  winrt::check_hresult(m_textServices->TxSendMessage(EM_SETEDITSTYLE, SES_USECTF, SES_USECTF, nullptr));
+
   m_caretVisual = m_compContext.CreateCaretVisual();
   visual.InsertAt(m_caretVisual.InnerVisual(), 0);
   m_caretVisual.IsVisible(false);
@@ -1545,4 +1645,39 @@ void WindowsTextInputComponentView::autoCapitalizeOnUpdateProps(
   }
 }
 
+void WindowsTextInputComponentView::updateLetterSpacing(float letterSpacing) noexcept {
+  CHARFORMAT2W cf = {};
+  cf.cbSize = sizeof(CHARFORMAT2W);
+  cf.dwMask = CFM_SPACING;
+  cf.sSpacing = static_cast<SHORT>(letterSpacing * 20); // Convert to TWIPS
+
+  LRESULT res;
+
+  // Apply to all existing text like placeholder
+  winrt::check_hresult(m_textServices->TxSendMessage(EM_SETCHARFORMAT, SCF_ALL, reinterpret_cast<LPARAM>(&cf), &res));
+
+  // Apply to future text input
+  winrt::check_hresult(
+      m_textServices->TxSendMessage(EM_SETCHARFORMAT, SCF_SELECTION, reinterpret_cast<LPARAM>(&cf), &res));
+}
+
+void WindowsTextInputComponentView::updateAutoCorrect(bool enable) noexcept {
+  LRESULT lresult;
+  winrt::check_hresult(m_textServices->TxSendMessage(
+      EM_SETAUTOCORRECTPROC, enable ? 0 : reinterpret_cast<WPARAM>(AutoCorrectOffCallback), 0, &lresult));
+}
+
+void WindowsTextInputComponentView::updateSpellCheck(bool enable) noexcept {
+  LRESULT currentLangOptions;
+  winrt::check_hresult(m_textServices->TxSendMessage(EM_GETLANGOPTIONS, 0, 0, &currentLangOptions));
+
+  DWORD newLangOptions = static_cast<DWORD>(currentLangOptions);
+  if (enable) {
+    newLangOptions |= IMF_SPELLCHECKING;
+  }
+
+  LRESULT lresult;
+  winrt::check_hresult(
+      m_textServices->TxSendMessage(EM_SETLANGOPTIONS, IMF_SPELLCHECKING, enable ? newLangOptions : 0, &lresult));
+}
 } // namespace winrt::Microsoft::ReactNative::Composition::implementation

package/Microsoft.ReactNative/Fabric/Composition/TextInput/WindowsTextInputComponentView.h

@@ -97,6 +97,7 @@ struct WindowsTextInputComponentView
   void UpdateText(const std::string &str) noexcept;
   void OnTextUpdated() noexcept;
   void OnSelectionChanged(LONG start, LONG end) noexcept;
+  std::pair<float, float> GetContentSize() const noexcept;
   std::string GetTextFromRichEdit() const noexcept;
   void updateCursorColor(
       const facebook::react::SharedColor &cursorColor,
@@ -110,6 +111,10 @@ struct WindowsTextInputComponentView
       const std::string &previousCapitalizationType,
       const std::string &newcapitalizationType) noexcept;
 
+  void updateLetterSpacing(float letterSpacing) noexcept;
+  void updateAutoCorrect(bool value) noexcept;
+  void updateSpellCheck(bool value) noexcept;
+
   winrt::Windows::UI::Composition::CompositionSurfaceBrush m_brush{nullptr};
   winrt::Microsoft::ReactNative::Composition::Experimental::ICaretVisual m_caretVisual{nullptr};
   winrt::Microsoft::ReactNative::Composition::Experimental::IDrawingSurfaceBrush m_drawingSurface{nullptr};

package/Microsoft.ReactNative/Fabric/Composition/TextInput/WindowsTextInputProps.cpp

@@ -24,6 +24,7 @@ WindowsTextInputProps::WindowsTextInputProps(
           */
 
       allowFontScaling(convertRawProp(context, rawProps, "allowFontScaling", sourceProps.allowFontScaling, {true})),
+      autoCorrect(convertRawProp(context, rawProps, "autoCorrect", sourceProps.autoCorrect, {true})),
       clearTextOnFocus(convertRawProp(context, rawProps, "clearTextOnFocus", sourceProps.clearTextOnFocus, {false})),
       editable(convertRawProp(context, rawProps, "editable", sourceProps.editable, {true})),
       maxLength(convertRawProp(context, rawProps, "maxLength", sourceProps.maxLength, {0})),
@@ -36,7 +37,7 @@ WindowsTextInputProps::WindowsTextInputProps(
       selection(convertRawProp(context, rawProps, "selection", sourceProps.selection, {})),
       selectionColor(convertRawProp(context, rawProps, "selectionColor", sourceProps.selectionColor, {})),
       selectTextOnFocus(convertRawProp(context, rawProps, "selectTextOnFocus", sourceProps.selectTextOnFocus, {false})),
-      spellCheck(convertRawProp(context, rawProps, "spellCheck", sourceProps.spellCheck, {false})),
+      spellCheck(convertRawProp(context, rawProps, "spellCheck", sourceProps.spellCheck, {true})),
       text(convertRawProp(context, rawProps, "text", sourceProps.text, {})),
       mostRecentEventCount(
           convertRawProp(context, rawProps, "mostRecentEventCount", sourceProps.mostRecentEventCount, {0})),

package/Microsoft.ReactNative/Fabric/Composition/TextInput/WindowsTextInputProps.h

@@ -97,6 +97,7 @@ class WindowsTextInputProps final : public ViewProps, public BaseTextProps {
   setProp(const PropsParserContext &context, RawPropsPropNameHash hash, const char *propName, RawValue const &value);
 
   bool allowFontScaling{true};
+  bool autoCorrect{true};
   bool clearTextOnFocus{false};
   bool editable{true};
   int maxLength{0};
@@ -108,7 +109,7 @@ class WindowsTextInputProps final : public ViewProps, public BaseTextProps {
   CompWindowsTextInputSelectionStruct selection{};
   SharedColor selectionColor{};
   bool selectTextOnFocus{false};
-  bool spellCheck{false};
+  bool spellCheck{true};
   std::string text{};
   int mostRecentEventCount{0};
   bool secureTextEntry{false};

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,
@@ -180,6 +198,16 @@ void UpdateUiaProperty(
       spProviderSimple.get(), propId, CComVariant(oldValue.c_str()), CComVariant(newValue.c_str()));
 }
 
+void UpdateUiaProperty(
+    winrt::IInspectable provider,
+    PROPERTYID propId,
+    const std::optional<std::string> &oldValue,
+    const std::optional<std::string> &newValue) noexcept {
+  std::string oldData = oldValue.value_or("");
+  std::string newData = newValue.value_or("");
+  UpdateUiaProperty(provider, propId, oldData, newData);
+}
+
 long GetLiveSetting(const std::string &liveRegion) noexcept {
   if (liveRegion == "polite") {
     return LiveSetting::Polite;
@@ -254,4 +282,18 @@ ToggleState GetToggleState(const std::optional<facebook::react::AccessibilitySta
   return ToggleState::ToggleState_Off;
 }
 
-} // namespace winrt::Microsoft::ReactNative::implementation
+TextDecorationLineStyle GetTextDecorationLineStyle(facebook::react::TextDecorationStyle style) noexcept {
+  if (style == facebook::react::TextDecorationStyle::Dashed) {
+    return TextDecorationLineStyle_Dash;
+  } else if (style == facebook::react::TextDecorationStyle::Dotted) {
+    return TextDecorationLineStyle_Dot;
+  } else if (style == facebook::react::TextDecorationStyle::Double) {
+    return TextDecorationLineStyle_Double;
+  } else if (style == facebook::react::TextDecorationStyle::Solid) {
+    return TextDecorationLineStyle_Single;
+  } else {
+    return TextDecorationLineStyle_Single;
+  }
+}
+
+} // namespace winrt::Microsoft::ReactNative::implementation

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

@@ -2,6 +2,7 @@
 
 #include <Fabric/ComponentView.h>
 #include <Fabric/Composition/CompositionDynamicAutomationProvider.h>
+#include <Fabric/Composition/ParagraphComponentView.h>
 #include <Fabric/ReactTaggedView.h>
 #include <UIAutomation.h>
 
@@ -22,14 +23,36 @@ HRESULT UiaGetBoundingRectangleHelper(::Microsoft::ReactNative::ReactTaggedView
 
 HRESULT UiaSetFocusHelper(::Microsoft::ReactNative::ReactTaggedView &view) noexcept;
 
-void UpdateUiaProperty(winrt::IInspectable provider, PROPERTYID propId, bool oldValue, bool newValue) noexcept;
+void UpdateUiaProperty(
+    winrt::Windows::Foundation::IInspectable provider,
+    PROPERTYID propId,
+    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::IInspectable provider,
+    winrt::Windows::Foundation::IInspectable provider,
     PROPERTYID propId,
     const std::string &oldValue,
     const std::string &newValue) noexcept;
 
+void UpdateUiaProperty(
+    winrt::Windows::Foundation::IInspectable provider,
+    PROPERTYID propId,
+    const std::optional<std::string> &oldValue,
+    const std::optional<std::string> &newValue) noexcept;
+
 long GetLiveSetting(const std::string &liveRegion) noexcept;
 
 void DispatchAccessibilityAction(::Microsoft::ReactNative::ReactTaggedView &view, const std::string &action) noexcept;
@@ -41,4 +64,6 @@ void AddSelectionItemsToContainer(CompositionDynamicAutomationProvider *provider
 void RemoveSelectionItemsFromContainer(CompositionDynamicAutomationProvider *provider) noexcept;
 
 ToggleState GetToggleState(const std::optional<facebook::react::AccessibilityState> &state) noexcept;
+
+TextDecorationLineStyle GetTextDecorationLineStyle(facebook::react::TextDecorationStyle style) noexcept;
 } // namespace winrt::Microsoft::ReactNative::implementation

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

@@ -38,20 +38,38 @@ void HostPlatformViewEventEmitter::onBlur() const {
 
 #pragma mark - Mouse Events
 
-void HostPlatformViewEventEmitter::onMouseEnter(PointerEvent const &pointerEvent) const {
+void HostPlatformViewEventEmitter::onMouseEnter(MouseEvent const &pointerEvent) const {
   dispatchEvent(
       "mouseEnter",
-      std::make_shared<PointerEvent>(pointerEvent),
+      std::make_shared<MouseEvent>(pointerEvent),
       EventPriority::AsynchronousBatched,
       RawEvent::Category::ContinuousStart);
 }
 
-void HostPlatformViewEventEmitter::onMouseLeave(PointerEvent const &pointerEvent) const {
+void HostPlatformViewEventEmitter::onMouseLeave(MouseEvent const &pointerEvent) const {
   dispatchEvent(
       "mouseLeave",
-      std::make_shared<PointerEvent>(pointerEvent),
+      std::make_shared<MouseEvent>(pointerEvent),
       EventPriority::AsynchronousBatched,
       RawEvent::Category::ContinuousStart);
 }
 
+#pragma mark - Touch Events
+
+void HostPlatformViewEventEmitter::onPressIn(GestureResponderEvent event) const {
+  dispatchEvent("pressIn", [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

@@ -5,9 +5,18 @@
 
 #include <react/renderer/components/view/BaseViewEventEmitter.h>
 #include "KeyEvent.h"
+#include "MouseEvent.h"
 
 namespace facebook::react {
 
+struct GestureResponderEvent {
+  Tag target;
+  Point pagePoint;
+  Point offsetPoint;
+  double timestamp;
+  int identifier;
+};
+
 class HostPlatformViewEventEmitter : public BaseViewEventEmitter {
  public:
   using BaseViewEventEmitter::BaseViewEventEmitter;
@@ -24,8 +33,12 @@ class HostPlatformViewEventEmitter : public BaseViewEventEmitter {
 
 #pragma mark - Mouse Events
 
-  void onMouseEnter(PointerEvent const &pointerEvent) const;
-  void onMouseLeave(PointerEvent const &pointerEvent) const;
+  void onMouseEnter(MouseEvent const &pointerEvent) const;
+  void onMouseLeave(MouseEvent const &pointerEvent) const;
+
+#pragma mark - Touch Events
+
+  virtual void onPressIn(GestureResponderEvent event) const;
 };
 
-} // namespace facebook::react
+} // namespace facebook::react