react-native-windows 0.73.10 → 0.74.0-preview.1

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

@@ -5,27 +5,30 @@
 #pragma once
 
 #include <Fabric/ComponentView.h>
-#include <Microsoft.ReactNative.Cxx/ReactContext.h>
 
+#include "Composition.SwitchComponentView.g.h"
 #include "CompositionViewComponentView.h"
 
 #include <react/components/rnwcore/ShadowNodes.h>
 
-namespace Microsoft::ReactNative {
+namespace winrt::Microsoft::ReactNative::Composition::implementation {
 
-struct SwitchComponentView;
+struct SwitchComponentView : SwitchComponentViewT<SwitchComponentView, ComponentView> {
+  using Super = SwitchComponentViewT<SwitchComponentView, ComponentView>;
 
-struct SwitchComponentView : CompositionBaseComponentView {
-  using Super = CompositionBaseComponentView;
-
-  [[nodiscard]] static std::shared_ptr<SwitchComponentView> Create(
+  [[nodiscard]] static winrt::Microsoft::ReactNative::ComponentView Create(
       const winrt::Microsoft::ReactNative::Composition::ICompositionContext &compContext,
       facebook::react::Tag tag,
       winrt::Microsoft::ReactNative::ReactContext const &reactContext) noexcept;
 
-  void mountChildComponentView(IComponentView &childComponentView, uint32_t index) noexcept override;
-  void unmountChildComponentView(IComponentView &childComponentView, uint32_t index) noexcept override;
-  void handleCommand(std::string const &commandName, folly::dynamic const &arg) noexcept override;
+  void MountChildComponentView(
+      const winrt::Microsoft::ReactNative::ComponentView &childComponentView,
+      uint32_t index) noexcept override;
+  void UnmountChildComponentView(
+      const winrt::Microsoft::ReactNative::ComponentView &childComponentView,
+      uint32_t index) noexcept override;
+  void HandleCommand(winrt::hstring commandName, const winrt::Microsoft::ReactNative::IJSValueReader &args) noexcept
+      override;
   void updateProps(facebook::react::Props::Shared const &props, facebook::react::Props::Shared const &oldProps) noexcept
       override;
   void updateState(facebook::react::State::Shared const &state, facebook::react::State::Shared const &oldState) noexcept
@@ -33,14 +36,21 @@ struct SwitchComponentView : CompositionBaseComponentView {
   void updateLayoutMetrics(
       facebook::react::LayoutMetrics const &layoutMetrics,
       facebook::react::LayoutMetrics const &oldLayoutMetrics) noexcept override;
-  void finalizeUpdates(RNComponentViewUpdateMask updateMask) noexcept override;
+  void FinalizeUpdates(winrt::Microsoft::ReactNative::ComponentViewUpdateMask updateMask) noexcept override;
   void prepareForRecycle() noexcept override;
-  facebook::react::Props::Shared props() noexcept override;
+  facebook::react::SharedViewProps viewProps() noexcept override;
   bool focusable() const noexcept override;
-  void onKeyUp(
+  void onThemeChanged() noexcept override;
+  void OnKeyUp(
       const winrt::Microsoft::ReactNative::Composition::Input::KeyboardSource &source,
       const winrt::Microsoft::ReactNative::Composition::Input::KeyRoutedEventArgs &args) noexcept override;
-  void onPointerPressed(
+  void OnPointerPressed(
+      const winrt::Microsoft::ReactNative::Composition::Input::PointerRoutedEventArgs &args) noexcept override;
+  void OnPointerReleased(
+      const winrt::Microsoft::ReactNative::Composition::Input::PointerRoutedEventArgs &args) noexcept override;
+  void OnPointerEntered(
+      const winrt::Microsoft::ReactNative::Composition::Input::PointerRoutedEventArgs &args) noexcept override;
+  void OnPointerExited(
       const winrt::Microsoft::ReactNative::Composition::Input::PointerRoutedEventArgs &args) noexcept override;
 
   facebook::react::Tag hitTest(facebook::react::Point pt, facebook::react::Point &localPt, bool ignorePointerEvents)
@@ -48,23 +58,26 @@ struct SwitchComponentView : CompositionBaseComponentView {
   winrt::Microsoft::ReactNative::Composition::IVisual Visual() const noexcept override;
   std::string DefaultControlType() const noexcept override;
 
- private:
   SwitchComponentView(
       const winrt::Microsoft::ReactNative::Composition::ICompositionContext &compContext,
       facebook::react::Tag tag,
       winrt::Microsoft::ReactNative::ReactContext const &reactContext);
 
+ private:
   void ensureVisual() noexcept;
-  void Draw() noexcept;
-  void ensureDrawingSurface() noexcept;
   bool toggle() noexcept;
+  void handleScaleChange() noexcept;
+  void updateVisuals() noexcept;
 
+  bool m_hovered{false};
+  bool m_pressed{false};
+  bool m_supressAnimationForNextFrame{false};
+  bool m_visualUpdateRequired{true};
   facebook::react::Size m_contentSize;
   winrt::Microsoft::ReactNative::Composition::ISpriteVisual m_visual{nullptr};
-  winrt::Microsoft::ReactNative::ReactContext m_context;
+  winrt::Microsoft::ReactNative::Composition::IRoundedRectangleVisual m_trackVisual{nullptr};
+  winrt::Microsoft::ReactNative::Composition::IRoundedRectangleVisual m_thumbVisual{nullptr};
   facebook::react::SharedViewProps m_props;
-  winrt::Microsoft::ReactNative::Composition::IDrawingSurfaceBrush m_drawingSurface;
-  winrt::Microsoft::ReactNative::Composition::ISwitchThumbVisual m_thumbVisual;
 };
 
-} // namespace Microsoft::ReactNative
+} // namespace winrt::Microsoft::ReactNative::Composition::implementation

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

@@ -0,0 +1,179 @@
+
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "TextDrawing.h"
+
+#include <AutoDraw.h>
+#include <Utils/ValueUtils.h>
+#include <unicode.h>
+#include <windows.ui.composition.interop.h>
+#include <winrt/Microsoft.ReactNative.Composition.h>
+#include "CompositionHelpers.h"
+
+namespace winrt::Microsoft::ReactNative::Composition {
+
+void RenderText(
+    ID2D1DeviceContext &deviceContext,
+    ::IDWriteTextLayout &textLayout,
+    const facebook::react::AttributedString &attributedString,
+    const facebook::react::TextAttributes &textAttributes,
+    facebook::react::Point offset,
+    float pointScaleFactor,
+    winrt::Microsoft::ReactNative::Composition::implementation::Theme &theme) noexcept {
+  float offsetX = offset.x / pointScaleFactor;
+  float offsetY = offset.y / pointScaleFactor;
+
+  assert(deviceContext.GetUnitMode() == D2D1_UNIT_MODE_DIPS);
+  const auto dpi = pointScaleFactor * 96.0f;
+  float oldDpiX, oldDpiY;
+  deviceContext.GetDpi(&oldDpiX, &oldDpiY);
+  deviceContext.SetDpi(dpi, dpi);
+
+  // Create a solid color brush for the text. A more sophisticated application might want
+  // to cache and reuse a brush across all text elements instead, taking care to recreate
+  // it in the event of device removed.
+  winrt::com_ptr<ID2D1SolidColorBrush> brush;
+  if (textAttributes.foregroundColor) {
+    auto color = theme.D2DColor(*textAttributes.foregroundColor);
+    winrt::check_hresult(deviceContext.CreateSolidColorBrush(color, brush.put()));
+  } else {
+    winrt::check_hresult(deviceContext.CreateSolidColorBrush(D2D1::ColorF(D2D1::ColorF::Black, 1.0f), brush.put()));
+  }
+
+  if (textAttributes.textDecorationLineType) {
+    DWRITE_TEXT_RANGE range = {0, std::numeric_limits<uint32_t>::max()};
+    if (*(textAttributes.textDecorationLineType) == facebook::react::TextDecorationLineType::Underline ||
+        *(textAttributes.textDecorationLineType) == facebook::react::TextDecorationLineType::UnderlineStrikethrough) {
+      textLayout.SetUnderline(true, range);
+    } else {
+      textLayout.SetUnderline(false, range);
+    }
+  }
+
+  if (textAttributes.textDecorationLineType) {
+    DWRITE_TEXT_RANGE range = {0, std::numeric_limits<uint32_t>::max()};
+    if (*(textAttributes.textDecorationLineType) == facebook::react::TextDecorationLineType::Strikethrough ||
+        *(textAttributes.textDecorationLineType) == facebook::react::TextDecorationLineType::UnderlineStrikethrough) {
+      textLayout.SetStrikethrough(true, range);
+    } else {
+      textLayout.SetStrikethrough(false, range);
+    }
+  }
+
+  // Create color effects for individual text fragments.
+  unsigned int position = 0;
+  unsigned int length = 0;
+  for (auto fragment : attributedString.getFragments()) {
+    length = static_cast<UINT32>(fragment.string.length());
+    DWRITE_TEXT_RANGE range = {position, length};
+    if (fragment.textAttributes.foregroundColor &&
+            (fragment.textAttributes.foregroundColor != textAttributes.foregroundColor) ||
+        !isnan(fragment.textAttributes.opacity)) {
+      winrt::com_ptr<ID2D1SolidColorBrush> fragmentBrush;
+      if (fragment.textAttributes.foregroundColor) {
+        auto color = theme.D2DColor(*fragment.textAttributes.foregroundColor);
+        winrt::check_hresult(deviceContext.CreateSolidColorBrush(color, fragmentBrush.put()));
+      } else {
+        winrt::check_hresult(
+            deviceContext.CreateSolidColorBrush(D2D1::ColorF(D2D1::ColorF::Black, 1.0f), fragmentBrush.put()));
+      }
+
+      if (fragment.textAttributes.textDecorationLineType) {
+        if (*(fragment.textAttributes.textDecorationLineType) == facebook::react::TextDecorationLineType::Underline ||
+            *(fragment.textAttributes.textDecorationLineType) ==
+                facebook::react::TextDecorationLineType::UnderlineStrikethrough) {
+          textLayout.SetUnderline(true, range);
+        } else {
+          textLayout.SetUnderline(false, range);
+        }
+      }
+
+      if (fragment.textAttributes.textDecorationLineType) {
+        if (*(fragment.textAttributes.textDecorationLineType) ==
+                facebook::react::TextDecorationLineType::Strikethrough ||
+            *(fragment.textAttributes.textDecorationLineType) ==
+                facebook::react::TextDecorationLineType::UnderlineStrikethrough) {
+          textLayout.SetStrikethrough(true, range);
+        } else {
+          textLayout.SetStrikethrough(false, range);
+        }
+      }
+
+      if (!isnan(fragment.textAttributes.opacity)) {
+        fragmentBrush->SetOpacity(fragment.textAttributes.opacity);
+      }
+      textLayout.SetDrawingEffect(fragmentBrush.get(), range);
+
+      // DWrite doesn't handle background highlight colors, so we manually draw the background color for ranges
+      if (facebook::react::isColorMeaningful(fragment.textAttributes.backgroundColor)) {
+        UINT32 actualHitTestCount = 0;
+        if (range.length > 0) {
+          textLayout.HitTestTextRange(
+              range.startPosition,
+              range.length,
+              0, // x
+              0, // y
+              NULL,
+              0, // metrics count
+              &actualHitTestCount);
+        }
+
+        // Allocate enough room to return all hit-test metrics.
+        std::vector<DWRITE_HIT_TEST_METRICS> hitTestMetrics(actualHitTestCount);
+        if (range.length > 0) {
+          textLayout.HitTestTextRange(
+              range.startPosition,
+              range.length,
+              0, // x
+              0, // y
+              &hitTestMetrics[0],
+              static_cast<UINT32>(hitTestMetrics.size()),
+              &actualHitTestCount);
+        }
+
+        // Draw the selection ranges behind the text.
+        if (actualHitTestCount > 0) {
+          // Note that an ideal layout will return fractional values,
+          // so you may see slivers between the selection ranges due
+          // to the per-primitive anti-aliasing of the edges unless
+          // it is disabled (better for performance anyway).
+          auto oldAliasMode = deviceContext.GetAntialiasMode();
+          deviceContext.SetAntialiasMode(D2D1_ANTIALIAS_MODE_ALIASED);
+
+          winrt::com_ptr<ID2D1SolidColorBrush> textHighlightBrush;
+          winrt::check_hresult(deviceContext.CreateSolidColorBrush(
+              theme.D2DColor(*fragment.textAttributes.backgroundColor), textHighlightBrush.put()));
+
+          for (size_t i = 0; i < actualHitTestCount; ++i) {
+            const DWRITE_HIT_TEST_METRICS &htm = hitTestMetrics[i];
+
+            const D2D1_RECT_F rect = {
+                std::round(htm.left + offsetX),
+                std::round(htm.top + offsetY),
+                std::round(htm.left + htm.width + offsetX),
+                std::round(htm.top + htm.height + offsetY)};
+
+            deviceContext.FillRectangle(rect, textHighlightBrush.get());
+          }
+          deviceContext.SetAntialiasMode(oldAliasMode);
+        }
+      }
+    }
+
+    position += length;
+  }
+
+  // Draw the line of text at the specified offset, which corresponds to the top-left
+  // corner of our drawing surface. Notice we don't call BeginDraw on the D2D device
+  // context; this has already been done for us by the composition API.
+  deviceContext.DrawTextLayout(
+      D2D1::Point2F(offsetX, offsetY), &textLayout, brush.get(), D2D1_DRAW_TEXT_OPTIONS_ENABLE_COLOR_FONT);
+
+  // restore dpi to old state
+  deviceContext.SetDpi(oldDpiX, oldDpiY);
+}
+
+} // namespace winrt::Microsoft::ReactNative::Composition

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

@@ -0,0 +1,25 @@
+
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include <Fabric/Composition/Theme.h>
+#include <d2d1_1.h>
+#include <dwrite.h>
+#include <react/renderer/attributedstring/AttributedString.h>
+#include <winrt/Windows.UI.Composition.h>
+#include "CompositionHelpers.h"
+
+namespace winrt::Microsoft::ReactNative::Composition {
+
+void RenderText(
+    ID2D1DeviceContext &deviceContext,
+    ::IDWriteTextLayout &textLayout,
+    const facebook::react::AttributedString &attributedString,
+    const facebook::react::TextAttributes &textAttributes,
+    facebook::react::Point offset,
+    float pointScaleFactor,
+    winrt::Microsoft::ReactNative::Composition::implementation::Theme &theme) noexcept;
+
+} // namespace winrt::Microsoft::ReactNative::Composition

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

@@ -7,7 +7,6 @@
 
 #include <yoga/YGEnums.h>
 #include <yoga/YGValue.h>
-#include <yoga/style/CompactValue.h>
 
 #include <unordered_map>
 
@@ -28,52 +27,42 @@ class WindowsTextInputComponentDescriptor final : public ConcreteComponentDescri
   }
 
   /*
-    virtual State::Shared createInitialState(
-        facebook::react::Props::Shared const &props,
-        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);
+virtual State::Shared createInitialState(
+      const Props::Shared& props,
+      const ShadowNodeFamily::Shared& family) const override {
+    int surfaceId = family->getSurfaceId();
+
+    ThemePadding 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.start = defaultTextInputPadding[0];
+        theme.end = defaultTextInputPadding[1];
+        theme.top = defaultTextInputPadding[2];
+        theme.bottom = defaultTextInputPadding[3];
+        surfaceIdToThemePaddingMap_.emplace(std::make_pair(surfaceId, theme));
+        env->ReleaseFloatArrayElements(
+            defaultTextInputPaddingArray, defaultTextInputPadding, JNI_ABORT);
       }
 
     return std::make_shared<AndroidTextInputShadowNode::ConcreteState>(
         std::make_shared<const AndroidTextInputState>(AndroidTextInputState(
-            0,
-            {},
-            {},
-            {},
-            ((YGValue)theme[YGEdgeStart]).value,
-            ((YGValue)theme[YGEdgeEnd]).value,
-            ((YGValue)theme[YGEdgeTop]).value,
-            ((YGValue)theme[YGEdgeBottom]).value)),
+            0, {}, {}, {}, theme.start, theme.end, theme.top, theme.bottom)),
         family);
   }
   */
@@ -89,78 +78,73 @@ class WindowsTextInputComponentDescriptor final : public ConcreteComponentDescri
     textInputShadowNode.setContextContainer(const_cast<ContextContainer *>(getContextContainer().get()));
 
     /*
-        int surfaceId = textInputShadowNode->getSurfaceId();
-        if (surfaceIdToThemePaddingMap_.find(surfaceId) !=
-            surfaceIdToThemePaddingMap_.end()) {
-          yoga::Style::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.
-          yoga::Style::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();
+            int surfaceId = textInputShadowNode.getSurfaceId();
+    if (surfaceIdToThemePaddingMap_.find(surfaceId) !=
+        surfaceIdToThemePaddingMap_.end()) {
+      const auto& theme = surfaceIdToThemePaddingMap_[surfaceId];
+
+      auto& textInputProps = textInputShadowNode.getConcreteProps();
+
+      // 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.
+      auto& style = const_cast<yoga::Style&>(textInputProps.yogaStyle);
+      bool changedPadding = false;
+      if (!textInputProps.hasPadding && !textInputProps.hasPaddingStart &&
+          !textInputProps.hasPaddingLeft &&
+          !textInputProps.hasPaddingHorizontal) {
+        changedPadding = true;
+        style.setPadding(
+            YGEdgeStart, yoga::CompactValue::of<YGUnitPoint>(theme.start));
+      }
+      if (!textInputProps.hasPadding && !textInputProps.hasPaddingEnd &&
+          !textInputProps.hasPaddingRight &&
+          !textInputProps.hasPaddingHorizontal) {
+        changedPadding = true;
+        style.setPadding(
+            YGEdgeEnd, yoga::CompactValue::of<YGUnitPoint>(theme.end));
+      }
+      if (!textInputProps.hasPadding && !textInputProps.hasPaddingTop &&
+          !textInputProps.hasPaddingVertical) {
+        changedPadding = true;
+        style.setPadding(
+            YGEdgeTop, yoga::CompactValue::of<YGUnitPoint>(theme.top));
+      }
+      if (!textInputProps.hasPadding && !textInputProps.hasPaddingBottom &&
+          !textInputProps.hasPaddingVertical) {
+        changedPadding = true;
+        style.setPadding(
+            YGEdgeBottom, yoga::CompactValue::of<YGUnitPoint>(theme.bottom));
+      }
+
+      // 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 ((textInputProps.hasPadding || textInputProps.hasPaddingLeft ||
+           textInputProps.hasPaddingHorizontal) &&
+          !textInputProps.hasPaddingStart) {
+        style.setPadding(YGEdgeStart, yoga::CompactValue::ofUndefined());
+      }
+      if ((textInputProps.hasPadding || textInputProps.hasPaddingRight ||
+           textInputProps.hasPaddingHorizontal) &&
+          !textInputProps.hasPaddingEnd) {
+        style.setPadding(YGEdgeEnd, yoga::CompactValue::ofUndefined());
+      }
+
+      // 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) {
+        // Communicate new props to Yoga part of the node
+        textInputShadowNode.updateYogaProps();
+      }
+    }
+
+    textInputShadowNode.dirtyLayout();
 
         */
     textInputShadowNode.enableMeasurement();
@@ -169,7 +153,18 @@ class WindowsTextInputComponentDescriptor final : public ConcreteComponentDescri
   }
 
  private:
+  struct ThemePadding {
+    float start{};
+    float end{};
+    float top{};
+    float bottom{};
+  };
+
+  // TODO T68526882: Unify with Binding::UIManagerJavaDescriptor
+  constexpr static auto UIManagerJavaDescriptor = "com/facebook/react/fabric/FabricUIManager";
+
   SharedTextLayoutManager m_textLayoutManager;
+  mutable std::unordered_map<int, ThemePadding> surfaceIdToThemePaddingMap_;
 };
 
 } // namespace facebook::react