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

package/ReactCommon/react/renderer/components/view/YogaLayoutableShadowNode.cpp

@@ -6,6 +6,9 @@
  */
 
 #include "YogaLayoutableShadowNode.h"
+#include <logger/react_native_log.h>
+#include <react/debug/flags.h>
+#include <react/debug/react_native_assert.h>
 #include <react/renderer/components/view/ViewProps.h>
 #include <react/renderer/components/view/conversions.h>
 #include <react/renderer/core/LayoutConstraints.h>
@@ -20,25 +23,43 @@
 namespace facebook {
 namespace react {
 
-thread_local LayoutContext threadLocalLayoutContext;
-
-static void applyLayoutConstraints(
-    YGStyle &yogaStyle,
-    LayoutConstraints const &layoutConstraints) {
-  yogaStyle.minDimensions()[YGDimensionWidth] =
-      yogaStyleValueFromFloat(layoutConstraints.minimumSize.width);
-  yogaStyle.minDimensions()[YGDimensionHeight] =
-      yogaStyleValueFromFloat(layoutConstraints.minimumSize.height);
-
-  yogaStyle.maxDimensions()[YGDimensionWidth] =
-      yogaStyleValueFromFloat(layoutConstraints.maximumSize.width);
-  yogaStyle.maxDimensions()[YGDimensionHeight] =
-      yogaStyleValueFromFloat(layoutConstraints.maximumSize.height);
+static int FabricDefaultYogaLog(
+    const YGConfigRef,
+    const YGNodeRef,
+    YGLogLevel level,
+    const char *format,
+    va_list args) {
+  va_list args_copy;
+  va_copy(args_copy, args);
+
+  // Adding 1 to add space for terminating null character.
+  int size_s = vsnprintf(NULL, 0, format, args);
+  auto size = static_cast<size_t>(size_s);
+  std::vector<char> buffer(size);
+
+  vsnprintf(buffer.data(), size, format, args_copy);
+  switch (level) {
+    case YGLogLevelError:
+      react_native_log_error(buffer.data());
+      break;
+    case YGLogLevelFatal:
+      react_native_log_fatal(buffer.data());
+      break;
+    case YGLogLevelWarn:
+      react_native_log_warn(buffer.data());
+      break;
+    case YGLogLevelInfo:
+    case YGLogLevelDebug:
+    case YGLogLevelVerbose:
+    default:
+      react_native_log_info(buffer.data());
+  }
 
-  yogaStyle.direction() =
-      yogaDirectionFromLayoutDirection(layoutConstraints.layoutDirection);
+  return size_s;
 }
 
+thread_local LayoutContext threadLocalLayoutContext;
+
 ShadowNodeTraits YogaLayoutableShadowNode::BaseTraits() {
   auto traits = LayoutableShadowNode::BaseTraits();
   traits.set(ShadowNodeTraits::Trait::YogaLayoutableKind);
@@ -50,7 +71,7 @@ YogaLayoutableShadowNode::YogaLayoutableShadowNode(
     ShadowNodeFamily::Shared const &family,
     ShadowNodeTraits traits)
     : LayoutableShadowNode(fragment, family, traits),
-      yogaConfig_(nullptr),
+      yogaConfig_(FabricDefaultYogaLog),
       yogaNode_(&initializeYogaConfig(yogaConfig_)) {
   yogaNode_.setContext(this);
 
@@ -59,7 +80,8 @@ YogaLayoutableShadowNode::YogaLayoutableShadowNode(
   yogaNode_.setDirty(true);
 
   if (getTraits().check(ShadowNodeTraits::Trait::MeasurableYogaNode)) {
-    assert(getTraits().check(ShadowNodeTraits::Trait::LeafYogaNode));
+    react_native_assert(
+        getTraits().check(ShadowNodeTraits::Trait::LeafYogaNode));
 
     yogaNode_.setMeasureFunc(
         YogaLayoutableShadowNode::yogaNodeMeasureCallbackConnector);
@@ -75,7 +97,7 @@ YogaLayoutableShadowNode::YogaLayoutableShadowNode(
     ShadowNode const &sourceShadowNode,
     ShadowNodeFragment const &fragment)
     : LayoutableShadowNode(sourceShadowNode, fragment),
-      yogaConfig_(nullptr),
+      yogaConfig_(FabricDefaultYogaLog),
       yogaNode_(
           static_cast<YogaLayoutableShadowNode const &>(sourceShadowNode)
               .yogaNode_,
@@ -84,7 +106,7 @@ YogaLayoutableShadowNode::YogaLayoutableShadowNode(
   // dirty flag, measure function, and other properties being set originally in
   // the `YogaLayoutableShadowNode` constructor above.
 
-  assert(
+  react_native_assert(
       static_cast<YogaLayoutableShadowNode const &>(sourceShadowNode)
               .yogaNode_.isDirty() == yogaNode_.isDirty() &&
       "Yoga node must inherit dirty flag.");
@@ -135,14 +157,16 @@ void YogaLayoutableShadowNode::enableMeasurement() {
 
 void YogaLayoutableShadowNode::appendYogaChild(ShadowNode const &childNode) {
   // The caller must check this before calling this method.
-  assert(!getTraits().check(ShadowNodeTraits::Trait::LeafYogaNode));
+  react_native_assert(
+      !getTraits().check(ShadowNodeTraits::Trait::LeafYogaNode));
 
   ensureYogaChildrenLookFine();
 
   auto &layoutableChildNode =
       traitCast<YogaLayoutableShadowNode const &>(childNode);
   yogaNode_.insertChild(
-      &layoutableChildNode.yogaNode_, yogaNode_.getChildren().size());
+      &layoutableChildNode.yogaNode_,
+      static_cast<uint32_t>(yogaNode_.getChildren().size()));
 
   ensureYogaChildrenLookFine();
 }
@@ -152,13 +176,14 @@ void YogaLayoutableShadowNode::adoptYogaChild(size_t index) {
   ensureYogaChildrenLookFine();
 
   // The caller must check this before calling this method.
-  assert(!getTraits().check(ShadowNodeTraits::Trait::LeafYogaNode));
+  react_native_assert(
+      !getTraits().check(ShadowNodeTraits::Trait::LeafYogaNode));
 
   auto &children = getChildren();
 
   // Overflow checks.
-  assert(children.size() > index);
-  assert(children.size() >= yogaNode_.getChildren().size());
+  react_native_assert(children.size() > index);
+  react_native_assert(children.size() >= yogaNode_.getChildren().size());
 
   auto &childNode = *children.at(index);
 
@@ -168,13 +193,14 @@ void YogaLayoutableShadowNode::adoptYogaChild(size_t index) {
   // Note, the following (commented out) assert is conceptually valid but still
   // might produce false-positive signals because of the ABA problem (different
   // objects with non-interleaving life-times being allocated on the same
-  // address). assert(layoutableChildNode.yogaNode_.getOwner() != &yogaNode_);
+  // address). react_native_assert(layoutableChildNode.yogaNode_.getOwner() !=
+  // &yogaNode_);
 
   if (layoutableChildNode.yogaNode_.getOwner() == nullptr) {
     // The child node is not owned.
     layoutableChildNode.yogaNode_.setOwner(&yogaNode_);
     // At this point the child yoga node must be already inserted by the caller.
-    // assert(layoutableChildNode.yogaNode_.isDirty());
+    // react_native_assert(layoutableChildNode.yogaNode_.isDirty());
   } else {
     // The child is owned by some other node, we need to clone that.
     auto clonedChildNode = childNode.clone({});
@@ -182,16 +208,18 @@ void YogaLayoutableShadowNode::adoptYogaChild(size_t index) {
         traitCast<YogaLayoutableShadowNode const &>(*clonedChildNode);
 
     // The owner must be nullptr for a newly cloned node.
-    assert(layoutableClonedChildNode.yogaNode_.getOwner() == nullptr);
+    react_native_assert(
+        layoutableClonedChildNode.yogaNode_.getOwner() == nullptr);
 
     // Establishing ownership.
     layoutableClonedChildNode.yogaNode_.setOwner(&yogaNode_);
 
     // Replace the child node with a newly cloned one in the children list.
-    replaceChild(childNode, clonedChildNode, index);
+    replaceChild(childNode, clonedChildNode, static_cast<int>(index));
 
     // Replace the Yoga node inside the Yoga node children list.
-    yogaNode_.replaceChild(&layoutableClonedChildNode.yogaNode_, index);
+    yogaNode_.replaceChild(
+        &layoutableClonedChildNode.yogaNode_, static_cast<int>(index));
   }
 
   ensureYogaChildrenLookFine();
@@ -217,19 +245,26 @@ void YogaLayoutableShadowNode::appendChild(
   yogaNode_.setDirty(true);
 
   // All children of a non-leaf `YogaLayoutableShadowNode` must be a
-  // `YogaLayoutableShadowNode`s.
-  assert(traitCast<YogaLayoutableShadowNode const *>(childNode.get()));
-
-  // Appending the Yoga node.
-  appendYogaChild(*childNode);
-
-  ensureYogaChildrenLookFine();
-  ensureYogaChildrenAlighment();
-
-  // Adopting the Yoga node.
-  adoptYogaChild(getChildren().size() - 1);
-
-  ensureConsistency();
+  // `YogaLayoutableShadowNode`s to be appended. This happens when invalid
+  // string/numeric child is passed which is not YogaLayoutableShadowNode
+  // (e.g. RCTRawText). This used to throw an error, but we are ignoring it
+  // because we want core library components to be fault-tolerant and degrade
+  // gracefully. A soft error will be emitted from JavaScript.
+  if (traitCast<YogaLayoutableShadowNode const *>(childNode.get())) {
+    // Appending the Yoga node.
+    appendYogaChild(*childNode);
+
+    ensureYogaChildrenLookFine();
+    ensureYogaChildrenAlighment();
+
+    // Adopting the Yoga node.
+    adoptYogaChild(getChildren().size() - 1);
+
+    ensureConsistency();
+  } else {
+    react_native_log_error(
+        "Text strings must be rendered within a <Text> component.");
+  }
 }
 
 bool YogaLayoutableShadowNode::doesOwn(
@@ -273,7 +308,7 @@ void YogaLayoutableShadowNode::updateYogaChildren() {
     }
   }
 
-  assert(getChildren().size() == yogaNode_.getChildren().size());
+  react_native_assert(getChildren().size() == yogaNode_.getChildren().size());
 
   yogaNode_.setDirty(!isClean);
 }
@@ -350,7 +385,59 @@ void YogaLayoutableShadowNode::layoutTree(
    */
   yogaConfig_.pointScaleFactor = layoutContext.pointScaleFactor;
 
-  applyLayoutConstraints(yogaNode_.getStyle(), layoutConstraints);
+  auto minimumSize = layoutConstraints.minimumSize;
+  auto maximumSize = layoutConstraints.maximumSize;
+
+  // The caller must ensure that layout constraints make sense.
+  // Values cannot be NaN.
+  react_native_assert(!std::isnan(minimumSize.width));
+  react_native_assert(!std::isnan(minimumSize.height));
+  react_native_assert(!std::isnan(maximumSize.width));
+  react_native_assert(!std::isnan(maximumSize.height));
+  // Values cannot be negative.
+  react_native_assert(minimumSize.width >= 0);
+  react_native_assert(minimumSize.height >= 0);
+  react_native_assert(maximumSize.width >= 0);
+  react_native_assert(maximumSize.height >= 0);
+  // Mimimum size cannot be infinity.
+  react_native_assert(!std::isinf(minimumSize.width));
+  react_native_assert(!std::isinf(minimumSize.height));
+
+  // Internally Yoga uses three different measurement modes controlling layout
+  // constraints: `Undefined`, `Exactly`, and `AtMost`. These modes are an
+  // implementation detail and are not defined in `CSS Flexible Box Layout
+  // Module`. Yoga C++ API (and `YGNodeCalculateLayout` function particularly)
+  // does not allow to specify the measure modes explicitly. Instead, it infers
+  // these from styles associated with the root node.
+  // To pass the actual layout constraints to Yoga we represent them as
+  // `(min/max)(Height/Width)` style properties. Also, we pass `ownerWidth` &
+  // `ownerHeight` to allow proper calculation of relative (e.g. specified in
+  // percents) style values.
+
+  auto &yogaStyle = yogaNode_.getStyle();
+
+  auto ownerWidth = yogaFloatFromFloat(maximumSize.width);
+  auto ownerHeight = yogaFloatFromFloat(maximumSize.height);
+
+  yogaStyle.maxDimensions()[YGDimensionWidth] = std::isfinite(maximumSize.width)
+      ? yogaStyleValueFromFloat(maximumSize.width)
+      : YGValueUndefined;
+
+  yogaStyle.maxDimensions()[YGDimensionHeight] =
+      std::isfinite(maximumSize.height)
+      ? yogaStyleValueFromFloat(maximumSize.height)
+      : YGValueUndefined;
+
+  yogaStyle.minDimensions()[YGDimensionWidth] = minimumSize.width > 0
+      ? yogaStyleValueFromFloat(minimumSize.width)
+      : YGValueUndefined;
+
+  yogaStyle.minDimensions()[YGDimensionHeight] = minimumSize.height > 0
+      ? yogaStyleValueFromFloat(minimumSize.height)
+      : YGValueUndefined;
+
+  auto direction =
+      yogaDirectionFromLayoutDirection(layoutConstraints.layoutDirection);
 
   threadLocalLayoutContext = layoutContext;
 
@@ -360,9 +447,7 @@ void YogaLayoutableShadowNode::layoutTree(
 
   {
     SystraceSection s("YogaLayoutableShadowNode::YGNodeCalculateLayout");
-
-    YGNodeCalculateLayout(
-        &yogaNode_, YGUndefined, YGUndefined, YGDirectionInherit);
+    YGNodeCalculateLayout(&yogaNode_, ownerWidth, ownerHeight, direction);
   }
 
   if (yogaNode_.getHasNewLayout()) {
@@ -391,7 +476,7 @@ static EdgeInsets calculateOverflowInset(
 
 void YogaLayoutableShadowNode::layout(LayoutContext layoutContext) {
   // Reading data from a dirtied node does not make sense.
-  assert(!yogaNode_.isDirty());
+  react_native_assert(!yogaNode_.isDirty());
 
   auto contentFrame = Rect{};
 
@@ -400,17 +485,17 @@ void YogaLayoutableShadowNode::layout(LayoutContext layoutContext) {
         *static_cast<YogaLayoutableShadowNode *>(childYogaNode->getContext());
 
     // Verifying that the Yoga node belongs to the ShadowNode.
-    assert(&childNode.yogaNode_ == childYogaNode);
+    react_native_assert(&childNode.yogaNode_ == childYogaNode);
 
     if (childYogaNode->getHasNewLayout()) {
       childYogaNode->setHasNewLayout(false);
 
       // Reading data from a dirtied node does not make sense.
-      assert(!childYogaNode->isDirty());
+      react_native_assert(!childYogaNode->isDirty());
 
       // We must copy layout metrics from Yoga node only once (when the parent
       // node exclusively ownes the child node).
-      assert(childYogaNode->getOwner() == &yogaNode_);
+      react_native_assert(childYogaNode->getOwner() == &yogaNode_);
 
       // We are about to mutate layout metrics of the node.
       childNode.ensureUnsealed();
@@ -521,28 +606,12 @@ YGSize YogaLayoutableShadowNode::yogaNodeMeasureCallbackConnector(
       yogaFloatFromFloat(size.width), yogaFloatFromFloat(size.height)};
 }
 
-#ifdef RN_DEBUG_YOGA_LOGGER
-static int YogaLog(
-    const YGConfigRef config,
-    const YGNodeRef node,
-    YGLogLevel level,
-    const char *format,
-    va_list args) {
-  int result = vsnprintf(NULL, 0, format, args);
-  std::vector<char> buffer(1 + result);
-  vsnprintf(buffer.data(), buffer.size(), format, args);
-  LOG(INFO) << "RNYogaLogger " << buffer.data();
-  return result;
-}
-#endif
-
 YGConfig &YogaLayoutableShadowNode::initializeYogaConfig(YGConfig &config) {
   config.setCloneNodeCallback(
       YogaLayoutableShadowNode::yogaNodeCloneCallbackConnector);
   config.useLegacyStretchBehaviour = true;
 #ifdef RN_DEBUG_YOGA_LOGGER
   config.printTree = true;
-  config.setLogger(&YogaLog);
 #endif
   return config;
 }
@@ -674,7 +743,7 @@ void YogaLayoutableShadowNode::ensureConsistency() const {
 }
 
 void YogaLayoutableShadowNode::ensureYogaChildrenOwnersConsistency() const {
-#ifndef NDEBUG
+#ifdef REACT_NATIVE_DEBUG
   // Checking that all Yoga node children have the same `owner`.
   // The owner might be not equal to the `yogaNode_` though.
   auto &yogaChildren = yogaNode_.getChildren();
@@ -682,14 +751,14 @@ void YogaLayoutableShadowNode::ensureYogaChildrenOwnersConsistency() const {
   if (!yogaChildren.empty()) {
     auto owner = yogaChildren.at(0)->getOwner();
     for (auto const &child : yogaChildren) {
-      assert(child->getOwner() == owner);
+      react_native_assert(child->getOwner() == owner);
     }
   }
 #endif
 }
 
 void YogaLayoutableShadowNode::ensureYogaChildrenLookFine() const {
-#ifndef NDEBUG
+#ifdef REACT_NATIVE_DEBUG
   // Checking that the shapes of Yoga node children object look fine.
   // This is the only heuristic that might produce false-positive results
   // (really broken dangled nodes might look fine). This is useful as an early
@@ -697,17 +766,17 @@ void YogaLayoutableShadowNode::ensureYogaChildrenLookFine() const {
   auto &yogaChildren = yogaNode_.getChildren();
 
   for (auto const &yogaChild : yogaChildren) {
-    assert(yogaChild->getContext());
-    assert(yogaChild->getChildren().size() < 16384);
+    react_native_assert(yogaChild->getContext());
+    react_native_assert(yogaChild->getChildren().size() < 16384);
     if (!yogaChild->getChildren().empty()) {
-      assert(!yogaChild->hasMeasureFunc());
+      react_native_assert(!yogaChild->hasMeasureFunc());
     }
   }
 #endif
 }
 
 void YogaLayoutableShadowNode::ensureYogaChildrenAlighment() const {
-#ifndef NDEBUG
+#ifdef REACT_NATIVE_DEBUG
   // If the node is not a leaf node, checking that:
   // - All children are `YogaLayoutableShadowNode` subclasses.
   // - All Yoga children are owned/connected to corresponding children of
@@ -717,16 +786,16 @@ void YogaLayoutableShadowNode::ensureYogaChildrenAlighment() const {
   auto &children = getChildren();
 
   if (getTraits().check(ShadowNodeTraits::Trait::LeafYogaNode)) {
-    assert(yogaChildren.empty());
+    react_native_assert(yogaChildren.empty());
     return;
   }
 
-  assert(yogaChildren.size() == children.size());
+  react_native_assert(yogaChildren.size() == children.size());
 
   for (size_t i = 0; i < children.size(); i++) {
     auto &yogaChild = yogaChildren.at(i);
     auto &child = children.at(i);
-    assert(
+    react_native_assert(
         yogaChild->getContext() ==
         traitCast<YogaLayoutableShadowNode const *>(child.get()));
   }

package/ReactCommon/react/renderer/components/view/YogaLayoutableShadowNode.h

@@ -12,6 +12,7 @@
 
 #include <yoga/YGNode.h>
 
+#include <react/debug/react_native_assert.h>
 #include <react/renderer/components/view/YogaStylableProps.h>
 #include <react/renderer/core/LayoutableShadowNode.h>
 #include <react/renderer/core/Sealable.h>
@@ -149,8 +150,8 @@ class YogaLayoutableShadowNode : public LayoutableShadowNode {
    * - borderBottom(Left|Right)Radius → borderBottom(Start|End)Radius
    * - border(Left|Right)Width → border(Start|End)Width
    * - border(Left|Right)Color → border(Start|End)Color
-   * This is neccesarry to be backwards compatible with Paper, it swaps the
-   * values as well in https://fburl.com/diffusion/kl7bjr3h
+   * This is neccesarry to be backwards compatible with old renderer, it swaps
+   * the values as well in https://fburl.com/diffusion/kl7bjr3h
    */
   static void swapLeftAndRightInTree(
       YogaLayoutableShadowNode const &shadowNode);
@@ -185,10 +186,7 @@ inline YogaLayoutableShadowNode const &
 traitCast<YogaLayoutableShadowNode const &>(ShadowNode const &shadowNode) {
   bool castable =
       shadowNode.getTraits().check(ShadowNodeTraits::Trait::YogaLayoutableKind);
-  assert(
-      castable ==
-      (dynamic_cast<YogaLayoutableShadowNode const *>(&shadowNode) != nullptr));
-  assert(castable);
+  react_native_assert(castable);
   (void)castable;
   return static_cast<YogaLayoutableShadowNode const &>(shadowNode);
 }
@@ -201,9 +199,6 @@ traitCast<YogaLayoutableShadowNode const *>(ShadowNode const *shadowNode) {
   }
   bool castable = shadowNode->getTraits().check(
       ShadowNodeTraits::Trait::YogaLayoutableKind);
-  assert(
-      castable ==
-      (dynamic_cast<YogaLayoutableShadowNode const *>(shadowNode) != nullptr));
   if (!castable) {
     return nullptr;
   }

package/ReactCommon/react/renderer/components/view/YogaStylableProps.cpp

@@ -20,10 +20,11 @@ namespace facebook {
 namespace react {
 
 YogaStylableProps::YogaStylableProps(
+    const PropsParserContext &context,
     YogaStylableProps const &sourceProps,
     RawProps const &rawProps)
-    : Props(sourceProps, rawProps),
-      yogaStyle(convertRawProp(rawProps, sourceProps.yogaStyle)){};
+    : Props(context, sourceProps, rawProps),
+      yogaStyle(convertRawProp(context, rawProps, sourceProps.yogaStyle)){};
 
 #pragma mark - DebugStringConvertible
 

package/ReactCommon/react/renderer/components/view/YogaStylableProps.h

@@ -10,6 +10,7 @@
 #include <yoga/YGStyle.h>
 
 #include <react/renderer/core/Props.h>
+#include <react/renderer/core/PropsParserContext.h>
 #include <react/renderer/debug/DebugStringConvertible.h>
 
 namespace facebook {
@@ -19,6 +20,7 @@ class YogaStylableProps : public Props {
  public:
   YogaStylableProps() = default;
   YogaStylableProps(
+      const PropsParserContext &context,
       YogaStylableProps const &sourceProps,
       RawProps const &rawProps);
 

package/ReactCommon/react/renderer/components/view/accessibilityPropsConversions.h

@@ -8,7 +8,10 @@
 #pragma once
 
 #include <folly/dynamic.h>
+#include <glog/logging.h>
+#include <react/debug/react_native_assert.h>
 #include <react/renderer/components/view/AccessibilityPrimitives.h>
+#include <react/renderer/core/PropsParserContext.h>
 #include <react/renderer/core/propsConversions.h>
 
 namespace facebook {
@@ -19,7 +22,7 @@ inline void fromString(const std::string &string, AccessibilityTraits &result) {
     result = AccessibilityTraits::None;
     return;
   }
-  if (string == "button") {
+  if (string == "button" || string == "togglebutton") {
     result = AccessibilityTraits::Button;
     return;
   }
@@ -91,37 +94,53 @@ inline void fromString(const std::string &string, AccessibilityTraits &result) {
     result = AccessibilityTraits::Switch;
     return;
   }
+  if (string == "tabbar") {
+    result = AccessibilityTraits::TabBar;
+    return;
+  }
+  if (string == "progressbar") {
+    result = AccessibilityTraits::UpdatesFrequently;
+    return;
+  }
   result = AccessibilityTraits::None;
 }
 
-inline void fromRawValue(const RawValue &value, AccessibilityTraits &result) {
+inline void fromRawValue(
+    const PropsParserContext &context,
+    const RawValue &value,
+    AccessibilityTraits &result) {
   if (value.hasType<std::string>()) {
     fromString((std::string)value, result);
     return;
   }
 
+  result = {};
+
+  react_native_assert(value.hasType<std::vector<std::string>>());
   if (value.hasType<std::vector<std::string>>()) {
-    result = {};
     auto items = (std::vector<std::string>)value;
     for (auto &item : items) {
       AccessibilityTraits itemAccessibilityTraits;
       fromString(item, itemAccessibilityTraits);
       result = result | itemAccessibilityTraits;
     }
+  } else {
+    LOG(ERROR) << "AccessibilityTraits parsing: unsupported type";
   }
-
-  abort();
 }
 
-inline void fromRawValue(const RawValue &value, AccessibilityState &result) {
+inline void fromRawValue(
+    const PropsParserContext &context,
+    const RawValue &value,
+    AccessibilityState &result) {
   auto map = (better::map<std::string, RawValue>)value;
   auto selected = map.find("selected");
   if (selected != map.end()) {
-    fromRawValue(selected->second, result.selected);
+    fromRawValue(context, selected->second, result.selected);
   }
   auto disabled = map.find("disabled");
   if (disabled != map.end()) {
-    fromRawValue(disabled->second, result.disabled);
+    fromRawValue(context, disabled->second, result.disabled);
   }
   auto checked = map.find("checked");
   if (checked != map.end()) {
@@ -143,11 +162,11 @@ inline void fromRawValue(const RawValue &value, AccessibilityState &result) {
   }
   auto busy = map.find("busy");
   if (busy != map.end()) {
-    fromRawValue(busy->second, result.busy);
+    fromRawValue(context, busy->second, result.busy);
   }
   auto expanded = map.find("expanded");
   if (expanded != map.end()) {
-    fromRawValue(expanded->second, result.expanded);
+    fromRawValue(context, expanded->second, result.expanded);
   }
 }
 
@@ -166,26 +185,82 @@ inline std::string toString(
 }
 
 inline void fromRawValue(
+    const PropsParserContext &context,
     const RawValue &value,
     ImportantForAccessibility &result) {
-  auto string = (std::string)value;
-  if (string == "auto") {
-    result = ImportantForAccessibility::Auto;
-    return;
+  react_native_assert(value.hasType<std::string>());
+  if (value.hasType<std::string>()) {
+    auto string = (std::string)value;
+    if (string == "auto") {
+      result = ImportantForAccessibility::Auto;
+    } else if (string == "yes") {
+      result = ImportantForAccessibility::Yes;
+    } else if (string == "no") {
+      result = ImportantForAccessibility::No;
+    } else if (string == "no-hide-descendants") {
+      result = ImportantForAccessibility::NoHideDescendants;
+    } else {
+      LOG(ERROR) << "Unsupported ImportantForAccessiblity value: " << string;
+      react_native_assert(false);
+    }
+  } else {
+    LOG(ERROR) << "Unsupported ImportantForAccessiblity type";
   }
-  if (string == "yes") {
-    result = ImportantForAccessibility::Yes;
-    return;
+}
+
+inline void fromRawValue(
+    const PropsParserContext &context,
+    const RawValue &value,
+    AccessibilityAction &result) {
+  auto map = (better::map<std::string, RawValue>)value;
+
+  auto name = map.find("name");
+  react_native_assert(name != map.end() && name->second.hasType<std::string>());
+  if (name != map.end()) {
+    fromRawValue(context, name->second, result.name);
   }
-  if (string == "no") {
-    result = ImportantForAccessibility::No;
-    return;
+
+  auto label = map.find("label");
+  if (label != map.end()) {
+    if (label->second.hasType<std::string>()) {
+      result.label = (std::string)label->second;
+    }
   }
-  if (string == "no-hide-descendants") {
-    result = ImportantForAccessibility::NoHideDescendants;
-    return;
+}
+
+inline void fromRawValue(
+    const PropsParserContext &,
+    const RawValue &value,
+    AccessibilityValue &result) {
+  auto map = (better::map<std::string, RawValue>)value;
+
+  auto min = map.find("min");
+  if (min != map.end()) {
+    if (min->second.hasType<int>()) {
+      result.min = (int)min->second;
+    }
+  }
+
+  auto max = map.find("max");
+  if (max != map.end()) {
+    if (max->second.hasType<int>()) {
+      result.max = (int)max->second;
+    }
+  }
+
+  auto now = map.find("now");
+  if (now != map.end()) {
+    if (now->second.hasType<int>()) {
+      result.now = (int)now->second;
+    }
+  }
+
+  auto text = map.find("text");
+  if (text != map.end()) {
+    if (text->second.hasType<std::string>()) {
+      result.text = (std::string)text->second;
+    }
   }
-  abort();
 }
 
 } // namespace react