react-native-windows 0.66.1 → 0.67.0-preview.2

package/Microsoft.ReactNative/Views/Text/TextTransformVisitor.cpp

@@ -0,0 +1,70 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#include "TextTransformVisitor.h"
+#include <UI.Xaml.Documents.h>
+#include <Utils/TransformableText.h>
+#include <Views/RawTextViewManager.h>
+#include <Views/TextViewManager.h>
+#include <Views/VirtualTextViewManager.h>
+#include "TextVisitorScope.h"
+
+namespace winrt {
+using namespace xaml::Documents;
+} // namespace winrt
+
+namespace Microsoft::ReactNative {
+
+void TextTransformVisitor::VisitRawText(ShadowNodeBase *node) {
+  const auto rawTextNode = static_cast<RawTextShadowNode *>(node);
+  auto originalText = rawTextNode->originalText;
+  auto run = node->GetView().as<winrt::Run>();
+  // Set originalText on the raw text node if it hasn't been set yet
+  if (originalText.size() == 0) {
+    // Lazily setting original text to avoid keeping two copies of all raw text strings
+    originalText = run.Text();
+    rawTextNode->originalText = originalText;
+  }
+
+  run.Text(TransformableText::TransformText(originalText, m_textTransforms.top()));
+
+  if (std::wcscmp(originalText.c_str(), run.Text().c_str()) == 0) {
+    // If the transformed text is the same as the original, we no longer need a second copy
+    rawTextNode->originalText = winrt::hstring{};
+  }
+}
+
+void TextTransformVisitor::VisitText(ShadowNodeBase *node) {
+  const auto transform = TextViewManager::GetTextTransformValue(node);
+  if (ShouldApplyTransform(transform)) {
+    TextVisitorScope<TextTransform> scope{m_textTransforms, transform};
+    Super::VisitText(node);
+  }
+}
+
+void TextTransformVisitor::VisitVirtualText(ShadowNodeBase *node) {
+  const auto textNode = static_cast<VirtualTextShadowNode *>(node);
+  const auto transform = textNode->textTransform;
+  if (ShouldApplyTransform(transform)) {
+    TextVisitorScope<TextTransform> scope{m_textTransforms, transform};
+    Super::VisitVirtualText(node);
+  }
+}
+
+bool TextTransformVisitor::ShouldApplyTransform(TextTransform transform) {
+  // If the visitor is applied in the context of a textTransfrom prop value
+  // change, the m_forceUpdate flag is set to true.
+  if (m_forceUpdate) {
+    // When the textTransform prop changes, only recurse if at the root node
+    // or if the current node is has an undefined textTransform.
+    return m_textTransforms.size() == 1 || transform == TextTransform::Undefined;
+  } else {
+    // When a node is added to the tree, only recurse if the added node is has
+    // an undefined textTransform and the parent is not "none" or undefined.
+    const auto parentTransform = m_textTransforms.top();
+    return parentTransform != TextTransform::Undefined && parentTransform != TextTransform::None &&
+        transform == TextTransform::Undefined;
+  }
+}
+
+} // namespace Microsoft::ReactNative

package/Microsoft.ReactNative/Views/Text/TextTransformVisitor.h

@@ -0,0 +1,34 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include <Utils/TextTransform.h>
+#include <stack>
+#include "TextVisitor.h"
+
+namespace Microsoft::ReactNative {
+
+class TextTransformVisitor : public TextVisitor {
+  using Super = TextVisitor;
+
+ public:
+  TextTransformVisitor(TextTransform parentTransform, bool forceUpdate) : Super(), m_forceUpdate{forceUpdate} {
+    m_textTransforms.push(parentTransform);
+  }
+
+ protected:
+  void VisitRawText(ShadowNodeBase *node) override;
+
+  void VisitText(ShadowNodeBase *node) override;
+
+  void VisitVirtualText(ShadowNodeBase *node) override;
+
+ private:
+  std::stack<TextTransform> m_textTransforms;
+  bool m_forceUpdate;
+
+  bool ShouldApplyTransform(TextTransform transform);
+};
+
+} // namespace Microsoft::ReactNative

