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

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

@@ -18,14 +18,30 @@ CompositionTextRangeProvider::CompositionTextRangeProvider(
 }
 
 HRESULT __stdcall CompositionTextRangeProvider::Clone(ITextRangeProvider **pRetVal) {
-  // no-op
-  *pRetVal = nullptr;
+  if (pRetVal == nullptr)
+    return E_POINTER;
+
+  auto clone = winrt::make<winrt::Microsoft::ReactNative::implementation::CompositionTextRangeProvider>(
+      m_view.view().as<winrt::Microsoft::ReactNative::Composition::ComponentView>(), m_parentProvider.get());
+  *pRetVal = clone.detach();
   return S_OK;
 }
 
 HRESULT __stdcall CompositionTextRangeProvider::Compare(ITextRangeProvider *range, BOOL *pRetVal) {
-  // no-op
-  *pRetVal = false;
+  if (pRetVal == nullptr)
+    return E_POINTER;
+  if (range == nullptr) {
+    *pRetVal = FALSE;
+    return S_OK;
+  }
+
+  // Try to cast to our type , considering provider only supports a single range per view
+  auto other = dynamic_cast<CompositionTextRangeProvider *>(range);
+  if (other && other->m_view.view() == m_view.view()) {
+    *pRetVal = TRUE;
+  } else {
+    *pRetVal = FALSE;
+  }
   return S_OK;
 }
 
@@ -34,7 +50,10 @@ HRESULT __stdcall CompositionTextRangeProvider::CompareEndpoints(
     ITextRangeProvider *targetRange,
     TextPatternRangeEndpoint targetEndpoint,
     int *pRetVal) {
-  // no-op
+  if (pRetVal == nullptr)
+    return E_POINTER;
+
+  // For a single-range provider, always equal:
   *pRetVal = 0;
   return S_OK;
 }
@@ -98,13 +117,13 @@ HRESULT __stdcall CompositionTextRangeProvider::GetAttributeValue(TEXTATTRIBUTEI
       textTransform = props->textAttributes.textTransform.value();
     }
     if (fontVariant == facebook::react::FontVariant::SmallCaps) {
-      return CapStyle_SmallCap;
+      pRetVal->lVal = CapStyle_SmallCap;
     } else if (textTransform == facebook::react::TextTransform::Capitalize) {
-      return CapStyle_Titling;
+      pRetVal->lVal = CapStyle_Titling;
     } else if (textTransform == facebook::react::TextTransform::Lowercase) {
-      return CapStyle_None;
+      pRetVal->lVal = CapStyle_None;
     } else if (textTransform == facebook::react::TextTransform::Uppercase) {
-      return CapStyle_AllCap;
+      pRetVal->lVal = CapStyle_AllCap;
     }
   } else if (attributeId == UIA_FontNameAttributeId) {
     pRetVal->vt = VT_BSTR;
@@ -282,6 +301,8 @@ HRESULT __stdcall CompositionTextRangeProvider::ScrollIntoView(BOOL alignToTop)
   return S_OK;
 }
 
+// All the below methods should be implemented once the selection comes for paragraph and TextInput
+
 HRESULT __stdcall CompositionTextRangeProvider::AddToSelection() {
   // no-op
   return S_OK;

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

@@ -819,6 +819,42 @@ 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);
+
+  // Handle annotation properties with single call
+  winrt::Microsoft::ReactNative::implementation::UpdateUiaPropertiesForAnnotation(
+      EnsureUiaProvider(), oldViewProps.accessibilityAnnotation, newViewProps.accessibilityAnnotation);
+
+  // Handle expand/collapse state changes
+  if (oldViewProps.accessibilityState.has_value() != newViewProps.accessibilityState.has_value() ||
+      (oldViewProps.accessibilityState.has_value() && newViewProps.accessibilityState.has_value() &&
+       oldViewProps.accessibilityState->expanded != newViewProps.accessibilityState->expanded)) {
+    auto oldExpanded =
+        oldViewProps.accessibilityState.has_value() && oldViewProps.accessibilityState->expanded.has_value()
+        ? oldViewProps.accessibilityState->expanded.value()
+        : false;
+    auto newExpanded =
+        newViewProps.accessibilityState.has_value() && newViewProps.accessibilityState->expanded.has_value()
+        ? newViewProps.accessibilityState->expanded.value()
+        : false;
+
+    winrt::Microsoft::ReactNative::implementation::UpdateUiaProperty(
+        EnsureUiaProvider(),
+        UIA_ExpandCollapseExpandCollapseStatePropertyId,
+        static_cast<int>(winrt::Microsoft::ReactNative::implementation::GetExpandCollapseState(oldExpanded)),
+        static_cast<int>(winrt::Microsoft::ReactNative::implementation::GetExpandCollapseState(newExpanded)));
+  }
+
   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/ReactNativeIsland.cpp

