react-native-tvos 0.77.0-0rc5 → 0.78.0-0rc4

package/ReactCommon/react/renderer/components/image/ImageState.h

@@ -8,6 +8,7 @@
 #pragma once
 
 #include <react/renderer/imagemanager/ImageRequest.h>
+#include <react/renderer/imagemanager/ImageRequestParams.h>
 #include <react/renderer/imagemanager/primitives.h>
 
 #ifdef ANDROID
@@ -26,10 +27,10 @@ class ImageState final {
   ImageState(
       const ImageSource& imageSource,
       ImageRequest imageRequest,
-      const Float blurRadius)
+      const ImageRequestParams& imageRequestParams)
       : imageSource_(imageSource),
         imageRequest_(std::make_shared<ImageRequest>(std::move(imageRequest))),
-        blurRadius_(blurRadius){};
+        imageRequestParams_(imageRequestParams) {}
 
   /*
    * Returns stored ImageSource object.
@@ -42,11 +43,13 @@ class ImageState final {
    */
   const ImageRequest& getImageRequest() const;
 
-  Float getBlurRadius() const;
-
+  /*
+   * Returns stored ImageRequestParams object.
+   */
+  const ImageRequestParams& getImageRequestParams() const;
 #ifdef ANDROID
   ImageState(const ImageState& previousState, folly::dynamic data)
