react-native-windows 0.79.4 → 0.80.0-preview.2

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

@@ -14,6 +14,21 @@
 
 namespace winrt::Microsoft::ReactNative::implementation {
 
+// Helper function to check if any parent has NoHideDescendants
+bool IsHiddenByParent(const winrt::Microsoft::ReactNative::ComponentView &view) {
+  auto parent = view.Parent();
+  while (parent) {
+    auto parentProps = std::static_pointer_cast<const facebook::react::ViewProps>(
+        winrt::get_self<winrt::Microsoft::ReactNative::implementation::ComponentView>(parent)->props());
+    if (parentProps &&
+        parentProps->importantForAccessibility == facebook::react::ImportantForAccessibility::NoHideDescendants) {
+      return true;
+    }
+    parent = parent.Parent();
+  }
+  return false;
+}
+
 CompositionDynamicAutomationProvider::CompositionDynamicAutomationProvider(
     const winrt::Microsoft::ReactNative::Composition::ComponentView &componentView) noexcept
     : m_view{componentView} {
@@ -521,16 +536,25 @@ HRESULT __stdcall CompositionDynamicAutomationProvider::GetPropertyValue(PROPERT
     }
     case UIA_IsContentElementPropertyId: {
       pRetVal->vt = VT_BOOL;
-      pRetVal->boolVal =
-          (props->accessible && (props->accessibilityRole != "none" || props->role != facebook::react::Role::None))
+      // Check if this element or any parent has NoHideDescendants
+      bool isHidden =
+          props->importantForAccessibility == facebook::react::ImportantForAccessibility::NoHideDescendants ||
+          IsHiddenByParent(strongView);
+      pRetVal->boolVal = (!isHidden && props->accessible &&
+                          (props->accessibilityRole != "none" || props->role != facebook::react::Role::None))
           ? VARIANT_TRUE
           : VARIANT_FALSE;
       break;
     }
+
     case UIA_IsControlElementPropertyId: {
       pRetVal->vt = VT_BOOL;
-      pRetVal->boolVal =
-          (props->accessible && (props->accessibilityRole != "none" || props->role != facebook::react::Role::None))
+      // Check if this element or any parent has NoHideDescendants
+      bool isHidden =
+          props->importantForAccessibility == facebook::react::ImportantForAccessibility::NoHideDescendants ||
+          IsHiddenByParent(strongView);
+      pRetVal->boolVal = (!isHidden && props->accessible &&
+                          (props->accessibilityRole != "none" || props->role != facebook::react::Role::None))
           ? VARIANT_TRUE
           : VARIANT_FALSE;
       break;
@@ -588,6 +612,12 @@ HRESULT __stdcall CompositionDynamicAutomationProvider::GetPropertyValue(PROPERT
       pRetVal->bstrVal = SysAllocString(itemtype.c_str());
       break;
     }
+    case UIA_FullDescriptionPropertyId: {
+      pRetVal->vt = VT_BSTR;
+      auto desc = ::Microsoft::Common::Unicode::Utf8ToUtf16(props->accessibilityDescription.value_or(""));
+      pRetVal->bstrVal = SysAllocString(desc.c_str());
+      break;
+    }
   }
   return hr;
 }

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

@@ -819,6 +819,18 @@ void ComponentView::updateAccessibilityProps(
       oldViewProps.accessibilityItemType,
       newViewProps.accessibilityItemType);
 
+  winrt::Microsoft::ReactNative::implementation::UpdateUiaProperty(
+      EnsureUiaProvider(),
+      UIA_FullDescriptionPropertyId,
+      oldViewProps.accessibilityDescription,
+      newViewProps.accessibilityDescription);
+
+  winrt::Microsoft::ReactNative::implementation::UpdateUiaProperty(
+      EnsureUiaProvider(),
+      UIA_ValueValuePropertyId,
+      oldViewProps.accessibilityValue.text,
+      newViewProps.accessibilityValue.text);
+
   if ((oldViewProps.accessibilityState.has_value() && oldViewProps.accessibilityState->selected.has_value()) !=
       ((newViewProps.accessibilityState.has_value() && newViewProps.accessibilityState->selected.has_value()))) {
     auto compProvider =

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

@@ -63,8 +63,12 @@ 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_requireRedraw = true;
+    m_textLayout = nullptr;
   }
 
   Super::updateProps(props, oldProps);
@@ -100,7 +104,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;
@@ -123,35 +127,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 {
@@ -163,7 +140,6 @@ void ParagraphComponentView::updateVisualBrush() noexcept {
 
   // TODO
   // updateTextAlignment(paragraphProps.textAttributes.alignment);
-
   if (!m_textLayout) {
     facebook::react::LayoutConstraints constraints;
     constraints.maximumSize.width =
@@ -174,6 +150,35 @@ void ParagraphComponentView::updateVisualBrush() noexcept {
     facebook::react::WindowsTextLayoutManager::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;
   }
 
@@ -275,9 +280,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/ScrollViewComponentView.cpp

@@ -15,6 +15,7 @@
 #pragma warning(pop)
 
 #include <windows.ui.composition.interop.h>
+#include <winrt/Windows.UI.ViewManagement.Core.h>
 
 #include <AutoDraw.h>
 #include <Fabric/DWriteHelpers.h>
@@ -26,6 +27,7 @@
 namespace winrt::Microsoft::ReactNative::Composition::implementation {
 
 constexpr float c_scrollerLineDelta = 16.0f;
+constexpr auto c_maxSnapPoints = 1000;
 
 enum class ScrollbarHitRegion : int {
   Unknown = -1,
@@ -739,6 +741,15 @@ void ScrollViewComponentView::updateBackgroundColor(const facebook::react::Share
   }
 }
 
+winrt::Windows::Foundation::Collections::IVector<float> ScrollViewComponentView::CreateSnapToOffsets(
+    const std::vector<float> &offsets) {
+  auto snapToOffsets = winrt::single_threaded_vector<float>();
+  for (const auto &offset : offsets) {
+    snapToOffsets.Append(offset);
+  }
+  return snapToOffsets;
+}
+
 void ScrollViewComponentView::updateProps(
     facebook::react::Props::Shared const &props,
     facebook::react::Props::Shared const &oldProps) noexcept {
@@ -804,6 +815,17 @@ void ScrollViewComponentView::updateProps(
   if (oldViewProps.zoomScale != newViewProps.zoomScale) {
     m_scrollVisual.Scale({newViewProps.zoomScale, newViewProps.zoomScale, newViewProps.zoomScale});
   }
+
+  if (oldViewProps.snapToStart != newViewProps.snapToStart || oldViewProps.snapToEnd != newViewProps.snapToEnd ||
+      oldViewProps.snapToOffsets != newViewProps.snapToOffsets) {
+    if (oldViewProps.snapToInterval != newViewProps.snapToInterval) {
+      updateSnapPoints();
+    } else {
+      const auto snapToOffsets = CreateSnapToOffsets(newViewProps.snapToOffsets);
+      m_scrollVisual.SetSnapPoints(
+          newViewProps.snapToStart, newViewProps.snapToEnd, snapToOffsets.GetView(), SnapAlignment::Center);
+    }
+  }
 }
 
 void ScrollViewComponentView::updateState(
@@ -853,6 +875,9 @@ void ScrollViewComponentView::updateContentVisualSize() noexcept {
   m_verticalScrollbarComponent->ContentSize(contentSize);
   m_horizontalScrollbarComponent->ContentSize(contentSize);
   m_scrollVisual.ContentSize(contentSize);
+
+  // Update snap points if snapToInterval is being used, as content size affects the number of snap points
+  updateSnapPoints();
 }
 
 void ScrollViewComponentView::prepareForRecycle() noexcept {}
@@ -1276,6 +1301,16 @@ winrt::Microsoft::ReactNative::Composition::Experimental::IVisual ScrollViewComp
         auto now = std::chrono::steady_clock::now();
         auto elapsed = std::chrono::duration_cast<std::chrono::duration<double>>(now - m_lastScrollEventTime).count();
 
+        // Dismiss keyboard if mode is "on-drag"
+        auto keyboardDismissMode =
+            std::static_pointer_cast<const facebook::react::ScrollViewProps>(viewProps())->keyboardDismissMode;
+        if (keyboardDismissMode == facebook::react::ScrollViewKeyboardDismissMode::OnDrag) {
+          auto coreInputView = winrt::Windows::UI::ViewManagement::Core::CoreInputView::GetForCurrentView();
+          if (coreInputView) {
+            coreInputView.TryHide();
+          }
+        }
+
         if (m_allowNextScrollNoMatterWhat ||
             (m_scrollEventThrottle < std::max(std::chrono::duration<double>(0.017).count(), elapsed))) {
           updateStateWithContentOffset();
@@ -1415,4 +1450,50 @@ void ScrollViewComponentView::updateShowsVerticalScrollIndicator(bool value) noe
 void ScrollViewComponentView::updateDecelerationRate(float value) noexcept {
   m_scrollVisual.SetDecelerationRate({value, value, value});
 }
+
+SnapAlignment ScrollViewComponentView::convertSnapToAlignment(
+    facebook::react::ScrollViewSnapToAlignment alignment) noexcept {
+  switch (alignment) {
+    case facebook::react::ScrollViewSnapToAlignment::Center:
+      return SnapAlignment::Center;
+    case facebook::react::ScrollViewSnapToAlignment::End:
+      return SnapAlignment::End;
+    case facebook::react::ScrollViewSnapToAlignment::Start:
+    default:
+      return SnapAlignment::Start;
+  }
+}
+
+void ScrollViewComponentView::updateSnapPoints() noexcept {
+  const auto &viewProps = *std::static_pointer_cast<const facebook::react::ScrollViewProps>(this->viewProps());
+  const auto snapToOffsets = CreateSnapToOffsets(viewProps.snapToOffsets);
+  // Typically used in combination with snapToAlignment and decelerationRate="fast"
+  auto snapAlignment = SnapAlignment::Center;
+  auto decelerationRate = viewProps.decelerationRate;
+
+  // snapToOffsets has priority over snapToInterval (matches React Native behavior)
+  if (viewProps.snapToInterval > 0 && decelerationRate >= 0.99) {
+    snapAlignment = convertSnapToAlignment(viewProps.snapToAlignment);
+    // Generate snap points based on interval
+    // Calculate the content size to determine how many intervals to create
+    float contentLength = viewProps.horizontal
+        ? std::max(m_contentSize.width, m_layoutMetrics.frame.size.width) * m_layoutMetrics.pointScaleFactor
+        : std::max(m_contentSize.height, m_layoutMetrics.frame.size.height) * m_layoutMetrics.pointScaleFactor;
+
+    float interval = static_cast<float>(viewProps.snapToInterval) * m_layoutMetrics.pointScaleFactor;
+
+    // Ensure we have a reasonable minimum interval to avoid infinite loops or excessive memory usage
+    if (interval >= 1.0f && contentLength > 0) {
+      // Generate offsets at each interval, but limit the number of snap points to avoid excessive memory usage
+      int snapPointCount = 0;
+
+      for (float offset = 0; offset <= contentLength && snapPointCount < c_maxSnapPoints; offset += interval) {
+        snapToOffsets.Append(offset);
+        snapPointCount++;
+      }
+    }
+  }
+
+  m_scrollVisual.SetSnapPoints(viewProps.snapToStart, viewProps.snapToEnd, snapToOffsets.GetView(), snapAlignment);
+}
 } // namespace winrt::Microsoft::ReactNative::Composition::implementation

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

@@ -18,6 +18,8 @@
 
 namespace winrt::Microsoft::ReactNative::Composition::implementation {
 
+using namespace Microsoft::ReactNative::Composition::Experimental;
+
 struct ScrollBarComponent;
 
 struct ScrollViewComponentView : ScrollViewComponentViewT<ScrollViewComponentView, ViewComponentView> {
@@ -121,6 +123,7 @@ struct ScrollInteractionTrackerOwner : public winrt::implements<
  private:
   void updateDecelerationRate(float value) noexcept;
   void updateContentVisualSize() noexcept;
+  void updateSnapPoints() noexcept;
   bool scrollToEnd(bool animate) noexcept;
   bool scrollToStart(bool animate) noexcept;
   bool scrollDown(float delta, bool animate) noexcept;
@@ -134,6 +137,8 @@ struct ScrollInteractionTrackerOwner : public winrt::implements<
       winrt::Microsoft::ReactNative::Composition::Experimental::IScrollPositionChangedArgs const &args) noexcept;
   void updateShowsHorizontalScrollIndicator(bool value) noexcept;
   void updateShowsVerticalScrollIndicator(bool value) noexcept;
+  SnapAlignment convertSnapToAlignment(facebook::react::ScrollViewSnapToAlignment alignment) noexcept;
+  winrt::Windows::Foundation::Collections::IVector<float> CreateSnapToOffsets(const std::vector<float> &offsets);
 
   facebook::react::Size m_contentSize;
   winrt::Microsoft::ReactNative::Composition::Experimental::IScrollVisual m_scrollVisual{nullptr};

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

@@ -320,20 +320,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);
@@ -749,6 +759,24 @@ void WindowsTextInputComponentView::OnPointerReleased(
     auto hr = m_textServices->TxSendMessage(msg, static_cast<WPARAM>(wParam), static_cast<LPARAM>(lParam), &lresult);
     args.Handled(hr != S_FALSE);
   }
+
+  // Emits the OnPressOut event
+  if (m_eventEmitter && !m_comingFromJS) {
+    auto emitter = std::static_pointer_cast<const facebook::react::WindowsTextInputEventEmitter>(m_eventEmitter);
+    float offsetX = position.X - m_layoutMetrics.frame.origin.x;
+    float offsetY = position.Y - m_layoutMetrics.frame.origin.y;
+    float neutralX = m_layoutMetrics.frame.origin.x;
+    float neutralY = m_layoutMetrics.frame.origin.y;
+
+    facebook::react::GestureResponderEvent pressOutArgs;
+    pressOutArgs.target = m_tag;
+    pressOutArgs.pagePoint = {position.X, position.Y};
+    pressOutArgs.offsetPoint = {offsetX, offsetY}; //{LocationX,LocationY}
+    pressOutArgs.timestamp = static_cast<double>(pp.Timestamp()) / 1000.0;
+    pressOutArgs.identifier = pp.PointerId();
+
+    emitter->onPressOut(pressOutArgs);
+  }
 }
 
 void WindowsTextInputComponentView::OnPointerMoved(
@@ -783,6 +811,29 @@ void WindowsTextInputComponentView::OnPointerMoved(
       DVASPECT_CONTENT, -1, nullptr, nullptr, nullptr, nullptr, nullptr, ptContainer.x, ptContainer.y);
 }
 
+void WindowsTextInputComponentView::OnPointerWheelChanged(
+    const winrt::Microsoft::ReactNative::Composition::Input::PointerRoutedEventArgs &args) noexcept {
+  if (windowsTextInputProps().scrollEnabled && windowsTextInputProps().multiline) {
+    auto pointerPointProperties = args.GetCurrentPoint(-1).Properties();
+
+    auto delta = static_cast<float>(pointerPointProperties.MouseWheelDelta());
+
+    if (m_textServices && !pointerPointProperties.IsHorizontalMouseWheel()) {
+      // Vertical scrolling
+      if (delta > 0) {
+        m_textServices->TxSendMessage(WM_VSCROLL, SB_LINEUP, 0, nullptr);
+      } else {
+        m_textServices->TxSendMessage(WM_VSCROLL, SB_LINEDOWN, 0, nullptr);
+      }
+      args.Handled(true);
+    }
+    // Emit the onScroll event
+    EmitOnScrollEvent();
+
+    // We don't support horizontal scrolling yet cause it is not implemented in Android/IOS
+  }
+  Super::OnPointerWheelChanged(args);
+}
 void WindowsTextInputComponentView::OnKeyDown(
     const winrt::Microsoft::ReactNative::Composition::Input::KeyRoutedEventArgs &args) noexcept {
   // Do not forward tab keys into the TextInput, since we want that to do the tab loop instead.  This aligns with WinUI
@@ -808,7 +859,6 @@ void WindowsTextInputComponentView::OnKeyDown(
       args.Handled(true);
     }
   }
-
   Super::OnKeyDown(args);
 }
 
@@ -838,7 +888,6 @@ void WindowsTextInputComponentView::OnKeyUp(
       args.Handled(true);
     }
   }
-
   Super::OnKeyUp(args);
 }
 
@@ -1052,7 +1101,10 @@ void WindowsTextInputComponentView::updateProps(
       oldTextInputProps.textAttributes.fontWeight != newTextInputProps.textAttributes.fontWeight ||
       !facebook::react::floatEquality(
           oldTextInputProps.textAttributes.letterSpacing, newTextInputProps.textAttributes.letterSpacing) ||
-      oldTextInputProps.textAttributes.fontFamily != newTextInputProps.textAttributes.fontFamily) {
+      oldTextInputProps.textAttributes.fontFamily != newTextInputProps.textAttributes.fontFamily ||
+      !facebook::react::floatEquality(
+          oldTextInputProps.textAttributes.maxFontSizeMultiplier,
+          newTextInputProps.textAttributes.maxFontSizeMultiplier)) {
     m_propBitsMask |= TXTBIT_CHARFORMATCHANGE;
     m_propBits |= TXTBIT_CHARFORMATCHANGE;
   }
@@ -1126,11 +1178,14 @@ void WindowsTextInputComponentView::updateProps(
     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();
 }
 
@@ -1216,6 +1271,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();
@@ -1234,6 +1332,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 (UiaClientsAreListening()) {
@@ -1243,6 +1348,22 @@ void WindowsTextInputComponentView::OnTextUpdated() noexcept {
   }
 }
 
+void WindowsTextInputComponentView::EmitOnScrollEvent() noexcept {
+  if (!windowsTextInputProps().scrollEnabled || !m_eventEmitter || m_comingFromJS || !m_textServices) {
+    return;
+  }
+  LONG hMin, hMax, hPos, hPage;
+  LONG vMin, vMax, vPos, vPage;
+  BOOL hEnabled, vEnabled;
+  winrt::check_hresult(m_textServices->TxGetHScroll(&hMin, &hMax, &hPos, &hPage, &hEnabled));
+  winrt::check_hresult(m_textServices->TxGetVScroll(&vMin, &vMax, &vPos, &vPage, &vEnabled));
+  facebook::react::Point offset;
+  offset.x = static_cast<float>(hPos);
+  offset.y = static_cast<float>(vPos);
+  auto emitter = std::static_pointer_cast<const facebook::react::WindowsTextInputEventEmitter>(m_eventEmitter);
+  emitter->onScroll(offset);
+}
+
 void WindowsTextInputComponentView::OnSelectionChanged(LONG start, LONG end) noexcept {
   if (m_eventEmitter && !m_comingFromState /* && !m_comingFromJS ?? */) {
     auto emitter = std::static_pointer_cast<const facebook::react::WindowsTextInputEventEmitter>(m_eventEmitter);
@@ -1308,6 +1429,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 {
@@ -1352,9 +1480,15 @@ 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);
+
+  // Apply maxFontSizeMultiplier if specified
+  auto maxFontSizeMultiplier = windowsTextInputProps().textAttributes.maxFontSizeMultiplier;
+  fontSize *=
+      (maxFontSizeMultiplier >= 1.0f) ? std::min(maxFontSizeMultiplier, m_fontSizeMultiplier) : m_fontSizeMultiplier;
+
   // TODO get fontSize from props.textAttributes, or defaultTextAttributes, or fragment?
   cfNew.dwMask |= CFM_SIZE;
   cfNew.yHeight = static_cast<LONG>(fontSize * 15);

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

@@ -60,6 +60,8 @@ struct WindowsTextInputComponentView
       const winrt::Microsoft::ReactNative::Composition::Input::PointerRoutedEventArgs &args) noexcept override;
   void OnPointerMoved(
       const winrt::Microsoft::ReactNative::Composition::Input::PointerRoutedEventArgs &args) noexcept override;
+  void OnPointerWheelChanged(
+      const winrt::Microsoft::ReactNative::Composition::Input::PointerRoutedEventArgs &args) noexcept override;
 
   void OnKeyDown(const winrt::Microsoft::ReactNative::Composition::Input::KeyRoutedEventArgs &args) noexcept override;
   void OnKeyUp(const winrt::Microsoft::ReactNative::Composition::Input::KeyRoutedEventArgs &args) noexcept override;
@@ -97,7 +99,9 @@ struct WindowsTextInputComponentView
   void UpdateParaFormat() noexcept;
   void UpdateText(const std::string &str) noexcept;
   void OnTextUpdated() noexcept;
+  void EmitOnScrollEvent() 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,

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

@@ -93,4 +93,33 @@ void WindowsTextInputEventEmitter::onEndEditing(OnEndEditing event) const {
   });
 }
 
+void WindowsTextInputEventEmitter::onPressOut(GestureResponderEvent event) const {
+  dispatchEvent("textInputPressOut", [event = std::move(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", static_cast<double>(event.identifier));
+    payload.setProperty(runtime, "nativeEvent", nativeEvent);
+    return payload;
+  });
+}
+
+void WindowsTextInputEventEmitter::onScroll(facebook::react::Point offset) const {
+  dispatchEvent("textInputScroll", [offset = std::move(offset)](jsi::Runtime &runtime) {
+    auto payload = jsi::Object(runtime);
+    {
+      auto contentOffsetObj = jsi::Object(runtime);
+      contentOffsetObj.setProperty(runtime, "x", offset.x);
+      contentOffsetObj.setProperty(runtime, "y", offset.y);
+      payload.setProperty(runtime, "contentOffset", contentOffsetObj);
+    }
+    return payload;
+  });
+}
+
 } // namespace facebook::react

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

@@ -54,6 +54,8 @@ class WindowsTextInputEventEmitter : public ViewEventEmitter {
   void onContentSizeChange(OnContentSizeChange value) const;
   void onPressIn(GestureResponderEvent event) const override;
   void onEndEditing(OnEndEditing value) const;
+  void onPressOut(GestureResponderEvent event) const override;
+  void onScroll(facebook::react::Point offset) const;
 };
 
 } // namespace facebook::react