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

package/ReactCommon/react/renderer/core/tests/RawPropsTest.cpp

@@ -10,6 +10,7 @@
 #include <gtest/gtest.h>
 #include <react/debug/flags.h>
 #include <react/renderer/core/ConcreteShadowNode.h>
+#include <react/renderer/core/PropsParserContext.h>
 #include <react/renderer/core/ShadowNode.h>
 #include <react/renderer/core/propsConversions.h>
 
@@ -21,9 +22,11 @@ class PropsSingleFloat : public Props {
  public:
   PropsSingleFloat() = default;
   PropsSingleFloat(
+      const PropsParserContext &context,
       const PropsSingleFloat &sourceProps,
       const RawProps &rawProps)
       : floatValue(convertRawProp(
+            context,
             rawProps,
             "floatValue",
             sourceProps.floatValue,
@@ -37,9 +40,11 @@ class PropsSingleDouble : public Props {
  public:
   PropsSingleDouble() = default;
   PropsSingleDouble(
+      const PropsParserContext &context,
       const PropsSingleDouble &sourceProps,
       const RawProps &rawProps)
       : doubleValue(convertRawProp(
+            context,
             rawProps,
             "doubleValue",
             sourceProps.doubleValue,
@@ -52,9 +57,16 @@ class PropsSingleDouble : public Props {
 class PropsSingleInt : public Props {
  public:
   PropsSingleInt() = default;
-  PropsSingleInt(const PropsSingleInt &sourceProps, const RawProps &rawProps)
-      : intValue(
-            convertRawProp(rawProps, "intValue", sourceProps.intValue, 17)) {}
+  PropsSingleInt(
+      const PropsParserContext &context,
+      const PropsSingleInt &sourceProps,
+      const RawProps &rawProps)
+      : intValue(convertRawProp(
+            context,
+            rawProps,
+            "intValue",
+            sourceProps.intValue,
+            17)) {}
 
  private:
   const int intValue{17};
@@ -64,26 +76,35 @@ class PropsPrimitiveTypes : public Props {
  public:
   PropsPrimitiveTypes() = default;
   PropsPrimitiveTypes(
+      const PropsParserContext &context,
       const PropsPrimitiveTypes &sourceProps,
       const RawProps &rawProps)
-      : intValue(
-            convertRawProp(rawProps, "intValue", sourceProps.intValue, 17)),
+      : intValue(convertRawProp(
+            context,
+            rawProps,
+            "intValue",
+            sourceProps.intValue,
+            17)),
         doubleValue(convertRawProp(
+            context,
             rawProps,
             "doubleValue",
             sourceProps.doubleValue,
             17.56)),
         floatValue(convertRawProp(
+            context,
             rawProps,
             "floatValue",
             sourceProps.floatValue,
             56.75)),
         stringValue(convertRawProp(
+            context,
             rawProps,
             "stringValue",
             sourceProps.stringValue,
             "")),
         boolValue(convertRawProp(
+            context,
             rawProps,
             "boolValue",
             sourceProps.boolValue,
@@ -101,9 +122,11 @@ class PropsMultiLookup : public Props {
  public:
   PropsMultiLookup() = default;
   PropsMultiLookup(
+      const PropsParserContext &context,
       const PropsMultiLookup &sourceProps,
       const RawProps &rawProps)
       : floatValue(convertRawProp(
+            context,
             rawProps,
             "floatValue",
             sourceProps.floatValue,
@@ -112,7 +135,12 @@ class PropsMultiLookup : public Props {
         // pattern that does occur a lot: nested structs that access props we
         // have already accessed populating Props
         derivedFloatValue(
-            convertRawProp(rawProps, "floatValue", sourceProps.floatValue, 40) *
+            convertRawProp(
+                context,
+                rawProps,
+                "floatValue",
+                sourceProps.floatValue,
+                40) *
             2) {}
 
   const float floatValue{17.5};
@@ -120,12 +148,15 @@ class PropsMultiLookup : public Props {
 };
 
 TEST(RawPropsTest, handleProps) {
+  ContextContainer contextContainer{};
+  PropsParserContext parserContext{-1, contextContainer};
+
   const auto &raw = RawProps(folly::dynamic::object("nativeID", "abc"));
   auto parser = RawPropsParser();
   parser.prepare<Props>();
-  raw.parse(parser);
+  raw.parse(parser, parserContext);
 
-  auto props = std::make_shared<Props>(Props(), raw);
+  auto props = std::make_shared<Props>(parserContext, Props(), raw);
 
   // Props are not sealed after applying raw props.
   EXPECT_FALSE(props->getSealed());
@@ -134,10 +165,13 @@ TEST(RawPropsTest, handleProps) {
 }
 
 TEST(RawPropsTest, handleRawPropsSingleString) {
+  ContextContainer contextContainer{};
+  PropsParserContext parserContext{-1, contextContainer};
+
   const auto &raw = RawProps(folly::dynamic::object("nativeID", "abc"));
   auto parser = RawPropsParser();
   parser.prepare<Props>();
-  raw.parse(parser);
+  raw.parse(parser, parserContext);
 
   std::string value = (std::string)*raw.at("nativeID", nullptr, nullptr);
 
@@ -145,11 +179,14 @@ TEST(RawPropsTest, handleRawPropsSingleString) {
 }
 
 TEST(RawPropsTest, handleRawPropsSingleFloat) {
+  ContextContainer contextContainer{};
+  PropsParserContext parserContext{-1, contextContainer};
+
   const auto &raw =
       RawProps(folly::dynamic::object("floatValue", (float)42.42));
   auto parser = RawPropsParser();
   parser.prepare<PropsSingleFloat>();
-  raw.parse(parser);
+  raw.parse(parser, parserContext);
 
   float value = (float)*raw.at("floatValue", nullptr, nullptr);
 
@@ -157,11 +194,14 @@ TEST(RawPropsTest, handleRawPropsSingleFloat) {
 }
 
 TEST(RawPropsTest, handleRawPropsSingleDouble) {
+  ContextContainer contextContainer{};
+  PropsParserContext parserContext{-1, contextContainer};
+
   const auto &raw =
       RawProps(folly::dynamic::object("doubleValue", (double)42.42));
   auto parser = RawPropsParser();
   parser.prepare<PropsSingleDouble>();
-  raw.parse(parser);
+  raw.parse(parser, parserContext);
 
   double value = (double)*raw.at("doubleValue", nullptr, nullptr);
 
@@ -169,10 +209,13 @@ TEST(RawPropsTest, handleRawPropsSingleDouble) {
 }
 
 TEST(RawPropsTest, handleRawPropsSingleInt) {
+  ContextContainer contextContainer{};
+  PropsParserContext parserContext{-1, contextContainer};
+
   const auto &raw = RawProps(folly::dynamic::object("intValue", (int)42.42));
   auto parser = RawPropsParser();
   parser.prepare<PropsSingleInt>();
-  raw.parse(parser);
+  raw.parse(parser, parserContext);
 
   int value = (int)*raw.at("intValue", nullptr, nullptr);
 
@@ -180,10 +223,13 @@ TEST(RawPropsTest, handleRawPropsSingleInt) {
 }
 
 TEST(RawPropsTest, handleRawPropsSingleIntGetManyTimes) {
+  ContextContainer contextContainer{};
+  PropsParserContext parserContext{-1, contextContainer};
+
   const auto &raw = RawProps(folly::dynamic::object("intValue", (int)42.42));
   auto parser = RawPropsParser();
   parser.prepare<PropsSingleInt>();
-  raw.parse(parser);
+  raw.parse(parser, parserContext);
 
   EXPECT_EQ((int)*raw.at("intValue", nullptr, nullptr), 42);
   EXPECT_EQ((int)*raw.at("intValue", nullptr, nullptr), 42);
@@ -191,13 +237,17 @@ TEST(RawPropsTest, handleRawPropsSingleIntGetManyTimes) {
 }
 
 TEST(RawPropsTest, handleRawPropsPrimitiveTypes) {
-  const auto &raw = RawProps(folly::dynamic::object("intValue", (int)42)(
-      "doubleValue", (double)17.42)("floatValue", (float)66.67)(
-      "stringValue", "helloworld")("boolValue", true));
+  ContextContainer contextContainer{};
+  PropsParserContext parserContext{-1, contextContainer};
+
+  const auto &raw = RawProps(
+      folly::dynamic::object("intValue", (int)42)("doubleValue", (double)17.42)(
+          "floatValue",
+          (float)66.67)("stringValue", "helloworld")("boolValue", true));
 
   auto parser = RawPropsParser();
   parser.prepare<PropsPrimitiveTypes>();
-  raw.parse(parser);
+  raw.parse(parser, parserContext);
 
   EXPECT_EQ((int)*raw.at("intValue", nullptr, nullptr), 42);
   EXPECT_NEAR((double)*raw.at("doubleValue", nullptr, nullptr), 17.42, 0.0001);
@@ -209,13 +259,17 @@ TEST(RawPropsTest, handleRawPropsPrimitiveTypes) {
 }
 
 TEST(RawPropsTest, handleRawPropsPrimitiveTypesGetTwice) {
-  const auto &raw = RawProps(folly::dynamic::object("intValue", (int)42)(
-      "doubleValue", (double)17.42)("floatValue", (float)66.67)(
-      "stringValue", "helloworld")("boolValue", true));
+  ContextContainer contextContainer{};
+  PropsParserContext parserContext{-1, contextContainer};
+
+  const auto &raw = RawProps(
+      folly::dynamic::object("intValue", (int)42)("doubleValue", (double)17.42)(
+          "floatValue",
+          (float)66.67)("stringValue", "helloworld")("boolValue", true));
 
   auto parser = RawPropsParser();
   parser.prepare<PropsPrimitiveTypes>();
-  raw.parse(parser);
+  raw.parse(parser, parserContext);
 
   EXPECT_EQ((int)*raw.at("intValue", nullptr, nullptr), 42);
   EXPECT_NEAR((double)*raw.at("doubleValue", nullptr, nullptr), 17.42, 0.0001);
@@ -235,13 +289,17 @@ TEST(RawPropsTest, handleRawPropsPrimitiveTypesGetTwice) {
 }
 
 TEST(RawPropsTest, handleRawPropsPrimitiveTypesGetOutOfOrder) {
-  const auto &raw = RawProps(folly::dynamic::object("intValue", (int)42)(
-      "doubleValue", (double)17.42)("floatValue", (float)66.67)(
-      "stringValue", "helloworld")("boolValue", true));
+  ContextContainer contextContainer{};
+  PropsParserContext parserContext{-1, contextContainer};
+
+  const auto &raw = RawProps(
+      folly::dynamic::object("intValue", (int)42)("doubleValue", (double)17.42)(
+          "floatValue",
+          (float)66.67)("stringValue", "helloworld")("boolValue", true));
 
   auto parser = RawPropsParser();
   parser.prepare<PropsPrimitiveTypes>();
-  raw.parse(parser);
+  raw.parse(parser, parserContext);
 
   EXPECT_EQ((int)*raw.at("intValue", nullptr, nullptr), 42);
   EXPECT_NEAR((double)*raw.at("doubleValue", nullptr, nullptr), 17.42, 0.0001);
@@ -261,11 +319,14 @@ TEST(RawPropsTest, handleRawPropsPrimitiveTypesGetOutOfOrder) {
 }
 
 TEST(RawPropsTest, handleRawPropsPrimitiveTypesIncomplete) {
+  ContextContainer contextContainer{};
+  PropsParserContext parserContext{-1, contextContainer};
+
   const auto &raw = RawProps(folly::dynamic::object("intValue", (int)42));
 
   auto parser = RawPropsParser();
   parser.prepare<PropsPrimitiveTypes>();
-  raw.parse(parser);
+  raw.parse(parser, parserContext);
 
   EXPECT_EQ((int)*raw.at("intValue", nullptr, nullptr), 42);
   EXPECT_EQ(raw.at("doubleValue", nullptr, nullptr), nullptr);
@@ -278,11 +339,14 @@ TEST(RawPropsTest, handleRawPropsPrimitiveTypesIncomplete) {
 
 #ifdef REACT_NATIVE_DEBUG
 TEST(RawPropsTest, handleRawPropsPrimitiveTypesIncorrectLookup) {
+  ContextContainer contextContainer{};
+  PropsParserContext parserContext{-1, contextContainer};
+
   const auto &raw = RawProps(folly::dynamic::object("intValue", (int)42));
 
   auto parser = RawPropsParser();
   parser.prepare<PropsPrimitiveTypes>();
-  raw.parse(parser);
+  raw.parse(parser, parserContext);
 
   // Before D18662135, looking up an invalid key would trigger
   // an infinite loop. This is out of contract, so we should only
@@ -293,12 +357,16 @@ TEST(RawPropsTest, handleRawPropsPrimitiveTypesIncorrectLookup) {
 #endif
 
 TEST(RawPropsTest, handlePropsMultiLookup) {
+  ContextContainer contextContainer{};
+  PropsParserContext parserContext{-1, contextContainer};
+
   const auto &raw = RawProps(folly::dynamic::object("floatValue", (float)10.0));
   auto parser = RawPropsParser();
   parser.prepare<PropsMultiLookup>();
-  raw.parse(parser);
+  raw.parse(parser, parserContext);
 
-  auto props = std::make_shared<PropsMultiLookup>(PropsMultiLookup(), raw);
+  auto props = std::make_shared<PropsMultiLookup>(
+      parserContext, PropsMultiLookup(), raw);
 
   // Props are not sealed after applying raw props.
   EXPECT_FALSE(props->getSealed());

package/ReactCommon/react/renderer/core/tests/TestComponent.h

@@ -14,6 +14,7 @@
 #include <react/renderer/components/view/ViewEventEmitter.h>
 #include <react/renderer/components/view/ViewProps.h>
 #include <react/renderer/core/ConcreteComponentDescriptor.h>
+#include <react/renderer/core/PropsParserContext.h>
 #include <react/renderer/core/RawProps.h>
 #include <react/renderer/core/ShadowNode.h>
 
@@ -35,8 +36,11 @@ class TestProps : public ViewProps {
  public:
   TestProps() = default;
 
-  TestProps(const TestProps &sourceProps, const RawProps &rawProps)
-      : ViewProps(sourceProps, rawProps) {}
+  TestProps(
+      const PropsParserContext &context,
+      const TestProps &sourceProps,
+      const RawProps &rawProps)
+      : ViewProps(context, sourceProps, rawProps) {}
 };
 
 using SharedTestProps = std::shared_ptr<const TestProps>;

package/ReactCommon/react/renderer/core/tests/traitCastTest.cpp

@@ -47,6 +47,9 @@ TEST(traitCastTest, testOne) {
 
   auto rootShadowNode = builder.build(element);
 
+  std::shared_ptr<ShadowNode> shadowNodeForRawTextShadowNode{rawTextShadowNode};
+  std::shared_ptr<ShadowNode> shadowNodeForTextShadowNode{textShadowNode};
+
   // Casting `nullptr` returns `nullptrs`.
   EXPECT_FALSE(traitCast<LayoutableShadowNode const *>(nullptr));
   EXPECT_FALSE(traitCast<YogaLayoutableShadowNode const *>(nullptr));
@@ -102,4 +105,32 @@ TEST(traitCastTest, testOne) {
       traitCast<LayoutableShadowNode const &>(*rawTextShadowNode), "");
   EXPECT_DEATH_IF_SUPPORTED(
       traitCast<YogaLayoutableShadowNode const &>(*rawTextShadowNode), "");
+
+  // trait cast to `RawTextShadowNode` works on `RawTextShadowNode`
+  // and not on TextShadowNode or ViewShadowNode
+  EXPECT_TRUE(traitCast<RawTextShadowNode const *>(
+      shadowNodeForRawTextShadowNode.get()));
+  EXPECT_NO_FATAL_FAILURE(
+      traitCast<RawTextShadowNode const &>(*shadowNodeForRawTextShadowNode));
+  EXPECT_FALSE(
+      traitCast<RawTextShadowNode const *>(shadowNodeForTextShadowNode.get()));
+  EXPECT_DEATH_IF_SUPPORTED(
+      traitCast<RawTextShadowNode const &>(*shadowNodeForTextShadowNode), "");
+  EXPECT_FALSE(traitCast<RawTextShadowNode const *>(viewShadowNode.get()));
+  EXPECT_DEATH_IF_SUPPORTED(
+      traitCast<RawTextShadowNode const &>(*viewShadowNode), "");
+
+  // trait cast to `TextShadowNode` works on `TextShadowNode`
+  // and not on RawTextShadowNode or ViewShadowNode
+  EXPECT_TRUE(
+      traitCast<TextShadowNode const *>(shadowNodeForTextShadowNode.get()));
+  EXPECT_NO_FATAL_FAILURE(
+      traitCast<TextShadowNode const &>(*shadowNodeForTextShadowNode));
+  EXPECT_FALSE(
+      traitCast<TextShadowNode const *>(shadowNodeForRawTextShadowNode.get()));
+  EXPECT_DEATH_IF_SUPPORTED(
+      traitCast<TextShadowNode const &>(*shadowNodeForRawTextShadowNode), "");
+  EXPECT_FALSE(traitCast<TextShadowNode const *>(viewShadowNode.get()));
+  EXPECT_DEATH_IF_SUPPORTED(
+      traitCast<TextShadowNode const &>(*viewShadowNode), "");
 }

package/ReactCommon/react/renderer/debug/DebugStringConvertible.h

@@ -192,16 +192,16 @@ std::string getDebugChildrenDescription(
     return "";
   }
 
-  auto trailing = options.format ? std::string{"\n"} : std::string{""};
+  auto separator = options.format ? std::string{"\n"} : std::string{""};
   auto childrenString = std::string{""};
   options.depth++;
 
   for (auto child : getDebugChildren(object, options)) {
-    childrenString += getDebugDescription(child, options) + trailing;
+    childrenString += getDebugDescription(child, options) + separator;
   }
 
-  if (!childrenString.empty() && !trailing.empty()) {
-    // Removing trailing fragment.
+  if (!childrenString.empty() && !separator.empty()) {
+    // Removing separator fragment.
     childrenString.erase(childrenString.end() - 1);
   }
 
@@ -230,16 +230,16 @@ std::string getDebugDescription(
   auto childrenString = getDebugChildrenDescription(object, options);
   auto propsString = getDebugPropsDescription(object, options);
 
-  auto leading =
+  auto prefix =
       options.format ? std::string(options.depth * 2, ' ') : std::string{""};
-  auto trailing = options.format ? std::string{"\n"} : std::string{""};
+  auto separator = options.format ? std::string{"\n"} : std::string{""};
 
-  return leading + "<" + nameString +
+  return prefix + "<" + nameString +
       (valueString.empty() ? "" : "=" + valueString) +
       (propsString.empty() ? "" : " " + propsString) +
       (childrenString.empty() ? "/>"
-                              : ">" + trailing + childrenString + trailing +
-               leading + "</" + nameString + ">");
+                              : ">" + separator + childrenString + separator +
+               prefix + "</" + nameString + ">");
 }
 
 /*

package/ReactCommon/react/renderer/graphics/Android.mk

@@ -11,11 +11,11 @@ LOCAL_MODULE := react_render_graphics
 
 LOCAL_SRC_FILES := $(wildcard $(LOCAL_PATH)/*.cpp $(LOCAL_PATH)/platform/cxx/react/renderer/graphics/*.cpp)
 
-LOCAL_SHARED_LIBRARIES := libfolly_json libreact_debug
+LOCAL_SHARED_LIBRARIES := libfolly_json libreact_debug libfb libfbjni libfolly_json glog
 
 LOCAL_STATIC_LIBRARIES :=
 
-LOCAL_C_INCLUDES := $(LOCAL_PATH)/../../../ $(LOCAL_PATH)/platform/cxx/
+LOCAL_C_INCLUDES := $(LOCAL_PATH)/ $(LOCAL_PATH)/../../../ $(LOCAL_PATH)/platform/cxx/
 
 LOCAL_EXPORT_C_INCLUDES := $(LOCAL_PATH)/../../../ $(LOCAL_PATH)/platform/cxx/
 
@@ -26,5 +26,8 @@ LOCAL_CFLAGS += -fexceptions -frtti -std=c++17 -Wall
 
 include $(BUILD_SHARED_LIBRARY)
 
+$(call import-module,glog)
+$(call import-module,fbjni)
+$(call import-module,fb)
 $(call import-module,folly)
 $(call import-module,react/debug)

package/ReactCommon/react/renderer/graphics/BUCK

@@ -3,10 +3,12 @@ load(
     "ANDROID",
     "APPLE",
     "CXX",
+    "FBJNI_TARGET",
     "fb_xplat_cxx_test",
     "get_apple_compiler_flags",
     "get_apple_inspector_flags",
     "get_preprocessor_flags_for_build_mode",
+    "react_native_target",
     "react_native_xplat_target",
     "rn_xplat_cxx_library",
     "subdir_glob",
@@ -51,23 +53,32 @@ rn_xplat_cxx_library(
             "platform/cxx/react/renderer/graphics/**/*.cpp",
         ],
     ),
+    fbandroid_allow_jni_merging = True,
+    fbandroid_deps = [
+        FBJNI_TARGET,
+        react_native_target("jni/react/jni:jni"),
+    ],
     fbandroid_exported_headers = subdir_glob(
         [
+            ("platform/android/react/renderer/graphics", "**/*.h"),
             ("platform/cxx/react/renderer/graphics", "**/*.h"),
         ],
+        exclude = ["platform/cxx/react/renderer/graphics/PlatformColorParser.h"],
         prefix = "react/renderer/graphics",
     ),
     fbandroid_srcs = glob(
         [
             "platform/cxx/react/renderer/graphics/**/*.cpp",
+            "platform/android/react/renderer/graphics/**/*.cpp",
         ],
+        exclude = ["platform/cxx/react/renderer/graphics/PlatformColorParser.h"],
     ),
     fbobjc_compiler_flags = APPLE_COMPILER_FLAGS,
     fbobjc_preprocessor_flags = get_preprocessor_flags_for_build_mode() + get_apple_inspector_flags(),
     force_static = True,
     ios_deps = [
-        "//xplat/js:RCTImage",
         "//xplat/js/react-native-github:RCTCxxBridge",
+        "//xplat/js/react-native-github:RCTImage",
     ],
     ios_exported_headers = subdir_glob(
         [

package/ReactCommon/react/renderer/graphics/React-graphics.podspec

@@ -17,7 +17,7 @@ else
 end
 
 folly_compiler_flags = '-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1 -Wno-comma -Wno-shorten-64-to-32'
-folly_version = '2021.04.26.00'
+folly_version = '2021.06.28.00-v2'
 boost_compiler_flags = '-Wno-documentation'
 
 Pod::Spec.new do |s|
@@ -36,7 +36,8 @@ Pod::Spec.new do |s|
                              "platform/android",
                              "platform/cxx"
   s.header_dir             = "react/renderer/graphics"
-  s.pod_target_xcconfig  = { "USE_HEADERMAP" => "NO", "HEADER_SEARCH_PATHS" => "\"$(PODS_ROOT)/boost-for-react-native\" \"$(PODS_TARGET_SRCROOT)/../../../\" \"$(PODS_ROOT)/RCT-Folly\"" }
+  s.pod_target_xcconfig  = { "USE_HEADERMAP" => "NO", "HEADER_SEARCH_PATHS" => "\"$(PODS_ROOT)/boost\" \"$(PODS_TARGET_SRCROOT)/../../../\" \"$(PODS_ROOT)/RCT-Folly\"" }
 
   s.dependency "RCT-Folly/Fabric", folly_version
+  s.dependency "React-Core/Default", version
 end

package/ReactCommon/react/renderer/graphics/Transform.cpp

@@ -183,14 +183,14 @@ TransformOperation Transform::DefaultTransformOperation(
 }
 
 Transform Transform::Interpolate(
-    float animationProgress,
+    Float animationProgress,
     Transform const &lhs,
     Transform const &rhs) {
   // Iterate through operations and reconstruct an interpolated resulting
   // transform If at any point we hit an "Arbitrary" Transform, return at that
   // point
   Transform result = Transform::Identity();
-  for (int i = 0, j = 0;
+  for (size_t i = 0, j = 0;
        i < lhs.operations.size() || j < rhs.operations.size();) {
     bool haveLHS = i < lhs.operations.size();
     bool haveRHS = j < rhs.operations.size();

package/ReactCommon/react/renderer/graphics/Transform.h

@@ -117,7 +117,7 @@ struct Transform {
    * @return
    */
   static Transform Interpolate(
-      float animationProgress,
+      Float animationProgress,
       Transform const &lhs,
       Transform const &rhs);
 

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

@@ -8,42 +8,45 @@
 #pragma once
 
 #include <better/map.h>
-#include <folly/dynamic.h>
 #include <glog/logging.h>
 #include <react/debug/react_native_assert.h>
+#include <react/renderer/core/PropsParserContext.h>
 #include <react/renderer/core/RawProps.h>
 #include <react/renderer/graphics/Color.h>
 #include <react/renderer/graphics/Geometry.h>
+#include <react/renderer/graphics/PlatformColorParser.h>
 
 namespace facebook {
 namespace react {
 
 #pragma mark - Color
 
-inline void fromRawValue(const RawValue &value, SharedColor &result) {
-  float red = 0;
-  float green = 0;
-  float blue = 0;
-  float alpha = 0;
+inline void fromRawValue(
+    const PropsParserContext &context,
+    const RawValue &value,
+    SharedColor &result) {
+  ColorComponents colorComponents = {0, 0, 0, 0};
 
   if (value.hasType<int>()) {
     auto argb = (int64_t)value;
     auto ratio = 255.f;
-    alpha = ((argb >> 24) & 0xFF) / ratio;
-    red = ((argb >> 16) & 0xFF) / ratio;
-    green = ((argb >> 8) & 0xFF) / ratio;
-    blue = (argb & 0xFF) / ratio;
+    colorComponents.alpha = ((argb >> 24) & 0xFF) / ratio;
+    colorComponents.red = ((argb >> 16) & 0xFF) / ratio;
+    colorComponents.green = ((argb >> 8) & 0xFF) / ratio;
+    colorComponents.blue = (argb & 0xFF) / ratio;
   } else if (value.hasType<std::vector<float>>()) {
     auto items = (std::vector<float>)value;
     auto length = items.size();
     react_native_assert(length == 3 || length == 4);
-    red = items.at(0);
-    green = items.at(1);
-    blue = items.at(2);
-    alpha = length == 4 ? items.at(3) : 1.0f;
+    colorComponents.red = items.at(0);
+    colorComponents.green = items.at(1);
+    colorComponents.blue = items.at(2);
+    colorComponents.alpha = length == 4 ? items.at(3) : 1.0f;
+  } else {
+    colorComponents = parsePlatformColor(context, value);
   }
 
-  result = colorFromComponents({red, green, blue, alpha});
+  result = colorFromComponents(colorComponents);
 }
 
 #ifdef ANDROID
@@ -81,7 +84,10 @@ inline std::string toString(const SharedColor &value) {
 
 #pragma mark - Geometry
 
-inline void fromRawValue(const RawValue &value, Point &result) {
+inline void fromRawValue(
+    const PropsParserContext &context,
+    const RawValue &value,
+    Point &result) {
   if (value.hasType<better::map<std::string, Float>>()) {
     auto map = (better::map<std::string, Float>)value;
     for (const auto &pair : map) {
@@ -109,7 +115,10 @@ inline void fromRawValue(const RawValue &value, Point &result) {
   }
 }
 
-inline void fromRawValue(const RawValue &value, Size &result) {
+inline void fromRawValue(
+    const PropsParserContext &context,
+    const RawValue &value,
+    Size &result) {
   if (value.hasType<better::map<std::string, Float>>()) {
     auto map = (better::map<std::string, Float>)value;
     for (const auto &pair : map) {
@@ -140,7 +149,10 @@ inline void fromRawValue(const RawValue &value, Size &result) {
   }
 }
 
-inline void fromRawValue(const RawValue &value, EdgeInsets &result) {
+inline void fromRawValue(
+    const PropsParserContext &context,
+    const RawValue &value,
+    EdgeInsets &result) {
   if (value.hasType<Float>()) {
     auto number = (Float)value;
     result = {number, number, number, number};
@@ -180,7 +192,10 @@ inline void fromRawValue(const RawValue &value, EdgeInsets &result) {
   }
 }
 
-inline void fromRawValue(const RawValue &value, CornerInsets &result) {
+inline void fromRawValue(
+    const PropsParserContext &context,
+    const RawValue &value,
+    CornerInsets &result) {
   if (value.hasType<Float>()) {
     auto number = (Float)value;
     result = {number, number, number, number};