-      : blurRadius_{0} {};
+      : imageRequestParams_{} {};
 
   /*
    * Empty implementation for Android because it doesn't use this class.
@@ -59,7 +62,7 @@ class ImageState final {
  private:
   ImageSource imageSource_;
   std::shared_ptr<ImageRequest> imageRequest_;
-  const Float blurRadius_;
+  ImageRequestParams imageRequestParams_;
 };
 
 } // namespace facebook::react

package/ReactCommon/react/renderer/components/progressbar/android/react/renderer/components/progressbar/AndroidProgressBarComponentDescriptor.h

@@ -36,10 +36,6 @@ class AndroidProgressBarComponentDescriptor final
     // `AndroidProgressBarMeasurementsManager` to provide measurements to Yoga.
     androidProgressBarShadowNode.setAndroidProgressBarMeasurementsManager(
         measurementsManager_);
-
-    // All `AndroidProgressBarShadowNode`s must have leaf Yoga nodes with
-    // properly setup measure function.
-    androidProgressBarShadowNode.enableMeasurement();
   }
 
  private:

package/ReactCommon/react/renderer/components/progressbar/android/react/renderer/components/progressbar/AndroidProgressBarShadowNode.h

@@ -26,6 +26,13 @@ class AndroidProgressBarShadowNode final : public ConcreteViewShadowNode<
  public:
   using ConcreteViewShadowNode::ConcreteViewShadowNode;
 
+  static ShadowNodeTraits BaseTraits() {
+    auto traits = ConcreteViewShadowNode::BaseTraits();
+    traits.set(ShadowNodeTraits::Trait::LeafYogaNode);
+    traits.set(ShadowNodeTraits::Trait::MeasurableYogaNode);
+    return traits;
+  }
+
   // Associates a shared `AndroidProgressBarMeasurementsManager` with the node.
   void setAndroidProgressBarMeasurementsManager(
       const std::shared_ptr<AndroidProgressBarMeasurementsManager>&

package/ReactCommon/react/renderer/components/root/RootShadowNode.cpp

@@ -7,7 +7,7 @@
 
 #include "RootShadowNode.h"
 
-#include <cxxreact/SystraceSection.h>
+#include <cxxreact/TraceSection.h>
 #include <react/renderer/components/view/conversions.h>
 
 namespace facebook::react {
@@ -16,7 +16,7 @@ const char RootComponentName[] = "RootView";
 
 bool RootShadowNode::layoutIfNeeded(
     std::vector<const LayoutableShadowNode*>* affectedNodes) {
-  SystraceSection s("RootShadowNode::layout");
+  TraceSection s("RootShadowNode::layout");
 
   if (getIsLayoutClean()) {
     return false;

package/ReactCommon/react/renderer/components/scrollview/CMakeLists.txt

@@ -14,10 +14,10 @@ add_compile_options(
         -Wpedantic
         -DLOG_TAG=\"Fabric\")
 
-file(GLOB rrc_scrollview_SRC CONFIGURE_DEPENDS *.cpp)
+file(GLOB rrc_scrollview_SRC CONFIGURE_DEPENDS *.cpp platform/android/react/renderer/components/scrollview/*.cpp)
 add_library(rrc_scrollview STATIC ${rrc_scrollview_SRC})
 
-target_include_directories(rrc_scrollview PUBLIC ${REACT_COMMON_DIR})
+target_include_directories(rrc_scrollview PUBLIC ${REACT_COMMON_DIR} . ${CMAKE_CURRENT_SOURCE_DIR}/platform/android/)
 
 target_link_libraries(rrc_scrollview
         glog

package/ReactCommon/react/renderer/components/scrollview/ScrollEvent.cpp

@@ -76,6 +76,39 @@ EventPayloadType ScrollEvent::getType() const {
   return EventPayloadType::ScrollEvent;
 }
 
+jsi::Value ScrollEndDragEvent::asJSIValue(jsi::Runtime& runtime) const {
+  auto payload = ScrollEvent::asJSIValue(runtime).asObject(runtime);
+
+  {
+    auto targetContentOffsetObj = jsi::Object(runtime);
+    targetContentOffsetObj.setProperty(runtime, "x", targetContentOffset.x);
+    targetContentOffsetObj.setProperty(runtime, "y", targetContentOffset.y);
+    payload.setProperty(runtime, "targetContentOffset", targetContentOffsetObj);
+  }
+
+  {
+    auto velocityObj = jsi::Object(runtime);
+    velocityObj.setProperty(runtime, "x", velocity.x);
+    velocityObj.setProperty(runtime, "y", velocity.y);
+    payload.setProperty(runtime, "velocity", velocityObj);
+  }
+
+  return payload;
+}
+
+folly::dynamic ScrollEndDragEvent::asDynamic() const {
+  auto metrics = ScrollEvent::asDynamic();
+
+  auto targetContentOffsetObj = folly::dynamic::object(
+      "x", targetContentOffset.x)("y", targetContentOffset.y);
+  metrics["targetContentOffset"] = std::move(targetContentOffsetObj);
+
+  auto velocityObj = folly::dynamic::object("x", velocity.x)("y", velocity.y);
+  metrics["velocity"] = std::move(velocityObj);
+
+  return metrics;
+};
+
 #if RN_DEBUG_STRING_CONVERTIBLE
 
 std::string getDebugName(const ScrollEvent& /*scrollEvent*/) {

package/ReactCommon/react/renderer/components/scrollview/ScrollEvent.h

@@ -37,6 +37,23 @@ struct ScrollEvent : public EventPayload {
   EventPayloadType getType() const override;
 };
 
+struct ScrollEndDragEvent : public ScrollEvent {
+  Point targetContentOffset;
+  Point velocity;
+
+  ScrollEndDragEvent() = default;
+
+  ScrollEndDragEvent(const ScrollEvent& scrollEvent)
+      : ScrollEvent(scrollEvent), targetContentOffset({}), velocity({}) {}
+
+  folly::dynamic asDynamic() const;
+
+  /*
+   * EventPayload implementations
+   */
+  jsi::Value asJSIValue(jsi::Runtime& runtime) const override;
+};
+
 #if RN_DEBUG_STRING_CONVERTIBLE
 
 std::string getDebugName(const ScrollEvent& scrollEvent);

package/ReactCommon/react/renderer/components/scrollview/ScrollViewEventEmitter.cpp

@@ -25,8 +25,9 @@ void ScrollViewEventEmitter::onScrollBeginDrag(
 }
 
 void ScrollViewEventEmitter::onScrollEndDrag(
-    const ScrollEvent& scrollEvent) const {
-  dispatchScrollViewEvent("scrollEndDrag", scrollEvent);
+    const ScrollEndDragEvent& scrollEvent) const {
+  dispatchEvent(
+      "scrollEndDrag", std::make_shared<ScrollEndDragEvent>(scrollEvent));
 }
 
 void ScrollViewEventEmitter::onMomentumScrollBegin(

package/ReactCommon/react/renderer/components/scrollview/ScrollViewEventEmitter.h

@@ -21,10 +21,11 @@ class ScrollViewEventEmitter : public ViewEventEmitter {
   using ViewEventEmitter::ViewEventEmitter;
 
   using Metrics = ScrollEvent;
+  using EndDragMetrics = ScrollEndDragEvent;
 
   void onScroll(const ScrollEvent& scrollEvent) const;
   void onScrollBeginDrag(const ScrollEvent& scrollEvent) const;
-  void onScrollEndDrag(const ScrollEvent& scrollEvent) const;
+  void onScrollEndDrag(const ScrollEndDragEvent& scrollEvent) const;
   void onMomentumScrollBegin(const ScrollEvent& scrollEvent) const;
   void onMomentumScrollEnd(const ScrollEvent& scrollEvent) const;
   void onScrollToTop(const ScrollEvent& scrollEvent) const;

package/ReactCommon/react/renderer/components/switch/androidswitch/react/renderer/components/androidswitch/AndroidSwitchComponentDescriptor.h

@@ -36,10 +36,6 @@ class AndroidSwitchComponentDescriptor final
     // provide measurements to Yoga.
     androidSwitchShadowNode.setAndroidSwitchMeasurementsManager(
         measurementsManager_);
-
-    // All `AndroidSwitchShadowNode`s must have leaf Yoga nodes with properly
-    // setup measure function.
-    androidSwitchShadowNode.enableMeasurement();
   }
 
  private:

package/ReactCommon/react/renderer/components/switch/androidswitch/react/renderer/components/androidswitch/AndroidSwitchShadowNode.h

@@ -27,6 +27,13 @@ class AndroidSwitchShadowNode final : public ConcreteViewShadowNode<
  public:
   using ConcreteViewShadowNode::ConcreteViewShadowNode;
 
+  static ShadowNodeTraits BaseTraits() {
+    auto traits = ConcreteViewShadowNode::BaseTraits();
+    traits.set(ShadowNodeTraits::Trait::LeafYogaNode);
+    traits.set(ShadowNodeTraits::Trait::MeasurableYogaNode);
+    return traits;
+  }
+
   // Associates a shared `AndroidSwitchMeasurementsManager` with the node.
   void setAndroidSwitchMeasurementsManager(
       const std::shared_ptr<AndroidSwitchMeasurementsManager>&

package/ReactCommon/react/renderer/components/text/BaseTextProps.cpp

@@ -73,6 +73,12 @@ static TextAttributes convertRawProp(
       "allowFontScaling",
       sourceTextAttributes.allowFontScaling,
       defaultTextAttributes.allowFontScaling);
+  textAttributes.maxFontSizeMultiplier = convertRawProp(
+      context,
+      rawProps,
+      "maxFontSizeMultiplier",
+      sourceTextAttributes.maxFontSizeMultiplier,
+      defaultTextAttributes.maxFontSizeMultiplier);
   textAttributes.dynamicTypeRamp = convertRawProp(
       context,
       rawProps,
@@ -266,6 +272,12 @@ void BaseTextProps::setProp(
         defaults, value, textAttributes, fontVariant, "fontVariant");
     REBUILD_FIELD_SWITCH_CASE(
         defaults, value, textAttributes, allowFontScaling, "allowFontScaling");
+    REBUILD_FIELD_SWITCH_CASE(
+        defaults,
+        value,
+        textAttributes,
+        maxFontSizeMultiplier,
+        "maxFontSizeMultiplier");
     REBUILD_FIELD_SWITCH_CASE(
         defaults, value, textAttributes, letterSpacing, "letterSpacing");
     REBUILD_FIELD_SWITCH_CASE(

package/ReactCommon/react/renderer/{uimanager/bindingUtils.h → components/text/ParagraphComponentDescriptor.cpp}

@@ -5,16 +5,10 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-#pragma once
-
-#include <jsi/jsi.h>
+#include "ParagraphComponentDescriptor.h"
 
 namespace facebook::react {
 
-jsi::Value callMethodOfModule(
-    jsi::Runtime& runtime,
-    const std::string& moduleName,
-    const std::string& methodName,
-    std::initializer_list<jsi::Value> args);
+extern const char TextLayoutManagerKey[] = "TextLayoutManager";
 
 } // namespace facebook::react

package/ReactCommon/react/renderer/components/text/ParagraphComponentDescriptor.h

@@ -14,18 +14,20 @@
 
 namespace facebook::react {
 
+extern const char TextLayoutManagerKey[];
+
 /*
  * Descriptor for <Paragraph> component.
  */
 class ParagraphComponentDescriptor final
     : public ConcreteComponentDescriptor<ParagraphShadowNode> {
  public:
-  ParagraphComponentDescriptor(const ComponentDescriptorParameters& parameters)
-      : ConcreteComponentDescriptor<ParagraphShadowNode>(parameters) {
-    // Every single `ParagraphShadowNode` will have a reference to
-    // a shared `TextLayoutManager`.
-    textLayoutManager_ = std::make_shared<TextLayoutManager>(contextContainer_);
-  }
+  explicit ParagraphComponentDescriptor(
+      const ComponentDescriptorParameters& parameters)
+      : ConcreteComponentDescriptor<ParagraphShadowNode>(parameters),
+        textLayoutManager_(getManagerByName<TextLayoutManager>(
+            contextContainer_,
+            TextLayoutManagerKey)) {}
 
  protected:
   void adopt(ShadowNode& shadowNode) const override {
@@ -39,7 +41,8 @@ class ParagraphComponentDescriptor final
   }
 
  private:
-  std::shared_ptr<const TextLayoutManager> textLayoutManager_;
+  // Every `ParagraphShadowNode` has a reference to a shared `TextLayoutManager`
+  const std::shared_ptr<const TextLayoutManager> textLayoutManager_;
 };
 
 } // namespace facebook::react

package/ReactCommon/react/renderer/components/textinput/BaseTextInputProps.cpp

@@ -126,6 +126,12 @@ BaseTextInputProps::BaseTextInputProps(
           rawProps,
           "multiline",
           sourceProps.multiline,
+          {false})),
+      disableKeyboardShortcuts(convertRawProp(
+          context,
+          rawProps,
+          "disableKeyboardShortcuts",
+          sourceProps.disableKeyboardShortcuts,
           {false})) {}
 
 void BaseTextInputProps::setProp(
@@ -208,9 +214,26 @@ void BaseTextInputProps::setProp(
     RAW_SET_PROP_SWITCH_CASE_BASIC(readOnly);
     RAW_SET_PROP_SWITCH_CASE_BASIC(submitBehavior);
     RAW_SET_PROP_SWITCH_CASE_BASIC(multiline);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(disableKeyboardShortcuts);
   }
 }
 
+TextAttributes BaseTextInputProps::getEffectiveTextAttributes(
+    Float fontSizeMultiplier) const {
+  auto result = TextAttributes::defaultTextAttributes();
+  result.fontSizeMultiplier = fontSizeMultiplier;
+  result.apply(textAttributes);
+
+  /*
+   * These props are applied to `View`, therefore they must not be a part of
+   * base text attributes.
+   */
+  result.backgroundColor = clearColor();
+  result.opacity = 1;
+
+  return result;
+}
+
 SubmitBehavior BaseTextInputProps::getNonDefaultSubmitBehavior() const {
   if (submitBehavior == SubmitBehavior::Default) {
     return multiline ? SubmitBehavior::Newline : SubmitBehavior::BlurAndSubmit;

package/ReactCommon/react/renderer/components/textinput/BaseTextInputProps.h

@@ -31,6 +31,13 @@ class BaseTextInputProps : public ViewProps, public BaseTextProps {
       const char* propName,
       const RawValue& value);
 
+  SubmitBehavior getNonDefaultSubmitBehavior() const;
+
+  /*
+   * Accessors
+   */
+  TextAttributes getEffectiveTextAttributes(Float fontSizeMultiplier) const;
+
 #pragma mark - Props
 
   /*
@@ -72,7 +79,7 @@ class BaseTextInputProps : public ViewProps, public BaseTextProps {
 
   bool multiline{false};
 
-  SubmitBehavior getNonDefaultSubmitBehavior() const;
+  bool disableKeyboardShortcuts{false};
 };
 
 } // namespace facebook::react

package/ReactCommon/react/renderer/components/textinput/BaseTextInputShadowNode.h

@@ -0,0 +1,243 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <react/renderer/attributedstring/AttributedString.h>
+#include <react/renderer/attributedstring/AttributedStringBox.h>
+#include <react/renderer/components/text/BaseTextShadowNode.h>
+#include <react/renderer/components/textinput/BaseTextInputProps.h>
+#include <react/renderer/components/textinput/TextInputState.h>
+#include <react/renderer/components/view/ConcreteViewShadowNode.h>
+#include <react/renderer/components/view/YogaLayoutableShadowNode.h>
+#include <react/renderer/core/LayoutConstraints.h>
+#include <react/renderer/core/LayoutContext.h>
+#include <react/renderer/textlayoutmanager/TextLayoutContext.h>
+#include <react/renderer/textlayoutmanager/TextLayoutManager.h>
+#include <react/utils/ContextContainer.h>
+
+namespace facebook::react {
+
+/*
+ * Base `ShadowNode` for <TextInput> component.
+ */
+template <
+    const char* concreteComponentName,
+    typename ViewPropsT,
+    typename ViewEventEmitterT,
+    typename StateDataT,
+    bool usesMapBufferForStateData = false>
+class BaseTextInputShadowNode : public ConcreteViewShadowNode<
+                                    concreteComponentName,
+                                    ViewPropsT,
+                                    ViewEventEmitterT,
+                                    StateDataT,
+                                    usesMapBufferForStateData>,
+                                public BaseTextShadowNode {
+ public:
+  using BaseShadowNode = ConcreteViewShadowNode<
+      concreteComponentName,
+      ViewPropsT,
+      ViewEventEmitterT,
+      StateDataT,
+      usesMapBufferForStateData>;
+
+  using BaseShadowNode::ConcreteViewShadowNode;
+
+  static ShadowNodeTraits BaseTraits() {
+    auto traits = BaseShadowNode::BaseTraits();
+    traits.set(ShadowNodeTraits::Trait::LeafYogaNode);
+    traits.set(ShadowNodeTraits::Trait::MeasurableYogaNode);
+    traits.set(ShadowNodeTraits::Trait::BaselineYogaNode);
+    return traits;
+  }
+
+  /*
+   * Associates a shared `TextLayoutManager` with the node.
+   * `TextInputShadowNode` uses the manager to measure text content
+   * and construct `TextInputState` objects.
+   */
+  void setTextLayoutManager(
+      std::shared_ptr<const TextLayoutManager> textLayoutManager) {
+    Sealable::ensureUnsealed();
+    textLayoutManager_ = std::move(textLayoutManager);
+  }
+
+ protected:
+  Size measureContent(
+      const LayoutContext& layoutContext,
+      const LayoutConstraints& layoutConstraints) const override {
+    const auto& props = BaseShadowNode::getConcreteProps();
+    auto textConstraints = getTextConstraints(layoutConstraints);
+
+    TextLayoutContext textLayoutContext{
+        .pointScaleFactor = layoutContext.pointScaleFactor};
+    auto textSize = textLayoutManager_
+                        ->measure(
+                            attributedStringBoxToMeasure(layoutContext),
+                            props.paragraphAttributes,
+                            textLayoutContext,
+                            textConstraints)
+                        .size;
+
+    return layoutConstraints.clamp(textSize);
+  }
+
+  void layout(LayoutContext layoutContext) override {
+    updateStateIfNeeded(layoutContext);
+    BaseShadowNode::layout(layoutContext);
+  }
+
+  Float baseline(const LayoutContext& layoutContext, Size size) const override {
+    const auto& props = BaseShadowNode::getConcreteProps();
+    auto attributedString = getAttributedString(layoutContext);
+
+    if (attributedString.isEmpty()) {
+      attributedString = getPlaceholderAttributedString(layoutContext);
+    }
+
+    // Yoga expects a baseline relative to the Node's border-box edge instead of
+    // the content, so we need to adjust by the padding and border widths, which
+    // have already been set by the time of baseline alignment
+    auto top = YGNodeLayoutGetBorder(
+                   &(YogaLayoutableShadowNode::yogaNode_), YGEdgeTop) +
+        YGNodeLayoutGetPadding(
+                   &(YogaLayoutableShadowNode::yogaNode_), YGEdgeTop);
+
+    AttributedStringBox attributedStringBox{attributedString};
+    return textLayoutManager_->baseline(
+               attributedStringBox, props.paragraphAttributes, size) +
+        top;
+  }
+
+  /*
+   * Determines the constraints to use while measure the underlying text
+   */
+  LayoutConstraints getTextConstraints(
+      const LayoutConstraints& layoutConstraints) const {
+    if (BaseShadowNode::getConcreteProps().multiline) {
+      return layoutConstraints;
+    } else {
+      // A single line TextInput acts as a horizontal scroller of infinitely
+      // expandable text, so we want to measure the text as if it is allowed to
+      // infinitely expand horizontally, and later clamp to the constraints of
+      // the input.
+      return LayoutConstraints{
+          .minimumSize = layoutConstraints.minimumSize,
+          .maximumSize =
+              Size{
+                  .width = std::numeric_limits<Float>::infinity(),
+                  .height = layoutConstraints.maximumSize.height,
+              },
+          .layoutDirection = layoutConstraints.layoutDirection,
+      };
+    }
+  }
+
+  std::shared_ptr<const TextLayoutManager> textLayoutManager_;
+
+ private:
+  /*
+   * Creates a `State` object if needed.
+   */
+  void updateStateIfNeeded(const LayoutContext& layoutContext) {
+    Sealable::ensureUnsealed();
+    const auto& stateData = BaseShadowNode::getStateData();
+    const auto& reactTreeAttributedString = getAttributedString(layoutContext);
+
+    react_native_assert(textLayoutManager_);
+    if (stateData.reactTreeAttributedString.isContentEqual(
+            reactTreeAttributedString)) {
+      return;
+    }
+
+    const auto& props = BaseShadowNode::getConcreteProps();
+    TextInputState newState(
+        AttributedStringBox{reactTreeAttributedString},
+        reactTreeAttributedString,
+        props.paragraphAttributes,
+        props.mostRecentEventCount);
+    BaseShadowNode::setStateData(std::move(newState));
+  }
+
+  /*
+   * Returns a `AttributedString` which represents text content of the node.
+   */
+  AttributedString getAttributedString(
+      const LayoutContext& layoutContext) const {
+    const auto& props = BaseShadowNode::getConcreteProps();
+    const auto textAttributes =
+        props.getEffectiveTextAttributes(layoutContext.fontSizeMultiplier);
+
+    AttributedString attributedString;
+    attributedString.appendFragment(AttributedString::Fragment{
+        .string = props.text,
+        .textAttributes = textAttributes,
+        .parentShadowView = ShadowView(*this)});
+
+    auto attachments = BaseTextShadowNode::Attachments{};
+    BaseTextShadowNode::buildAttributedString(
+        textAttributes, *this, attributedString, attachments);
+    attributedString.setBaseTextAttributes(textAttributes);
+    return attributedString;
+  }
+
+  /*
+   * Returns an `AttributedStringBox` which represents text content that should
+   * be used for measuring purposes. It might contain actual text value,
+   * placeholder value or some character that represents the size of the font.
+   */
+  AttributedStringBox attributedStringBoxToMeasure(
+      const LayoutContext& layoutContext) const {
+    bool meaningfulState = BaseShadowNode::getState() &&
+        BaseShadowNode::getState()->getRevision() !=
+            State::initialRevisionValue;
+    if (meaningfulState) {
+      const auto& stateData = BaseShadowNode::getStateData();
+      auto attributedStringBox = stateData.attributedStringBox;
+      if (attributedStringBox.getMode() ==
+              AttributedStringBox::Mode::OpaquePointer ||
+          !attributedStringBox.getValue().isEmpty()) {
+        return stateData.attributedStringBox;
+      }
+    }
+
+    auto attributedString = meaningfulState
+        ? AttributedString{}
+        : getAttributedString(layoutContext);
+
+    if (attributedString.isEmpty()) {
+      attributedString = getPlaceholderAttributedString(layoutContext);
+    }
+    return AttributedStringBox{attributedString};
+  }
+
+  // For measurement purposes, we want to make sure that there's at least a
+  // single character in the string so that the measured height is greater
+  // than zero. Otherwise, empty TextInputs with no placeholder don't
+  // display at all.
+  // TODO T67606511: We will redefine the measurement of empty strings as part
+  // of T67606511
+  AttributedString getPlaceholderAttributedString(
+      const LayoutContext& layoutContext) const {
+    const auto& props = BaseShadowNode::getConcreteProps();
+
+    AttributedString attributedString;
+    auto placeholderString = !props.placeholder.empty()
+        ? props.placeholder
+        : BaseTextShadowNode::getEmptyPlaceholder();
+    auto textAttributes =
+        props.getEffectiveTextAttributes(layoutContext.fontSizeMultiplier);
+    attributedString.appendFragment(
+        {.string = std::move(placeholderString),
+         .textAttributes = textAttributes,
+         .parentShadowView = {}});
+    return attributedString;
+  }
+};
+
+} // namespace facebook::react