react-native-windows 0.70.9 → 0.71.0-preview.2

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

@@ -0,0 +1,355 @@
+
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "ScrollViewComponentView.h"
+
+#include <UI.Xaml.Controls.h>
+#include <Utils/ValueUtils.h>
+
+#pragma warning(push)
+#pragma warning(disable : 4305)
+#include <react/renderer/components/scrollview/ScrollViewShadowNode.h>
+#pragma warning(pop)
+
+#include <windows.ui.composition.interop.h>
+
+#include <unicode.h>
+
+namespace Microsoft::ReactNative {
+
+ScrollViewComponentView::ScrollViewComponentView(
+    const winrt::Microsoft::ReactNative::Composition::ICompositionContext &compContext,
+    facebook::react::Tag tag)
+    : Super(compContext, tag) {
+  // static auto const defaultProps = std::make_shared<facebook::react::TextProps const>();
+  // m_props = defaultProps;
+
+  // m_element.Content(m_contentPanel);
+
+  /*
+    m_scrollViewerViewChangingRevoker =
+        m_element.ViewChanging(winrt::auto_revoke, [this](const auto &sender, const auto &args) {
+          const auto scrollViewerNotNull = sender.as<xaml::Controls::ScrollViewer>();
+
+          facebook::react::ScrollViewMetrics scrollMetrics;
+          scrollMetrics.containerSize.height = static_cast<facebook::react::Float>(m_element.ActualHeight());
+          scrollMetrics.containerSize.width = static_cast<facebook::react::Float>(m_element.ActualWidth());
+          scrollMetrics.contentOffset.x = static_cast<facebook::react::Float>(args.NextView().HorizontalOffset());
+          scrollMetrics.contentOffset.y = static_cast<facebook::react::Float>(args.NextView().VerticalOffset());
+          scrollMetrics.zoomScale = args.NextView().ZoomFactor();
+          scrollMetrics.contentSize.height = static_cast<facebook::react::Float>(m_contentPanel.ActualHeight());
+          scrollMetrics.contentSize.width = static_cast<facebook::react::Float>(m_contentPanel.ActualWidth());
+
+          // If we are transitioning to inertial scrolling.
+          if (m_isScrolling && !m_isScrollingFromInertia && args.IsInertial()) {
+            m_isScrollingFromInertia = true;
+
+            if (m_eventEmitter) {
+              std::static_pointer_cast<facebook::react::ScrollViewEventEmitter const>(m_eventEmitter)
+                  ->onScrollEndDrag(scrollMetrics);
+              std::static_pointer_cast<facebook::react::ScrollViewEventEmitter const>(m_eventEmitter)
+                  ->onMomentumScrollBegin(scrollMetrics);
+            }
+          }
+
+          if (m_eventEmitter) {
+            std::static_pointer_cast<facebook::react::ScrollViewEventEmitter const>(m_eventEmitter)
+                ->onScroll(scrollMetrics);
+          }
+        });
+
+    m_scrollViewerDirectManipulationStartedRevoker =
+        m_element.DirectManipulationStarted(winrt::auto_revoke, [this](const auto &sender, const auto &) {
+          m_isScrolling = true;
+
+
+          //if (m_dismissKeyboardOnDrag && m_SIPEventHandler) {
+          //  m_SIPEventHandler->TryHide();
+          //}
+
+
+          facebook::react::ScrollViewMetrics scrollMetrics;
+          scrollMetrics.containerSize.height = static_cast<facebook::react::Float>(m_element.ActualHeight());
+          scrollMetrics.containerSize.width = static_cast<facebook::react::Float>(m_element.ActualWidth());
+          scrollMetrics.contentOffset.x = static_cast<facebook::react::Float>(m_element.HorizontalOffset());
+          scrollMetrics.contentOffset.y = static_cast<facebook::react::Float>(m_element.VerticalOffset());
+          scrollMetrics.zoomScale = m_element.ZoomFactor();
+          scrollMetrics.contentSize.height = static_cast<facebook::react::Float>(m_contentPanel.ActualHeight());
+          scrollMetrics.contentSize.width = static_cast<facebook::react::Float>(m_contentPanel.ActualWidth());
+
+          const auto scrollViewer = sender.as<xaml::Controls::ScrollViewer>();
+          if (m_eventEmitter) {
+            std::static_pointer_cast<facebook::react::ScrollViewEventEmitter const>(m_eventEmitter)
+                ->onScrollBeginDrag(scrollMetrics);
+          }
+        });
+
+    m_scrollViewerDirectManipulationCompletedRevoker =
+        m_element.DirectManipulationCompleted(winrt::auto_revoke, [this](const auto &sender, const auto &args) {
+          const auto scrollViewer = sender.as<xaml::Controls::ScrollViewer>();
+
+          facebook::react::ScrollViewMetrics scrollMetrics;
+          scrollMetrics.containerSize.height = static_cast<facebook::react::Float>(m_element.ActualHeight());
+          scrollMetrics.containerSize.width = static_cast<facebook::react::Float>(m_element.ActualWidth());
+          scrollMetrics.contentOffset.x = static_cast<facebook::react::Float>(m_element.HorizontalOffset());
+          scrollMetrics.contentOffset.y = static_cast<facebook::react::Float>(m_element.VerticalOffset());
+          scrollMetrics.zoomScale = m_element.ZoomFactor();
+          scrollMetrics.contentSize.height = static_cast<facebook::react::Float>(m_contentPanel.ActualHeight());
+          scrollMetrics.contentSize.width = static_cast<facebook::react::Float>(m_contentPanel.ActualWidth());
+
+          if (m_eventEmitter) {
+            if (m_isScrollingFromInertia) {
+              std::static_pointer_cast<facebook::react::ScrollViewEventEmitter const>(m_eventEmitter)
+                  ->onMomentumScrollEnd(scrollMetrics);
+            } else {
+              std::static_pointer_cast<facebook::react::ScrollViewEventEmitter const>(m_eventEmitter)
+                  ->onScrollEndDrag(scrollMetrics);
+            }
+          }
+
+          m_isScrolling = false;
+          m_isScrollingFromInertia = false;
+        });
+        */
+}
+
+std::vector<facebook::react::ComponentDescriptorProvider>
+ScrollViewComponentView::supplementalComponentDescriptorProviders() noexcept {
+  return {};
+}
+
+void ScrollViewComponentView::mountChildComponentView(
+    const IComponentView &childComponentView,
+    uint32_t index) noexcept {
+  ensureVisual();
+
+  m_children.insert(std::next(m_children.begin(), index), &childComponentView);
+  const_cast<IComponentView &>(childComponentView).parent(this);
+
+  m_visual.InsertAt(static_cast<const CompositionBaseComponentView &>(childComponentView).Visual(), index);
+}
+
+void ScrollViewComponentView::unmountChildComponentView(
+    const IComponentView &childComponentView,
+    uint32_t index) noexcept {
+  m_children.erase(std::next(m_children.begin(), index));
+
+  m_visual.Remove(static_cast<const CompositionBaseComponentView &>(childComponentView).Visual());
+  const_cast<IComponentView &>(childComponentView).parent(nullptr);
+}
+
+void ScrollViewComponentView::updateProps(
+    facebook::react::Props::Shared const &props,
+    facebook::react::Props::Shared const &oldProps) noexcept {
+  const auto &newViewProps = *std::static_pointer_cast<const facebook::react::ScrollViewProps>(props);
+  const auto &oldViewProps = *std::static_pointer_cast<const facebook::react::ScrollViewProps>(oldProps);
+
+  ensureVisual();
+
+  if (!oldProps || oldViewProps.backgroundColor != newViewProps.backgroundColor) {
+    if (newViewProps.backgroundColor) {
+      m_visual.Brush(m_compContext.CreateColorBrush((*newViewProps.backgroundColor).m_color));
+    } else {
+      m_visual.Brush(m_compContext.CreateColorBrush({0, 0, 0, 0}));
+    }
+  }
+
+  /*
+  if (oldViewProps.borderColors != newViewProps.borderColors) {
+    if (newViewProps.borderColors.all) {
+      m_element.BorderBrush(SolidColorBrushFrom(*newViewProps.borderColors.all));
+    } else {
+      m_element.ClearValue(winrt::Microsoft::ReactNative::ViewPanel::BorderBrushProperty());
+    }
+  }
+
+  if (oldViewProps.borderStyles != newViewProps.borderStyles) {
+    m_needsBorderUpdate = true;
+  }
+  */
+  m_props = std::static_pointer_cast<facebook::react::ViewProps const>(props);
+}
+
+void ScrollViewComponentView::updateEventEmitter(facebook::react::EventEmitter::Shared const &eventEmitter) noexcept {}
+
+void ScrollViewComponentView::updateState(
+    facebook::react::State::Shared const &state,
+    facebook::react::State::Shared const &oldState) noexcept {
+  const auto &newState = *std::static_pointer_cast<facebook::react::ScrollViewShadowNode::ConcreteState const>(state);
+
+  m_contentSize = newState.getData().getContentSize();
+  updateContentVisualSize();
+}
+
+void ScrollViewComponentView::updateLayoutMetrics(
+    facebook::react::LayoutMetrics const &layoutMetrics,
+    facebook::react::LayoutMetrics const &oldLayoutMetrics) noexcept {
+  // Set Position & Size Properties
+  ensureVisual();
+
+  if ((layoutMetrics.displayType != m_layoutMetrics.displayType)) {
+    m_visual.IsVisible(layoutMetrics.displayType != facebook::react::DisplayType::None);
+  }
+
+  // m_needsBorderUpdate = true;
+  m_layoutMetrics = layoutMetrics;
+
+  UpdateCenterPropertySet();
+  m_visual.Size(
+      {layoutMetrics.frame.size.width * layoutMetrics.pointScaleFactor,
+       layoutMetrics.frame.size.height * layoutMetrics.pointScaleFactor});
+  m_visual.Offset({
+      layoutMetrics.frame.origin.x * layoutMetrics.pointScaleFactor,
+      layoutMetrics.frame.origin.y * layoutMetrics.pointScaleFactor,
+      0.0f,
+  });
+  updateContentVisualSize();
+}
+
+void ScrollViewComponentView::updateContentVisualSize() noexcept {
+  m_visual.ContentSize(
+      {std::max(m_contentSize.width, m_layoutMetrics.frame.size.width) * m_layoutMetrics.pointScaleFactor,
+       std::max(m_contentSize.height, m_layoutMetrics.frame.size.height) * m_layoutMetrics.pointScaleFactor});
+}
+
+void ScrollViewComponentView::finalizeUpdates(RNComponentViewUpdateMask updateMask) noexcept {
+  // m_element.FinalizeProperties();
+}
+void ScrollViewComponentView::prepareForRecycle() noexcept {}
+facebook::react::Props::Shared ScrollViewComponentView::props() noexcept {
+  assert(false);
+  return {};
+}
+
+/*
+ScrollViewComponentView::ScrollInteractionTrackerOwner::ScrollInteractionTrackerOwner(
+    ScrollViewComponentView *outer)
+    : m_outer(outer) {}
+
+void ScrollViewComponentView::ScrollInteractionTrackerOwner::CustomAnimationStateEntered(
+    winrt::Windows::UI::Composition::Interactions::InteractionTracker sender,
+    winrt::Windows::UI::Composition::Interactions::InteractionTrackerCustomAnimationStateEnteredArgs args) noexcept {}
+void ScrollViewComponentView::ScrollInteractionTrackerOwner::IdleStateEntered(
+    winrt::Windows::UI::Composition::Interactions::InteractionTracker sender,
+    winrt::Windows::UI::Composition::Interactions::InteractionTrackerIdleStateEnteredArgs args) noexcept {}
+void ScrollViewComponentView::ScrollInteractionTrackerOwner::InertiaStateEntered(
+    winrt::Windows::UI::Composition::Interactions::InteractionTracker sender,
+    winrt::Windows::UI::Composition::Interactions::InteractionTrackerInertiaStateEnteredArgs args) noexcept {}
+void ScrollViewComponentView::ScrollInteractionTrackerOwner::InteractingStateEntered(
+    winrt::Windows::UI::Composition::Interactions::InteractionTracker sender,
+    winrt::Windows::UI::Composition::Interactions::InteractionTrackerInteractingStateEnteredArgs args) noexcept {}
+void ScrollViewComponentView::ScrollInteractionTrackerOwner::RequestIgnored(
+    winrt::Windows::UI::Composition::Interactions::InteractionTracker sender,
+    winrt::Windows::UI::Composition::Interactions::InteractionTrackerRequestIgnoredArgs args) noexcept {}
+
+void ScrollViewComponentView::ScrollInteractionTrackerOwner::ValuesChanged(
+    winrt::Windows::UI::Composition::Interactions::InteractionTracker sender,
+    winrt::Windows::UI::Composition::Interactions::InteractionTrackerValuesChangedArgs args) noexcept {
+
+  auto eventEmitter = m_outer->GetEventEmitter();
+  if (eventEmitter) {
+    facebook::react::ScrollViewMetrics scrollMetrics;
+    scrollMetrics.containerSize.height = m_outer->Visual().Size().y / m_outer->m_layoutMetrics.pointScaleFactor;
+    scrollMetrics.containerSize.width = m_outer->Visual().Size().x / m_outer->m_layoutMetrics.pointScaleFactor;
+    scrollMetrics.contentOffset.x = args.Position().x / m_outer->m_layoutMetrics.pointScaleFactor;
+    scrollMetrics.contentOffset.y = args.Position().y / m_outer->m_layoutMetrics.pointScaleFactor;
+    scrollMetrics.zoomScale = m_outer->ContentVisual().Scale().x;
+    scrollMetrics.contentSize.height = m_outer->ContentVisual().Size().y / m_outer->m_layoutMetrics.pointScaleFactor;
+    scrollMetrics.contentSize.width = m_outer->ContentVisual().Size().x / m_outer->m_layoutMetrics.pointScaleFactor;
+    std::static_pointer_cast<facebook::react::ScrollViewEventEmitter const>(eventEmitter)->onScroll(scrollMetrics);
+  }
+}
+*/
+/*
+void ScrollViewComponentView::OnPointerDown(const winrt::Windows::UI::Input::PointerPoint &pp) noexcept {
+  m_visualInteractionSource.TryRedirectForManipulation(pp);
+}
+*/
+
+bool ScrollViewComponentView::ScrollWheel(facebook::react::Point pt, int32_t delta) noexcept {
+  facebook::react::Point ptViewport{pt.x - m_layoutMetrics.frame.origin.x, pt.y - m_layoutMetrics.frame.origin.y};
+
+  facebook::react::Point ptContent{
+      ptViewport.x + m_visual.ScrollPosition().x / m_layoutMetrics.pointScaleFactor,
+      ptViewport.y + m_visual.ScrollPosition().y / m_layoutMetrics.pointScaleFactor};
+
+  if (std::any_of(m_children.rbegin(), m_children.rend(), [ptContent, delta](auto child) {
+        return const_cast<CompositionBaseComponentView *>(static_cast<const CompositionBaseComponentView *>(child))
+            ->ScrollWheel(ptContent, delta);
+      }))
+    return true;
+
+  if (ptViewport.x >= 0 && ptViewport.x <= m_layoutMetrics.frame.size.width && ptViewport.y >= 0 &&
+      ptViewport.y <= m_layoutMetrics.frame.size.height) {
+    m_visual.ScrollBy({0, static_cast<float>(-delta), 0});
+    return true;
+  }
+
+  return false;
+}
+
+void ScrollViewComponentView::ensureVisual() noexcept {
+  if (!m_visual) {
+    m_visual = m_compContext.CreateScrollerVisual();
+    m_scrollPositionChangedRevoker = m_visual.ScrollPositionChanged(
+        winrt::auto_revoke,
+        [this](
+            winrt::IInspectable const & /*sender*/,
+            winrt::Microsoft::ReactNative::Composition::ScrollPositionChangedArgs const &args) {
+          auto eventEmitter = GetEventEmitter();
+          if (eventEmitter) {
+            facebook::react::ScrollViewMetrics scrollMetrics;
+            scrollMetrics.containerSize.height = m_layoutMetrics.frame.size.height;
+            scrollMetrics.containerSize.width = m_layoutMetrics.frame.size.width;
+            scrollMetrics.contentOffset.x = args.Position().x / m_layoutMetrics.pointScaleFactor;
+            scrollMetrics.contentOffset.y = args.Position().y / m_layoutMetrics.pointScaleFactor;
+            scrollMetrics.zoomScale = 1.0;
+            scrollMetrics.contentSize.height = std::max(m_contentSize.height, m_layoutMetrics.frame.size.height);
+            scrollMetrics.contentSize.width = std::max(m_contentSize.width, m_layoutMetrics.frame.size.width);
+            std::static_pointer_cast<facebook::react::ScrollViewEventEmitter const>(eventEmitter)
+                ->onScroll(scrollMetrics);
+          }
+        });
+  }
+}
+
+facebook::react::Tag ScrollViewComponentView::hitTest(facebook::react::Point pt, facebook::react::Point &localPt)
+    const noexcept {
+  facebook::react::Point ptViewport{pt.x - m_layoutMetrics.frame.origin.x, pt.y - m_layoutMetrics.frame.origin.y};
+
+  facebook::react::Point ptContent{
+      ptViewport.x + m_visual.ScrollPosition().x / m_layoutMetrics.pointScaleFactor,
+      ptViewport.y + m_visual.ScrollPosition().y / m_layoutMetrics.pointScaleFactor};
+
+  facebook::react::Tag targetTag;
+  if ((m_props->pointerEvents == facebook::react::PointerEventsMode::Auto ||
+       m_props->pointerEvents == facebook::react::PointerEventsMode::BoxNone) &&
+      std::any_of(m_children.rbegin(), m_children.rend(), [&targetTag, &ptContent, &localPt](auto child) {
+        targetTag = static_cast<const CompositionBaseComponentView *>(child)->hitTest(ptContent, localPt);
+        return targetTag != -1;
+      }))
+    return targetTag;
+
+  if ((m_props->pointerEvents == facebook::react::PointerEventsMode::Auto ||
+       m_props->pointerEvents == facebook::react::PointerEventsMode::BoxOnly) &&
+      ptViewport.x >= 0 && ptViewport.x <= m_layoutMetrics.frame.size.width && ptViewport.y >= 0 &&
+      ptViewport.y <= m_layoutMetrics.frame.size.height) {
+    localPt = ptViewport;
+    return this->tag();
+  }
+
+  return -1;
+}
+
+facebook::react::SharedTouchEventEmitter ScrollViewComponentView::touchEventEmitter() noexcept {
+  return m_eventEmitter;
+}
+
+winrt::Microsoft::ReactNative::Composition::IVisual ScrollViewComponentView::Visual() const noexcept {
+  return m_visual;
+}
+
+} // namespace Microsoft::ReactNative

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

