yeet

node_modules/react-native/ReactCommon/fabric/attributedstring/AttributedString.cpp

@@ -0,0 +1,151 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include "AttributedString.h"
+
+#include <react/debug/DebugStringConvertibleItem.h>
+
+namespace facebook {
+namespace react {
+
+using Fragment = AttributedString::Fragment;
+using Fragments = AttributedString::Fragments;
+
+#pragma mark - Fragment
+
+std::string Fragment::AttachmentCharacter() {
+  return "\uFFFC"; // Unicode `OBJECT REPLACEMENT CHARACTER`
+}
+
+bool Fragment::isAttachment() const {
+  return string == AttachmentCharacter();
+}
+
+bool Fragment::operator==(const Fragment &rhs) const {
+  return std::tie(
+             string,
+             textAttributes,
+             parentShadowView.tag,
+             parentShadowView.layoutMetrics) ==
+      std::tie(
+             rhs.string,
+             rhs.textAttributes,
+             rhs.parentShadowView.tag,
+             rhs.parentShadowView.layoutMetrics);
+}
+
+bool Fragment::operator!=(const Fragment &rhs) const {
+  return !(*this == rhs);
+}
+
+#pragma mark - AttributedString
+
+void AttributedString::appendFragment(const Fragment &fragment) {
+  ensureUnsealed();
+
+  if (fragment.string.empty()) {
+    return;
+  }
+
+  fragments_.push_back(fragment);
+}
+
+void AttributedString::prependFragment(const Fragment &fragment) {
+  ensureUnsealed();
+
+  if (fragment.string.empty()) {
+    return;
+  }
+
+  fragments_.insert(fragments_.begin(), fragment);
+}
+
+void AttributedString::appendAttributedString(
+    const AttributedString &attributedString) {
+  ensureUnsealed();
+  fragments_.insert(
+      fragments_.end(),
+      attributedString.fragments_.begin(),
+      attributedString.fragments_.end());
+}
+
+void AttributedString::prependAttributedString(
+    const AttributedString &attributedString) {
+  ensureUnsealed();
+  fragments_.insert(
+      fragments_.begin(),
+      attributedString.fragments_.begin(),
+      attributedString.fragments_.end());
+}
+
+Fragments const &AttributedString::getFragments() const {
+  return fragments_;
+}
+
+Fragments &AttributedString::getFragments() {
+  return fragments_;
+}
+
+std::string AttributedString::getString() const {
+  auto string = std::string{};
+  for (const auto &fragment : fragments_) {
+    string += fragment.string;
+  }
+  return string;
+}
+
+bool AttributedString::isEmpty() const {
+  return fragments_.empty();
+}
+
+bool AttributedString::compareTextAttributesWithoutFrame(
+    const AttributedString &rhs) const {
+  if (fragments_.size() != rhs.fragments_.size()) {
+    return false;
+  }
+
+  for (unsigned i = 0; i < fragments_.size(); i++) {
+    if (fragments_[i].textAttributes != rhs.fragments_[i].textAttributes ||
+        fragments_[i].string != rhs.fragments_[i].string) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+bool AttributedString::operator==(const AttributedString &rhs) const {
+  return fragments_ == rhs.fragments_;
+}
+
+bool AttributedString::operator!=(const AttributedString &rhs) const {
+  return !(*this == rhs);
+}
+
+#pragma mark - DebugStringConvertible
+
+#if RN_DEBUG_STRING_CONVERTIBLE
+SharedDebugStringConvertibleList AttributedString::getDebugChildren() const {
+  auto list = SharedDebugStringConvertibleList{};
+
+  for (auto &&fragment : fragments_) {
+    auto propsList =
+        fragment.textAttributes.DebugStringConvertible::getDebugProps();
+
+    list.push_back(std::make_shared<DebugStringConvertibleItem>(
+        "Fragment",
+        fragment.string,
+        SharedDebugStringConvertibleList(),
+        propsList));
+  }
+
+  return list;
+}
+#endif
+
+} // namespace react
+} // namespace facebook

node_modules/react-native/ReactCommon/fabric/attributedstring/AttributedString.h

@@ -0,0 +1,139 @@
+/*
+ * Copyright (c) Facebook, Inc. and its 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 <functional>
+#include <memory>
+
+#include <folly/Hash.h>
+#include <folly/Optional.h>
+#include <react/attributedstring/TextAttributes.h>
+#include <react/core/Sealable.h>
+#include <react/core/ShadowNode.h>
+#include <react/debug/DebugStringConvertible.h>
+#include <react/mounting/ShadowView.h>
+
+namespace facebook {
+namespace react {
+
+class AttributedString;
+
+using SharedAttributedString = std::shared_ptr<const AttributedString>;
+
+/*
+ * Simple, cross-platfrom, React-specific implementation of attributed string
+ * (aka spanned string).
+ * `AttributedString` is basically a list of `Fragments` which have `string` and
+ * `textAttributes` + `shadowNode` associated with the `string`.
+ */
+class AttributedString : public Sealable, public DebugStringConvertible {
+ public:
+  class Fragment {
+   public:
+    static std::string AttachmentCharacter();
+
+    std::string string;
+    TextAttributes textAttributes;
+    ShadowView parentShadowView;
+
+    /*
+     * Returns true is the Fragment represents an attachment.
+     * Equivalent to `string == AttachmentCharacter()`.
+     */
+    bool isAttachment() const;
+
+    bool operator==(const Fragment &rhs) const;
+    bool operator!=(const Fragment &rhs) const;
+  };
+
+  class Range {
+   public:
+    int location{0};
+    int length{0};
+  };
+
+  using Fragments = better::small_vector<Fragment, 1>;
+
+  /*
+   * Appends and prepends a `fragment` to the string.
+   */
+  void appendFragment(const Fragment &fragment);
+  void prependFragment(const Fragment &fragment);
+
+  /*
+   * Appends and prepends an `attributedString` (all its fragments) to
+   * the string.
+   */
+  void appendAttributedString(const AttributedString &attributedString);
+  void prependAttributedString(const AttributedString &attributedString);
+
+  /*
+   * Returns a read-only reference to a list of fragments.
+   */
+  Fragments const &getFragments() const;
+
+  /*
+   * Returns a reference to a list of fragments.
+   */
+  Fragments &getFragments();
+
+  /*
+   * Returns a string constructed from all strings in all fragments.
+   */
+  std::string getString() const;
+
+  /*
+   * Returns `true` if the string is empty (has no any fragments).
+   */
+  bool isEmpty() const;
+
+  /**
+   * Compares equality of TextAttributes of all Fragments on both sides.
+   */
+  bool compareTextAttributesWithoutFrame(const AttributedString &rhs) const;
+
+  bool operator==(const AttributedString &rhs) const;
+  bool operator!=(const AttributedString &rhs) const;
+
+#pragma mark - DebugStringConvertible
+
+#if RN_DEBUG_STRING_CONVERTIBLE
+  SharedDebugStringConvertibleList getDebugChildren() const override;
+#endif
+
+ private:
+  Fragments fragments_;
+};
+
+} // namespace react
+} // namespace facebook
+
+namespace std {
+template <>
+struct hash<facebook::react::AttributedString::Fragment> {
+  size_t operator()(
+      const facebook::react::AttributedString::Fragment &fragment) const {
+    return folly::hash::hash_combine(
+        0, fragment.string, fragment.textAttributes, fragment.parentShadowView);
+  }
+};
+
+template <>
+struct hash<facebook::react::AttributedString> {
+  size_t operator()(
+      const facebook::react::AttributedString &attributedString) const {
+    auto seed = size_t{0};
+
+    for (const auto &fragment : attributedString.getFragments()) {
+      seed = folly::hash::hash_combine(seed, fragment);
+    }
+
+    return seed;
+  }
+};
+} // namespace std