package/Microsoft.ReactNative/Views/Text/TextVisitor.cpp

@@ -0,0 +1,56 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#include "TextVisitor.h"
+#include <Utils/ShadowNodeTypeUtils.h>
+
+namespace Microsoft::ReactNative {
+
+void TextVisitor::Visit(ShadowNode *node) {
+  if (!node || !EnsureNativeUIManager(node))
+    return;
+
+  const auto baseNode = static_cast<ShadowNodeBase *>(node);
+  if (IsTextShadowNode(baseNode)) {
+    VisitText(baseNode);
+  } else if (IsVirtualTextShadowNode(baseNode)) {
+    VisitVirtualText(baseNode);
+  } else if (IsRawTextShadowNode(baseNode)) {
+    VisitRawText(baseNode);
+  } else {
+    VisitCore(baseNode);
+  }
+}
+
+void TextVisitor::VisitCore(ShadowNodeBase *node) {
+  for (auto childTag : node->m_children) {
+    Visit(GetShadowNode(childTag));
+  }
+}
+
+void TextVisitor::VisitRawText(ShadowNodeBase *node) {
+  VisitCore(node);
+}
+
+void TextVisitor::VisitText(ShadowNodeBase *node) {
+  VisitCore(node);
+}
+
+void TextVisitor::VisitVirtualText(ShadowNodeBase *node) {
+  VisitCore(node);
+}
+
+ShadowNode *TextVisitor::GetShadowNode(int64_t tag) {
+  return m_uiManager->getHost()->FindShadowNodeForTag(tag);
+}
+
+std::shared_ptr<NativeUIManager> TextVisitor::EnsureNativeUIManager(ShadowNode *node) {
+  if (!m_uiManager) {
+    const auto baseNode = static_cast<ShadowNodeBase *>(node);
+    m_uiManager = GetNativeUIManager(baseNode->GetViewManager()->GetReactContext()).lock();
+  }
+
+  return m_uiManager;
+}
+
+} // namespace Microsoft::ReactNative

package/Microsoft.ReactNative/Views/Text/TextVisitor.h

@@ -0,0 +1,34 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include <Modules/NativeUIManager.h>
+#include <Modules/PaperUIManagerModule.h>
+#include <UI.Xaml.Documents.h>
+#include <Views/ShadowNodeBase.h>
+
+namespace Microsoft::ReactNative {
+
+class TextVisitor {
+ public:
+  void Visit(ShadowNode *node);
+
+ protected:
+  virtual void VisitCore(ShadowNodeBase *node);
+
+  virtual void VisitRawText(ShadowNodeBase *node);
+
+  virtual void VisitText(ShadowNodeBase *node);
+
+  virtual void VisitVirtualText(ShadowNodeBase *node);
+
+  ShadowNode *GetShadowNode(int64_t tag);
+
+ private:
+  std::shared_ptr<NativeUIManager> m_uiManager;
+
+  std::shared_ptr<NativeUIManager> EnsureNativeUIManager(ShadowNode *node);
+};
+
+}; // namespace Microsoft::ReactNative

package/Microsoft.ReactNative/Views/Text/TextVisitorScope.h

@@ -0,0 +1,35 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include <stack>
+
+namespace Microsoft::ReactNative {
+
+template <class T>
+struct TextVisitorScope {
+  TextVisitorScope(std::stack<T> &stack, T scopedValue) : m_stack{stack} {
+    // There's an assumption here that the scoped value should not be pushed if
+    // it has a default value. Check this assumption for future usages.
+    if (scopedValue != T{}) {
+      m_stack.push(scopedValue);
+      m_pushed = true;
+    }
+  }
+
+  ~TextVisitorScope() {
+    if (m_pushed) {
+      m_stack.pop();
+    }
+  }
+
+  TextVisitorScope(TextVisitorScope const &) = delete;
+  TextVisitorScope &operator=(TextVisitorScope other) = delete;
+
+ private:
+  std::stack<T> &m_stack;
+  bool m_pushed{false};
+};
+
+} // namespace Microsoft::ReactNative

package/Microsoft.ReactNative/Views/Text/TextVisitors.h

