react-native-windows 0.81.1 → 0.82.0-preview.1

package/Microsoft.ReactNative/Views/ViewViewManager.cpp

@@ -1,507 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-
-#include "pch.h"
-#include "ViewViewManager.h"
-#include <cdebug.h>
-
-#include "ViewControl.h"
-
-#include <UI.Xaml.Automation.Peers.h>
-#include "DynamicAutomationProperties.h"
-
-#include <JSValueWriter.h>
-#include <Modules/NativeUIManager.h>
-#include <Modules/PaperUIManagerModule.h>
-#include <Utils/AccessibilityUtils.h>
-#include <Utils/PropertyUtils.h>
-
-#include <INativeUIManager.h>
-#include <IReactInstance.h>
-
-#include <cxxreact/TraceSection.h>
-#include <inspectable.h>
-#include <unicode.h>
-#include <winrt/Windows.System.h>
-#include <winrt/Windows.UI.Xaml.Interop.h>
-#include <winstring.h>
-
-#if defined(_DEBUG)
-// Currently only used for tagging controls in debug
-#include <winrt/Windows.Foundation.h>
-#endif
-
-using namespace facebook::react;
-
-namespace Microsoft::ReactNative {
-
-// ViewShadowNode
-
-class ViewShadowNode : public ShadowNodeBase {
-  using Super = ShadowNodeBase;
-
- public:
-  ViewShadowNode() = default;
-
-  void createView(const winrt::Microsoft::ReactNative::JSValueObject &props) override {
-    Super::createView(props);
-
-    auto panel = GetPanel();
-    IsAccessible(false);
-    IsFocusable(false);
-
-    DynamicAutomationProperties::SetAccessibilityInvokeEventHandler(panel, [=]() {
-      if (OnClick())
-        DispatchEvent("topClick", std::move(folly::dynamic::object("target", m_tag)));
-      else
-        DispatchEvent("topAccessibilityTap", std::move(folly::dynamic::object("target", m_tag)));
-    });
-
-    DynamicAutomationProperties::SetAccessibilityActionEventHandler(
-        panel, [=](winrt::Microsoft::ReactNative::AccessibilityAction const &action) {
-          folly::dynamic eventData = folly::dynamic::object("target", m_tag);
-
-          eventData.insert(
-              "actionName", action.Label.empty() ? HstringToDynamic(action.Name) : HstringToDynamic(action.Label));
-
-          DispatchEvent("topAccessibilityAction", std::move(eventData));
-        });
-  }
-
-  void dispatchCommand(const std::string &commandId, winrt::Microsoft::ReactNative::JSValueArray &&commandArgs) {
-    if (commandId == "focus") {
-      if (auto uiManager = GetNativeUIManager(GetViewManager()->GetReactContext()).lock()) {
-        uiManager->focus(m_tag);
-      }
-    } else if (commandId == "blur") {
-      if (auto uiManager = GetNativeUIManager(GetViewManager()->GetReactContext()).lock()) {
-        uiManager->blur(m_tag);
-      }
-    } else {
-      Super::dispatchCommand(commandId, std::move(commandArgs));
-    }
-  }
-
-  bool IsControl() {
-    return m_isControl;
-  }
-  void IsControl(bool isControl) {
-    m_isControl = isControl;
-  }
-
-  bool EnableFocusRing() {
-    return m_enableFocusRing;
-  }
-  void EnableFocusRing(bool enable) {
-    m_enableFocusRing = enable;
-
-    if (IsControl())
-      GetControl().UseSystemFocusVisuals(m_enableFocusRing);
-  }
-
-  int32_t TabIndex() {
-    return m_tabIndex;
-  }
-  void TabIndex(int32_t tabIndex) {
-    m_tabIndex = tabIndex;
-
-    if (IsControl())
-      GetControl().TabIndex(m_tabIndex);
-  }
-
-  bool OnClick() const {
-    return m_onClick;
-  }
-  void OnClick(bool isSet) {
-    m_onClick = isSet;
-  }
-
-  bool IsHitTestBrushRequired() const {
-    return IsRegisteredForMouseEvents();
-  }
-
-  void AddView(ShadowNode &child, int64_t index) override {
-    const auto &view = static_cast<ShadowNodeBase &>(child).GetView();
-    if (view.try_as<xaml::UIElement>() == nullptr) {
-      const auto &ii = view.as<winrt::IInspectable>();
-      auto name = winrt::get_class_name(ii);
-      YellowBox(
-          std::string("ViewViewManager::AddView expected a UIElement but got a ") +
-          Microsoft::Common::Unicode::Utf16ToUtf8(name.c_str()));
-    }
-
-    GetPanel().Children().InsertAt(static_cast<uint32_t>(index), view.as<xaml::UIElement>());
-  }
-
-  void RemoveChildAt(int64_t indexToRemove) override {
-    if (indexToRemove == static_cast<uint32_t>(indexToRemove))
-      GetPanel().Children().RemoveAt(static_cast<uint32_t>(indexToRemove));
-  }
-
-  void removeAllChildren() override {
-    GetPanel().Children().Clear();
-
-    XamlView current = m_view;
-
-    // TODO NOW: Why do we do this? Removal of children doesn't seem to imply we
-    // tear down the infrastructure
-    if (IsControl()) {
-      if (auto control = m_view.try_as<xaml::Controls::ContentControl>()) {
-        current = control.Content().as<XamlView>();
-        control.Content(nullptr);
-      } else {
-        std::string name = Microsoft::Common::Unicode::Utf16ToUtf8(winrt::get_class_name(current).c_str());
-        cdebug << "Tearing down, IsControl=true but the control is not a ContentControl, it's a " << name << "\n";
-      }
-    }
-  }
-
-  void ReplaceChild(const XamlView &oldChildView, const XamlView &newChildView) override {
-    auto pPanel = GetPanel();
-    if (pPanel != nullptr) {
-      uint32_t index;
-      if (pPanel.Children().IndexOf(oldChildView.as<xaml::UIElement>(), index)) {
-        pPanel.Children().RemoveAt(index);
-        pPanel.Children().InsertAt(index, newChildView.as<xaml::UIElement>());
-      } else {
-        assert(false);
-      }
-    }
-  }
-
-  void RefreshProperties() {
-    // The view may have been replaced, so transfer properties stored on the
-    // shadow node to the view
-    EnableFocusRing(EnableFocusRing());
-    TabIndex(TabIndex());
-    IsFocusable(IsFocusable());
-    static_cast<FrameworkElementViewManager *>(GetViewManager())->RefreshTransformMatrix(this);
-  }
-
-  xaml::Controls::Panel GetPanel() {
-    XamlView current = m_view;
-
-    if (IsControl()) {
-      if (auto control = m_view.try_as<xaml::Controls::ContentControl>()) {
-        current = control.Content().as<XamlView>();
-      }
-    }
-
-    auto panel = current.try_as<xaml::Controls::Panel>();
-    assert(panel != nullptr);
-
-    return panel;
-  }
-
-  winrt::Microsoft::ReactNative::ViewControl GetControl() {
-    return IsControl() ? m_view.as<winrt::Microsoft::ReactNative::ViewControl>() : nullptr;
-  }
-
-  XamlView CreateViewControl() {
-    auto contentControl = winrt::make<winrt::Microsoft::ReactNative::implementation::ViewControl>();
-
-    m_contentControlGotFocusRevoker = contentControl.GotFocus(winrt::auto_revoke, [=](auto &&, auto &&args) {
-      if (args.OriginalSource().try_as<xaml::UIElement>() == contentControl.as<xaml::UIElement>()) {
-        auto tag = m_tag;
-        DispatchEvent("topFocus", std::move(folly::dynamic::object("target", tag)));
-      }
-    });
-
-    m_contentControlLostFocusRevoker = contentControl.LostFocus(winrt::auto_revoke, [=](auto &&, auto &&args) {
-      if (args.OriginalSource().try_as<xaml::UIElement>() == contentControl.as<xaml::UIElement>()) {
-        auto tag = m_tag;
-        DispatchEvent("topBlur", std::move(folly::dynamic::object("target", tag)));
-      }
-    });
-
-    return contentControl.try_as<XamlView>();
-  }
-
-  void DispatchEvent(std::string &&eventName, folly::dynamic &&eventData) {
-    GetViewManager()->GetReactContext().DispatchEvent(m_tag, std::move(eventName), std::move(eventData));
-  }
-
- private:
-  bool m_isControl = false;
-  bool m_enableFocusRing = true;
-  bool m_onClick = false;
-  int32_t m_tabIndex = std::numeric_limits<std::int32_t>::max();
-
-  xaml::Controls::ContentControl::GotFocus_revoker m_contentControlGotFocusRevoker{};
-  xaml::Controls::ContentControl::LostFocus_revoker m_contentControlLostFocusRevoker{};
-};
-
-// ViewViewManager
-
-ViewViewManager::ViewViewManager(const Mso::React::IReactContext &context) : Super(context) {}
-
-const wchar_t *ViewViewManager::GetName() const {
-  return L"RCTView";
-}
-
-void ViewViewManager::GetExportedCustomDirectEventTypeConstants(
-    const winrt::Microsoft::ReactNative::IJSValueWriter &writer) const {
-  Super::GetExportedCustomDirectEventTypeConstants(writer);
-
-  writer.WritePropertyName(L"topAccessibilityTap");
-  writer.WriteObjectBegin();
-  winrt::Microsoft::ReactNative::WriteProperty(writer, L"registrationName", L"onAccessibilityTap");
-  writer.WriteObjectEnd();
-}
-
-ShadowNode *ViewViewManager::createShadow() const {
-  return new ViewShadowNode();
-}
-
-XamlView ViewViewManager::CreateViewCore(int64_t /*tag*/, const winrt::Microsoft::ReactNative::JSValueObject &) {
-  auto panel = winrt::make<winrt::Microsoft::ReactNative::implementation::ViewPanel>();
-  panel.VerticalAlignment(xaml::VerticalAlignment::Stretch);
-  panel.HorizontalAlignment(xaml::HorizontalAlignment::Stretch);
-  panel.BorderBrush(DefaultBrushStore::Instance().GetDefaultBorderBrush());
-  return panel.as<XamlView>();
-}
-
-void ViewViewManager::GetNativeProps(const winrt::Microsoft::ReactNative::IJSValueWriter &writer) const {
-  Super::GetNativeProps(writer);
-
-  winrt::Microsoft::ReactNative::WriteProperty(writer, L"pointerEvents", L"string");
-  winrt::Microsoft::ReactNative::WriteProperty(writer, L"onClick", L"function");
-  winrt::Microsoft::ReactNative::WriteProperty(writer, L"focusable", L"boolean");
-  winrt::Microsoft::ReactNative::WriteProperty(writer, L"enableFocusRing", L"boolean");
-  winrt::Microsoft::ReactNative::WriteProperty(writer, L"tabIndex", L"number");
-  winrt::Microsoft::ReactNative::WriteProperty(writer, L"disabled", L"boolean");
-  winrt::Microsoft::ReactNative::WriteProperty(writer, L"collapsable", L"boolean");
-}
-
-bool ViewViewManager::UpdateProperty(
-    ShadowNodeBase *nodeToUpdate,
-    const std::string &propertyName,
-    const winrt::Microsoft::ReactNative::JSValue &propertyValue) {
-  auto *pViewShadowNode = static_cast<ViewShadowNode *>(nodeToUpdate);
-
-  auto pPanel = pViewShadowNode->GetPanel().as<winrt::Microsoft::ReactNative::ViewPanel>();
-  bool ret = true;
-  if (pPanel != nullptr) {
-    if (TryUpdateBackgroundBrush(pPanel.as<xaml::Controls::Panel>(), propertyName, propertyValue)) {
-    } else if (TryUpdateBorderProperties(nodeToUpdate, pPanel, propertyName, propertyValue)) {
-    } else if (TryUpdateCornerRadiusOnNode(nodeToUpdate, pPanel, propertyName, propertyValue)) {
-      // Do not clamp until a size has been set for the View
-      auto maxCornerRadius = std::numeric_limits<double>::max();
-      // The Width and Height properties are not always set on ViewPanel. In
-      // cases where it is embedded in a Control, the values dimensions are
-      // set on those wrapper elements. We cannot depend on the default
-      // behavior of `UpdateCornerRadiusOnElement` to check for the clamp
-      // dimension from only the ViewPanel.
-      const xaml::FrameworkElement sizingElement =
-          pViewShadowNode->IsControl() ? pViewShadowNode->GetControl().as<xaml::FrameworkElement>() : pPanel;
-      if (sizingElement.ReadLocalValue(xaml::FrameworkElement::WidthProperty()) !=
-              xaml::DependencyProperty::UnsetValue() &&
-          sizingElement.ReadLocalValue(xaml::FrameworkElement::HeightProperty()) !=
-              xaml::DependencyProperty::UnsetValue()) {
-        maxCornerRadius = std::min(sizingElement.Width(), sizingElement.Height()) / 2;
-      }
-      UpdateCornerRadiusOnElement(nodeToUpdate, pPanel, maxCornerRadius);
-    } else if (TryUpdateMouseEvents(nodeToUpdate, propertyName, propertyValue)) {
-    } else if (propertyName == "onClick") {
-      pViewShadowNode->OnClick(propertyValue.AsBoolean());
-    } else if (propertyName == "focusable") {
-      pViewShadowNode->IsFocusable(propertyValue.AsBoolean());
-    } else if (propertyName == "enableFocusRing") {
-      pViewShadowNode->EnableFocusRing(propertyValue.AsBoolean());
-    } else if (propertyName == "tabIndex") {
-      auto resetTabIndex = true;
-      if (propertyValue.Type() == winrt::Microsoft::ReactNative::JSValueType::Int64 ||
-          propertyValue.Type() == winrt::Microsoft::ReactNative::JSValueType::Double) {
-        const auto tabIndex = propertyValue.AsInt64();
-        if (tabIndex == static_cast<int32_t>(tabIndex)) {
-          pViewShadowNode->TabIndex(static_cast<int32_t>(tabIndex));
-          resetTabIndex = false;
-        }
-      }
-      if (resetTabIndex) {
-        pViewShadowNode->TabIndex(std::numeric_limits<std::int32_t>::max());
-      }
-    } else {
-      if (propertyName == "accessible") {
-        pViewShadowNode->IsAccessible(propertyValue.AsBoolean());
-      }
-      if (propertyName == "disabled") {
-        pViewShadowNode->IsDisable(propertyValue.AsBoolean());
-      }
-      ret = Super::UpdateProperty(nodeToUpdate, propertyName, propertyValue);
-    }
-  }
-
-  return ret;
-}
-
-void ViewViewManager::OnPropertiesUpdated(ShadowNodeBase *node) {
-  auto *viewShadowNode = static_cast<ViewShadowNode *>(node);
-  auto panel = viewShadowNode->GetPanel().as<winrt::Microsoft::ReactNative::ViewPanel>();
-
-  if (panel.ReadLocalValue(ViewPanel::ViewBackgroundProperty()) == xaml::DependencyProperty::UnsetValue()) {
-    // In XAML, a null background means no hit-test will happen.
-    // We actually want hit-testing to happen if the app has registered
-    // for mouse events, so detect that case and add a transparent background.
-    if (viewShadowNode->IsHitTestBrushRequired()) {
-      panel.ViewBackground(EnsureTransparentBrush());
-    }
-    // Note:  Technically we could detect when the transparent brush is
-    // no longer needed, but this adds complexity and it can't hurt to
-    // keep it around, so not adding that code (yet).
-  }
-
-  // If component is focusable, it should be a ViewControl.
-  // If component is a View with accessible set to true, the component should be focusable, thus we need a ViewControl.
-  bool shouldBeControl = viewShadowNode->IsDisable()
-      ? false
-      : ((viewShadowNode->IsFocusable() || (viewShadowNode->IsAccessible() && !viewShadowNode->OnClick())));
-
-  if (auto view = viewShadowNode->GetView().try_as<xaml::UIElement>()) {
-    // If we have DynamicAutomationProperties, we need a ViewControl with a
-    // DynamicAutomationPeer
-    shouldBeControl = shouldBeControl || HasDynamicAutomationProperties(view);
-  }
-
-  TryUpdateView(viewShadowNode, panel, shouldBeControl);
-  SyncFocusableAndAccessible(viewShadowNode, shouldBeControl);
-}
-
-void ViewViewManager::TryUpdateView(
-    ViewShadowNode *pViewShadowNode,
-    winrt::Microsoft::ReactNative::ViewPanel &pPanel,
-    bool useControl) {
-  bool isControl = pViewShadowNode->IsControl();
-
-  // This short-circuits all of the update code when we have the same hierarchy
-  if (isControl == useControl)
-    return;
-
-  //
-  // 1. Ensure we have the new 'root' and do the child replacement
-  //      This is first to ensure that we can re-parent the ViewPanel
-  //      we already have
-  // 2. Transfer properties
-  //      There are likely some complexities to handle here
-  // 3. Do any sub=parenting
-  //      This means Panel under Control
-  //
-
-  XamlView oldXamlView(pViewShadowNode->GetView());
-  XamlView newXamlView(nullptr);
-
-  //
-  // 1. Determine new view & clean up any parent-child relationships
-  //
-
-  // If we need a Control then get existing reference or create it
-  if (useControl) {
-    newXamlView = pViewShadowNode->GetControl().try_as<XamlView>();
-    if (newXamlView == nullptr) {
-      newXamlView = pViewShadowNode->CreateViewControl();
-    }
-  }
-
-  // Clean up child of Control if needed
-  if (isControl) {
-    pViewShadowNode->GetControl().Content(nullptr);
-  }
-
-  // If don't need a control, then set the Panel as the view root
-  if (!useControl) {
-    newXamlView = pPanel;
-  }
-
-  // ASSERT: One of the scenarios should be true, so we should have a root view
-  assert(newXamlView != nullptr);
-
-  //
-  // 2. Transfer needed properties from old to new view
-  //
-  {
-    TraceSection s("ViewViewManager::TransferProperties");
-    // Transfer properties from old XamlView to the new one
-    TransferProperties(oldXamlView, newXamlView);
-  }
-
-  // Update the meta-data in the shadow node
-  pViewShadowNode->IsControl(useControl);
-
-  //
-  // 3. Setup any new parent-child relationships
-  //
-
-  // If we need to change the root of our view, do it now
-  if (oldXamlView != newXamlView) {
-    if (auto pNativeUiManager = GetNativeUIManager(*m_context).lock()) {
-      // Inform the parent ShadowNode of this change so the hierarchy can be
-      // updated
-      int64_t parentTag = pViewShadowNode->GetParent();
-      auto host = pNativeUiManager->getHost();
-      auto *pParentNode = static_cast<ShadowNodeBase *>(host->FindShadowNodeForTag(parentTag));
-      if (pParentNode != nullptr)
-        pParentNode->ReplaceChild(oldXamlView, newXamlView);
-
-      // Update the ShadowNode with the new XamlView
-      pViewShadowNode->ReplaceView(newXamlView);
-      pViewShadowNode->RefreshProperties();
-
-      // Inform the NativeUIManager of this change so the yoga layout can be
-      // updated
-      pNativeUiManager->ReplaceView(*pViewShadowNode);
-    }
-  }
-
-  if (useControl)
-    pViewShadowNode->GetControl().Content(pPanel);
-}
-
-void ViewViewManager::SyncFocusableAndAccessible(ViewShadowNode *pViewShadowNode, bool useControl) {
-  if (useControl) {
-    const auto isFocusable = pViewShadowNode->IsFocusable();
-    const auto isAccessible = pViewShadowNode->IsAccessible();
-    const auto isDisabled = pViewShadowNode->IsDisable();
-    const auto isTabStop = !isDisabled && isFocusable;
-    const auto accessibilityView = isAccessible ? xaml::Automation::Peers::AccessibilityView::Content
-                                                : xaml::Automation::Peers::AccessibilityView::Raw;
-    pViewShadowNode->GetControl().IsTabStop(isTabStop);
-    xaml::Automation::AutomationProperties::SetAccessibilityView(pViewShadowNode->GetControl(), accessibilityView);
-  }
-}
-
-void ViewViewManager::SetLayoutProps(
-    ShadowNodeBase &nodeToUpdate,
-    const XamlView &viewToUpdate,
-    float left,
-    float top,
-    float width,
-    float height) {
-  // When the View has a ContentControl the ViewPanel must also have the Width &
-  // Height set
-  // Do this first so that it is setup properly before any events are fired by
-  // the Super implementation
-  auto *pViewShadowNode = static_cast<ViewShadowNode *>(&nodeToUpdate);
-  auto pPanel = pViewShadowNode->GetPanel().as<winrt::Microsoft::ReactNative::ViewPanel>();
-  if (pViewShadowNode->IsControl()) {
-    pPanel.Width(width);
-    pPanel.Height(height);
-  }
-
-  Super::SetLayoutProps(nodeToUpdate, viewToUpdate, left, top, width, height);
-  if (pPanel.ReadLocalValue(ViewPanel::CornerRadiusProperty()) != xaml::DependencyProperty::UnsetValue()) {
-    if (pPanel.GetValue(React::ViewPanel::CornerRadiusProperty()) != xaml::DependencyProperty::UnsetValue()) {
-      const auto maxCornerRadius = std::min(width, height) / 2;
-      UpdateCornerRadiusOnElement(&nodeToUpdate, pPanel, maxCornerRadius);
-      pPanel.CornerRadius(pPanel.CornerRadius());
-    }
-  }
-}
-
-xaml::Media::SolidColorBrush ViewViewManager::EnsureTransparentBrush() {
-  if (!m_transparentBrush) {
-    m_transparentBrush = xaml::Media::SolidColorBrush(winrt::Colors::Transparent());
-  }
-  return m_transparentBrush;
-}
-
-} // namespace Microsoft::ReactNative

