react-native 0.0.0-201c10733 → 0.0.0-268efb102

package/ReactCommon/react/renderer/attributedstring/conversions.h

@@ -9,12 +9,14 @@
 
 #include <folly/Conv.h>
 #include <folly/dynamic.h>
+#include <react/debug/react_native_assert.h>
 #include <react/renderer/attributedstring/AttributedString.h>
 #include <react/renderer/attributedstring/ParagraphAttributes.h>
 #include <react/renderer/attributedstring/TextAttributes.h>
 #include <react/renderer/attributedstring/conversions.h>
 #include <react/renderer/attributedstring/primitives.h>
 #include <react/renderer/core/LayoutableShadowNode.h>
+#include <react/renderer/core/PropsParserContext.h>
 #include <react/renderer/core/ShadowNode.h>
 #include <react/renderer/core/conversions.h>
 #include <react/renderer/core/propsConversions.h>
@@ -22,6 +24,11 @@
 #include <react/renderer/graphics/conversions.h>
 #include <cmath>
 
+#ifdef ANDROID
+#include <react/renderer/mapbuffer/MapBuffer.h>
+#include <react/renderer/mapbuffer/MapBufferBuilder.h>
+#endif
+
 #include <glog/logging.h>
 
 namespace facebook {
@@ -38,27 +45,43 @@ inline std::string toString(const EllipsizeMode &ellipsisMode) {
     case EllipsizeMode::Middle:
       return "middle";
   }
+
+  LOG(ERROR) << "Unsupported EllipsizeMode value";
+  react_native_assert(false);
+
+  // Sane default in case of parsing errors
+  return "tail";
 }
 
-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;
+inline void fromRawValue(
+    const PropsParserContext &context,
+    const RawValue &value,
+    EllipsizeMode &result) {
+  react_native_assert(value.hasType<std::string>());
+  if (value.hasType<std::string>()) {
+    auto string = (std::string)value;
+    if (string == "clip") {
+      result = EllipsizeMode::Clip;
+    } else if (string == "head") {
+      result = EllipsizeMode::Head;
+    } else if (string == "tail") {
+      result = EllipsizeMode::Tail;
+    } else if (string == "middle") {
+      result = EllipsizeMode::Middle;
+    } else {
+      // sane default
+      LOG(ERROR) << "Unsupported EllipsizeMode value: " << string;
+      react_native_assert(false);
+      result = EllipsizeMode::Tail;
+    }
     return;
   }
-  abort();
+
+  LOG(ERROR) << "Unsupported EllipsizeMode type";
+  react_native_assert(false);
+
+  // Sane default in case of parsing errors
+  result = EllipsizeMode::Tail;
 }
 
 inline std::string toString(const TextBreakStrategy &textBreakStrategy) {
@@ -70,97 +93,114 @@ inline std::string toString(const TextBreakStrategy &textBreakStrategy) {
     case TextBreakStrategy::Balanced:
       return "balanced";
   }
+
+  LOG(ERROR) << "Unsupported TextBreakStrategy value";
+  react_native_assert(false);
+  return "highQuality";
 }
 
-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;
+inline void fromRawValue(
+    const PropsParserContext &context,
+    const RawValue &value,
+    TextBreakStrategy &result) {
+  react_native_assert(value.hasType<std::string>());
+  if (value.hasType<std::string>()) {
+    auto string = (std::string)value;
+    if (string == "simple") {
+      result = TextBreakStrategy::Simple;
+    } else if (string == "highQuality") {
+      result = TextBreakStrategy::HighQuality;
+    } else if (string == "balanced") {
+      result = TextBreakStrategy::Balanced;
+    } else {
+      // sane default
+      LOG(ERROR) << "Unsupported TextBreakStrategy value: " << string;
+      react_native_assert(false);
+      result = TextBreakStrategy::HighQuality;
+    }
     return;
   }
-  abort();
+
+  LOG(ERROR) << "Unsupported TextBreakStrategy type";
+  react_native_assert(false);
+  result = TextBreakStrategy::HighQuality;
 }
 
-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;
+inline void fromRawValue(
+    const PropsParserContext &context,
+    const RawValue &value,
+    FontWeight &result) {
+  react_native_assert(value.hasType<std::string>());
+  if (value.hasType<std::string>()) {
+    auto string = (std::string)value;
+    if (string == "normal") {
+      result = FontWeight::Regular;
+    } else if (string == "regular") {
+      result = FontWeight::Regular;
+    } else if (string == "bold") {
+      result = FontWeight::Bold;
+    } else if (string == "100") {
+      result = FontWeight::Weight100;
+    } else if (string == "200") {
+      result = FontWeight::Weight200;
+    } else if (string == "300") {
+      result = FontWeight::Weight300;
+    } else if (string == "400") {
+      result = FontWeight::Weight400;
+    } else if (string == "500") {
+      result = FontWeight::Weight500;
+    } else if (string == "600") {
+      result = FontWeight::Weight600;
+    } else if (string == "700") {
+      result = FontWeight::Weight700;
+    } else if (string == "800") {
+      result = FontWeight::Weight800;
+    } else if (string == "900") {
+      result = FontWeight::Weight900;
+    } else {
+      LOG(ERROR) << "Unsupported FontWeight value: " << string;
+      react_native_assert(false);
+      // sane default for prod
+      result = FontWeight::Regular;
+    }
     return;
   }
-  abort();
+
+  LOG(ERROR) << "Unsupported FontWeight type";
+  react_native_assert(false);
+  result = FontWeight::Regular;
 }
 
 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;