@@ -40,6 +40,14 @@
 
 namespace winrt::Microsoft::ReactNative::implementation {
 
+ReactPropertyId<winrt::Microsoft::ReactNative::ReactNonAbiValue<
+    winrt::weak_ref<winrt::Microsoft::ReactNative::implementation::ReactNativeIsland>>>
+ReactNativeIsland::LastFocusedReactNativeIslandProperty() noexcept {
+  static const ReactPropertyId<winrt::Microsoft::ReactNative::ReactNonAbiValue<
+      winrt::weak_ref<winrt::Microsoft::ReactNative::implementation::ReactNativeIsland>>>
+      prop{L"ReactNative.Composition", L"ReactNativeIsland"};
+  return prop;
+}
 constexpr float loadingActivitySize = 12.0f;
 constexpr float loadingActivityHorizontalOffset = 16.0f;
 constexpr float loadingBarHeight = 36.0f;
@@ -861,6 +869,20 @@ winrt::Microsoft::UI::Content::ContentIsland ReactNativeIsland::Island() {
             }
           }
         });
+    focusController.GotFocus(
+        [weakThis = get_weak()](const auto &sender, const winrt::Microsoft::UI::Input::FocusChangedEventArgs &args) {
+          if (auto pThis = weakThis.get()) {
+            // Set the island to React context so it can be accessed by native modules
+            if (pThis->m_context && pThis->m_island) {
+              auto properties = pThis->m_context.Properties();
+              properties.Set(
+                  ReactNativeIsland::LastFocusedReactNativeIslandProperty(),
+                  winrt::Microsoft::ReactNative::ReactNonAbiValue<
+                      winrt::weak_ref<winrt::Microsoft::ReactNative::implementation::ReactNativeIsland>>{
+                      std::in_place, weakThis});
+            }
+          }
+        });
 
     // ContentIsland does not support weak_ref, so we cannot use auto_revoke for these events
     m_islandAutomationProviderRequestedToken = m_island.AutomationProviderRequested(

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

@@ -49,6 +49,9 @@ struct ReactNativeIsland
   ~ReactNativeIsland() noexcept;
 
   ReactNativeIsland(const winrt::Microsoft::UI::Composition::Compositor &compositor) noexcept;
+  static ReactPropertyId<winrt::Microsoft::ReactNative::ReactNonAbiValue<
+      winrt::weak_ref<winrt::Microsoft::ReactNative::implementation::ReactNativeIsland>>>
+  LastFocusedReactNativeIslandProperty() noexcept;
   ReactNativeIsland(const winrt::Microsoft::ReactNative::Composition::PortalComponentView &portal) noexcept;
 
   static winrt::Microsoft::ReactNative::ReactNativeIsland CreatePortal(

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>
@@ -804,6 +805,15 @@ 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) {
+    const auto snapToOffsets = winrt::single_threaded_vector<float>();
+    for (const auto &offset : newViewProps.snapToOffsets) {
+      snapToOffsets.Append(static_cast<float>(offset));
+    }
+    m_scrollVisual.SetSnapPoints(newViewProps.snapToStart, newViewProps.snapToEnd, snapToOffsets.GetView());
+  }
 }
 
 void ScrollViewComponentView::updateState(
@@ -1276,6 +1286,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();
@@ -1319,6 +1339,32 @@ winrt::Microsoft::ReactNative::Composition::Experimental::IVisual ScrollViewComp
         }
       });
 
+  m_scrollMomentumBeginRevoker = m_scrollVisual.ScrollMomentumBegin(
+      winrt::auto_revoke,
+      [this](
+          winrt::IInspectable const & /*sender*/,
+          winrt::Microsoft::ReactNative::Composition::Experimental::IScrollPositionChangedArgs const &args) {
+        auto eventEmitter = GetEventEmitter();
+        if (eventEmitter) {
+          auto scrollMetrics = getScrollMetrics(eventEmitter, args);
+          std::static_pointer_cast<facebook::react::ScrollViewEventEmitter const>(eventEmitter)
+              ->onMomentumScrollBegin(scrollMetrics);
+        }
+      });
+
+  m_scrollMomentumEndRevoker = m_scrollVisual.ScrollMomentumEnd(
+      winrt::auto_revoke,
+      [this](
+          winrt::IInspectable const & /*sender*/,
+          winrt::Microsoft::ReactNative::Composition::Experimental::IScrollPositionChangedArgs const &args) {
+        auto eventEmitter = GetEventEmitter();
+        if (eventEmitter) {
+          auto scrollMetrics = getScrollMetrics(eventEmitter, args);
+          std::static_pointer_cast<facebook::react::ScrollViewEventEmitter const>(eventEmitter)
+              ->onMomentumScrollEnd(scrollMetrics);
+        }
+      });
+
   return visual;
 }
 

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