@@ -0,0 +1,103 @@
+
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include <Fabric/ComponentView.h>
+
+#include "CompositionViewComponentView.h"
+
+#pragma warning(push)
+#pragma warning(disable : 4305)
+#include <react/renderer/components/scrollview/ScrollViewProps.h>
+#pragma warning(pop)
+#include <winrt/Windows.UI.Composition.interactions.h>
+
+namespace Microsoft::ReactNative {
+
+struct ScrollViewComponentView;
+
+struct ScrollViewComponentView : CompositionBaseComponentView {
+  /*
+struct ScrollInteractionTrackerOwner : public winrt::implements<
+                                           ScrollInteractionTrackerOwner,
+                                           winrt::Windows::UI::Composition::Interactions::IInteractionTrackerOwner> {
+  ScrollInteractionTrackerOwner(ScrollViewComponentView *outer);
+
+  void CustomAnimationStateEntered(
+      winrt::Windows::UI::Composition::Interactions::InteractionTracker sender,
+      winrt::Windows::UI::Composition::Interactions::InteractionTrackerCustomAnimationStateEnteredArgs args) noexcept;
+  void IdleStateEntered(
+      winrt::Windows::UI::Composition::Interactions::InteractionTracker sender,
+      winrt::Windows::UI::Composition::Interactions::InteractionTrackerIdleStateEnteredArgs args) noexcept;
+  void InertiaStateEntered(
+      winrt::Windows::UI::Composition::Interactions::InteractionTracker sender,
+      winrt::Windows::UI::Composition::Interactions::InteractionTrackerInertiaStateEnteredArgs args) noexcept;
+  void InteractingStateEntered(
+      winrt::Windows::UI::Composition::Interactions::InteractionTracker sender,
+      winrt::Windows::UI::Composition::Interactions::InteractionTrackerInteractingStateEnteredArgs args) noexcept;
+  void RequestIgnored(
+      winrt::Windows::UI::Composition::Interactions::InteractionTracker sender,
+      winrt::Windows::UI::Composition::Interactions::InteractionTrackerRequestIgnoredArgs args) noexcept;
+  void ValuesChanged(
+      winrt::Windows::UI::Composition::Interactions::InteractionTracker sender,
+      winrt::Windows::UI::Composition::Interactions::InteractionTrackerValuesChangedArgs args) noexcept;
+
+ private:
+  ScrollViewComponentView *m_outer;
+};
+
+*/
+
+  using Super = CompositionBaseComponentView;
+  ScrollViewComponentView(
+      const winrt::Microsoft::ReactNative::Composition::ICompositionContext &compContext,
+      facebook::react::Tag tag);
+
+  std::vector<facebook::react::ComponentDescriptorProvider> supplementalComponentDescriptorProviders() noexcept
+      override;
+  void mountChildComponentView(const IComponentView &childComponentView, uint32_t index) noexcept override;
+  void unmountChildComponentView(const IComponentView &childComponentView, uint32_t index) noexcept override;
+  void updateProps(facebook::react::Props::Shared const &props, facebook::react::Props::Shared const &oldProps) noexcept
+      override;
+  void updateEventEmitter(facebook::react::EventEmitter::Shared const &eventEmitter) noexcept override;
+  void updateState(facebook::react::State::Shared const &state, facebook::react::State::Shared const &oldState) noexcept
+      override;
+  void updateLayoutMetrics(
+      facebook::react::LayoutMetrics const &layoutMetrics,
+      facebook::react::LayoutMetrics const &oldLayoutMetrics) noexcept override;
+  void finalizeUpdates(RNComponentViewUpdateMask updateMask) noexcept override;
+  void prepareForRecycle() noexcept override;
+  facebook::react::Props::Shared props() noexcept override;
+  facebook::react::SharedTouchEventEmitter touchEventEmitter() noexcept override;
+
+  facebook::react::Tag hitTest(facebook::react::Point pt, facebook::react::Point &localPt) const noexcept override;
+  winrt::Microsoft::ReactNative::Composition::IVisual Visual() const noexcept override;
+
+  // void OnPointerDown(const winrt::Windows::UI::Input::PointerPoint &pp) noexcept override;
+  bool ScrollWheel(facebook::react::Point pt, int32_t delta) noexcept override;
+
+ private:
+  void ensureVisual() noexcept;
+  void updateContentVisualSize() noexcept;
+
+  facebook::react::Size m_contentSize;
+  winrt::Microsoft::ReactNative::Composition::ScrollVisual m_visual{nullptr};
+  winrt::Microsoft::ReactNative::Composition::ScrollVisual::ScrollPositionChanged_revoker
+      m_scrollPositionChangedRevoker{};
+
+  facebook::react::SharedViewProps m_props;
+  float m_zoomFactor{1.0f};
+  bool m_isScrollingFromInertia = false;
+  bool m_isScrolling = false;
+  bool m_isHorizontal = false;
+  bool m_isScrollingEnabled = true;
+  bool m_changeViewAfterLoaded = false;
+  bool m_dismissKeyboardOnDrag = false;
+
+ private:
+  bool shouldBeControl() const noexcept;
+};
+
+} // namespace Microsoft::ReactNative

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