node_modules/react-native/ReactCommon/fabric/attributedstring/AttributedStringBox.cpp

@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include "AttributedStringBox.h"
+
+namespace facebook {
+namespace react {
+
+AttributedStringBox::AttributedStringBox()
+    : mode_(Mode::Value),
+      value_(std::make_shared<AttributedString const>(AttributedString{})),
+      opaquePointer_({}){};
+
+AttributedStringBox::AttributedStringBox(AttributedString const &value)
+    : mode_(Mode::Value),
+      value_(std::make_shared<AttributedString const>(value)),
+      opaquePointer_({}){};
+
+AttributedStringBox::AttributedStringBox(
+    std::shared_ptr<void> const &opaquePointer)
+    : mode_(Mode::OpaquePointer), value_({}), opaquePointer_(opaquePointer) {}
+
+AttributedStringBox::Mode AttributedStringBox::getMode() const {
+  return mode_;
+}
+
+AttributedString const &AttributedStringBox::getValue() const {
+  assert(mode_ == AttributedStringBox::Mode::Value);
+  assert(value_);
+  return *value_;
+}
+
+std::shared_ptr<void> AttributedStringBox::getOpaquePointer() const {
+  assert(mode_ == AttributedStringBox::Mode::OpaquePointer);
+  assert(opaquePointer_);
+  return opaquePointer_;
+}
+
+bool operator==(
+    AttributedStringBox const &lhs,
+    AttributedStringBox const &rhs) {
+  if (lhs.getMode() != rhs.getMode()) {
+    return false;
+  }
+
+  switch (lhs.getMode()) {
+    case facebook::react::AttributedStringBox::Mode::Value:
+      return lhs.getValue() == rhs.getValue();
+    case facebook::react::AttributedStringBox::Mode::OpaquePointer:
+      return lhs.getOpaquePointer() == rhs.getOpaquePointer();
+  }
+}
+
+bool operator!=(
+    AttributedStringBox const &lhs,
+    AttributedStringBox const &rhs) {
+  return !(lhs == rhs);
+}
+
+} // namespace react
+} // namespace facebook

node_modules/react-native/ReactCommon/fabric/attributedstring/AttributedStringBox.h

@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) Facebook, Inc. and its 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 <memory>
+
+#include <react/attributedstring/AttributedString.h>
+
+namespace facebook {
+namespace react {
+
+/*
+ * Represents an object storing a shared `AttributedString` or a shared pointer
+ * to some opaque platform-specific object that can be used as an attributed
+ * string. The class serves two main purposes:
+ *  - Represent type-erased attributed string entity (which can be
+ * platform-specific or platform-independent);
+ *  - Represent a container that can be copied with constant complexity.
+ */
+class AttributedStringBox final {
+ public:
+  enum class Mode { Value, OpaquePointer };
+
+  /*
+   * Default constructor constructs an empty string.
+   */
+  AttributedStringBox();
+
+  /*
+   * Custom explicit constructors.
+   */
+  explicit AttributedStringBox(AttributedString const &value);
+  explicit AttributedStringBox(std::shared_ptr<void> const &opaquePointer);
+
+  /*
+   * Movable, Copyable, Assignable.
+   */
+  AttributedStringBox(AttributedStringBox const &other) = default;
+  AttributedStringBox(AttributedStringBox &&other) noexcept = default;
+  AttributedStringBox &operator=(AttributedStringBox const &other) = default;
+  AttributedStringBox &operator=(AttributedStringBox &&other) = default;
+
+  /*
+   * Getters.
+   */
+  Mode getMode() const;
+  AttributedString const &getValue() const;
+  std::shared_ptr<void> getOpaquePointer() const;
+
+ private:
+  Mode mode_;
+  std::shared_ptr<AttributedString const> value_;
+  std::shared_ptr<void> opaquePointer_;
+};
+
+bool operator==(AttributedStringBox const &lhs, AttributedStringBox const &rhs);
+bool operator!=(AttributedStringBox const &lhs, AttributedStringBox const &rhs);
+
+} // namespace react
+} // namespace facebook
+
+template <>
+struct std::hash<facebook::react::AttributedStringBox> {
+  size_t operator()(
+      facebook::react::AttributedStringBox const &attributedStringBox) const {
+    switch (attributedStringBox.getMode()) {
+      case facebook::react::AttributedStringBox::Mode::Value:
+        return std::hash<facebook::react::AttributedString>()(
+            attributedStringBox.getValue());
+      case facebook::react::AttributedStringBox::Mode::OpaquePointer:
+        return std::hash<std::shared_ptr<void>>()(
+            attributedStringBox.getOpaquePointer());
+    }
+  }
+};

node_modules/react-native/ReactCommon/fabric/attributedstring/BUCK

@@ -0,0 +1,83 @@
+load("@fbsource//tools/build_defs/apple:flag_defs.bzl", "get_preprocessor_flags_for_build_mode")
+load(
+    "//tools/build_defs/oss:rn_defs.bzl",
+    "ANDROID",
+    "APPLE",
+    "CXX",
+    "fb_xplat_cxx_test",
+    "get_apple_compiler_flags",
+    "get_apple_inspector_flags",
+    "react_native_xplat_target",
+    "rn_xplat_cxx_library",
+    "subdir_glob",
+)
+
+APPLE_COMPILER_FLAGS = get_apple_compiler_flags()
+
+rn_xplat_cxx_library(
+    name = "attributedstring",
+    srcs = glob(
+        ["**/*.cpp"],
+        exclude = glob(["tests/**/*.cpp"]),
+    ),
+    headers = glob(
+        ["**/*.h"],
+        exclude = glob(["tests/**/*.h"]),
+    ),
+    header_namespace = "",
+    exported_headers = subdir_glob(
+        [
+            ("", "*.h"),
+        ],
+        prefix = "react/attributedstring",
+    ),
+    compiler_flags = [
+        "-fexceptions",
+        "-frtti",
+        "-std=c++14",
+        "-Wall",
+    ],
+    fbobjc_compiler_flags = APPLE_COMPILER_FLAGS,
+    fbobjc_labels = ["supermodule:ios/default/public.react_native.infra"],
+    fbobjc_preprocessor_flags = get_preprocessor_flags_for_build_mode() + get_apple_inspector_flags(),
+    force_static = True,
+    macosx_tests_override = [],
+    platforms = (ANDROID, APPLE, CXX),
+    preprocessor_flags = [
+        "-DLOG_TAG=\"ReactNative\"",
+        "-DWITH_FBSYSTRACE=1",
+    ],
+    tests = [":tests"],
+    visibility = ["PUBLIC"],
+    deps = [
+        "//xplat/fbsystrace:fbsystrace",
+        "//xplat/folly:headers_only",
+        "//xplat/folly:memory",
+        "//xplat/folly:molly",
+        "//xplat/third-party/glog:glog",
+        react_native_xplat_target("utils:utils"),
+        react_native_xplat_target("fabric/debug:debug"),
+        react_native_xplat_target("fabric/core:core"),
+        react_native_xplat_target("fabric/graphics:graphics"),
+        react_native_xplat_target("fabric/mounting:mounting"),
+    ],
+)
+
+fb_xplat_cxx_test(
+    name = "tests",
+    srcs = glob(["tests/**/*.cpp"]),
+    headers = glob(["tests/**/*.h"]),
+    compiler_flags = [
+        "-fexceptions",
+        "-frtti",
+        "-std=c++14",
+        "-Wall",
+    ],
+    contacts = ["oncall+react_native@xmail.facebook.com"],
+    platforms = (ANDROID, APPLE, CXX),
+    deps = [
+        ":attributedstring",
+        "//xplat/folly:molly",
+        "//xplat/third-party/gmock:gtest",
+    ],
+)

node_modules/react-native/ReactCommon/fabric/attributedstring/ParagraphAttributes.cpp