@@ -0,0 +1,47 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "TextHighlighterVisitor.h"
+#include "TextHitTestVisitor.h"
+#include "TextPropertyChangedParentVisitor.h"
+#include "TextTransformParentVisitor.h"
+#include "TextTransformVisitor.h"
+
+namespace Microsoft::ReactNative {
+using Color = std::optional<winrt::Windows::UI::Color>;
+
+static inline std::vector<xaml::Documents::TextHighlighter>
+GetNestedTextHighlighters(ShadowNode *node, Color foregroundColor, Color backgroundColor) {
+  TextHighlighterVisitor visitor{foregroundColor, backgroundColor};
+  visitor.Visit(node);
+  return visitor.highlighters;
+}
+
+static inline void ApplyTextTransformToChild(ShadowNode *node) {
+  TextTransformParentVisitor parentVisitor;
+  parentVisitor.Visit(node);
+  TextTransformVisitor visitor{parentVisitor.textTransform, false};
+  visitor.Visit(node);
+}
+
+static inline void
+HitTest(ShadowNode *node, winrt::Microsoft::ReactNative::ReactPointerEventArgs const &args, winrt::Point const &point) {
+  TextHitTestVisitor visitor{args, point};
+  visitor.Visit(node);
+}
+
+static inline void UpdateTextTransformForChildren(ShadowNode *node) {
+  TextTransformParentVisitor parentVisitor;
+  parentVisitor.Visit(node);
+  TextTransformVisitor visitor{parentVisitor.textTransform, true};
+  visitor.Visit(node);
+}
+
+static inline void NotifyAncestorsTextPropertyChanged(ShadowNode *node, PropertyChangeType type) {
+  TextPropertyChangedParentVisitor visitor{type};
+  visitor.Visit(node);
+}
+
+} // namespace Microsoft::ReactNative

package/Microsoft.ReactNative/Views/TextViewManager.cpp

@@ -4,23 +4,28 @@
 #include "pch.h"
 
 #include "TextViewManager.h"
+#include "TouchEventHandler.h"
 #include "Utils/ShadowNodeTypeUtils.h"
 #include "Utils/XamlIslandUtils.h"
 
-#include <Modules/NativeUIManager.h>
-#include <Modules/PaperUIManagerModule.h>
-#include <Views/RawTextViewManager.h>
 #include <Views/ShadowNodeBase.h>
+#include <Views/Text/TextVisitors.h>
 #include <Views/VirtualTextViewManager.h>
 
+#include <UI.Input.h>
 #include <UI.Xaml.Automation.Peers.h>
 #include <UI.Xaml.Automation.h>
 #include <UI.Xaml.Controls.h>
 #include <UI.Xaml.Documents.h>
+#include <UI.Xaml.Input.h>
 #include <Utils/PropertyUtils.h>
 #include <Utils/TransformableText.h>
 #include <Utils/ValueUtils.h>
 