@@ -0,0 +1,177 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "WindowsTextInputShadowNode.h"
+
+#include <yoga/CompactValue.h>
+#include <yoga/YGEnums.h>
+#include <yoga/YGValue.h>
+
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+
+namespace facebook {
+namespace react {
+
+/*
+ * Descriptor for <WindowsTextInput> component.
+ */
+class WindowsTextInputComponentDescriptor final : public ConcreteComponentDescriptor<WindowsTextInputShadowNode> {
+ public:
+  WindowsTextInputComponentDescriptor(ComponentDescriptorParameters const &parameters)
+      : ConcreteComponentDescriptor<WindowsTextInputShadowNode>(parameters) {
+    // Every single `WindowsTextInputShadowNode` will have a reference to
+    // a shared `TextLayoutManager`.
+    m_textLayoutManager = std::make_shared<TextLayoutManager>(contextContainer_);
+  }
+
+  /*
+    virtual State::Shared createInitialState(
+        ShadowNodeFragment const &fragment,
+        ShadowNodeFamily::Shared const &family) const override {
+      int surfaceId = family->getSurfaceId();
+
+      YGStyle::Edges theme;
+      // TODO: figure out RTL/start/end/left/right stuff here
+      if (surfaceIdToThemePaddingMap_.find(surfaceId) !=
+          surfaceIdToThemePaddingMap_.end()) {
+        theme = surfaceIdToThemePaddingMap_[surfaceId];
+      } else {
+        const jni::global_ref<jobject> &fabricUIManager =
+            contextContainer_->at<jni::global_ref<jobject>>("FabricUIManager");
+
+        auto env = jni::Environment::current();
+        auto defaultTextInputPaddingArray = env->NewFloatArray(4);
+        static auto getThemeData =
+            jni::findClassStatic(UIManagerJavaDescriptor)
+                ->getMethod<jboolean(jint, jfloatArray)>("getThemeData");
+
+        if (getThemeData(
+                fabricUIManager, surfaceId, defaultTextInputPaddingArray)) {
+          jfloat *defaultTextInputPadding =
+              env->GetFloatArrayElements(defaultTextInputPaddingArray, 0);
+          theme[YGEdgeStart] = (YGValue){defaultTextInputPadding[0], YGUnitPoint};
+          theme[YGEdgeEnd] = (YGValue){defaultTextInputPadding[1], YGUnitPoint};
+          theme[YGEdgeTop] = (YGValue){defaultTextInputPadding[2], YGUnitPoint};
+          theme[YGEdgeBottom] =
+              (YGValue){defaultTextInputPadding[3], YGUnitPoint};
+          surfaceIdToThemePaddingMap_.emplace(std::make_pair(surfaceId, theme));
+          env->ReleaseFloatArrayElements(
+              defaultTextInputPaddingArray, defaultTextInputPadding, JNI_ABORT);
+        }
+        env->DeleteLocalRef(defaultTextInputPaddingArray);
+      }
+
+      return std::make_shared<AndroidTextInputShadowNode::ConcreteState>(
+          std::make_shared<AndroidTextInputState const>(AndroidTextInputState(
+              0,
+              {},
+              {},
+              {},
+              {},
+              {},
+              ((YGValue)theme[YGEdgeStart]).value,
+              ((YGValue)theme[YGEdgeEnd]).value,
+              ((YGValue)theme[YGEdgeTop]).value,
+              ((YGValue)theme[YGEdgeBottom]).value)),
+          family);
+    }
+  */
+
+ protected:
+  void adopt(ShadowNode::Unshared const &shadowNode) const override {
+    auto textInputShadowNode = std::static_pointer_cast<WindowsTextInputShadowNode>(shadowNode);
+
+    // `ParagraphShadowNode` uses `TextLayoutManager` to measure text content
+    // and communicate text rendering metrics to mounting layer.
+    textInputShadowNode->setTextLayoutManager(m_textLayoutManager);
+
+    textInputShadowNode->setContextContainer(const_cast<ContextContainer *>(getContextContainer().get()));
+
+    /*
+        int surfaceId = textInputShadowNode->getSurfaceId();
+        if (surfaceIdToThemePaddingMap_.find(surfaceId) !=
+            surfaceIdToThemePaddingMap_.end()) {
+          YGStyle::Edges theme = surfaceIdToThemePaddingMap_[surfaceId];
+
+          // Override padding
+          // Node is still unsealed during adoption, before layout is complete
+          // TODO: T62959168 account for RTL and paddingLeft when setting default
+          // paddingStart, and vice-versa with paddingRight/paddingEnd.
+          // For now this assumes no RTL.
+          YGStyle::Edges result =
+              textInputShadowNode->getConcreteProps().yogaStyle.padding();
+          bool changedPadding = false;
+          if (!textInputShadowNode->getConcreteProps().hasPadding &&
+              !textInputShadowNode->getConcreteProps().hasPaddingStart &&
+              !textInputShadowNode->getConcreteProps().hasPaddingLeft &&
+              !textInputShadowNode->getConcreteProps().hasPaddingHorizontal) {
+            changedPadding = true;
+            result[YGEdgeStart] = theme[YGEdgeStart];
+          }
+          if (!textInputShadowNode->getConcreteProps().hasPadding &&
+              !textInputShadowNode->getConcreteProps().hasPaddingEnd &&
+              !textInputShadowNode->getConcreteProps().hasPaddingRight &&
+              !textInputShadowNode->getConcreteProps().hasPaddingHorizontal) {
+            changedPadding = true;
+            result[YGEdgeEnd] = theme[YGEdgeEnd];
+          }
+          if (!textInputShadowNode->getConcreteProps().hasPadding &&
+              !textInputShadowNode->getConcreteProps().hasPaddingTop &&
+              !textInputShadowNode->getConcreteProps().hasPaddingVertical) {
+            changedPadding = true;
+            result[YGEdgeTop] = theme[YGEdgeTop];
+          }
+          if (!textInputShadowNode->getConcreteProps().hasPadding &&
+              !textInputShadowNode->getConcreteProps().hasPaddingBottom &&
+              !textInputShadowNode->getConcreteProps().hasPaddingVertical) {
+            changedPadding = true;
+            result[YGEdgeBottom] = theme[YGEdgeBottom];
+          }
+
+          // If the TextInput initially does not have paddingLeft or paddingStart, a
+          // paddingStart may be set from the theme. If that happens, when there's a
+          // paddingLeft update, we must explicitly unset paddingStart... (same with
+          // paddingEnd)
+          // TODO: support RTL
+          if ((textInputShadowNode->getConcreteProps().hasPadding ||
+               textInputShadowNode->getConcreteProps().hasPaddingLeft ||
+               textInputShadowNode->getConcreteProps().hasPaddingHorizontal) &&
+              !textInputShadowNode->getConcreteProps().hasPaddingStart) {
+            result[YGEdgeStart] = YGValueUndefined;
+          }
+          if ((textInputShadowNode->getConcreteProps().hasPadding ||
+               textInputShadowNode->getConcreteProps().hasPaddingRight ||
+               textInputShadowNode->getConcreteProps().hasPaddingHorizontal) &&
+              !textInputShadowNode->getConcreteProps().hasPaddingEnd) {
+            result[YGEdgeEnd] = YGValueUndefined;
+          }
+
+          // Note that this is expensive: on every adopt, we need to set the Yoga
+          // props again, which normally only happens during prop parsing. Every
+          // commit, state update, etc, will incur this cost.
+          if (changedPadding) {
+            // Set new props on node
+            const_cast<AndroidTextInputProps &>(
+                textInputShadowNode->getConcreteProps())
+                .yogaStyle.padding() = result;
+            // Communicate new props to Yoga part of the node
+            textInputShadowNode->updateYogaProps();
+          }
+        }
+
+        textInputShadowNode->dirtyLayout();
+
+        */
+    textInputShadowNode->enableMeasurement();
+
+    ConcreteComponentDescriptor::adopt(shadowNode);
+  }
+
+ private:
+  SharedTextLayoutManager m_textLayoutManager;
+};
+
+} // namespace react
+} // namespace facebook