+inline void fromRawValue(
+    const PropsParserContext &context,
+    const RawValue &value,
+    FontStyle &result) {
+  react_native_assert(value.hasType<std::string>());
+  if (value.hasType<std::string>()) {
+    auto string = (std::string)value;
+    if (string == "normal") {
+      result = FontStyle::Normal;
+    } else if (string == "italic") {
+      result = FontStyle::Italic;
+    } else if (string == "oblique") {
+      result = FontStyle::Oblique;
+    } else {
+      LOG(ERROR) << "Unsupported FontStyle value: " << string;
+      react_native_assert(false);
+      // sane default for prod
+      result = FontStyle::Normal;
+    }
     return;
   }
-  abort();
+
+  LOG(ERROR) << "Unsupported FontStyle type";
+  react_native_assert(false);
+  // sane default for prod
+  result = FontStyle::Normal;
 }
 
 inline std::string toString(const FontStyle &fontStyle) {
@@ -172,33 +212,41 @@ inline std::string toString(const FontStyle &fontStyle) {
     case FontStyle::Oblique:
       return "oblique";
   }
+
+  LOG(ERROR) << "Unsupported FontStyle value";
+  react_native_assert(false);
+  // sane default for prod
+  return "normal";
 }
 
-inline void fromRawValue(const RawValue &value, FontVariant &result) {
-  assert(value.hasType<std::vector<std::string>>());
+inline void fromRawValue(
+    const PropsParserContext &context,
+    const RawValue &value,
+    FontVariant &result) {
+  react_native_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);
+  if (value.hasType<std::vector<std::string>>()) {
+    auto items = std::vector<std::string>{value};
+    for (const auto &item : items) {
+      if (item == "small-caps") {
+        result = (FontVariant)((int)result | (int)FontVariant::SmallCaps);
+      } else if (item == "oldstyle-nums") {
+        result = (FontVariant)((int)result | (int)FontVariant::OldstyleNums);
+      } else if (item == "lining-nums") {
+        result = (FontVariant)((int)result | (int)FontVariant::LiningNums);
+      } else if (item == "tabular-nums") {
+        result = (FontVariant)((int)result | (int)FontVariant::TabularNums);
+      } else if (item == "proportional-nums") {
+        result =
+            (FontVariant)((int)result | (int)FontVariant::ProportionalNums);
+      } else {
+        LOG(ERROR) << "Unsupported FontVariant value: " << item;
+        react_native_assert(false);
+      }
       continue;
     }
+  } else {
+    LOG(ERROR) << "Unsupported FontVariant type";
   }
 }
 