package/Microsoft.ReactNative/Views/ViewViewManager.h

@@ -1,52 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-
-#pragma once
-
-#include <Views/FrameworkElementViewManager.h>
-#include <Views/ViewPanel.h>
-
-namespace Microsoft::ReactNative {
-
-class ViewShadowNode;
-
-class ViewViewManager : public FrameworkElementViewManager {
-  using Super = FrameworkElementViewManager;
-
- public:
-  ViewViewManager(const Mso::React::IReactContext &context);
-
-  const wchar_t *GetName() const override;
-
-  void GetNativeProps(const winrt::Microsoft::ReactNative::IJSValueWriter &writer) const override;
-  void GetExportedCustomDirectEventTypeConstants(
-      const winrt::Microsoft::ReactNative::IJSValueWriter &writer) const override;
-  ShadowNode *createShadow() const override;
-
-  // Yoga Layout
-  void SetLayoutProps(
-      ShadowNodeBase &nodeToUpdate,
-      const XamlView &viewToUpdate,
-      float left,
-      float top,
-      float width,
-      float height) override;
-
- protected:
-  bool UpdateProperty(
-      ShadowNodeBase *nodeToUpdate,
-      const std::string &propertyName,
-      const winrt::Microsoft::ReactNative::JSValue &propertyValue) override;
-  void OnPropertiesUpdated(ShadowNodeBase *node) override;
-
-  XamlView CreateViewCore(int64_t tag, const winrt::Microsoft::ReactNative::JSValueObject &) override;
-  void TryUpdateView(ViewShadowNode *viewShadowNode, winrt::Microsoft::ReactNative::ViewPanel &pPanel, bool useControl);
-  void SyncFocusableAndAccessible(ViewShadowNode *viewShadowNode, bool useControl);
-
-  xaml::Media::SolidColorBrush EnsureTransparentBrush();
-
- private:
-  xaml::Media::SolidColorBrush m_transparentBrush{nullptr};
-};
-
-} // namespace Microsoft::ReactNative