@@ -143,9 +143,12 @@ struct ScrollInteractionTrackerOwner : public winrt::implements<
       m_scrollPositionChangedRevoker{};
   winrt::Microsoft::ReactNative::Composition::Experimental::IScrollVisual::ScrollBeginDrag_revoker
       m_scrollBeginDragRevoker{};
-
   winrt::Microsoft::ReactNative::Composition::Experimental::IScrollVisual::ScrollEndDrag_revoker
       m_scrollEndDragRevoker{};
+  winrt::Microsoft::ReactNative::Composition::Experimental::IScrollVisual::ScrollMomentumBegin_revoker
+      m_scrollMomentumBeginRevoker{};
+  winrt::Microsoft::ReactNative::Composition::Experimental::IScrollVisual::ScrollMomentumEnd_revoker
+      m_scrollMomentumEndRevoker{};
 
   float m_zoomFactor{1.0f};
   bool m_isScrollingFromInertia = false;

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/TextDrawing.cpp

@@ -7,6 +7,7 @@
 #include "TextDrawing.h"
 
 #include <AutoDraw.h>
+#include <Fabric/platform/react/renderer/graphics/PlatformColorUtils.h>
 #include <Utils/ValueUtils.h>
 #include <unicode.h>
 #include <windows.ui.composition.interop.h>
@@ -35,11 +36,27 @@ void RenderText(
   // to cache and reuse a brush across all text elements instead, taking care to recreate
   // it in the event of device removed.
   winrt::com_ptr<ID2D1SolidColorBrush> brush;
+
+  // Check if we should use theme-aware default color instead of hardcoded black
+  bool useDefaultColor = false;
   if (textAttributes.foregroundColor) {
+    auto &color = *textAttributes.foregroundColor;
+    // If it's black (or very dark) without explicit PlatformColor, use theme-aware color
+    if (color.m_platformColor.empty() && color.m_color.R <= 10 && color.m_color.G <= 10 && color.m_color.B <= 10) {
+      useDefaultColor = true;
+    }
+  } else {
+    useDefaultColor = true;
+  }
+
+  if (useDefaultColor) {
+    // Use theme-aware TextFillColorPrimary which adapts to light/dark mode
+    auto d2dColor = theme.D2DPlatformColor("TextFillColorPrimary");
+    winrt::check_hresult(deviceContext.CreateSolidColorBrush(d2dColor, brush.put()));
+  } else {
+    // User set explicit color or PlatformColor - use it
     auto color = theme.D2DColor(*textAttributes.foregroundColor);
     winrt::check_hresult(deviceContext.CreateSolidColorBrush(color, brush.put()));
-  } else {
-    winrt::check_hresult(deviceContext.CreateSolidColorBrush(D2D1::ColorF(D2D1::ColorF::Black, 1.0f), brush.put()));
   }
 
   if (textAttributes.textDecorationLineType) {
@@ -72,12 +89,27 @@ void RenderText(
             (fragment.textAttributes.foregroundColor != textAttributes.foregroundColor) ||
         !isnan(fragment.textAttributes.opacity)) {
       winrt::com_ptr<ID2D1SolidColorBrush> fragmentBrush;
+
+      // Check if we should use theme-aware default color for this fragment
+      bool useFragmentDefaultColor = false;
       if (fragment.textAttributes.foregroundColor) {
+        auto &color = *fragment.textAttributes.foregroundColor;
+        // If it's black (or very dark) without explicit PlatformColor, use theme-aware color
+        if (color.m_platformColor.empty() && color.m_color.R <= 10 && color.m_color.G <= 10 && color.m_color.B <= 10) {
+          useFragmentDefaultColor = true;
+        }
+      } else {
+        useFragmentDefaultColor = true;
+      }
+
+      if (useFragmentDefaultColor) {
+        // Use theme-aware TextFillColorPrimary which adapts to light/dark mode
+        auto d2dColor = theme.D2DPlatformColor("TextFillColorPrimary");
+        winrt::check_hresult(deviceContext.CreateSolidColorBrush(d2dColor, fragmentBrush.put()));
+      } else {
+        // User set explicit color or PlatformColor - use it
         auto color = theme.D2DColor(*fragment.textAttributes.foregroundColor);
         winrt::check_hresult(deviceContext.CreateSolidColorBrush(color, fragmentBrush.put()));
-      } else {
-        winrt::check_hresult(
-            deviceContext.CreateSolidColorBrush(D2D1::ColorF(D2D1::ColorF::Black, 1.0f), fragmentBrush.put()));
       }
 
       if (fragment.textAttributes.textDecorationLineType) {