@@ -228,35 +276,93 @@ inline std::string toString(const FontVariant &fontVariant) {
   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;
+inline void fromRawValue(
+    const PropsParserContext &context,
+    const RawValue &value,
+    TextTransform &result) {
+  react_native_assert(value.hasType<std::string>());
+  if (value.hasType<std::string>()) {
+    auto string = (std::string)value;
+    if (string == "none") {
+      result = TextTransform::None;
+    } else if (string == "uppercase") {
+      result = TextTransform::Uppercase;
+    } else if (string == "lowercase") {
+      result = TextTransform::Lowercase;
+    } else if (string == "capitalize") {
+      result = TextTransform::Capitalize;
+    } else if (string == "unset") {
+      result = TextTransform::Unset;
+    } else {
+      LOG(ERROR) << "Unsupported TextTransform value: " << string;
+      react_native_assert(false);
+      // sane default for prod
+      result = TextTransform::None;
+    }
     return;
   }
-  if (string == "right") {
-    result = TextAlignment::Right;
-    return;
+
+  LOG(ERROR) << "Unsupported TextTransform type";
+  react_native_assert(false);
+  // sane default for prod
+  result = TextTransform::None;
+}
+
+inline std::string toString(const TextTransform &textTransform) {
+  switch (textTransform) {
+    case TextTransform::None:
+      return "none";
+    case TextTransform::Uppercase:
+      return "uppercase";
+    case TextTransform::Lowercase:
+      return "lowercase";
+    case TextTransform::Capitalize:
+      return "capitalize";
+    case TextTransform::Unset:
+      return "unset";
   }
-  if (string == "justify") {
-    result = TextAlignment::Justified;
+
+  LOG(ERROR) << "Unsupported TextTransform value";
+  react_native_assert(false);
+  // sane default for prod
+  return "none";
+}
+
+inline void fromRawValue(
+    const PropsParserContext &context,
+    const RawValue &value,
+    TextAlignment &result) {
+  react_native_assert(value.hasType<std::string>());
+  if (value.hasType<std::string>()) {
+    auto string = (std::string)value;
+    if (string == "auto") {
+      result = TextAlignment::Natural;
+    } else if (string == "left") {
+      result = TextAlignment::Left;
+    } else if (string == "center") {
+      result = TextAlignment::Center;
+    } else if (string == "right") {
+      result = TextAlignment::Right;
+    } else if (string == "justify") {
+      result = TextAlignment::Justified;
+    } else {
+      LOG(ERROR) << "Unsupported TextAlignment value: " << string;
+      react_native_assert(false);
+      // sane default for prod
+      result = TextAlignment::Natural;
+    }
     return;
   }
-  abort();
+
+  LOG(ERROR) << "Unsupported TextAlignment type";
+  // sane default for prod
+  result = TextAlignment::Natural;
 }
 
 inline std::string toString(const TextAlignment &textAlignment) {
   switch (textAlignment) {
     case TextAlignment::Natural:
-      return "natural";
+      return "auto";
     case TextAlignment::Left:
       return "left";
     case TextAlignment::Center:
@@ -266,62 +372,85 @@ inline std::string toString(const TextAlignment &textAlignment) {
     case TextAlignment::Justified:
       return "justified";
   }
+
+  LOG(ERROR) << "Unsupported TextAlignment value";
+  // sane default for prod
+  return "auto";
 }
 
-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;
+inline void fromRawValue(
+    const PropsParserContext &context,
+    const RawValue &value,
+    WritingDirection &result) {
+  react_native_assert(value.hasType<std::string>());
+  if (value.hasType<std::string>()) {
+    auto string = (std::string)value;
+    if (string == "natural" || string == "auto") {
+      result = WritingDirection::Natural;
+    } else if (string == "ltr") {
+      result = WritingDirection::LeftToRight;
+    } else if (string == "rtl") {
+      result = WritingDirection::RightToLeft;
+    } else {
+      LOG(ERROR) << "Unsupported WritingDirection value: " << string;
+      react_native_assert(false);
+      // sane default for prod
+      result = WritingDirection::Natural;
+    }
     return;
   }
-  abort();
+
+  LOG(ERROR) << "Unsupported WritingDirection type";
+  // sane default for prod
+  result = WritingDirection::Natural;
 }
 
 inline std::string toString(const WritingDirection &writingDirection) {
   switch (writingDirection) {
     case WritingDirection::Natural:
-      return "natural";
+      return "auto";
     case WritingDirection::LeftToRight:
       return "ltr";
     case WritingDirection::RightToLeft:
       return "rtl";
   }
+
+  LOG(ERROR) << "Unsupported WritingDirection value";
+  // sane default for prod
+  return "auto";
 }
 
 inline void fromRawValue(
+    const PropsParserContext &context,
     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;
+  react_native_assert(value.hasType<std::string>());
+  if (value.hasType<std::string>()) {
+    auto string = (std::string)value;
+    if (string == "none") {
+      result = TextDecorationLineType::None;
+    } else if (string == "underline") {
+      result = TextDecorationLineType::Underline;
+    } else if (string == "strikethrough" || string == "line-through") {
+      // TODO: remove "line-through" after deprecation
+      result = TextDecorationLineType::Strikethrough;
+    } else if (
+        string == "underline-strikethrough" ||
+        string == "underline line-through") {
+      // TODO: remove "underline line-through" after "line-through" deprecation
+      result = TextDecorationLineType::UnderlineStrikethrough;
+    } else {
+      LOG(ERROR) << "Unsupported TextDecorationLineType value: " << string;
+      react_native_assert(false);
+      // sane default for prod
+      result = TextDecorationLineType::None;
+    }
     return;
   }
 
-  // TODO: remove "underline line-through" after "line-through" deprecation
-  if (string == "underline-strikethrough" ||
-      string == "underline line-through") {
-    result = TextDecorationLineType::UnderlineStrikethrough;
-    return;
-  }
-  abort();
+  LOG(ERROR) << "Unsupported TextDecorationLineType type";
+  // sane default for prod
+  result = TextDecorationLineType::None;
 }
 
 inline std::string toString(
@@ -336,25 +465,38 @@ inline std::string toString(
     case TextDecorationLineType::UnderlineStrikethrough:
       return "underline-strikethrough";
   }
+
+  LOG(ERROR) << "Unsupported TextDecorationLineType value";
+  react_native_assert(false);
+  // sane default for prod
+  return "none";
 }
 
 inline void fromRawValue(
+    const PropsParserContext &context,
     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;
+  react_native_assert(value.hasType<std::string>());
+  if (value.hasType<std::string>()) {
+    auto string = (std::string)value;
+    if (string == "single") {
+      result = TextDecorationLineStyle::Single;
+    } else if (string == "thick") {
+      result = TextDecorationLineStyle::Thick;
+    } else if (string == "double") {
+      result = TextDecorationLineStyle::Double;
+    } else {
+      LOG(ERROR) << "Unsupported TextDecorationLineStyle value: " << string;
+      react_native_assert(false);
+      // sane default for prod
+      result = TextDecorationLineStyle::Single;
+    }
     return;
   }
-  abort();
+
+  LOG(ERROR) << "Unsupported TextDecorationLineStyle type";
+  // sane default for prod
+  result = TextDecorationLineStyle::Single;
 }
 
 inline std::string toString(
@@ -367,33 +509,42 @@ inline std::string toString(
     case TextDecorationLineStyle::Double:
       return "double";
   }
+
+  LOG(ERROR) << "Unsupported TextDecorationLineStyle value";
+  react_native_assert(false);
+  // sane default for prod
+  return "single";
 }
 
 inline void fromRawValue(
+    const PropsParserContext &context,
     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;
+  react_native_assert(value.hasType<std::string>());
+  if (value.hasType<std::string>()) {
+    auto string = (std::string)value;
+    if (string == "solid") {
+      result = TextDecorationLinePattern::Solid;
+    } else if (string == "dot") {
+      result = TextDecorationLinePattern::Dot;
+    } else if (string == "dash") {
+      result = TextDecorationLinePattern::Dash;
+    } else if (string == "dash-dot") {
+      result = TextDecorationLinePattern::DashDot;
+    } else if (string == "dash-dot-dot") {
+      result = TextDecorationLinePattern::DashDotDot;
+    } else {
+      LOG(ERROR) << "Unsupported TextDecorationLinePattern value: " << string;
+      react_native_assert(false);
+      // sane default for prod
+      result = TextDecorationLinePattern::Solid;
+    }
     return;
   }
-  abort();
+
+  LOG(ERROR) << "Unsupported TextDecorationLineStyle type";
+  // sane default for prod
+  result = TextDecorationLinePattern::Solid;
 }
 
 inline std::string toString(
@@ -410,6 +561,11 @@ inline std::string toString(
     case TextDecorationLinePattern::DashDotDot:
       return "dash-dot-dot";
   }
+
+  LOG(ERROR) << "Unsupported TextDecorationLinePattern value";
+  react_native_assert(false);
+  // sane default for prod
+  return "solid";
 }
 
 inline std::string toString(const AccessibilityRole &accessibilityRole) {
@@ -462,6 +618,8 @@ inline std::string toString(const AccessibilityRole &accessibilityRole) {
       return "switch";
     case AccessibilityRole::Tab:
       return "tab";
+    case AccessibilityRole::TabBar:
+      return "tabbar";
     case AccessibilityRole::Tablist:
       return "tablist";
     case AccessibilityRole::Timer:
@@ -469,167 +627,194 @@ inline std::string toString(const AccessibilityRole &accessibilityRole) {
     case AccessibilityRole::Toolbar:
       return "toolbar";
   }
+
+  LOG(ERROR) << "Unsupported AccessibilityRole value";
+  react_native_assert(false);
+  // sane default for prod
+  return "none";
 }
 
-inline void fromRawValue(const RawValue &value, AccessibilityRole &result) {
-  auto string = (std::string)value;
-  if (string == "none") {
-    result = AccessibilityRole::None;
-    return;
-  }
-  if (string == "button") {
-    result = AccessibilityRole::Button;
-    return;
-  }
-  if (string == "link") {
-    result = AccessibilityRole::Link;
-    return;
-  }
-  if (string == "search") {
-    result = AccessibilityRole::Search;
-    return;
-  }
-  if (string == "image") {
-    result = AccessibilityRole::Image;
-    return;
-  }
-  if (string == "imagebutton") {
-    result = AccessibilityRole::Imagebutton;
-    return;
-  }
-  if (string == "keyboardkey") {
-    result = AccessibilityRole::Keyboardkey;
-    return;
-  }
-  if (string == "text") {
-    result = AccessibilityRole::Text;
-    return;
-  }
-  if (string == "adjustable") {
-    result = AccessibilityRole::Adjustable;
-    return;
-  }
-  if (string == "summary") {
-    result = AccessibilityRole::Summary;
-    return;
-  }
-  if (string == "header") {
-    result = AccessibilityRole::Header;
-    return;
-  }
-  if (string == "alert") {
-    result = AccessibilityRole::Alert;
-    return;
-  }
-  if (string == "checkbox") {
-    result = AccessibilityRole::Checkbox;
-    return;
-  }
-  if (string == "combobox") {
-    result = AccessibilityRole::Combobox;
-    return;
-  }
-  if (string == "menu") {
-    result = AccessibilityRole::Menu;
-    return;
-  }
-  if (string == "menubar") {
-    result = AccessibilityRole::Menubar;
-    return;
-  }
-  if (string == "menuitem") {
-    result = AccessibilityRole::Menuitem;
-    return;
-  }
-  if (string == "progressbar") {
-    result = AccessibilityRole::Progressbar;
-    return;
-  }
-  if (string == "radio") {
-    result = AccessibilityRole::Radio;
-    return;
-  }
-  if (string == "radiogroup") {
-    result = AccessibilityRole::Radiogroup;
-    return;
-  }
-  if (string == "scrollbar") {
-    result = AccessibilityRole::Scrollbar;
-    return;
-  }
-  if (string == "spinbutton") {
-    result = AccessibilityRole::Spinbutton;
-    return;
-  }
-  if (string == "switch") {
-    result = AccessibilityRole::Switch;
-    return;
-  }
-  if (string == "tab") {
-    result = AccessibilityRole::Tab;
-    return;
-  }
-  if (string == "tablist") {
-    result = AccessibilityRole::Tablist;
+inline void fromRawValue(
+    const PropsParserContext &context,
+    const RawValue &value,
+    AccessibilityRole &result) {
+  react_native_assert(value.hasType<std::string>());
+  if (value.hasType<std::string>()) {
+    auto string = (std::string)value;
+    if (string == "none") {
+      result = AccessibilityRole::None;
+    } else if (string == "button") {
+      result = AccessibilityRole::Button;
+    } else if (string == "link") {
+      result = AccessibilityRole::Link;
+    } else if (string == "search") {
+      result = AccessibilityRole::Search;
+    } else if (string == "image") {
+      result = AccessibilityRole::Image;
+    } else if (string == "imagebutton") {
+      result = AccessibilityRole::Imagebutton;
+    } else if (string == "keyboardkey") {
+      result = AccessibilityRole::Keyboardkey;
+    } else if (string == "text") {
+      result = AccessibilityRole::Text;
+    } else if (string == "adjustable") {
+      result = AccessibilityRole::Adjustable;
+    } else if (string == "summary") {
+      result = AccessibilityRole::Summary;
+    } else if (string == "header") {
+      result = AccessibilityRole::Header;
+    } else if (string == "alert") {
+      result = AccessibilityRole::Alert;
+    } else if (string == "checkbox") {
+      result = AccessibilityRole::Checkbox;
+    } else if (string == "combobox") {
+      result = AccessibilityRole::Combobox;
+    } else if (string == "menu") {
+      result = AccessibilityRole::Menu;
+    } else if (string == "menubar") {
+      result = AccessibilityRole::Menubar;
+    } else if (string == "menuitem") {
+      result = AccessibilityRole::Menuitem;
+    } else if (string == "progressbar") {
+      result = AccessibilityRole::Progressbar;
+    } else if (string == "radio") {
+      result = AccessibilityRole::Radio;
+    } else if (string == "radiogroup") {
+      result = AccessibilityRole::Radiogroup;
+    } else if (string == "scrollbar") {
+      result = AccessibilityRole::Scrollbar;
+    } else if (string == "spinbutton") {
+      result = AccessibilityRole::Spinbutton;
+    } else if (string == "switch") {
+      result = AccessibilityRole::Switch;
+    } else if (string == "tab") {
+      result = AccessibilityRole::Tab;
+    } else if (string == "tabbar") {
+      result = AccessibilityRole::TabBar;
+    } else if (string == "tablist") {
+      result = AccessibilityRole::Tablist;
+    } else if (string == "timer") {
+      result = AccessibilityRole::Timer;
+    } else if (string == "toolbar") {
+      result = AccessibilityRole::Toolbar;
+    } else {
+      LOG(ERROR) << "Unsupported AccessibilityRole value: " << string;
+      react_native_assert(false);
+      // sane default for prod
+      result = AccessibilityRole::None;
+    }
     return;
   }
-  if (string == "timer") {
-    result = AccessibilityRole::Timer;
-    return;
+
+  LOG(ERROR) << "Unsupported AccessibilityRole type";
+  react_native_assert(false);
+  // sane default for prod
+  result = AccessibilityRole::None;
+}
+
+inline std::string toString(const HyphenationFrequency &hyphenationFrequency) {
+  switch (hyphenationFrequency) {
+    case HyphenationFrequency::None:
+      return "none";
+    case HyphenationFrequency::Normal:
+      return "normal";
+    case HyphenationFrequency::Full:
+      return "full";
   }
-  if (string == "toolbar") {
-    result = AccessibilityRole::Toolbar;
+
+  LOG(ERROR) << "Unsupported HyphenationFrequency value";
+  react_native_assert(false);
+  return "none";
+}
+
+inline void fromRawValue(
+    const PropsParserContext &context,
+    const RawValue &value,
+    HyphenationFrequency &result) {
+  react_native_assert(value.hasType<std::string>());
+  if (value.hasType<std::string>()) {
+    auto string = (std::string)value;
+    if (string == "none") {
+      result = HyphenationFrequency::None;
+    } else if (string == "normal") {
+      result = HyphenationFrequency::Normal;
+    } else if (string == "full") {
+      result = HyphenationFrequency::Full;
+    } else {
+      // sane default
+      LOG(ERROR) << "Unsupported HyphenationFrequency value: " << string;
+      react_native_assert(false);
+      result = HyphenationFrequency::None;
+    }
     return;
   }
-  abort();
+
+  LOG(ERROR) << "Unsupported HyphenationFrequency type";
+  react_native_assert(false);
+  result = HyphenationFrequency::None;
 }
 
 inline ParagraphAttributes convertRawProp(
+    const PropsParserContext &context,
     RawProps const &rawProps,
     ParagraphAttributes const &sourceParagraphAttributes,
     ParagraphAttributes const &defaultParagraphAttributes) {
   auto paragraphAttributes = ParagraphAttributes{};
 
   paragraphAttributes.maximumNumberOfLines = convertRawProp(
+      context,
       rawProps,
       "numberOfLines",
       sourceParagraphAttributes.maximumNumberOfLines,
       defaultParagraphAttributes.maximumNumberOfLines);
   paragraphAttributes.ellipsizeMode = convertRawProp(
+      context,
       rawProps,
       "ellipsizeMode",
       sourceParagraphAttributes.ellipsizeMode,
       defaultParagraphAttributes.ellipsizeMode);
   paragraphAttributes.textBreakStrategy = convertRawProp(
+      context,
       rawProps,
       "textBreakStrategy",
       sourceParagraphAttributes.textBreakStrategy,
       defaultParagraphAttributes.textBreakStrategy);
   paragraphAttributes.adjustsFontSizeToFit = convertRawProp(
+      context,
       rawProps,
       "adjustsFontSizeToFit",
       sourceParagraphAttributes.adjustsFontSizeToFit,
       defaultParagraphAttributes.adjustsFontSizeToFit);
   paragraphAttributes.minimumFontSize = convertRawProp(
+      context,
       rawProps,
       "minimumFontSize",
       sourceParagraphAttributes.minimumFontSize,
       defaultParagraphAttributes.minimumFontSize);
   paragraphAttributes.maximumFontSize = convertRawProp(
+      context,
       rawProps,
       "maximumFontSize",
       sourceParagraphAttributes.maximumFontSize,
       defaultParagraphAttributes.maximumFontSize);
   paragraphAttributes.includeFontPadding = convertRawProp(
+      context,
       rawProps,
       "includeFontPadding",
       sourceParagraphAttributes.includeFontPadding,
       defaultParagraphAttributes.includeFontPadding);
+  paragraphAttributes.android_hyphenationFrequency = convertRawProp(
+      context,
+      rawProps,
+      "android_hyphenationFrequency",
+      sourceParagraphAttributes.android_hyphenationFrequency,
+      defaultParagraphAttributes.android_hyphenationFrequency);
 
   return paragraphAttributes;
 }
 
 inline void fromRawValue(
+    const PropsParserContext &context,
     RawValue const &value,
     AttributedString::Range &result) {
   auto map = (better::map<std::string, int>)value;
@@ -659,6 +844,9 @@ inline folly::dynamic toDynamic(
   values("textBreakStrategy", toString(paragraphAttributes.textBreakStrategy));
   values("adjustsFontSizeToFit", paragraphAttributes.adjustsFontSizeToFit);
   values("includeFontPadding", paragraphAttributes.includeFontPadding);
+  values(
+      "android_hyphenationFrequency",
+      toString(paragraphAttributes.android_hyphenationFrequency));
 
   return values;
 }
@@ -721,6 +909,9 @@ inline folly::dynamic toDynamic(const TextAttributes &textAttributes) {
   if (!std::isnan(textAttributes.letterSpacing)) {
     _textAttributes("letterSpacing", textAttributes.letterSpacing);
   }
+  if (textAttributes.textTransform.hasValue()) {
+    _textAttributes("textTransform", toString(*textAttributes.textTransform));
+  }
   if (!std::isnan(textAttributes.lineHeight)) {
     _textAttributes("lineHeight", textAttributes.lineHeight);
   }
@@ -808,6 +999,228 @@ inline folly::dynamic toDynamic(AttributedString::Range const &range) {
   return dynamicValue;
 }
 
+// constants for AttributedString serialization
+constexpr static Key AS_KEY_HASH = 0;
+constexpr static Key AS_KEY_STRING = 1;
+constexpr static Key AS_KEY_FRAGMENTS = 2;
+constexpr static Key AS_KEY_CACHE_ID = 3;
+
+// constants for Fragment serialization
+constexpr static Key FR_KEY_STRING = 0;
+constexpr static Key FR_KEY_REACT_TAG = 1;
+constexpr static Key FR_KEY_IS_ATTACHMENT = 2;
+constexpr static Key FR_KEY_WIDTH = 3;
+constexpr static Key FR_KEY_HEIGHT = 4;
+constexpr static Key FR_KEY_TEXT_ATTRIBUTES = 5;
+
+// constants for Text Attributes serialization
+constexpr static Key TA_KEY_FOREGROUND_COLOR = 0;
+constexpr static Key TA_KEY_BACKGROUND_COLOR = 1;
+constexpr static Key TA_KEY_OPACITY = 2;
+constexpr static Key TA_KEY_FONT_FAMILY = 3;
+constexpr static Key TA_KEY_FONT_SIZE = 4;
+constexpr static Key TA_KEY_FONT_SIZE_MULTIPLIER = 5;
+constexpr static Key TA_KEY_FONT_WEIGHT = 6;
+constexpr static Key TA_KEY_FONT_STYLE = 7;
+constexpr static Key TA_KEY_FONT_VARIANT = 8;
+constexpr static Key TA_KEY_ALLOW_FONT_SCALING = 9;
+constexpr static Key TA_KEY_LETTER_SPACING = 10;
+constexpr static Key TA_KEY_LINE_HEIGHT = 11;
+constexpr static Key TA_KEY_ALIGNMENT = 12;
+constexpr static Key TA_KEY_BEST_WRITING_DIRECTION = 13;
+constexpr static Key TA_KEY_TEXT_DECORATION_COLOR = 14;
+constexpr static Key TA_KEY_TEXT_DECORATION_LINE = 15;
+constexpr static Key TA_KEY_TEXT_DECORATION_LINE_STYLE = 16;
+constexpr static Key TA_KEY_TEXT_DECORATION_LINE_PATTERN = 17;
+constexpr static Key TA_KEY_TEXT_SHADOW_RAIDUS = 18;
+constexpr static Key TA_KEY_TEXT_SHADOW_COLOR = 19;
+constexpr static Key TA_KEY_IS_HIGHLIGHTED = 20;
+constexpr static Key TA_KEY_LAYOUT_DIRECTION = 21;
+constexpr static Key TA_KEY_ACCESSIBILITY_ROLE = 22;
+
+// constants for ParagraphAttributes serialization
+constexpr static Key PA_KEY_MAX_NUMBER_OF_LINES = 0;
+constexpr static Key PA_KEY_ELLIPSIZE_MODE = 1;
+constexpr static Key PA_KEY_TEXT_BREAK_STRATEGY = 2;
+constexpr static Key PA_KEY_ADJUST_FONT_SIZE_TO_FIT = 3;
+constexpr static Key PA_KEY_INCLUDE_FONT_PADDING = 4;
+constexpr static Key PA_KEY_HYPHENATION_FREQUENCY = 5;
+
+inline MapBuffer toMapBuffer(const ParagraphAttributes &paragraphAttributes) {
+  auto builder = MapBufferBuilder();
+  builder.putInt(
+      PA_KEY_MAX_NUMBER_OF_LINES, paragraphAttributes.maximumNumberOfLines);
+  builder.putString(
+      PA_KEY_ELLIPSIZE_MODE, toString(paragraphAttributes.ellipsizeMode));
+  builder.putString(
+      PA_KEY_TEXT_BREAK_STRATEGY,
+      toString(paragraphAttributes.textBreakStrategy));
+  builder.putBool(
+      PA_KEY_ADJUST_FONT_SIZE_TO_FIT, paragraphAttributes.adjustsFontSizeToFit);
+  builder.putBool(
+      PA_KEY_INCLUDE_FONT_PADDING, paragraphAttributes.includeFontPadding);
+  builder.putString(
+      PA_KEY_HYPHENATION_FREQUENCY,
+      toString(paragraphAttributes.android_hyphenationFrequency));
+
+  return builder.build();
+}
+
+inline MapBuffer toMapBuffer(const FontVariant &fontVariant) {
+  auto builder = MapBufferBuilder();
+  int index = 0;
+  if ((int)fontVariant & (int)FontVariant::SmallCaps) {
+    builder.putString(index++, "small-caps");
+  }
+  if ((int)fontVariant & (int)FontVariant::OldstyleNums) {
+    builder.putString(index++, "oldstyle-nums");
+  }
+  if ((int)fontVariant & (int)FontVariant::LiningNums) {
+    builder.putString(index++, "lining-nums");
+  }
+  if ((int)fontVariant & (int)FontVariant::TabularNums) {
+    builder.putString(index++, "tabular-nums");
+  }
+  if ((int)fontVariant & (int)FontVariant::ProportionalNums) {
+    builder.putString(index++, "proportional-nums");
+  }
+
+  return builder.build();
+}
+
+inline MapBuffer toMapBuffer(const TextAttributes &textAttributes) {
+  auto builder = MapBufferBuilder();
+  if (textAttributes.foregroundColor) {
+    builder.putInt(
+        TA_KEY_FOREGROUND_COLOR, toMapBuffer(textAttributes.foregroundColor));
+  }
+  if (textAttributes.backgroundColor) {
+    builder.putInt(
+        TA_KEY_BACKGROUND_COLOR, toMapBuffer(textAttributes.backgroundColor));
+  }
+  if (!std::isnan(textAttributes.opacity)) {
+    builder.putDouble(TA_KEY_OPACITY, textAttributes.opacity);
+  }
+  if (!textAttributes.fontFamily.empty()) {
+    builder.putString(TA_KEY_FONT_FAMILY, textAttributes.fontFamily);
+  }
+  if (!std::isnan(textAttributes.fontSize)) {
+    builder.putDouble(TA_KEY_FONT_SIZE, textAttributes.fontSize);
+  }
+  if (!std::isnan(textAttributes.fontSizeMultiplier)) {
+    builder.putDouble(
+        TA_KEY_FONT_SIZE_MULTIPLIER, textAttributes.fontSizeMultiplier);
+  }
+  if (textAttributes.fontWeight.has_value()) {
+    builder.putString(TA_KEY_FONT_WEIGHT, toString(*textAttributes.fontWeight));
+  }
+  if (textAttributes.fontStyle.has_value()) {
+    builder.putString(TA_KEY_FONT_STYLE, toString(*textAttributes.fontStyle));
+  }
+  if (textAttributes.fontVariant.has_value()) {
+    auto fontVariantMap = toMapBuffer(*textAttributes.fontVariant);
+    builder.putMapBuffer(TA_KEY_FONT_VARIANT, fontVariantMap);
+  }
+  if (textAttributes.allowFontScaling.has_value()) {
+    builder.putBool(
+        TA_KEY_ALLOW_FONT_SCALING, *textAttributes.allowFontScaling);
+  }
+  if (!std::isnan(textAttributes.letterSpacing)) {
+    builder.putDouble(TA_KEY_LETTER_SPACING, textAttributes.letterSpacing);
+  }
+  if (!std::isnan(textAttributes.lineHeight)) {
+    builder.putDouble(TA_KEY_LINE_HEIGHT, textAttributes.lineHeight);
+  }
+  if (textAttributes.alignment.has_value()) {
+    builder.putString(TA_KEY_ALIGNMENT, toString(*textAttributes.alignment));
+  }
+  if (textAttributes.baseWritingDirection.has_value()) {
+    builder.putString(
+        TA_KEY_BEST_WRITING_DIRECTION,
+        toString(*textAttributes.baseWritingDirection));
+  }
+  // Decoration
+  if (textAttributes.textDecorationColor) {
+    builder.putInt(
+        TA_KEY_TEXT_DECORATION_COLOR,
+        toMapBuffer(textAttributes.textDecorationColor));
+  }
+  if (textAttributes.textDecorationLineType.has_value()) {
+    builder.putString(
+        TA_KEY_TEXT_DECORATION_LINE,
+        toString(*textAttributes.textDecorationLineType));
+  }
+  if (textAttributes.textDecorationLineStyle.has_value()) {
+    builder.putString(
+        TA_KEY_TEXT_DECORATION_LINE_STYLE,
+        toString(*textAttributes.textDecorationLineStyle));
+  }
+  if (textAttributes.textDecorationLinePattern.has_value()) {
+    builder.putString(
+        TA_KEY_TEXT_DECORATION_LINE_PATTERN,
+        toString(*textAttributes.textDecorationLinePattern));
+  }
+  // Shadow
+  if (!std::isnan(textAttributes.textShadowRadius)) {
+    builder.putDouble(
+        TA_KEY_TEXT_SHADOW_RAIDUS, textAttributes.textShadowRadius);
+  }
+  if (textAttributes.textShadowColor) {
+    builder.putInt(
+        TA_KEY_TEXT_SHADOW_COLOR, toMapBuffer(textAttributes.textShadowColor));
+  }
+  // Special
+  if (textAttributes.isHighlighted.has_value()) {
+    builder.putBool(TA_KEY_IS_HIGHLIGHTED, *textAttributes.isHighlighted);
+  }
+  if (textAttributes.layoutDirection.has_value()) {
+    builder.putString(
+        TA_KEY_LAYOUT_DIRECTION, toString(*textAttributes.layoutDirection));
+  }
+  if (textAttributes.accessibilityRole.has_value()) {
+    builder.putString(
+        TA_KEY_ACCESSIBILITY_ROLE, toString(*textAttributes.accessibilityRole));
+  }
+  return builder.build();
+}
+
+inline MapBuffer toMapBuffer(const AttributedString &attributedString) {
+  auto fragmentsBuilder = MapBufferBuilder();
+
+  int index = 0;
+  for (auto fragment : attributedString.getFragments()) {
+    auto dynamicFragmentBuilder = MapBufferBuilder();
+    dynamicFragmentBuilder.putString(FR_KEY_STRING, fragment.string);
+    if (fragment.parentShadowView.componentHandle) {
+      dynamicFragmentBuilder.putInt(
+          FR_KEY_REACT_TAG, fragment.parentShadowView.tag);
+    }
+    if (fragment.isAttachment()) {
+      dynamicFragmentBuilder.putBool(FR_KEY_IS_ATTACHMENT, true);
+      dynamicFragmentBuilder.putDouble(
+          FR_KEY_WIDTH,
+          fragment.parentShadowView.layoutMetrics.frame.size.width);
+      dynamicFragmentBuilder.putDouble(
+          FR_KEY_HEIGHT,
+          fragment.parentShadowView.layoutMetrics.frame.size.height);
+    }
+    auto textAttributesMap = toMapBuffer(fragment.textAttributes);
+    dynamicFragmentBuilder.putMapBuffer(
+        FR_KEY_TEXT_ATTRIBUTES, textAttributesMap);
+    auto dynamicFragmentMap = dynamicFragmentBuilder.build();
+    fragmentsBuilder.putMapBuffer(index++, dynamicFragmentMap);
+  }
+
+  auto builder = MapBufferBuilder();
+  builder.putInt(
+      AS_KEY_HASH,
+      std::hash<facebook::react::AttributedString>{}(attributedString));
+  builder.putString(AS_KEY_STRING, attributedString.getString());
+  auto fragmentsMap = fragmentsBuilder.build();
+  builder.putMapBuffer(AS_KEY_FRAGMENTS, fragmentsMap);
+  return builder.build();
+}
+
 #endif
 
 } // namespace react