react-native 0.0.0-263478b91 → 0.0.0-268efb102

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

@@ -6,6 +6,7 @@
  */
 
 #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>
@@ -22,6 +23,41 @@
 namespace facebook {
 namespace react {
 
+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());
+  }
+
+  return size_s;
+}
+
 thread_local LayoutContext threadLocalLayoutContext;
 
 ShadowNodeTraits YogaLayoutableShadowNode::BaseTraits() {
@@ -35,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);
 
@@ -61,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_,
@@ -209,20 +245,26 @@ void YogaLayoutableShadowNode::appendChild(
   yogaNode_.setDirty(true);
 
   // All children of a non-leaf `YogaLayoutableShadowNode` must be a
-  // `YogaLayoutableShadowNode`s.
-  react_native_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(
@@ -405,7 +447,6 @@ void YogaLayoutableShadowNode::layoutTree(
 
   {
     SystraceSection s("YogaLayoutableShadowNode::YGNodeCalculateLayout");
-
     YGNodeCalculateLayout(&yogaNode_, ownerWidth, ownerHeight, direction);
   }
 
@@ -565,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(ERROR) << "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;
 }

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

@@ -150,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);
@@ -186,9 +186,6 @@ inline YogaLayoutableShadowNode const &
 traitCast<YogaLayoutableShadowNode const &>(ShadowNode const &shadowNode) {
   bool castable =
       shadowNode.getTraits().check(ShadowNodeTraits::Trait::YogaLayoutableKind);
-  react_native_assert(
-      castable ==
-      (dynamic_cast<YogaLayoutableShadowNode const *>(&shadowNode) != nullptr));
   react_native_assert(castable);
   (void)castable;
   return static_cast<YogaLayoutableShadowNode const &>(shadowNode);
@@ -202,9 +199,6 @@ traitCast<YogaLayoutableShadowNode const *>(ShadowNode const *shadowNode) {
   }
   bool castable = shadowNode->getTraits().check(
       ShadowNodeTraits::Trait::YogaLayoutableKind);
-  react_native_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

@@ -11,6 +11,7 @@
 #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 {
@@ -93,10 +94,21 @@ 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;
@@ -117,15 +129,18 @@ inline void fromRawValue(const RawValue &value, AccessibilityTraits &result) {
   }
 }
 
-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()) {
@@ -147,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);
   }
 }
 
@@ -170,6 +185,7 @@ inline std::string toString(
 }
 
 inline void fromRawValue(
+    const PropsParserContext &context,
     const RawValue &value,
     ImportantForAccessibility &result) {
   react_native_assert(value.hasType<std::string>());
@@ -192,5 +208,60 @@ inline void fromRawValue(
   }
 }
 
+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);
+  }
+
+  auto label = map.find("label");
+  if (label != map.end()) {
+    if (label->second.hasType<std::string>()) {
+      result.label = (std::string)label->second;
+    }
+  }
+}
+
+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;
+    }
+  }
+}
+
 } // namespace react
 } // namespace facebook

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

@@ -15,6 +15,7 @@
 #include <react/debug/react_native_assert.h>
 #include <react/renderer/components/view/primitives.h>
 #include <react/renderer/core/LayoutMetrics.h>
+#include <react/renderer/core/PropsParserContext.h>
 #include <react/renderer/graphics/Geometry.h>
 #include <react/renderer/graphics/Transform.h>
 #include <stdlib.h>
@@ -165,7 +166,10 @@ inline YGDirection yogaDirectionFromLayoutDirection(LayoutDirection direction) {
   }
 }
 