+#ifdef USE_WINUI3
+#include <winrt/Microsoft.UI.Input.Experimental.h>
+#endif
+
 namespace winrt {
 using namespace xaml::Documents;
 using namespace xaml::Automation;
@@ -36,10 +41,12 @@ class TextShadowNode final : public ShadowNodeBase {
  private:
   ShadowNode *m_firstChildNode;
 
+  bool m_hasDescendantTextHighlighter{false};
+  bool m_hasDescendantPressable{false};
   std::optional<winrt::Windows::UI::Color> m_backgroundColor{};
   std::optional<winrt::Windows::UI::Color> m_foregroundColor{};
-
-  int32_t m_prevCursorEnd = 0;
+  std::unique_ptr<TouchEventHandler> m_touchEventHandler = nullptr;
+  winrt::event_revoker<xaml::Controls::ITextBlock> m_selectionChangedRevoker;
 
  public:
   TextShadowNode() {
@@ -51,12 +58,12 @@ class TextShadowNode final : public ShadowNodeBase {
 
   void AddView(ShadowNode &child, int64_t index) override {
     auto &childNode = static_cast<ShadowNodeBase &>(child);
-    VirtualTextShadowNode::ApplyTextTransform(
-        childNode, textTransform, /* forceUpdate = */ false, /* isRoot = */ false);
+    ApplyTextTransformToChild(&child);
 
     if (IsVirtualTextShadowNode(&childNode)) {
       auto &textChildNode = static_cast<VirtualTextShadowNode &>(childNode);
-      m_hasDescendantBackgroundColor |= textChildNode.m_hasDescendantBackgroundColor;
+      m_hasDescendantTextHighlighter |= textChildNode.hasDescendantTextHighlighter;
+      m_hasDescendantPressable |= textChildNode.hasDescendantPressable;
     }
 
     auto addInline = true;
@@ -66,7 +73,6 @@ class TextShadowNode final : public ShadowNodeBase {
         m_firstChildNode = &child;
         auto textBlock = this->GetView().as<xaml::Controls::TextBlock>();
         textBlock.Text(run.Text());
-        m_prevCursorEnd += textBlock.Text().size();
         addInline = false;
       }
     } else if (index == 1 && m_firstChildNode != nullptr) {
@@ -84,16 +90,24 @@ class TextShadowNode final : public ShadowNodeBase {
   }
 
   void removeAllChildren() override {
-    m_firstChildNode = nullptr;
-    Super::removeAllChildren();
+    if (m_firstChildNode) {
+      auto textBlock = this->GetView().as<xaml::Controls::TextBlock>();
+      textBlock.ClearValue(xaml::Controls::TextBlock::TextProperty());
+      m_firstChildNode = nullptr;
+    } else {
+      Super::removeAllChildren();
+    }
     RecalculateTextHighlighters();
   }
 
   void RemoveChildAt(int64_t indexToRemove) override {
-    if (indexToRemove == 0) {
+    if (indexToRemove == 0 && m_firstChildNode) {
+      auto textBlock = this->GetView().as<xaml::Controls::TextBlock>();
+      textBlock.ClearValue(xaml::Controls::TextBlock::TextProperty());
       m_firstChildNode = nullptr;
+    } else {
+      Super::RemoveChildAt(indexToRemove);
     }
-    Super::RemoveChildAt(indexToRemove);
     RecalculateTextHighlighters();
   }
 
@@ -101,92 +115,70 @@ class TextShadowNode final : public ShadowNodeBase {
     const auto textBlock = this->GetView().as<xaml::Controls::TextBlock>();
     textBlock.TextHighlighters().Clear();
 
-    auto nestedIndex = 0;
-    if (m_hasDescendantBackgroundColor) {
-      const auto highlighterCount = textBlock.TextHighlighters().Size();
-      if (const auto uiManager = GetNativeUIManager(GetViewManager()->GetReactContext()).lock()) {
-        for (auto childTag : m_children) {
-          if (const auto childNode = uiManager->getHost()->FindShadowNodeForTag(childTag)) {
-            nestedIndex = AddNestedTextHighlighter(
-                m_backgroundColor, m_foregroundColor, static_cast<ShadowNodeBase *>(childNode), nestedIndex);
-          }
+    // Since TextShadowNode is not public, we lift some of the recursive
+    // algorithm into the shadow node implementation to detect when no
+    // descendants have background colors and we can skip recursion.
+    if (m_hasDescendantTextHighlighter) {
+      const auto highlighters = GetNestedTextHighlighters(this, m_foregroundColor, m_backgroundColor);
+      if (highlighters.size() == 0) {
+        m_hasDescendantTextHighlighter = false;
+      } else {
+        // We must add the highlighters in reverse order, as highlighters
+        // "deeper" in the text tree should render at the top.
+        auto iter = highlighters.rbegin();
+        while (iter != highlighters.rend()) {
+          textBlock.TextHighlighters().Append(*iter);
+          ++iter;
         }
       }
-
-      if (textBlock.TextHighlighters().Size() == 0) {
-        m_hasDescendantBackgroundColor = false;
-      }
-    } else {
-      nestedIndex = textBlock.Text().size();
     }
 
     if (m_backgroundColor) {
       winrt::TextHighlighter highlighter{};
-      highlighter.Ranges().Append({0, nestedIndex});
+      highlighter.Ranges().Append({0, static_cast<int32_t>(textBlock.Text().size())});
       highlighter.Background(SolidBrushFromColor(m_backgroundColor.value()));
       if (m_foregroundColor) {
         highlighter.Foreground(SolidBrushFromColor(m_foregroundColor.value()));
       }
-      GetView().as<xaml::Controls::TextBlock>().TextHighlighters().InsertAt(0, highlighter);
+      textBlock.TextHighlighters().InsertAt(0, highlighter);
     }
   }
 
-  int AddNestedTextHighlighter(
-      const std::optional<winrt::Windows::UI::Color> &backgroundColor,
-      const std::optional<winrt::Windows::UI::Color> &foregroundColor,
-      ShadowNodeBase *node,
-      int startIndex) {
-    if (const auto run = node->GetView().try_as<winrt::Run>()) {
-      return startIndex + run.Text().size();
-    } else if (const auto span = node->GetView().try_as<winrt::Span>()) {
-      const auto textBlock = GetView().as<xaml::Controls::TextBlock>();
-      winrt::TextHighlighter highlighter{nullptr};
-      auto parentBackgroundColor = backgroundColor;
-      auto parentForegroundColor = foregroundColor;
-      if (IsVirtualTextShadowNode(node)) {
-        const auto virtualTextNode = static_cast<VirtualTextShadowNode *>(node);
-        const auto requiresHighlighter =
-            virtualTextNode->m_backgroundColor || (backgroundColor && virtualTextNode->m_foregroundColor);
-        if (requiresHighlighter) {
-          highlighter = {};
-          parentBackgroundColor =
-              virtualTextNode->m_backgroundColor ? virtualTextNode->m_backgroundColor : parentBackgroundColor;
-          parentForegroundColor =
-              virtualTextNode->m_foregroundColor ? virtualTextNode->m_foregroundColor : parentForegroundColor;
-          highlighter.Background(SolidBrushFromColor(parentBackgroundColor.value()));
-          if (parentForegroundColor) {
-            highlighter.Foreground(SolidBrushFromColor(parentForegroundColor.value()));
-          }
-        }
+  void ToggleTouchEvents(XamlView xamlView, bool selectable) {
+    if (selectable) {
+      if (m_touchEventHandler == nullptr) {
+        m_touchEventHandler = std::make_unique<TouchEventHandler>(GetViewManager()->GetReactContext(), false);
       }
 
-      const auto initialHighlighterCount = textBlock.TextHighlighters().Size();
-      auto nestedIndex = startIndex;
-      if (const auto uiManager = GetNativeUIManager(node->GetViewManager()->GetReactContext()).lock()) {
-        for (auto childTag : node->m_children) {
-          if (const auto childNode = uiManager->getHost()->FindShadowNodeForTag(childTag)) {
-            nestedIndex = AddNestedTextHighlighter(
-                parentBackgroundColor, parentForegroundColor, static_cast<ShadowNodeBase *>(childNode), nestedIndex);
-          }
-        }
-      }
+      m_selectionChangedRevoker = xamlView.as<xaml::Controls::TextBlock>().SelectionChanged(
+          winrt::auto_revoke, [selectionChanged = this->selectionChanged](const auto &sender, auto &&) {
+            const auto textBlock = sender.as<xaml::Controls::TextBlock>();
+            *selectionChanged =
+                *selectionChanged || textBlock.SelectionStart().Offset() != textBlock.SelectionEnd().Offset();
+          });
 
-      if (highlighter) {
-        highlighter.Ranges().Append({startIndex, nestedIndex - startIndex});
-        textBlock.TextHighlighters().InsertAt(0, highlighter);
-      } else if (IsVirtualTextShadowNode(node) && textBlock.TextHighlighters().Size() == initialHighlighterCount) {
-        const auto virtualTextNode = static_cast<VirtualTextShadowNode *>(node);
-        virtualTextNode->m_hasDescendantBackgroundColor = false;
+      m_touchEventHandler->AddTouchHandlers(xamlView, GetRootView(), true);
+    } else {
+      if (m_touchEventHandler != nullptr) {
+        m_touchEventHandler->RemoveTouchHandlers();
+        m_selectionChangedRevoker.revoke();
       }
-
-      return nestedIndex;
     }
+  }
 
-    return 0;
+  XamlView GetRootView() {
+    if (auto uiManager = GetNativeUIManager(GetViewManager()->GetReactContext()).lock()) {
+      auto shadowNode = uiManager->getHost()->FindShadowNodeForTag(m_rootTag);
+      if (!shadowNode)
+        return nullptr;
+
+      return static_cast<::Microsoft::ReactNative::ShadowNodeBase *>(shadowNode)->GetView();
+    }
+    return nullptr;
   }
 
   TextTransform textTransform{TextTransform::Undefined};
-  bool m_hasDescendantBackgroundColor{false};
+  std::shared_ptr<bool> selectionChanged = std::make_shared<bool>(false);
 };
 
 TextViewManager::TextViewManager(const Mso::React::IReactContext &context) : Super(context) {}
@@ -223,8 +215,7 @@ bool TextViewManager::UpdateProperty(
   } else if (propertyName == "textTransform") {
     auto textNode = static_cast<TextShadowNode *>(nodeToUpdate);
     textNode->textTransform = TransformableText::GetTextTransform(propertyValue);
-    VirtualTextShadowNode::ApplyTextTransform(
-        *textNode, textNode->textTransform, /* forceUpdate = */ true, /* isRoot = */ true);
+    UpdateTextTransformForChildren(nodeToUpdate);
   } else if (TryUpdatePadding(nodeToUpdate, textBlock, propertyName, propertyValue)) {
   } else if (TryUpdateTextAlignment(textBlock, propertyName, propertyValue)) {
   } else if (TryUpdateTextTrimming(textBlock, propertyName, propertyValue)) {
@@ -261,14 +252,17 @@ bool TextViewManager::UpdateProperty(
       textBlock.ClearValue(xaml::Controls::TextBlock::LineStackingStrategyProperty());
     }
   } else if (propertyName == "selectable") {
+    const auto node = static_cast<TextShadowNode *>(nodeToUpdate);
     if (propertyValue.Type() == winrt::Microsoft::ReactNative::JSValueType::Boolean) {
       const auto selectable = propertyValue.AsBoolean();
       textBlock.IsTextSelectionEnabled(selectable);
+      node->ToggleTouchEvents(textBlock, selectable);
       if (selectable) {
         EnsureUniqueTextFlyoutForXamlIsland(textBlock);
       }
     } else if (propertyValue.IsNull()) {
       textBlock.ClearValue(xaml::Controls::TextBlock::IsTextSelectionEnabledProperty());
+      node->ToggleTouchEvents(textBlock, false);
       ClearUniqueTextFlyoutForXamlIsland(textBlock);
     }
   } else if (propertyName == "allowFontScaling") {
@@ -342,38 +336,53 @@ YGMeasureFunc TextViewManager::GetYogaCustomMeasureFunc() const {
   return DefaultYogaSelfMeasureFunc;
 }
 
-void TextViewManager::OnDescendantTextPropertyChanged(ShadowNodeBase *node, PropertyChangeType propertyChangeType) {
-  if (IsTextShadowNode(node)) {
-    const auto textNode = static_cast<TextShadowNode *>(node);
-
-    if ((propertyChangeType & PropertyChangeType::Text) == PropertyChangeType::Text) {
-      const auto element = node->GetView().as<xaml::Controls::TextBlock>();
-
-      // If name is set, it's controlled by accessibilityLabel, and it's already
-      // handled in FrameworkElementViewManager. Here it only handles when name is
-      // not set.
-      if (xaml::Automation::AutomationProperties::GetLiveSetting(element) != winrt::AutomationLiveSetting::Off &&
-          xaml::Automation::AutomationProperties::GetName(element).empty() &&
-          xaml::Automation::AutomationProperties::GetAccessibilityView(element) !=
-              winrt::Peers::AccessibilityView::Raw) {
-        if (auto peer = xaml::Automation::Peers::FrameworkElementAutomationPeer::FromElement(element)) {
-          peer.RaiseAutomationEvent(winrt::AutomationEvents::LiveRegionChanged);
-        }
-      }
+void TextViewManager::OnPointerEvent(
+    ShadowNodeBase *node,
+    winrt::Microsoft::ReactNative::ReactPointerEventArgs const &args) {
+  const auto textNode = static_cast<TextShadowNode *>(node);
+  const auto textBlock = node->GetView().as<xaml::Controls::TextBlock>();
+  if (textNode->m_hasDescendantPressable && args.Target() == node->GetView()) {
+    // Set the target to null temporarily
+    args.Target(nullptr);
+
+    // Get the pointer point and hit test
+    const auto point = args.Args().GetCurrentPoint(textBlock).RawPosition();
+    HitTest(node, args, point);
+
+    // Set the target back to the current view if hit test failed
+    if (!args.Target()) {
+      args.Target(node->GetView());
     }
+  }
 
-    // If a property change added a background color to the text tree, update
-    // the flag to signal recursive highlighter updates are required.
-    if ((propertyChangeType & PropertyChangeType::AddBackgroundColor) == PropertyChangeType::AddBackgroundColor) {
-      textNode->m_hasDescendantBackgroundColor = true;
+  if (args.Kind() == winrt::Microsoft::ReactNative::PointerEventKind::CaptureLost) {
+    if (!*textNode->selectionChanged) {
+      args.Kind(winrt::Microsoft::ReactNative::PointerEventKind::End);
     }
+    *textNode->selectionChanged = false;
+  }
 
-    // Recalculate text highlighters
+  Super::OnPointerEvent(node, args);
+}
+
+/*static*/ void TextViewManager::UpdateTextHighlighters(ShadowNodeBase *node, bool highlightAdded) {
+  if (IsTextShadowNode(node)) {
+    const auto textNode = static_cast<TextShadowNode *>(node);
+    if (highlightAdded) {
+      textNode->m_hasDescendantTextHighlighter = true;
+    }
     textNode->RecalculateTextHighlighters();
   }
 }
 
-TextTransform TextViewManager::GetTextTransformValue(ShadowNodeBase *node) {
+/*static*/ void TextViewManager::SetDescendantPressable(ShadowNodeBase *node) {
+  if (IsTextShadowNode(node)) {
+    const auto textNode = static_cast<TextShadowNode *>(node);
+    textNode->m_hasDescendantPressable = true;
+  }
+}
+
+/*static*/ TextTransform TextViewManager::GetTextTransformValue(ShadowNodeBase *node) {
   if (IsTextShadowNode(node)) {
     return static_cast<TextShadowNode *>(node)->textTransform;
   }

package/Microsoft.ReactNative/Views/TextViewManager.h

@@ -8,14 +8,6 @@
 
 namespace Microsoft::ReactNative {
 
-enum class PropertyChangeType : std::uint_fast8_t {
-  None = 0,
-  Text = 1 << 0,
-  AddBackgroundColor = 1 << 1,
-};
-
-DEFINE_ENUM_FLAG_OPERATORS(PropertyChangeType);
-
 class TextViewManager : public FrameworkElementViewManager {
   using Super = FrameworkElementViewManager;
 
@@ -32,11 +24,13 @@ class TextViewManager : public FrameworkElementViewManager {
 
   YGMeasureFunc GetYogaCustomMeasureFunc() const override;
 
-  void OnDescendantTextPropertyChanged(
-      ShadowNodeBase *node,
-      PropertyChangeType propertyChangeType = PropertyChangeType::Text);
+  void OnPointerEvent(ShadowNodeBase *node, const winrt::Microsoft::ReactNative::ReactPointerEventArgs &args) override;
+
+  static void UpdateTextHighlighters(ShadowNodeBase *node, bool highlightAdded);
+
+  static void SetDescendantPressable(ShadowNodeBase *node);
 
-  TextTransform GetTextTransformValue(ShadowNodeBase *node);
+  static TextTransform GetTextTransformValue(ShadowNodeBase *node);
 
  protected:
   bool UpdateProperty(