@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include "ParagraphAttributes.h"
+
+#include <react/attributedstring/conversions.h>
+#include <react/debug/debugStringConvertibleUtils.h>
+#include <react/graphics/conversions.h>
+#include <react/utils/FloatComparison.h>
+
+namespace facebook {
+namespace react {
+
+bool ParagraphAttributes::operator==(const ParagraphAttributes &rhs) const {
+  return std::tie(
+             maximumNumberOfLines,
+             ellipsizeMode,
+             textBreakStrategy,
+             adjustsFontSizeToFit) ==
+      std::tie(
+             rhs.maximumNumberOfLines,
+             rhs.ellipsizeMode,
+             rhs.textBreakStrategy,
+             rhs.adjustsFontSizeToFit) &&
+      floatEquality(minimumFontSize, rhs.minimumFontSize) &&
+      floatEquality(maximumFontSize, rhs.maximumFontSize);
+}
+
+bool ParagraphAttributes::operator!=(const ParagraphAttributes &rhs) const {
+  return !(*this == rhs);
+}
+
+#pragma mark - DebugStringConvertible
+
+#if RN_DEBUG_STRING_CONVERTIBLE
+SharedDebugStringConvertibleList ParagraphAttributes::getDebugProps() const {
+  return {
+      debugStringConvertibleItem("maximumNumberOfLines", maximumNumberOfLines),
+      debugStringConvertibleItem("ellipsizeMode", ellipsizeMode),
+      debugStringConvertibleItem("textBreakStrategy", textBreakStrategy),
+      debugStringConvertibleItem("adjustsFontSizeToFit", adjustsFontSizeToFit),
+      debugStringConvertibleItem("minimumFontSize", minimumFontSize),
+      debugStringConvertibleItem("maximumFontSize", maximumFontSize)};
+}
+#endif
+
+} // namespace react
+} // namespace facebook

node_modules/react-native/ReactCommon/fabric/attributedstring/ParagraphAttributes.h

@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) Facebook, Inc. and its 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 <limits>
+
+#include <folly/Hash.h>
+#include <react/attributedstring/primitives.h>
+#include <react/debug/DebugStringConvertible.h>
+#include <react/graphics/Geometry.h>
+
+namespace facebook {
+namespace react {
+
+class ParagraphAttributes;
+
+using SharedParagraphAttributes = std::shared_ptr<const ParagraphAttributes>;
+
+/*
+ * Represents all visual attributes of a paragraph of text.
+ * Two data structures, ParagraphAttributes and AttributedText, should be
+ * enough to define visual representation of a piece of text on the screen.
+ */
+class ParagraphAttributes : public DebugStringConvertible {
+ public:
+#pragma mark - Fields
+
+  /*
+   * Maximum number of lines which paragraph can take.
+   * Zero value represents "no limit".
+   */
+  int maximumNumberOfLines{};
+
+  /*
+   * In case if a text cannot fit given boundaries, defines a place where
+   * an ellipsize should be placed.
+   */
+  EllipsizeMode ellipsizeMode{};
+
+  TextBreakStrategy textBreakStrategy{};
+
+  /*
+   * Enables font size adjustment to fit constrained boundaries.
+   */
+  bool adjustsFontSizeToFit{};
+
+  /*
+   * In case of font size adjustment enabled, defines minimum and maximum
+   * font sizes.
+   */
+  Float minimumFontSize{std::numeric_limits<Float>::quiet_NaN()};
+  Float maximumFontSize{std::numeric_limits<Float>::quiet_NaN()};
+
+  bool operator==(const ParagraphAttributes &) const;
+  bool operator!=(const ParagraphAttributes &) const;
+
+#pragma mark - DebugStringConvertible
+
+#if RN_DEBUG_STRING_CONVERTIBLE
+  SharedDebugStringConvertibleList getDebugProps() const override;
+#endif
+};
+
+} // namespace react
+} // namespace facebook
+
+namespace std {
+
+template <>
+struct hash<facebook::react::ParagraphAttributes> {
+  size_t operator()(
+      const facebook::react::ParagraphAttributes &attributes) const {
+    return folly::hash::hash_combine(
+        0,
+        attributes.maximumNumberOfLines,
+        attributes.ellipsizeMode,
+        attributes.textBreakStrategy,
+        attributes.adjustsFontSizeToFit,
+        attributes.minimumFontSize,
+        attributes.maximumFontSize);
+  }
+};
+} // namespace std

node_modules/react-native/ReactCommon/fabric/attributedstring/TextAttributes.cpp

