react-native-windows 0.70.8 → 0.71.0-preview.1

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

@@ -40,13 +40,7 @@ void TextPropertyChangedParentVisitor::VisitText(ShadowNodeBase *node) {
       }
     }
 
-    // Update fast text content
-    if (!m_isNested && node->m_children.size() == 1) {
-      if (const auto childNode = GetShadowNode(node->m_children[0])) {
-        const auto run = static_cast<ShadowNodeBase *>(childNode)->GetView().as<winrt::Run>();
-        element.Text(run.Text());
-      }
-    }
+    TextViewManager::UpdateOptimizedText(node);
   }
 
   // Refresh text highlighters

package/Microsoft.ReactNative/Views/TextInputViewManager.cpp

@@ -134,6 +134,7 @@ class TextInputShadowNode : public ShadowNodeBase {
   void SetText(const winrt::Microsoft::ReactNative::JSValue &text);
   void SetSelection(int64_t start, int64_t end);
   winrt::Shape FindCaret(xaml::DependencyObject element);
+  bool IsTextBox();
 
   bool m_initialUpdateComplete = false;
   bool m_autoFocus = false;
@@ -141,7 +142,6 @@ class TextInputShadowNode : public ShadowNodeBase {
   bool m_shouldSelectTextOnFocus = false;
   bool m_contextMenuHidden = false;
   bool m_hideCaret = false;
-  bool m_isTextBox = true;
   bool m_shouldClearTextOnSubmit = false;
 
   winrt::Microsoft::ReactNative::JSValue m_placeholderTextColor;
@@ -190,6 +190,7 @@ void TextInputShadowNode::dispatchTextInputChangeEvent(winrt::hstring newText) {
 void TextInputShadowNode::registerEvents() {
   auto control = GetView().as<xaml::Controls::Control>();
   auto tag = m_tag;
+  auto isTextBox = IsTextBox();
 
   // TextChanged is implemented as async event in Xaml. If Javascript is like
   // this:
@@ -203,7 +204,7 @@ void TextInputShadowNode::registerEvents() {
   //
   // TextChanging is used to drop the Javascript response of 'A' and expect
   // another TextChanged event with correct event count.
-  if (m_isTextBox) {
+  if (isTextBox) {
     m_passwordBoxPasswordChangedRevoker = {};
     m_passwordBoxPasswordChangingRevoker = {};
     auto textBox = control.as<xaml::Controls::TextBox>();
@@ -223,7 +224,7 @@ void TextInputShadowNode::registerEvents() {
     }
   }
 
-  if (m_isTextBox) {
+  if (isTextBox) {
     m_passwordBoxContextMenuOpeningRevoker = {};
     auto textBox = control.as<xaml::Controls::TextBox>();
     m_textBoxContextMenuOpeningRevoker =
@@ -245,7 +246,7 @@ void TextInputShadowNode::registerEvents() {
 
   m_controlGotFocusRevoker = control.GotFocus(winrt::auto_revoke, [=](auto &&, auto &&) {
     if (m_shouldClearTextOnFocus) {
-      if (m_isTextBox) {
+      if (isTextBox) {
         control.as<xaml::Controls::TextBox>().ClearValue(xaml::Controls::TextBox::TextProperty());
       } else {
         control.as<xaml::Controls::PasswordBox>().ClearValue(xaml::Controls::PasswordBox::PasswordProperty());
@@ -253,7 +254,7 @@ void TextInputShadowNode::registerEvents() {
     }
 
     if (m_shouldSelectTextOnFocus) {
-      if (m_isTextBox) {
+      if (isTextBox) {
         control.as<xaml::Controls::TextBox>().SelectAll();
       } else {
         control.as<xaml::Controls::PasswordBox>().SelectAll();
@@ -269,7 +270,7 @@ void TextInputShadowNode::registerEvents() {
   m_controlLostFocusRevoker = control.LostFocus(winrt::auto_revoke, [=](auto &&, auto &&) {
     folly::dynamic eventDataBlur = folly::dynamic::object("target", tag);
     folly::dynamic eventDataEndEditing = {};
-    if (m_isTextBox) {
+    if (isTextBox) {
       eventDataEndEditing =
           folly::dynamic::object("target", tag)("text", HstringToDynamic(control.as<xaml::Controls::TextBox>().Text()));
     } else {
@@ -284,7 +285,7 @@ void TextInputShadowNode::registerEvents() {
 
   registerPreviewKeyDown();
 
-  if (m_isTextBox) {
+  if (isTextBox) {
     auto textBox = control.as<xaml::Controls::TextBox>();
     m_textBoxSelectionChangedRevoker = textBox.SelectionChanged(winrt::auto_revoke, [=](auto &&, auto &&) {
       folly::dynamic selectionData = folly::dynamic::object("start", textBox.SelectionStart())(
@@ -297,7 +298,7 @@ void TextInputShadowNode::registerEvents() {
 
   m_controlSizeChangedRevoker =
       control.SizeChanged(winrt::auto_revoke, [=](auto &&, winrt::SizeChangedEventArgs const &args) {
-        if (m_isTextBox) {
+        if (isTextBox) {
           if (control.as<xaml::Controls::TextBox>().TextWrapping() == xaml::TextWrapping::Wrap) {
             folly::dynamic contentSizeData =
                 folly::dynamic::object("width", args.NewSize().Width)("height", args.NewSize().Height);
@@ -371,9 +372,10 @@ void TextInputShadowNode::registerEvents() {
 void TextInputShadowNode::registerPreviewKeyDown() {
   auto control = GetView().as<xaml::Controls::Control>();
   auto tag = m_tag;
+  auto isTextBox = IsTextBox();
   m_controlPreviewKeyDownRevoker =
       control.PreviewKeyDown(winrt::auto_revoke, [=](auto &&, xaml::Input::KeyRoutedEventArgs const &args) {
-        auto isMultiline = m_isTextBox && control.as<xaml::Controls::TextBox>().AcceptsReturn();
+        auto isMultiline = isTextBox && control.as<xaml::Controls::TextBox>().AcceptsReturn();
         auto shouldSubmit = !args.Handled();
         if (shouldSubmit) {
           if (!isMultiline && m_submitKeyEvents.size() == 0) {
@@ -395,7 +397,7 @@ void TextInputShadowNode::registerPreviewKeyDown() {
 
         if (shouldSubmit) {
           folly::dynamic eventDataSubmitEditing = {};
-          if (m_isTextBox) {
+          if (isTextBox) {
             eventDataSubmitEditing = folly::dynamic::object("target", tag)(
                 "text", HstringToDynamic(control.as<xaml::Controls::TextBox>().Text()));
           } else {
@@ -407,7 +409,7 @@ void TextInputShadowNode::registerPreviewKeyDown() {
               tag, "topTextInputSubmitEditing", std::move(eventDataSubmitEditing));
 
           if (m_shouldClearTextOnSubmit) {
-            if (m_isTextBox) {
+            if (isTextBox) {
               control.as<xaml::Controls::TextBox>().ClearValue(xaml::Controls::TextBox::TextProperty());
             } else {
               control.as<xaml::Controls::PasswordBox>().ClearValue(xaml::Controls::PasswordBox::PasswordProperty());
@@ -440,6 +442,10 @@ xaml::Shapes::Shape TextInputShadowNode::FindCaret(xaml::DependencyObject elemen
   return nullptr;
 }
 
+bool TextInputShadowNode::IsTextBox() {
+  return !!GetView().try_as<xaml::Controls::TextBox>();
+}
+
 // hacking solution to hide the caret
 void TextInputShadowNode::HideCaretIfNeeded() {
   if (m_hideCaret) {
@@ -477,6 +483,7 @@ void TextInputShadowNode::updateProperties(winrt::Microsoft::ReactNative::JSValu
   auto hasKeyDownEvents = false;
 
   auto markDirty = false;
+  auto isTextBox = IsTextBox();
   for (auto &pair : props) {
     const std::string &propertyName = pair.first;
     const auto &propertyValue = pair.second;
@@ -524,10 +531,10 @@ void TextInputShadowNode::updateProperties(winrt::Microsoft::ReactNative::JSValu
       markDirty = true;
       if (propertyValue.Type() == winrt::Microsoft::ReactNative::JSValueType::Boolean) {
         if (propertyValue.AsBoolean()) {
-          if (m_isTextBox) {
+          if (isTextBox) {
             xaml::Controls::PasswordBox newPasswordBox;
             ReparentView(newPasswordBox);
-            m_isTextBox = false;
+            isTextBox = false;
             registerEvents();
             control = newPasswordBox.as<xaml::Controls::Control>();
             passwordBox = newPasswordBox;
@@ -536,10 +543,10 @@ void TextInputShadowNode::updateProperties(winrt::Microsoft::ReactNative::JSValu
             }
           }
         } else {
-          if (!m_isTextBox) {
+          if (!isTextBox) {
             xaml::Controls::TextBox newTextBox;
             ReparentView(newTextBox);
-            m_isTextBox = true;
+            isTextBox = true;
             registerEvents();
             control = newTextBox.as<xaml::Controls::Control>();
             textBox = newTextBox;
@@ -554,59 +561,58 @@ void TextInputShadowNode::updateProperties(winrt::Microsoft::ReactNative::JSValu
       if (propertyValue.Type() == winrt::Microsoft::ReactNative::JSValueType::Double ||
           propertyValue.Type() == winrt::Microsoft::ReactNative::JSValueType::Int64) {
         control.SetValue(
-            m_isTextBox ? xaml::Controls::TextBox::MaxLengthProperty()
-                        : xaml::Controls::PasswordBox::MaxLengthProperty(),
+            isTextBox ? xaml::Controls::TextBox::MaxLengthProperty() : xaml::Controls::PasswordBox::MaxLengthProperty(),
             winrt::PropertyValue::CreateInt32(propertyValue.AsInt32()));
       } else if (propertyValue.IsNull()) {
         control.ClearValue(
-            m_isTextBox ? xaml::Controls::TextBox::MaxLengthProperty()
-                        : xaml::Controls::PasswordBox::MaxLengthProperty());
+            isTextBox ? xaml::Controls::TextBox::MaxLengthProperty()
+                      : xaml::Controls::PasswordBox::MaxLengthProperty());
       }
     } else if (propertyName == "placeholder") {
       if (propertyValue.Type() == winrt::Microsoft::ReactNative::JSValueType::String) {
         control.SetValue(
-            m_isTextBox ? xaml::Controls::TextBox::PlaceholderTextProperty()
-                        : xaml::Controls::PasswordBox::PlaceholderTextProperty(),
+            isTextBox ? xaml::Controls::TextBox::PlaceholderTextProperty()
+                      : xaml::Controls::PasswordBox::PlaceholderTextProperty(),
             winrt::PropertyValue::CreateString(asHstring(propertyValue)));
       } else if (propertyValue.IsNull()) {
         control.ClearValue(
-            m_isTextBox ? xaml::Controls::TextBox::PlaceholderTextProperty()
-                        : xaml::Controls::PasswordBox::PlaceholderTextProperty());
+            isTextBox ? xaml::Controls::TextBox::PlaceholderTextProperty()
+                      : xaml::Controls::PasswordBox::PlaceholderTextProperty());
       }
     } else if (propertyName == "selectionColor") {
       if (IsValidColorValue(propertyValue)) {
         control.SetValue(
-            m_isTextBox ? xaml::Controls::TextBox::SelectionHighlightColorProperty()
-                        : xaml::Controls::PasswordBox::SelectionHighlightColorProperty(),
+            isTextBox ? xaml::Controls::TextBox::SelectionHighlightColorProperty()
+                      : xaml::Controls::PasswordBox::SelectionHighlightColorProperty(),
             SolidColorBrushFrom(propertyValue));
       } else if (propertyValue.IsNull())
         control.ClearValue(
-            m_isTextBox ? xaml::Controls::TextBox::SelectionHighlightColorProperty()
-                        : xaml::Controls::PasswordBox::SelectionHighlightColorProperty());
+            isTextBox ? xaml::Controls::TextBox::SelectionHighlightColorProperty()
+                      : xaml::Controls::PasswordBox::SelectionHighlightColorProperty());
     } else if (propertyName == "keyboardType") {
       if (propertyValue.Type() == winrt::Microsoft::ReactNative::JSValueType::String) {
-        auto inputScopeNameVaue = parseKeyboardType(propertyValue, m_isTextBox);
+        auto inputScopeNameVaue = parseKeyboardType(propertyValue, isTextBox);
         auto scope = xaml::Input::InputScope();
         auto scopeName = xaml::Input::InputScopeName(inputScopeNameVaue);
         auto names = scope.Names();
         names.Append(scopeName);
         control.SetValue(
-            m_isTextBox ? xaml::Controls::TextBox::InputScopeProperty()
-                        : xaml::Controls::PasswordBox::InputScopeProperty(),
+            isTextBox ? xaml::Controls::TextBox::InputScopeProperty()
+                      : xaml::Controls::PasswordBox::InputScopeProperty(),
             scope);
       } else if (propertyValue.IsNull())
         control.ClearValue(
-            m_isTextBox ? xaml::Controls::TextBox::InputScopeProperty()
-                        : xaml::Controls::PasswordBox::InputScopeProperty());
+            isTextBox ? xaml::Controls::TextBox::InputScopeProperty()
+                      : xaml::Controls::PasswordBox::InputScopeProperty());
     } else if (propertyName == "placeholderTextColor") {
       m_placeholderTextColor = nullptr;
-      if (textBox.try_as<xaml::Controls::ITextBox6>() && m_isTextBox) {
+      if (textBox.try_as<xaml::Controls::ITextBox6>() && isTextBox) {
         if (IsValidColorValue(propertyValue)) {
           m_placeholderTextColor = propertyValue.Copy();
           textBox.PlaceholderForeground(SolidColorBrushFrom(propertyValue));
         } else if (propertyValue.IsNull())
           textBox.ClearValue(xaml::Controls::TextBox::PlaceholderForegroundProperty());
-      } else if (m_isTextBox != true && IsValidColorValue(propertyValue)) {
+      } else if (isTextBox != true && IsValidColorValue(propertyValue)) {
         setPasswordBoxPlaceholderForeground(passwordBox, propertyValue);
       }
     } else if (propertyName == "clearTextOnSubmit") {
@@ -624,13 +630,13 @@ void TextInputShadowNode::updateProperties(winrt::Microsoft::ReactNative::JSValu
         m_autoFocus = propertyValue.AsBoolean();
     } else if (propertyName == "editable") {
       if (propertyValue.Type() == winrt::Microsoft::ReactNative::JSValueType::Boolean) {
-        m_isTextBox ? textBox.IsReadOnly(!propertyValue.AsBoolean()) : passwordBox.IsEnabled(propertyValue.AsBoolean());
+        isTextBox ? textBox.IsReadOnly(!propertyValue.AsBoolean()) : passwordBox.IsEnabled(propertyValue.AsBoolean());
       } else if (propertyValue.IsNull()) {
-        m_isTextBox ? textBox.ClearValue(xaml::Controls::TextBox::IsReadOnlyProperty())
-                    : passwordBox.ClearValue(xaml::Controls::Control::IsEnabledProperty());
+        isTextBox ? textBox.ClearValue(xaml::Controls::TextBox::IsReadOnlyProperty())
+                  : passwordBox.ClearValue(xaml::Controls::Control::IsEnabledProperty());
       }
     } else {
-      if (m_isTextBox) { // Applicable properties for TextBox
+      if (isTextBox) { // Applicable properties for TextBox
         if (TryUpdateTextAlignment(textBox, propertyName, propertyValue)) {
           continue;
         } else if (propertyName == "multiline") {
@@ -676,7 +682,7 @@ void TextInputShadowNode::updateProperties(winrt::Microsoft::ReactNative::JSValu
           }
         }
       } else { // Applicable properties for PasswordBox
-        if (propertyName == "text" && !m_isTextBox) {
+        if (propertyName == "text" && !isTextBox) {
           markDirty = true;
           SetText(propertyValue);
         }
@@ -828,9 +834,19 @@ ShadowNode *TextInputViewManager::createShadow() const {
   return new TextInputShadowNode();
 }
 
-XamlView TextInputViewManager::CreateViewCore(int64_t /*tag*/, const winrt::Microsoft::ReactNative::JSValueObject &) {
-  xaml::Controls::TextBox textBox;
-  return textBox;
+XamlView TextInputViewManager::CreateViewCore(
+    int64_t /*tag*/,
+    const winrt::Microsoft::ReactNative::JSValueObject &props) {
+  const auto secureTextEntry = props.find("secureTextEntry");
+  if (secureTextEntry != props.end() &&
+      secureTextEntry->second.Type() == winrt::Microsoft::ReactNative::JSValueType::Boolean &&
+      secureTextEntry->second.AsBoolean()) {
+    xaml::Controls::PasswordBox passwordBox;
+    return passwordBox;
+  } else {
+    xaml::Controls::TextBox textBox;
+    return textBox;
+  }
 }
 
 YGMeasureFunc TextInputViewManager::GetYogaCustomMeasureFunc() const {

package/Microsoft.ReactNative/Views/TextViewManager.cpp

@@ -39,8 +39,7 @@ class TextShadowNode final : public ShadowNodeBase {
   friend TextViewManager;
 
  private:
-  ShadowNode *m_firstChildNode;
-
+  bool m_isTextOptimized{true};
   bool m_hasDescendantTextHighlighter{false};
   bool m_hasDescendantPressable{false};
   std::optional<winrt::Windows::UI::Color> m_backgroundColor{};
@@ -49,9 +48,6 @@ class TextShadowNode final : public ShadowNodeBase {
   winrt::event_revoker<xaml::Controls::ITextBlock> m_selectionChangedRevoker;
 
  public:
-  TextShadowNode() {
-    m_firstChildNode = nullptr;
-  };
   bool ImplementsPadding() override {
     return true;
   }
@@ -66,25 +62,23 @@ class TextShadowNode final : public ShadowNodeBase {
       m_hasDescendantPressable |= textChildNode.hasDescendantPressable;
     }
 
-    auto addInline = true;
-    // Only convert to fast text when exactly one child is attached to the root Text node
-    if (index == 0 && m_children.size() == 1) {
-      auto run = childNode.GetView().try_as<winrt::Run>();
-      if (run != nullptr) {
-        m_firstChildNode = &child;
-        auto textBlock = this->GetView().as<xaml::Controls::TextBlock>();
-        textBlock.Text(run.Text());
-        addInline = false;
+    const auto wasOptimized = m_isTextOptimized;
+    m_isTextOptimized = IsRawTextShadowNode(&childNode) && m_isTextOptimized;
+    if (m_isTextOptimized) {
+      // Re-build optimized text from children
+      UpdateOptimizedText();
+    } else if (wasOptimized) {
+      // Remove optimized text and re-construct as Inline tree
+      UpdateOptimizedText();
+      if (const auto uiManager = GetNativeUIManager(GetViewManager()->GetReactContext()).lock()) {
+        for (size_t i = 0; i < m_children.size(); ++i) {
+          if (const auto childNode =
+                  static_cast<ShadowNodeBase *>(uiManager->getHost()->FindShadowNodeForTag(m_children[i]))) {
+            Super::AddView(*childNode, i);
+          }
+        }
       }
-    } else if (m_firstChildNode != nullptr) {
-      assert(m_children.size() == 2);
-      auto textBlock = this->GetView().as<xaml::Controls::TextBlock>();
-      textBlock.ClearValue(xaml::Controls::TextBlock::TextProperty());
-      Super::AddView(*m_firstChildNode, 0);
-      m_firstChildNode = nullptr;
-    }
-
-    if (addInline) {
+    } else {
       Super::AddView(child, index);
     }
 
@@ -92,10 +86,9 @@ class TextShadowNode final : public ShadowNodeBase {
   }
 
   void removeAllChildren() override {
-    if (m_firstChildNode) {
+    if (m_isTextOptimized) {
       auto textBlock = this->GetView().as<xaml::Controls::TextBlock>();
       textBlock.ClearValue(xaml::Controls::TextBlock::TextProperty());
-      m_firstChildNode = nullptr;
     } else {
       Super::removeAllChildren();
     }
@@ -103,17 +96,33 @@ class TextShadowNode final : public ShadowNodeBase {
   }
 
   void RemoveChildAt(int64_t indexToRemove) override {
-    if (m_firstChildNode) {
-      assert(indexToRemove == 0);
-      auto textBlock = this->GetView().as<xaml::Controls::TextBlock>();
-      textBlock.ClearValue(xaml::Controls::TextBlock::TextProperty());
-      m_firstChildNode = nullptr;
+    if (m_isTextOptimized) {
+      UpdateOptimizedText();
     } else {
       Super::RemoveChildAt(indexToRemove);
     }
     RecalculateTextHighlighters();
   }
 
+  void UpdateOptimizedText() {
+    if (m_children.size() > 0 && m_isTextOptimized) {
+      if (const auto uiManager = GetNativeUIManager(GetViewManager()->GetReactContext()).lock()) {
+        winrt::hstring text = L"";
+        for (const auto childTag : m_children) {
+          if (const auto childNode =
+                  static_cast<ShadowNodeBase *>(uiManager->getHost()->FindShadowNodeForTag(childTag))) {
+            text = text + childNode->GetView().as<winrt::Run>().Text();
+          }
+        }
+        auto textBlock = this->GetView().as<xaml::Controls::TextBlock>();
+        textBlock.Text(text);
+      }
+    } else {
+      auto textBlock = this->GetView().as<xaml::Controls::TextBlock>();
+      textBlock.ClearValue(xaml::Controls::TextBlock::TextProperty());
+    }
+  }
+
   void RecalculateTextHighlighters() {
     const auto textBlock = this->GetView().as<xaml::Controls::TextBlock>();
     textBlock.TextHighlighters().Clear();
@@ -150,7 +159,7 @@ class TextShadowNode final : public ShadowNodeBase {
   void ToggleTouchEvents(XamlView xamlView, bool selectable) {
     if (selectable) {
       if (m_touchEventHandler == nullptr) {
-        m_touchEventHandler = std::make_unique<TouchEventHandler>(GetViewManager()->GetReactContext(), false);
+        m_touchEventHandler = std::make_unique<TouchEventHandler>(GetViewManager()->GetReactContext());
       }
 
       m_selectionChangedRevoker = xamlView.as<xaml::Controls::TextBlock>().SelectionChanged(
@@ -389,6 +398,13 @@ void TextViewManager::OnPointerEvent(
   }
 }
 
+/*static*/ void TextViewManager::UpdateOptimizedText(ShadowNodeBase *node) {
+  if (IsTextShadowNode(node)) {
+    const auto textNode = static_cast<TextShadowNode *>(node);
+    textNode->UpdateOptimizedText();
+  }
+}
+
 /*static*/ void TextViewManager::SetDescendantPressable(ShadowNodeBase *node) {
   if (IsTextShadowNode(node)) {
     const auto textNode = static_cast<TextShadowNode *>(node);

package/Microsoft.ReactNative/Views/TextViewManager.h

@@ -29,6 +29,8 @@ class TextViewManager : public FrameworkElementViewManager {
 
   static void UpdateTextHighlighters(ShadowNodeBase *node, bool highlightAdded);
 
+  static void UpdateOptimizedText(ShadowNodeBase *node);
+
   static void SetDescendantPressable(ShadowNodeBase *node);
 
   static TextTransform GetTextTransformValue(ShadowNodeBase *node);