-inline void fromRawValue(const RawValue &value, YGDirection &result) {
+inline void fromRawValue(
+    const PropsParserContext &context,
+    const RawValue &value,
+    YGDirection &result) {
   react_native_assert(value.hasType<std::string>());
   auto stringValue = (std::string)value;
   if (stringValue == "inherit") {
@@ -184,7 +188,10 @@ inline void fromRawValue(const RawValue &value, YGDirection &result) {
   react_native_assert(false);
 }
 
-inline void fromRawValue(const RawValue &value, YGFlexDirection &result) {
+inline void fromRawValue(
+    const PropsParserContext &context,
+    const RawValue &value,
+    YGFlexDirection &result) {
   react_native_assert(value.hasType<std::string>());
   auto stringValue = (std::string)value;
   if (stringValue == "row") {
@@ -207,7 +214,10 @@ inline void fromRawValue(const RawValue &value, YGFlexDirection &result) {
   react_native_assert(false);
 }
 
-inline void fromRawValue(const RawValue &value, YGJustify &result) {
+inline void fromRawValue(
+    const PropsParserContext &context,
+    const RawValue &value,
+    YGJustify &result) {
   react_native_assert(value.hasType<std::string>());
   auto stringValue = (std::string)value;
   if (stringValue == "flex-start") {
@@ -238,7 +248,10 @@ inline void fromRawValue(const RawValue &value, YGJustify &result) {
   react_native_assert(false);
 }
 
-inline void fromRawValue(const RawValue &value, YGAlign &result) {
+inline void fromRawValue(
+    const PropsParserContext &context,
+    const RawValue &value,
+    YGAlign &result) {
   react_native_assert(value.hasType<std::string>());
   auto stringValue = (std::string)value;
   if (stringValue == "auto") {
@@ -277,7 +290,10 @@ inline void fromRawValue(const RawValue &value, YGAlign &result) {
   react_native_assert(false);
 }
 
-inline void fromRawValue(const RawValue &value, YGPositionType &result) {
+inline void fromRawValue(
+    const PropsParserContext &context,
+    const RawValue &value,
+    YGPositionType &result) {
   react_native_assert(value.hasType<std::string>());
   auto stringValue = (std::string)value;
   if (stringValue == "static") {
@@ -296,7 +312,10 @@ inline void fromRawValue(const RawValue &value, YGPositionType &result) {
   react_native_assert(false);
 }
 
-inline void fromRawValue(const RawValue &value, YGWrap &result) {
+inline void fromRawValue(
+    const PropsParserContext &context,
+    const RawValue &value,
+    YGWrap &result) {
   react_native_assert(value.hasType<std::string>());
   auto stringValue = (std::string)value;
   if (stringValue == "nowrap") {
@@ -315,7 +334,10 @@ inline void fromRawValue(const RawValue &value, YGWrap &result) {
   react_native_assert(false);
 }
 
-inline void fromRawValue(const RawValue &value, YGOverflow &result) {
+inline void fromRawValue(
+    const PropsParserContext &context,
+    const RawValue &value,
+    YGOverflow &result) {
   react_native_assert(value.hasType<std::string>());
   auto stringValue = (std::string)value;
   if (stringValue == "visible") {
@@ -334,7 +356,10 @@ inline void fromRawValue(const RawValue &value, YGOverflow &result) {
   react_native_assert(false);
 }
 
-inline void fromRawValue(const RawValue &value, YGDisplay &result) {
+inline void fromRawValue(
+    const PropsParserContext &context,
+    const RawValue &value,
+    YGDisplay &result) {
   react_native_assert(value.hasType<std::string>());
   auto stringValue = (std::string)value;
   if (stringValue == "flex") {
@@ -349,7 +374,10 @@ inline void fromRawValue(const RawValue &value, YGDisplay &result) {
   react_native_assert(false);
 }
 
-inline void fromRawValue(const RawValue &value, YGStyle::ValueRepr &result) {
+inline void fromRawValue(
+    const PropsParserContext &context,
+    const RawValue &value,
+    YGStyle::ValueRepr &result) {
   if (value.hasType<Float>()) {
     result = yogaStyleValueFromFloat((Float)value);
     return;
@@ -373,7 +401,10 @@ inline void fromRawValue(const RawValue &value, YGStyle::ValueRepr &result) {
   result = YGValueUndefined;
 }
 
-inline void fromRawValue(const RawValue &value, YGFloatOptional &result) {
+inline void fromRawValue(
+    const PropsParserContext &context,
+    const RawValue &value,
+    YGFloatOptional &result) {
   if (value.hasType<float>()) {
     result = YGFloatOptional((float)value);
     return;
@@ -404,7 +435,10 @@ inline Float toRadians(const RawValue &value) {
   return static_cast<Float>(num); // assume suffix is "rad"
 }
 
-inline void fromRawValue(const RawValue &value, Transform &result) {
+inline void fromRawValue(
+    const PropsParserContext &context,
+    const RawValue &value,
+    Transform &result) {
   react_native_assert(value.hasType<std::vector<RawValue>>());
   auto transformMatrix = Transform{};
   auto configurations = static_cast<std::vector<RawValue>>(value);
@@ -479,7 +513,10 @@ inline void fromRawValue(const RawValue &value, Transform &result) {
   result = transformMatrix;
 }
 
-inline void fromRawValue(const RawValue &value, PointerEventsMode &result) {
+inline void fromRawValue(
+    const PropsParserContext &context,
+    const RawValue &value,
+    PointerEventsMode &result) {
   react_native_assert(value.hasType<std::string>());
   auto stringValue = (std::string)value;
   if (stringValue == "auto") {
@@ -502,7 +539,10 @@ inline void fromRawValue(const RawValue &value, PointerEventsMode &result) {
   react_native_assert(false);
 }
 
-inline void fromRawValue(const RawValue &value, BackfaceVisibility &result) {
+inline void fromRawValue(
+    const PropsParserContext &context,
+    const RawValue &value,
+    BackfaceVisibility &result) {
   react_native_assert(value.hasType<std::string>());
   auto stringValue = (std::string)value;
   if (stringValue == "auto") {
@@ -521,7 +561,10 @@ inline void fromRawValue(const RawValue &value, BackfaceVisibility &result) {
   react_native_assert(false);
 }
 
-inline void fromRawValue(const RawValue &value, BorderStyle &result) {
+inline void fromRawValue(
+    const PropsParserContext &context,
+    const RawValue &value,
+    BorderStyle &result) {
   react_native_assert(value.hasType<std::string>());
   auto stringValue = (std::string)value;
   if (stringValue == "solid") {

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

@@ -38,18 +38,19 @@ struct CascadedRectangleEdges {
   OptionalT all{};
 
   Counterpart resolve(bool isRTL, T defaults) const {
-    const auto leading = isRTL ? end : start;
-    const auto trailing = isRTL ? start : end;
+    const auto leadingEdge = isRTL ? end : start;
+    const auto trailingEdge = isRTL ? start : end;
     const auto horizontalOrAllOrDefault =
         horizontal.value_or(all.value_or(defaults));
     const auto verticalOrAllOrDefault =
         vertical.value_or(all.value_or(defaults));
 
     return {
-        /* .left = */ left.value_or(leading.value_or(horizontalOrAllOrDefault)),
+        /* .left = */
+        left.value_or(leadingEdge.value_or(horizontalOrAllOrDefault)),
         /* .top = */ top.value_or(verticalOrAllOrDefault),
         /* .right = */
-        right.value_or(trailing.value_or(horizontalOrAllOrDefault)),
+        right.value_or(trailingEdge.value_or(horizontalOrAllOrDefault)),
         /* .bottom = */ bottom.value_or(verticalOrAllOrDefault),
     };
   }