@@ -0,0 +1,210 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include "TextAttributes.h"
+
+#include <react/attributedstring/conversions.h>
+#include <react/core/conversions.h>
+#include <react/graphics/conversions.h>
+#include <react/utils/FloatComparison.h>
+#include <cmath>
+
+#include <react/debug/debugStringConvertibleUtils.h>
+
+namespace facebook {
+namespace react {
+
+void TextAttributes::apply(TextAttributes textAttributes) {
+  // Color
+  foregroundColor = textAttributes.foregroundColor
+      ? textAttributes.foregroundColor
+      : foregroundColor;
+  backgroundColor = textAttributes.backgroundColor
+      ? textAttributes.backgroundColor
+      : backgroundColor;
+  opacity =
+      !std::isnan(textAttributes.opacity) ? textAttributes.opacity : opacity;
+
+  // Font
+  fontFamily = !textAttributes.fontFamily.empty() ? textAttributes.fontFamily
+                                                  : fontFamily;
+  fontSize =
+      !std::isnan(textAttributes.fontSize) ? textAttributes.fontSize : fontSize;
+  fontSizeMultiplier = !std::isnan(textAttributes.fontSizeMultiplier)
+      ? textAttributes.fontSizeMultiplier
+      : fontSizeMultiplier;
+  fontWeight = textAttributes.fontWeight.hasValue() ? textAttributes.fontWeight
+                                                    : fontWeight;
+  fontStyle = textAttributes.fontStyle.hasValue() ? textAttributes.fontStyle
+                                                  : fontStyle;
+  fontVariant = textAttributes.fontVariant.hasValue()
+      ? textAttributes.fontVariant
+      : fontVariant;
+  allowFontScaling = textAttributes.allowFontScaling.hasValue()
+      ? textAttributes.allowFontScaling
+      : allowFontScaling;
+  letterSpacing = !std::isnan(textAttributes.letterSpacing)
+      ? textAttributes.letterSpacing
+      : letterSpacing;
+
+  // Paragraph Styles
+  lineHeight = !std::isnan(textAttributes.lineHeight)
+      ? textAttributes.lineHeight
+      : lineHeight;
+  alignment = textAttributes.alignment.hasValue() ? textAttributes.alignment
+                                                  : alignment;
+  baseWritingDirection = textAttributes.baseWritingDirection.hasValue()
+      ? textAttributes.baseWritingDirection
+      : baseWritingDirection;
+
+  // Decoration
+  textDecorationColor = textAttributes.textDecorationColor
+      ? textAttributes.textDecorationColor
+      : textDecorationColor;
+  textDecorationLineType = textAttributes.textDecorationLineType.hasValue()
+      ? textAttributes.textDecorationLineType
+      : textDecorationLineType;
+  textDecorationLineStyle = textAttributes.textDecorationLineStyle.hasValue()
+      ? textAttributes.textDecorationLineStyle
+      : textDecorationLineStyle;
+  textDecorationLinePattern =
+      textAttributes.textDecorationLinePattern.hasValue()
+      ? textAttributes.textDecorationLinePattern
+      : textDecorationLinePattern;
+
+  // Shadow
+  textShadowOffset = textAttributes.textShadowOffset.hasValue()
+      ? textAttributes.textShadowOffset.value()
+      : textShadowOffset;
+  textShadowRadius = !std::isnan(textAttributes.textShadowRadius)
+      ? textAttributes.textShadowRadius
+      : textShadowRadius;
+  textShadowColor = textAttributes.textShadowColor
+      ? textAttributes.textShadowColor
+      : textShadowColor;
+
+  // Special
+  isHighlighted = textAttributes.isHighlighted.hasValue()
+      ? textAttributes.isHighlighted
+      : isHighlighted;
+  layoutDirection = textAttributes.layoutDirection.hasValue()
+      ? textAttributes.layoutDirection
+      : layoutDirection;
+}
+
+#pragma mark - Operators
+
+bool TextAttributes::operator==(const TextAttributes &rhs) const {
+  return std::tie(
+             foregroundColor,
+             backgroundColor,
+             fontFamily,
+             fontWeight,
+             fontStyle,
+             fontVariant,
+             allowFontScaling,
+             alignment,
+             baseWritingDirection,
+             textDecorationColor,
+             textDecorationLineType,
+             textDecorationLineStyle,
+             textDecorationLinePattern,
+             textShadowOffset,
+             textShadowColor,
+             isHighlighted,
+             layoutDirection) ==
+      std::tie(
+             rhs.foregroundColor,
+             rhs.backgroundColor,
+             rhs.fontFamily,
+             rhs.fontWeight,
+             rhs.fontStyle,
+             rhs.fontVariant,
+             rhs.allowFontScaling,
+             rhs.alignment,
+             rhs.baseWritingDirection,
+             rhs.textDecorationColor,
+             rhs.textDecorationLineType,
+             rhs.textDecorationLineStyle,
+             rhs.textDecorationLinePattern,
+             rhs.textShadowOffset,
+             rhs.textShadowColor,
+             rhs.isHighlighted,
+             rhs.layoutDirection) &&
+      floatEquality(opacity, rhs.opacity) &&
+      floatEquality(fontSize, rhs.fontSize) &&
+      floatEquality(fontSizeMultiplier, rhs.fontSizeMultiplier) &&
+      floatEquality(letterSpacing, rhs.letterSpacing) &&
+      floatEquality(lineHeight, rhs.lineHeight) &&
+      floatEquality(textShadowRadius, rhs.textShadowRadius);
+}
+
+bool TextAttributes::operator!=(const TextAttributes &rhs) const {
+  return !(*this == rhs);
+}
+
+TextAttributes TextAttributes::defaultTextAttributes() {
+  static auto textAttributes = [] {
+    auto textAttributes = TextAttributes{};
+    // Non-obvious (can be different among platforms) default text attributes.
+    textAttributes.foregroundColor = blackColor();
+    textAttributes.backgroundColor = clearColor();
+    textAttributes.fontSize = 14.0;
+    textAttributes.fontSizeMultiplier = 1.0;
+    return textAttributes;
+  }();
+  return textAttributes;
+}
+
+#pragma mark - DebugStringConvertible
+
+#if RN_DEBUG_STRING_CONVERTIBLE
+SharedDebugStringConvertibleList TextAttributes::getDebugProps() const {
+  return {
+      // Color
+      debugStringConvertibleItem("backgroundColor", backgroundColor),
+      debugStringConvertibleItem("foregroundColor", foregroundColor),
+      debugStringConvertibleItem("opacity", opacity),
+
+      // Font
+      debugStringConvertibleItem("fontFamily", fontFamily),
+      debugStringConvertibleItem("fontSize", fontSize),
+      debugStringConvertibleItem("fontSizeMultiplier", fontSizeMultiplier),
+      debugStringConvertibleItem("fontWeight", fontWeight),
+      debugStringConvertibleItem("fontStyle", fontStyle),
+      debugStringConvertibleItem("fontVariant", fontVariant),
+      debugStringConvertibleItem("allowFontScaling", allowFontScaling),
+      debugStringConvertibleItem("letterSpacing", letterSpacing),
+
+      // Paragraph Styles
+      debugStringConvertibleItem("lineHeight", lineHeight),
+      debugStringConvertibleItem("alignment", alignment),
+      debugStringConvertibleItem("baseWritingDirection", baseWritingDirection),
+
+      // Decoration
+      debugStringConvertibleItem("textDecorationColor", textDecorationColor),
+      debugStringConvertibleItem(
+          "textDecorationLineType", textDecorationLineType),
+      debugStringConvertibleItem(
+          "textDecorationLineStyle", textDecorationLineStyle),
+      debugStringConvertibleItem(
+          "textDecorationLinePattern", textDecorationLinePattern),
+
+      // Shadow
+      debugStringConvertibleItem("textShadowOffset", textShadowOffset),
+      debugStringConvertibleItem("textShadowRadius", textShadowRadius),
+      debugStringConvertibleItem("textShadowColor", textShadowColor),
+
+      // Special
+      debugStringConvertibleItem("isHighlighted", isHighlighted),
+      debugStringConvertibleItem("layoutDirection", layoutDirection),
+  };
+}
+#endif
+
+} // namespace react
+} // namespace facebook

node_modules/react-native/ReactCommon/fabric/attributedstring/TextAttributes.h

@@ -0,0 +1,133 @@
+/*
+ * Copyright (c) Facebook, Inc. and its 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 <functional>
+#include <limits>
+
+#include <folly/Hash.h>
+#include <folly/Optional.h>
+#include <react/attributedstring/primitives.h>
+#include <react/core/LayoutPrimitives.h>
+#include <react/core/ReactPrimitives.h>
+#include <react/debug/DebugStringConvertible.h>
+#include <react/graphics/Color.h>
+#include <react/graphics/Geometry.h>
+
+namespace facebook {
+namespace react {
+
+class TextAttributes;
+
+using SharedTextAttributes = std::shared_ptr<const TextAttributes>;
+
+class TextAttributes : public DebugStringConvertible {
+ public:
+  /*
+   * Returns TextAttribute object which has actual default attribute values
+   * (e.g. `foregroundColor = black`), in oppose to TextAttribute's default
+   * constructor which creates an object with nulled attributes.
+   */
+  static TextAttributes defaultTextAttributes();
+
+#pragma mark - Fields
+
+  // Color
+  SharedColor foregroundColor{};
+  SharedColor backgroundColor{};
+  Float opacity{std::numeric_limits<Float>::quiet_NaN()};
+
+  // Font
+  std::string fontFamily{""};
+  Float fontSize{std::numeric_limits<Float>::quiet_NaN()};
+  Float fontSizeMultiplier{std::numeric_limits<Float>::quiet_NaN()};
+  folly::Optional<FontWeight> fontWeight{};
+  folly::Optional<FontStyle> fontStyle{};
+  folly::Optional<FontVariant> fontVariant{};
+  folly::Optional<bool> allowFontScaling{};
+  Float letterSpacing{std::numeric_limits<Float>::quiet_NaN()};
+
+  // Paragraph Styles
+  Float lineHeight{std::numeric_limits<Float>::quiet_NaN()};
+  folly::Optional<TextAlignment> alignment{};
+  folly::Optional<WritingDirection> baseWritingDirection{};
+
+  // Decoration
+  SharedColor textDecorationColor{};
+  folly::Optional<TextDecorationLineType> textDecorationLineType{};
+  folly::Optional<TextDecorationLineStyle> textDecorationLineStyle{};
+  folly::Optional<TextDecorationLinePattern> textDecorationLinePattern{};
+
+  // Shadow
+  // TODO: Use `Point` type instead of `Size` for `textShadowOffset` attribute.
+  folly::Optional<Size> textShadowOffset{};
+  Float textShadowRadius{std::numeric_limits<Float>::quiet_NaN()};
+  SharedColor textShadowColor{};
+
+  // Special
+  folly::Optional<bool> isHighlighted{};
+
+  // TODO T59221129: document where this value comes from and how it is set.
+  // It's not clear if this is being used properly, or if it's being set at all.
+  // Currently, it is intentionally *not* being set as part of BaseTextProps
+  // construction.
+  folly::Optional<LayoutDirection> layoutDirection{};
+
+#pragma mark - Operations
+
+  void apply(TextAttributes textAttributes);
+
+#pragma mark - Operators
+
+  bool operator==(const TextAttributes &rhs) const;
+  bool operator!=(const TextAttributes &rhs) const;
+
+#pragma mark - DebugStringConvertible
+
+#if RN_DEBUG_STRING_CONVERTIBLE
+  SharedDebugStringConvertibleList getDebugProps() const override;
+#endif
+};
+
+} // namespace react
+} // namespace facebook
+
+namespace std {
+
+template <>
+struct hash<facebook::react::TextAttributes> {
+  size_t operator()(
+      const facebook::react::TextAttributes &textAttributes) const {
+    return folly::hash::hash_combine(
+        0,
+        textAttributes.foregroundColor,
+        textAttributes.backgroundColor,
+        textAttributes.opacity,
+        textAttributes.fontFamily,
+        textAttributes.fontSize,
+        textAttributes.fontSizeMultiplier,
+        textAttributes.fontWeight,
+        textAttributes.fontStyle,
+        textAttributes.fontVariant,
+        textAttributes.allowFontScaling,
+        textAttributes.letterSpacing,
+        textAttributes.lineHeight,
+        textAttributes.alignment,
+        textAttributes.baseWritingDirection,
+        textAttributes.textDecorationColor,
+        textAttributes.textDecorationLineType,
+        textAttributes.textDecorationLineStyle,
+        textAttributes.textDecorationLinePattern,
+        textAttributes.textShadowOffset,
+        textAttributes.textShadowRadius,
+        textAttributes.textShadowColor,
+        textAttributes.isHighlighted,
+        textAttributes.layoutDirection);
+  }
+};
+} // namespace std