package/Microsoft.ReactNative/Views/VirtualTextViewManager.cpp

@@ -1,143 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-
-#include "pch.h"
-
-#include "VirtualTextViewManager.h"
-
-#include <UI.Xaml.Documents.h>
-#include <Utils/PropertyUtils.h>
-#include <Utils/ShadowNodeTypeUtils.h>
-#include <Utils/TransformableText.h>
-#include <Utils/ValueUtils.h>
-#include <Views/Text/TextVisitors.h>
-
-namespace winrt {
-using namespace Windows::UI;
-using namespace xaml;
-using namespace xaml::Controls;
-using namespace xaml::Documents;
-} // namespace winrt
-
-namespace Microsoft::ReactNative {
-
-void VirtualTextShadowNode::AddView(ShadowNode &child, int64_t index) {
-  auto &childNode = static_cast<ShadowNodeBase &>(child);
-  ApplyTextTransformToChild(&child);
-  auto propertyChangeType = PropertyChangeType::Text;
-  if (IsVirtualTextShadowNode(&childNode)) {
-    const auto &childTextNode = static_cast<VirtualTextShadowNode &>(childNode);
-    propertyChangeType |=
-        childTextNode.hasDescendantTextHighlighter ? PropertyChangeType::AddHighlight : PropertyChangeType::None;
-    propertyChangeType |=
-        childTextNode.hasDescendantPressable ? PropertyChangeType::AddPressable : PropertyChangeType::None;
-  }
-  Super::AddView(child, index);
-  NotifyAncestorsTextPropertyChanged(this, propertyChangeType);
-}
-
-void VirtualTextShadowNode::RemoveChildAt(int64_t indexToRemove) {
-  Super::RemoveChildAt(indexToRemove);
-  NotifyAncestorsTextPropertyChanged(this, PropertyChangeType::Text);
-}
-
-void VirtualTextShadowNode::removeAllChildren() {
-  Super::removeAllChildren();
-  NotifyAncestorsTextPropertyChanged(this, PropertyChangeType::Text);
-}
-
-VirtualTextViewManager::VirtualTextViewManager(const Mso::React::IReactContext &context) : Super(context) {}
-
-const wchar_t *VirtualTextViewManager::GetName() const {
-  return L"RCTVirtualText";
-}
-
-XamlView VirtualTextViewManager::CreateViewCore(int64_t /*tag*/, const winrt::Microsoft::ReactNative::JSValueObject &) {
-  return winrt::Span();
-}
-
-void VirtualTextViewManager::UpdateProperties(
-    ShadowNodeBase *nodeToUpdate,
-    winrt::Microsoft::ReactNative::JSValueObject &props) {
-  // This could be optimized further, but rather than paying a penalty to mark
-  // the node dirty for each relevant property in UpdateProperty (which should
-  // be reasonably cheap given it just does an O(1) lookup of the Yoga node
-  // for the tag, for now this just marks the node dirty for any prop update.
-  MarkDirty(nodeToUpdate->m_tag);
-  Super::UpdateProperties(nodeToUpdate, props);
-}
-
-bool VirtualTextViewManager::UpdateProperty(
-    ShadowNodeBase *nodeToUpdate,
-    const std::string &propertyName,
-    const winrt::Microsoft::ReactNative::JSValue &propertyValue) {
-  auto span = nodeToUpdate->GetView().as<winrt::Span>();
-  if (span == nullptr)
-    return true;
-
-  // FUTURE: In the future cppwinrt will generate code where static methods on
-  // base types can be called.  For now we specify the base type explicitly
-  if (TryUpdateForeground<winrt::TextElement>(span, propertyName, propertyValue)) {
-    auto node = static_cast<VirtualTextShadowNode *>(nodeToUpdate);
-    if (IsValidOptionalColorValue(propertyValue)) {
-      node->foregroundColor = OptionalColorFrom(propertyValue);
-      const auto propertyChangeType =
-          node->foregroundColor ? PropertyChangeType::AddHighlight : PropertyChangeType::RemoveHighlight;
-      NotifyAncestorsTextPropertyChanged(node, propertyChangeType);
-    }
-  } else if (TryUpdateFontProperties<winrt::TextElement>(span, propertyName, propertyValue)) {
-  } else if (TryUpdateCharacterSpacing<winrt::TextElement>(span, propertyName, propertyValue)) {
-  } else if (TryUpdateTextDecorationLine<winrt::TextElement>(span, propertyName, propertyValue)) {
-  } else if (propertyName == "textTransform") {
-    auto node = static_cast<VirtualTextShadowNode *>(nodeToUpdate);
-    node->textTransform = TransformableText::GetTextTransform(propertyValue);
-    UpdateTextTransformForChildren(nodeToUpdate);
-  } else if (propertyName == "backgroundColor") {
-    auto node = static_cast<VirtualTextShadowNode *>(nodeToUpdate);
-    if (IsValidOptionalColorValue(propertyValue)) {
-      node->backgroundColor = OptionalColorFrom(propertyValue);
-      const auto propertyChangeType =
-          node->backgroundColor ? PropertyChangeType::AddHighlight : PropertyChangeType::RemoveHighlight;
-      NotifyAncestorsTextPropertyChanged(node, propertyChangeType);
-    }
-  } else if (propertyName == "isPressable") {
-    auto node = static_cast<VirtualTextShadowNode *>(nodeToUpdate);
-    node->isPressable = propertyValue.AsBoolean();
-    if (node->isPressable) {
-      NotifyAncestorsTextPropertyChanged(node, PropertyChangeType::AddPressable);
-    }
-  } else {
-    const auto isRegisteringMouseEvent =
-        (propertyName == "onMouseEnter" || propertyName == "onMouseLeave") && propertyValue.AsBoolean();
-    if (isRegisteringMouseEvent) {
-      auto node = static_cast<VirtualTextShadowNode *>(nodeToUpdate);
-      NotifyAncestorsTextPropertyChanged(node, PropertyChangeType::AddPressable);
-    }
-
-    return Super::UpdateProperty(nodeToUpdate, propertyName, propertyValue);
-  }
-
-  return true;
-}
-
-void VirtualTextViewManager::AddView(const XamlView &parent, const XamlView &child, int64_t index) {
-  auto span(parent.as<winrt::Span>());
-  auto childInline(child.as<winrt::Inline>());
-  span.Inlines().InsertAt(static_cast<uint32_t>(index), childInline);
-}
-
-void VirtualTextViewManager::RemoveAllChildren(const XamlView &parent) {
-  auto span(parent.as<winrt::Span>());
-  span.Inlines().Clear();
-}
-
-void VirtualTextViewManager::RemoveChildAt(const XamlView &parent, int64_t index) {
-  auto span(parent.as<winrt::Span>());
-  return span.Inlines().RemoveAt(static_cast<uint32_t>(index));
-}
-
-bool VirtualTextViewManager::RequiresYogaNode() const {
-  return false;
-}
-
-} // namespace Microsoft::ReactNative