node_modules/react-native/ReactCommon/fabric/attributedstring/conversions.h

@@ -0,0 +1,631 @@
+/*
+ * Copyright (c) Facebook, Inc. and its 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 <folly/Conv.h>
+#include <folly/dynamic.h>
+#include <react/attributedstring/AttributedString.h>
+#include <react/attributedstring/ParagraphAttributes.h>
+#include <react/attributedstring/TextAttributes.h>
+#include <react/attributedstring/conversions.h>
+#include <react/attributedstring/primitives.h>
+#include <react/core/LayoutableShadowNode.h>
+#include <react/core/ShadowNode.h>
+#include <react/core/conversions.h>
+#include <react/core/propsConversions.h>
+#include <react/graphics/Geometry.h>
+#include <react/graphics/conversions.h>
+#include <cmath>
+
+#include <glog/logging.h>
+
+namespace facebook {
+namespace react {
+
+inline std::string toString(const EllipsizeMode &ellipsisMode) {
+  switch (ellipsisMode) {
+    case EllipsizeMode::Clip:
+      return "clip";
+    case EllipsizeMode::Head:
+      return "head";
+    case EllipsizeMode::Tail:
+      return "tail";
+    case EllipsizeMode::Middle:
+      return "middle";
+  }
+}
+
+inline void fromRawValue(const RawValue &value, EllipsizeMode &result) {
+  auto string = (std::string)value;
+  if (string == "clip") {
+    result = EllipsizeMode::Clip;
+    return;
+  }
+  if (string == "head") {
+    result = EllipsizeMode::Head;
+    return;
+  }
+  if (string == "tail") {
+    result = EllipsizeMode::Tail;
+    return;
+  }
+  if (string == "middle") {
+    result = EllipsizeMode::Middle;
+    return;
+  }
+  abort();
+}
+
+inline std::string toString(const TextBreakStrategy &textBreakStrategy) {
+  switch (textBreakStrategy) {
+    case TextBreakStrategy::Simple:
+      return "simple";
+    case TextBreakStrategy::HighQuality:
+      return "highQuality";
+    case TextBreakStrategy::Balanced:
+      return "balanced";
+  }
+}
+
+inline void fromRawValue(const RawValue &value, TextBreakStrategy &result) {
+  auto string = (std::string)value;
+  if (string == "simple") {
+    result = TextBreakStrategy::Simple;
+    return;
+  }
+  if (string == "highQuality") {
+    result = TextBreakStrategy::HighQuality;
+    return;
+  }
+  if (string == "balanced") {
+    result = TextBreakStrategy::Balanced;
+    return;
+  }
+  abort();
+}
+
+inline void fromRawValue(const RawValue &value, FontWeight &result) {
+  auto string = (std::string)value;
+  if (string == "normal") {
+    result = FontWeight::Regular;
+    return;
+  }
+  if (string == "regular") {
+    result = FontWeight::Regular;
+    return;
+  }
+  if (string == "bold") {
+    result = FontWeight::Bold;
+    return;
+  }
+  if (string == "100") {
+    result = FontWeight::Weight100;
+    return;
+  }
+  if (string == "200") {
+    result = FontWeight::Weight200;
+    return;
+  }
+  if (string == "300") {
+    result = FontWeight::Weight300;
+    return;
+  }
+  if (string == "400") {
+    result = FontWeight::Weight400;
+    return;
+  }
+  if (string == "500") {
+    result = FontWeight::Weight500;
+    return;
+  }
+  if (string == "600") {
+    result = FontWeight::Weight600;
+    return;
+  }
+  if (string == "700") {
+    result = FontWeight::Weight700;
+    return;
+  }
+  if (string == "800") {
+    result = FontWeight::Weight800;
+    return;
+  }
+  if (string == "900") {
+    result = FontWeight::Weight900;
+    return;
+  }
+  abort();
+}
+
+inline std::string toString(const FontWeight &fontWeight) {
+  return folly::to<std::string>((int)fontWeight);
+}
+
+inline void fromRawValue(const RawValue &value, FontStyle &result) {
+  auto string = (std::string)value;
+  if (string == "normal") {
+    result = FontStyle::Normal;
+    return;
+  }
+  if (string == "italic") {
+    result = FontStyle::Italic;
+    return;
+  }
+  if (string == "oblique") {
+    result = FontStyle::Oblique;
+    return;
+  }
+  abort();
+}
+
+inline std::string toString(const FontStyle &fontStyle) {
+  switch (fontStyle) {
+    case FontStyle::Normal:
+      return "normal";
+    case FontStyle::Italic:
+      return "italic";
+    case FontStyle::Oblique:
+      return "oblique";
+  }
+}
+
+inline void fromRawValue(const RawValue &value, FontVariant &result) {
+  assert(value.hasType<std::vector<std::string>>());
+  result = FontVariant::Default;
+  auto items = std::vector<std::string>{value};
+  for (const auto &item : items) {
+    if (item == "small-caps") {
+      result = (FontVariant)((int)result | (int)FontVariant::SmallCaps);
+      continue;
+    }
+    if (item == "oldstyle-nums") {
+      result = (FontVariant)((int)result | (int)FontVariant::OldstyleNums);
+      continue;
+    }
+    if (item == "lining-nums") {
+      result = (FontVariant)((int)result | (int)FontVariant::LiningNums);
+      continue;
+    }
+    if (item == "tabular-nums") {
+      result = (FontVariant)((int)result | (int)FontVariant::TabularNums);
+      continue;
+    }
+    if (item == "proportional-nums") {
+      result = (FontVariant)((int)result | (int)FontVariant::ProportionalNums);
+      continue;
+    }
+  }
+}
+
+inline std::string toString(const FontVariant &fontVariant) {
+  auto result = std::string{};
+  auto separator = std::string{", "};
+  if ((int)fontVariant & (int)FontVariant::SmallCaps) {
+    result += "small-caps" + separator;
+  }
+  if ((int)fontVariant & (int)FontVariant::OldstyleNums) {
+    result += "oldstyle-nums" + separator;
+  }
+  if ((int)fontVariant & (int)FontVariant::LiningNums) {
+    result += "lining-nums" + separator;
+  }
+  if ((int)fontVariant & (int)FontVariant::TabularNums) {
+    result += "tabular-nums" + separator;
+  }
+  if ((int)fontVariant & (int)FontVariant::ProportionalNums) {
+    result += "proportional-nums" + separator;
+  }
+
+  if (!result.empty()) {
+    result.erase(result.length() - separator.length());
+  }
+
+  return result;
+}
+
+inline void fromRawValue(const RawValue &value, TextAlignment &result) {
+  auto string = (std::string)value;
+  if (string == "auto") {
+    result = TextAlignment::Natural;
+    return;
+  }
+  if (string == "left") {
+    result = TextAlignment::Left;
+    return;
+  }
+  if (string == "center") {
+    result = TextAlignment::Center;
+    return;
+  }
+  if (string == "right") {
+    result = TextAlignment::Right;
+    return;
+  }
+  if (string == "justify") {
+    result = TextAlignment::Justified;
+    return;
+  }
+  abort();
+}
+
+inline std::string toString(const TextAlignment &textAlignment) {
+  switch (textAlignment) {
+    case TextAlignment::Natural:
+      return "natural";
+    case TextAlignment::Left:
+      return "left";
+    case TextAlignment::Center:
+      return "center";
+    case TextAlignment::Right:
+      return "right";
+    case TextAlignment::Justified:
+      return "justified";
+  }
+}
+
+inline void fromRawValue(const RawValue &value, WritingDirection &result) {
+  auto string = (std::string)value;
+  if (string == "natural") {
+    result = WritingDirection::Natural;
+    return;
+  }
+  if (string == "ltr") {
+    result = WritingDirection::LeftToRight;
+    return;
+  }
+  if (string == "rtl") {
+    result = WritingDirection::RightToLeft;
+    return;
+  }
+  abort();
+}
+
+inline std::string toString(const WritingDirection &writingDirection) {
+  switch (writingDirection) {
+    case WritingDirection::Natural:
+      return "natural";
+    case WritingDirection::LeftToRight:
+      return "ltr";
+    case WritingDirection::RightToLeft:
+      return "rtl";
+  }
+}
+
+inline void fromRawValue(
+    const RawValue &value,
+    TextDecorationLineType &result) {
+  auto string = (std::string)value;
+  if (string == "none") {
+    result = TextDecorationLineType::None;
+    return;
+  }
+  if (string == "underline") {
+    result = TextDecorationLineType::Underline;
+    return;
+  }
+
+  // TODO: remove "line-through" after deprecation
+  if (string == "strikethrough" || string == "line-through") {
+    result = TextDecorationLineType::Strikethrough;
+    return;
+  }
+
+  // TODO: remove "underline line-through" after "line-through" deprecation
+  if (string == "underline-strikethrough" ||
+      string == "underline line-through") {
+    result = TextDecorationLineType::UnderlineStrikethrough;
+    return;
+  }
+  abort();
+}
+
+inline std::string toString(
+    const TextDecorationLineType &textDecorationLineType) {
+  switch (textDecorationLineType) {
+    case TextDecorationLineType::None:
+      return "none";
+    case TextDecorationLineType::Underline:
+      return "underline";
+    case TextDecorationLineType::Strikethrough:
+      return "strikethrough";
+    case TextDecorationLineType::UnderlineStrikethrough:
+      return "underline-strikethrough";
+  }
+}
+
+inline void fromRawValue(
+    const RawValue &value,
+    TextDecorationLineStyle &result) {
+  auto string = (std::string)value;
+  if (string == "single") {
+    result = TextDecorationLineStyle::Single;
+    return;
+  }
+  if (string == "thick") {
+    result = TextDecorationLineStyle::Thick;
+    return;
+  }
+  if (string == "double") {
+    result = TextDecorationLineStyle::Double;
+    return;
+  }
+  abort();
+}
+
+inline std::string toString(
+    const TextDecorationLineStyle &textDecorationLineStyle) {
+  switch (textDecorationLineStyle) {
+    case TextDecorationLineStyle::Single:
+      return "single";
+    case TextDecorationLineStyle::Thick:
+      return "thick";
+    case TextDecorationLineStyle::Double:
+      return "double";
+  }
+}
+
+inline void fromRawValue(
+    const RawValue &value,
+    TextDecorationLinePattern &result) {
+  auto string = (std::string)value;
+  if (string == "solid") {
+    result = TextDecorationLinePattern::Solid;
+    return;
+  }
+  if (string == "dot") {
+    result = TextDecorationLinePattern::Dot;
+    return;
+  }
+  if (string == "dash") {
+    result = TextDecorationLinePattern::Dash;
+    return;
+  }
+  if (string == "dash-dot") {
+    result = TextDecorationLinePattern::DashDot;
+    return;
+  }
+  if (string == "dash-dot-dot") {
+    result = TextDecorationLinePattern::DashDotDot;
+    return;
+  }
+  abort();
+}
+
+inline std::string toString(
+    const TextDecorationLinePattern &textDecorationLinePattern) {
+  switch (textDecorationLinePattern) {
+    case TextDecorationLinePattern::Solid:
+      return "solid";
+    case TextDecorationLinePattern::Dot:
+      return "dot";
+    case TextDecorationLinePattern::Dash:
+      return "dash";
+    case TextDecorationLinePattern::DashDot:
+      return "dash-dot";
+    case TextDecorationLinePattern::DashDotDot:
+      return "dash-dot-dot";
+  }
+}
+
+inline ParagraphAttributes convertRawProp(
+    RawProps const &rawProps,
+    ParagraphAttributes const &sourceParagraphAttributes,
+    ParagraphAttributes const &defaultParagraphAttributes) {
+  auto paragraphAttributes = ParagraphAttributes{};
+
+  paragraphAttributes.maximumNumberOfLines = convertRawProp(
+      rawProps,
+      "numberOfLines",
+      sourceParagraphAttributes.maximumNumberOfLines,
+      defaultParagraphAttributes.maximumNumberOfLines);
+  paragraphAttributes.ellipsizeMode = convertRawProp(
+      rawProps,
+      "ellipsizeMode",
+      sourceParagraphAttributes.ellipsizeMode,
+      defaultParagraphAttributes.ellipsizeMode);
+  paragraphAttributes.textBreakStrategy = convertRawProp(
+      rawProps,
+      "textBreakStrategy",
+      sourceParagraphAttributes.textBreakStrategy,
+      defaultParagraphAttributes.textBreakStrategy);
+  paragraphAttributes.adjustsFontSizeToFit = convertRawProp(
+      rawProps,
+      "adjustsFontSizeToFit",
+      sourceParagraphAttributes.adjustsFontSizeToFit,
+      defaultParagraphAttributes.adjustsFontSizeToFit);
+  paragraphAttributes.minimumFontSize = convertRawProp(
+      rawProps,
+      "minimumFontSize",
+      sourceParagraphAttributes.minimumFontSize,
+      defaultParagraphAttributes.minimumFontSize);
+  paragraphAttributes.maximumFontSize = convertRawProp(
+      rawProps,
+      "maximumFontSize",
+      sourceParagraphAttributes.maximumFontSize,
+      defaultParagraphAttributes.maximumFontSize);
+
+  return paragraphAttributes;
+}
+
+inline void fromRawValue(
+    RawValue const &value,
+    AttributedString::Range &result) {
+  auto map = (better::map<std::string, int>)value;
+
+  auto start = map.find("start");
+  if (start != map.end()) {
+    result.location = start->second;
+  }
+  auto end = map.find("end");
+  if (end != map.end()) {
+    result.length = start->second - result.location;
+  }
+}
+
+inline std::string toString(AttributedString::Range const &range) {
+  return "{location: " + folly::to<std::string>(range.location) +
+      ", length: " + folly::to<std::string>(range.length) + "}";
+}
+
+#ifdef ANDROID
+
+inline folly::dynamic toDynamic(
+    const ParagraphAttributes &paragraphAttributes) {
+  auto values = folly::dynamic::object();
+  values("maximumNumberOfLines", paragraphAttributes.maximumNumberOfLines);
+  values("ellipsizeMode", toString(paragraphAttributes.ellipsizeMode));
+  values("textBreakStrategy", toString(paragraphAttributes.textBreakStrategy));
+  values("adjustsFontSizeToFit", paragraphAttributes.adjustsFontSizeToFit);
+  return values;
+}
+
+inline folly::dynamic toDynamic(const FontVariant &fontVariant) {
+  auto result = folly::dynamic::array();
+  if ((int)fontVariant & (int)FontVariant::SmallCaps) {
+    result.push_back("small-caps");
+  }
+  if ((int)fontVariant & (int)FontVariant::OldstyleNums) {
+    result.push_back("oldstyle-nums");
+  }
+  if ((int)fontVariant & (int)FontVariant::LiningNums) {
+    result.push_back("lining-nums");
+  }
+  if ((int)fontVariant & (int)FontVariant::TabularNums) {
+    result.push_back("tabular-nums");
+  }
+  if ((int)fontVariant & (int)FontVariant::ProportionalNums) {
+    result.push_back("proportional-nums");
+  }
+
+  return result;
+}
+
+inline folly::dynamic toDynamic(const TextAttributes &textAttributes) {
+  auto _textAttributes = folly::dynamic::object();
+  if (textAttributes.foregroundColor) {
+    _textAttributes(
+        "foregroundColor", toDynamic(textAttributes.foregroundColor));
+  }
+  if (textAttributes.backgroundColor) {
+    _textAttributes(
+        "backgroundColor", toDynamic(textAttributes.backgroundColor));
+  }
+  if (!std::isnan(textAttributes.opacity)) {
+    _textAttributes("opacity", textAttributes.opacity);
+  }
+  if (!textAttributes.fontFamily.empty()) {
+    _textAttributes("fontFamily", textAttributes.fontFamily);
+  }
+  if (!std::isnan(textAttributes.fontSize)) {
+    _textAttributes("fontSize", textAttributes.fontSize);
+  }
+  if (!std::isnan(textAttributes.fontSizeMultiplier)) {
+    _textAttributes("fontSizeMultiplier", textAttributes.fontSizeMultiplier);
+  }
+  if (textAttributes.fontWeight.has_value()) {
+    _textAttributes("fontWeight", toString(*textAttributes.fontWeight));
+  }
+  if (textAttributes.fontStyle.has_value()) {
+    _textAttributes("fontStyle", toString(*textAttributes.fontStyle));
+  }
+  if (textAttributes.fontVariant.has_value()) {
+    _textAttributes("fontVariant", toDynamic(*textAttributes.fontVariant));
+  }
+  if (textAttributes.allowFontScaling.has_value()) {
+    _textAttributes("allowFontScaling", *textAttributes.allowFontScaling);
+  }
+  if (!std::isnan(textAttributes.letterSpacing)) {
+    _textAttributes("letterSpacing", textAttributes.letterSpacing);
+  }
+  if (!std::isnan(textAttributes.lineHeight)) {
+    _textAttributes("lineHeight", textAttributes.lineHeight);
+  }
+  if (textAttributes.alignment.has_value()) {
+    _textAttributes("alignment", toString(*textAttributes.alignment));
+  }
+  if (textAttributes.baseWritingDirection.has_value()) {
+    _textAttributes(
+        "baseWritingDirection", toString(*textAttributes.baseWritingDirection));
+  }
+  // Decoration
+  if (textAttributes.textDecorationColor) {
+    _textAttributes(
+        "textDecorationColor", toDynamic(textAttributes.textDecorationColor));
+  }
+  if (textAttributes.textDecorationLineType.has_value()) {
+    _textAttributes(
+        "textDecorationLine", toString(*textAttributes.textDecorationLineType));
+  }
+  if (textAttributes.textDecorationLineStyle.has_value()) {
+    _textAttributes(
+        "textDecorationLineStyle",
+        toString(*textAttributes.textDecorationLineStyle));
+  }
+  if (textAttributes.textDecorationLinePattern.has_value()) {
+    _textAttributes(
+        "textDecorationLinePattern",
+        toString(*textAttributes.textDecorationLinePattern));
+  }
+  // Shadow
+  // textShadowOffset = textAttributes.textShadowOffset.has_value() ?
+  // textAttributes.textShadowOffset.value() : textShadowOffset;
+  if (!std::isnan(textAttributes.textShadowRadius)) {
+    _textAttributes("textShadowRadius", textAttributes.textShadowRadius);
+  }
+  if (textAttributes.textShadowColor) {
+    _textAttributes(
+        "textShadowColor", toDynamic(textAttributes.textShadowColor));
+  }
+  // Special
+  if (textAttributes.isHighlighted.has_value()) {
+    _textAttributes("isHighlighted", *textAttributes.isHighlighted);
+  }
+  if (textAttributes.layoutDirection.has_value()) {
+    _textAttributes(
+        "layoutDirection", toString(*textAttributes.layoutDirection));
+  }
+  return _textAttributes;
+}
+
+inline folly::dynamic toDynamic(const AttributedString &attributedString) {
+  auto value = folly::dynamic::object();
+  auto fragments = folly::dynamic::array();
+  for (auto fragment : attributedString.getFragments()) {
+    folly::dynamic dynamicFragment = folly::dynamic::object();
+    dynamicFragment["string"] = fragment.string;
+    if (fragment.parentShadowView.componentHandle) {
+      dynamicFragment["reactTag"] = fragment.parentShadowView.tag;
+    }
+    if (fragment.isAttachment()) {
+      dynamicFragment["isAttachment"] = true;
+      dynamicFragment["width"] =
+          (int)fragment.parentShadowView.layoutMetrics.frame.size.width;
+      dynamicFragment["height"] =
+          (int)fragment.parentShadowView.layoutMetrics.frame.size.height;
+    }
+    dynamicFragment["textAttributes"] = toDynamic(fragment.textAttributes);
+    fragments.push_back(dynamicFragment);
+  }
+  value("fragments", fragments);
+  value(
+      "hash", std::hash<facebook::react::AttributedString>{}(attributedString));
+  value("string", attributedString.getString());
+  return value;
+}
+
+inline folly::dynamic toDynamic(AttributedString::Range const &range) {
+  folly::dynamic dynamicValue = folly::dynamic::object();
+  dynamicValue["location"] = range.location;
+  dynamicValue["length"] = range.length;
+  return dynamicValue;
+}
+
+#endif
+
+} // namespace react
+} // namespace facebook

node_modules/react-native/ReactCommon/fabric/attributedstring/primitives.h

@@ -0,0 +1,163 @@
+/*
+ * Copyright (c) Facebook, Inc. and its 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 <functional>
+#include <limits>
+
+namespace facebook {
+namespace react {
+
+enum class FontStyle { Normal, Italic, Oblique };
+
+enum class FontWeight : int {
+  Weight100 = 100,
+  UltraLight = 100,
+  Weight200 = 200,
+  Thin = 200,
+  Weight300 = 300,
+  Light = 300,
+  Weight400 = 400,
+  Regular = 400,
+  Weight500 = 500,
+  Medium = 500,
+  Weight600 = 600,
+  Semibold = 600,
+  Demibold = 600,
+  Weight700 = 700,
+  Bold = 700,
+  Weight800 = 800,
+  Heavy = 800,
+  Weight900 = 900,
+  Black = 900
+};
+
+enum class FontVariant : int {
+  Default = 0,
+  SmallCaps = 1 << 1,
+  OldstyleNums = 1 << 2,
+  LiningNums = 1 << 3,
+  TabularNums = 1 << 4,
+  ProportionalNums = 1 << 5
+};
+
+enum class EllipsizeMode {
+  Clip, // Do not add ellipsize, simply clip.
+  Head, // Truncate at head of line: "...wxyz".
+  Tail, // Truncate at tail of line: "abcd...".
+  Middle // Truncate middle of line: "ab...yz".
+};
+
+enum class TextBreakStrategy { Simple, Balanced, HighQuality };
+
+enum class TextAlignment {
+  Natural, // Indicates the default alignment for script.
+  Left, // Visually left aligned.
+  Center, // Visually centered.
+  Right, // Visually right aligned.
+  Justified // Fully-justified. The last line in a paragraph is natural-aligned.
+};
+
+enum class WritingDirection {
+  Natural, // Determines direction using the Unicode Bidi Algorithm rules P2 and
+           // P3.
+  LeftToRight, // Left to right writing direction.
+  RightToLeft // Right to left writing direction.
+};
+
+enum class TextDecorationLineType {
+  None,
+  Underline,
+  Strikethrough,
+  UnderlineStrikethrough
+};
+
+enum class TextDecorationLineStyle { Single, Thick, Double };
+
+enum class TextDecorationLinePattern {
+  Solid,
+  Dot,
+  Dash,
+  DashDot,
+  DashDotDot,
+};
+
+} // namespace react
+} // namespace facebook
+
+namespace std {
+template <>
+struct hash<facebook::react::FontVariant> {
+  size_t operator()(const facebook::react::FontVariant &v) const {
+    return hash<int>()(static_cast<int>(v));
+  }
+};
+
+template <>
+struct hash<facebook::react::TextAlignment> {
+  size_t operator()(const facebook::react::TextAlignment &v) const {
+    return hash<int>()(static_cast<int>(v));
+  }
+};
+
+template <>
+struct hash<facebook::react::FontStyle> {
+  size_t operator()(const facebook::react::FontStyle &v) const {
+    return hash<int>()(static_cast<int>(v));
+  }
+};
+
+template <>
+struct hash<facebook::react::TextDecorationLineType> {
+  size_t operator()(const facebook::react::TextDecorationLineType &v) const {
+    return hash<int>()(static_cast<int>(v));
+  }
+};
+
+template <>
+struct hash<facebook::react::WritingDirection> {
+  size_t operator()(const facebook::react::WritingDirection &v) const {
+    return hash<int>()(static_cast<int>(v));
+  }
+};
+
+template <>
+struct hash<facebook::react::TextDecorationLinePattern> {
+  size_t operator()(const facebook::react::TextDecorationLinePattern &v) const {
+    return hash<int>()(static_cast<int>(v));
+  }
+};
+
+template <>
+struct hash<facebook::react::TextDecorationLineStyle> {
+  size_t operator()(const facebook::react::TextDecorationLineStyle &v) const {
+    return hash<int>()(static_cast<int>(v));
+  }
+};
+
+template <>
+struct hash<facebook::react::FontWeight> {
+  size_t operator()(const facebook::react::FontWeight &v) const {
+    return hash<int>()(static_cast<int>(v));
+  }
+};
+
+template <>
+struct hash<facebook::react::EllipsizeMode> {
+  size_t operator()(const facebook::react::EllipsizeMode &v) const {
+    return hash<int>()(static_cast<int>(v));
+  }
+};
+
+template <>
+struct hash<facebook::react::TextBreakStrategy> {
+  size_t operator()(const facebook::react::TextBreakStrategy &v) const {
+    return hash<int>()(static_cast<int>(v));
+  }
+};
+} // namespace std

node_modules/react-native/ReactCommon/fabric/attributedstring/tests/AttributedStringTest.cpp

@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include <memory>
+
+#include <assert.h>
+#include <gtest/gtest.h>
+#include <react/attributedstring/TextAttributes.h>
+#include <react/attributedstring/conversions.h>
+#include <react/attributedstring/primitives.h>
+#include <react/graphics/conversions.h>
+
+namespace facebook {
+namespace react {
+
+#ifdef ANDROID
+
+TEST(AttributedStringTest, testToDynamic) {
+  auto attString = new AttributedString();
+  auto fragment = new AttributedString::Fragment();
+  fragment->string = "test";
+
+  auto text = new TextAttributes();
+  text->foregroundColor = {
+      colorFromComponents({100 / 255.0, 153 / 255.0, 200 / 255.0, 1.0})};
+  text->opacity = 0.5;
+  text->fontStyle = FontStyle::Italic;
+  text->fontWeight = FontWeight::Thin;
+  text->fontVariant = FontVariant::TabularNums;
+  fragment->textAttributes = *text;
+
+  attString->prependFragment(*fragment);
+
+  auto result = toDynamic(*attString);
+  assert(result["string"] == fragment->string);
+  auto textAttribute = result["fragments"][0]["textAttributes"];
+  assert(textAttribute["foregroundColor"] == toDynamic(text->foregroundColor));
+  assert(textAttribute["opacity"] == text->opacity);
+  assert(textAttribute["fontStyle"] == toString(*text->fontStyle));
+  assert(textAttribute["fontWeight"] == toString(*text->fontWeight));
+}
+
+#endif
+
+} // namespace react
+} // namespace facebook

node_modules/react-native/ReactCommon/fabric/attributedstring/tests/ParagraphAttributesTest.cpp

@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include <memory>
+
+#include <assert.h>
+#include <gtest/gtest.h>
+#include <react/attributedstring/ParagraphAttributes.h>
+#include <react/attributedstring/conversions.h>
+#include <react/attributedstring/primitives.h>
+
+namespace facebook {
+namespace react {
+
+#ifdef ANDROID
+
+TEST(ParagraphAttributesTest, testToDynamic) {
+  auto paragraphAttributes = ParagraphAttributes();
+  paragraphAttributes.maximumNumberOfLines = 2;
+  paragraphAttributes.adjustsFontSizeToFit = false;
+  paragraphAttributes.ellipsizeMode = EllipsizeMode::Middle;
+
+  auto result = toDynamic(paragraphAttributes);
+  assert(
+      result["maximumNumberOfLines"] ==
+      paragraphAttributes.maximumNumberOfLines);
+  assert(
+      result["adjustsFontSizeToFit"] ==
+      paragraphAttributes.adjustsFontSizeToFit);
+  assert(
+      result["ellipsizeMode"] == toString(paragraphAttributes.ellipsizeMode));
+}
+
+#endif
+
+} // namespace react
+} // namespace facebook

node_modules/react-native/ReactCommon/fabric/attributedstring/tests/TextAttributesTest.cpp

@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include <memory>
+
+#include <assert.h>
+#include <gtest/gtest.h>
+#include <react/attributedstring/TextAttributes.h>
+#include <react/attributedstring/conversions.h>
+#include <react/attributedstring/primitives.h>
+#include <react/graphics/conversions.h>
+
+namespace facebook {
+namespace react {
+
+#ifdef ANDROID
+
+TEST(TextAttributesTest, testToDynamic) {
+  auto text = TextAttributes();
+  text.foregroundColor = {
+      colorFromComponents({200 / 255.0, 153 / 255.0, 100 / 255.0, 1.0})};
+  text.opacity = 0.5;
+  text.fontStyle = FontStyle::Italic;
+  text.fontWeight = FontWeight::Thin;
+  text.fontVariant = FontVariant::TabularNums;
+
+  auto result = toDynamic(text);
+  assert(result["foregroundColor"] == toDynamic(text.foregroundColor));
+  assert(result["opacity"] == text.opacity);
+  assert(result["fontStyle"] == toString(*text.fontStyle));
+  assert(result["fontWeight"] == toString(*text.fontWeight));
+}
+
+#endif
+
+} // namespace react
+} // namespace facebook