react-native 0.0.0-17be3a003 → 0.0.0-18697adec

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 = '2020.01.13.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};

package/ReactCommon/react/renderer/graphics/platform/android/react/renderer/graphics/PlatformColorParser.h

@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <react/jni/ReadableNativeMap.h>
+#include <react/renderer/core/PropsParserContext.h>
+#include <react/renderer/core/RawProps.h>
+#include <react/renderer/graphics/ColorComponents.h>
+
+namespace facebook {
+namespace react {
+
+inline ColorComponents parsePlatformColor(
+    const PropsParserContext &context,
+    const RawValue &value) {
+  ColorComponents colorComponents = {0, 0, 0, 0};
+
+  if (value.hasType<better::map<std::string, std::vector<std::string>>>()) {
+    auto map = (better::map<std::string, std::vector<std::string>>)value;
+    auto resourcePaths = map["resource_paths"];
+    auto dynamicResourcePaths = folly::dynamic::array();
+    for (const auto &resourcePath : resourcePaths) {
+      dynamicResourcePaths.push_back(resourcePath);
+    }
+    folly::dynamic dynamicPlatformColor = folly::dynamic::object();
+    dynamicPlatformColor["resource_paths"] = dynamicResourcePaths;
+
+    auto fabricUIManager =
+        context.contextContainer.at<jni::global_ref<jobject>>(
+            "FabricUIManager");
+
+    static auto getColorFromJava =
+        facebook::jni::findClassStatic(
+            "com/facebook/react/fabric/FabricUIManager")
+            ->getMethod<jint(jint, ReadableMap::javaobject)>("getColor");
+
+    jni::local_ref<ReadableNativeMap::javaobject> dynamicPlatformColorRNM =
+        ReadableNativeMap::newObjectCxxArgs(dynamicPlatformColor);
+    jni::local_ref<ReadableMap::javaobject> dynamicPlatformColorRM =
+        jni::make_local(reinterpret_cast<ReadableMap::javaobject>(
+            dynamicPlatformColorRNM.get()));
+
+    auto color = getColorFromJava(
+        fabricUIManager, context.surfaceId, dynamicPlatformColorRM.get());
+
+    dynamicPlatformColorRM.reset();
+    dynamicPlatformColorRNM.reset();
+
+    auto argb = (int64_t)color;
+    auto ratio = 255.f;
+    colorComponents.alpha = ((argb >> 24) & 0xFF) / ratio;
+    colorComponents.red = ((argb >> 16) & 0xFF) / ratio;
+    colorComponents.green = ((argb >> 8) & 0xFF) / ratio;
+    colorComponents.blue = (argb & 0xFF) / ratio;
+  }
+
+  return colorComponents;
+}
+
+} // namespace react
+} // namespace facebook

package/ReactCommon/react/renderer/graphics/platform/cxx/react/renderer/graphics/Color.cpp

@@ -10,6 +10,14 @@
 namespace facebook {
 namespace react {
 
+bool isColorMeaningful(SharedColor const &color) noexcept {
+  if (!color) {
+    return false;
+  }
+
+  return colorComponentsFromColor(color).alpha > 0;
+}
+
 SharedColor colorFromComponents(ColorComponents components) {
   float ratio = 255;
   return SharedColor(

package/ReactCommon/react/renderer/graphics/platform/cxx/react/renderer/graphics/Color.h

@@ -59,6 +59,7 @@ class SharedColor {
   Color color_;
 };
 
+bool isColorMeaningful(SharedColor const &color) noexcept;
 SharedColor colorFromComponents(ColorComponents components);
 ColorComponents colorComponentsFromColor(SharedColor color);
 

package/ReactCommon/react/renderer/graphics/platform/cxx/react/renderer/graphics/PlatformColorParser.h

@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <react/renderer/core/PropsParserContext.h>
+#include <react/renderer/core/RawProps.h>
+#include <react/renderer/graphics/ColorComponents.h>
+
+namespace facebook {
+namespace react {
+
+inline ColorComponents parsePlatformColor(
+    const PropsParserContext &context,
+    const RawValue &value) {
+  float alpha = 0;
+  float red = 0;
+  float green = 0;
+  float blue = 0;
+
+  return {red, green, blue, alpha};
+}
+
+} // namespace react
+} // namespace facebook

package/ReactCommon/react/renderer/graphics/platform/ios/Color.cpp

@@ -11,6 +11,14 @@
 namespace facebook {
 namespace react {
 
+bool isColorMeaningful(SharedColor const &color) noexcept {
+  if (!color) {
+    return false;
+  }
+
+  return colorComponentsFromColor(color).alpha > 0;
+}
+
 SharedColor colorFromComponents(ColorComponents components) {
   float ratio = 255;
   return SharedColor(

package/ReactCommon/react/renderer/graphics/platform/ios/Color.h

@@ -10,6 +10,7 @@
 #include <better/optional.h>
 #include <cmath>
 
+#include <folly/Hash.h>
 #include <react/renderer/graphics/ColorComponents.h>
 #include <react/renderer/graphics/Float.h>
 
@@ -18,8 +19,42 @@ namespace react {
 
 using Color = int32_t;
 
-using SharedColor = better::optional<Color>;
+class SharedColor {
+ public:
+  static const Color UndefinedColor = std::numeric_limits<Color>::max();
 
+  SharedColor() : color_(UndefinedColor) {}
+
+  SharedColor(const SharedColor &sharedColor) : color_(sharedColor.color_) {}
+
+  SharedColor(Color color) : color_(color) {}
+
+  SharedColor &operator=(const SharedColor &sharedColor) {
+    color_ = sharedColor.color_;
+    return *this;
+  }
+
+  Color operator*() const {
+    return color_;
+  }
+
+  bool operator==(const SharedColor &otherColor) const {
+    return color_ == otherColor.color_;
+  }
+
+  bool operator!=(const SharedColor &otherColor) const {
+    return color_ != otherColor.color_;
+  }
+
+  operator bool() const {
+    return color_ != UndefinedColor;
+  }
+
+ private:
+  Color color_;
+};
+
+bool isColorMeaningful(SharedColor const &color) noexcept;
 SharedColor colorFromComponents(ColorComponents components);
 ColorComponents colorComponentsFromColor(SharedColor color);
 
@@ -29,3 +64,10 @@ SharedColor whiteColor();
 
 } // namespace react
 } // namespace facebook
+
+template <>
+struct std::hash<facebook::react::SharedColor> {
+  std::size_t operator()(facebook::react::SharedColor const &color) const {
+    return hash<int>()(*color);
+  }
+};

package/ReactCommon/react/renderer/graphics/platform/ios/PlatformColorParser.h

@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <react/renderer/core/PropsParserContext.h>
+#include <react/renderer/core/RawProps.h>
+#include <react/renderer/graphics/ColorComponents.h>
+#include <react/renderer/graphics/RCTPlatformColorUtils.h>
+
+namespace facebook {
+namespace react {
+
+inline ColorComponents parsePlatformColor(
+    const PropsParserContext &context,
+    const RawValue &value) {
+  if (value.hasType<better::map<std::string, RawValue>>()) {
+    auto items = (better::map<std::string, RawValue>)value;
+    if (items.find("semantic") != items.end() &&
+        items.at("semantic").hasType<std::vector<std::string>>()) {
+      auto semanticItems = (std::vector<std::string>)items.at("semantic");
+      return RCTPlatformColorComponentsFromSemanticItems(semanticItems);
+    }
+  }
+
+  return {0, 0, 0, 0};
+}
+
+} // namespace react
+} // namespace facebook

package/ReactCommon/react/renderer/graphics/platform/ios/RCTPlatformColorUtils.h

@@ -0,0 +1,12 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include <react/renderer/graphics/ColorComponents.h>
+#include <vector>
+
+facebook::react::ColorComponents RCTPlatformColorComponentsFromSemanticItems(
+    std::vector<std::string> &semanticItems);

package/ReactCommon/react/renderer/graphics/platform/ios/RCTPlatformColorUtils.mm

@@ -0,0 +1,206 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "RCTPlatformColorUtils.h"
+
+#import <Foundation/Foundation.h>
+#import <React/RCTUtils.h>
+#import <UIKit/UIKit.h>
+
+#include <string>
+
+NS_ASSUME_NONNULL_BEGIN
+
+static NSString *const kColorSuffix = @"Color";
+static NSString *const kFallbackARGBKey = @"fallback-argb";
+
+static NSDictionary<NSString *, NSDictionary *> *_PlatformColorSelectorsDict()
+{
+  static NSDictionary<NSString *, NSDictionary *> *dict;
+  static dispatch_once_t once_token;
+  dispatch_once(&once_token, ^(void) {
+    dict = @{
+      // https://developer.apple.com/documentation/uikit/uicolor/ui_element_colors
+      // Label Colors
+      @"label" : @{
+        kFallbackARGBKey : @(0xFF000000) // iOS 13.0
+      },
+      @"secondaryLabel" : @{
+        kFallbackARGBKey : @(0x993c3c43) // iOS 13.0
+      },
+      @"tertiaryLabel" : @{
+        kFallbackARGBKey : @(0x4c3c3c43) // iOS 13.0
+      },
+      @"quaternaryLabel" : @{
+        kFallbackARGBKey : @(0x2d3c3c43) // iOS 13.0
+      },
+      // Fill Colors
+      @"systemFill" : @{
+        kFallbackARGBKey : @(0x33787880) // iOS 13.0
+      },
+      @"secondarySystemFill" : @{
+        kFallbackARGBKey : @(0x28787880) // iOS 13.0
+      },
+      @"tertiarySystemFill" : @{
+        kFallbackARGBKey : @(0x1e767680) // iOS 13.0
+      },
+      @"quaternarySystemFill" : @{
+        kFallbackARGBKey : @(0x14747480) // iOS 13.0
+      },
+      // Text Colors
+      @"placeholderText" : @{
+        kFallbackARGBKey : @(0x4c3c3c43) // iOS 13.0
+      },
+      // Standard Content Background Colors
+      @"systemBackground" : @{
+        kFallbackARGBKey : @(0xFFffffff) // iOS 13.0
+      },
+      @"secondarySystemBackground" : @{
+        kFallbackARGBKey : @(0xFFf2f2f7) // iOS 13.0
+      },
+      @"tertiarySystemBackground" : @{
+        kFallbackARGBKey : @(0xFFffffff) // iOS 13.0
+      },
+      // Grouped Content Background Colors
+      @"systemGroupedBackground" : @{
+        kFallbackARGBKey : @(0xFFf2f2f7) // iOS 13.0
+      },
+      @"secondarySystemGroupedBackground" : @{
+        kFallbackARGBKey : @(0xFFffffff) // iOS 13.0
+      },
+      @"tertiarySystemGroupedBackground" : @{
+        kFallbackARGBKey : @(0xFFf2f2f7) // iOS 13.0
+      },
+      // Separator Colors
+      @"separator" : @{
+        kFallbackARGBKey : @(0x493c3c43) // iOS 13.0
+      },
+      @"opaqueSeparator" : @{
+        kFallbackARGBKey : @(0xFFc6c6c8) // iOS 13.0
+      },
+      // Link Color
+      @"link" : @{
+        kFallbackARGBKey : @(0xFF007aff) // iOS 13.0
+      },
+      // Nonadaptable Colors
+      @"darkText" : @{},
+      @"lightText" : @{},
+      // https://developer.apple.com/documentation/uikit/uicolor/standard_colors
+      // Adaptable Colors
+      @"systemBlue" : @{},
+      @"systemBrown" : @{
+        kFallbackARGBKey : @(0xFFa2845e) // iOS 13.0
+      },
+      @"systemGreen" : @{},
+      @"systemIndigo" : @{
+        kFallbackARGBKey : @(0xFF5856d6) // iOS 13.0
+      },
+      @"systemOrange" : @{},
+      @"systemPink" : @{},
+      @"systemPurple" : @{},
+      @"systemRed" : @{},
+      @"systemTeal" : @{},
+      @"systemYellow" : @{},
+      // Adaptable Gray Colors
+      @"systemGray" : @{},
+      @"systemGray2" : @{
+        kFallbackARGBKey : @(0xFFaeaeb2) // iOS 13.0
+      },
+      @"systemGray3" : @{
+        kFallbackARGBKey : @(0xFFc7c7cc) // iOS 13.0
+      },
+      @"systemGray4" : @{
+        kFallbackARGBKey : @(0xFFd1d1d6) // iOS 13.0
+      },
+      @"systemGray5" : @{
+        kFallbackARGBKey : @(0xFFe5e5ea) // iOS 13.0
+      },
+      @"systemGray6" : @{
+        kFallbackARGBKey : @(0xFFf2f2f7) // iOS 13.0
+      },
+      // Transparent Color
+      @"clear" : @{
+        kFallbackARGBKey : @(0x00000000) // iOS 13.0
+      },
+    };
+  });
+  return dict;
+}
+
+static UIColor *_UIColorFromHexValue(NSNumber *hexValue)
+{
+  NSUInteger hexIntValue = [hexValue unsignedIntegerValue];
+
+  CGFloat red = ((CGFloat)((hexIntValue & 0xFF000000) >> 24)) / 255.0;
+  CGFloat green = ((CGFloat)((hexIntValue & 0xFF0000) >> 16)) / 255.0;
+  CGFloat blue = ((CGFloat)((hexIntValue & 0xFF00) >> 8)) / 255.0;
+  CGFloat alpha = ((CGFloat)(hexIntValue & 0xFF)) / 255.0;
+
+  return [UIColor colorWithRed:red green:green blue:blue alpha:alpha];
+}
+
+static UIColor *_Nullable _UIColorFromSemanticString(NSString *semanticString)
+{
+  NSString *platformColorString = [semanticString hasSuffix:kColorSuffix]
+      ? [semanticString substringToIndex:[semanticString length] - [kColorSuffix length]]
+      : semanticString;
+  NSDictionary<NSString *, NSDictionary *> *platformColorSelectorsDict = _PlatformColorSelectorsDict();
+  NSDictionary<NSString *, id> *colorInfo = platformColorSelectorsDict[platformColorString];
+  if (colorInfo) {
+    SEL objcColorSelector = NSSelectorFromString([platformColorString stringByAppendingString:kColorSuffix]);
+    if (![UIColor respondsToSelector:objcColorSelector]) {
+      NSNumber *fallbackRGB = colorInfo[kFallbackARGBKey];
+      if (fallbackRGB) {
+        return _UIColorFromHexValue(fallbackRGB);
+      }
+    } else {
+      Class uiColorClass = [UIColor class];
+      IMP imp = [uiColorClass methodForSelector:objcColorSelector];
+      id (*getUIColor)(id, SEL) = ((id(*)(id, SEL))imp);
+      id colorObject = getUIColor(uiColorClass, objcColorSelector);
+      if ([colorObject isKindOfClass:[UIColor class]]) {
+        return colorObject;
+      }
+    }
+  }
+  return nil;
+}
+
+static inline NSString *_NSStringFromCString(
+    const std::string &string,
+    const NSStringEncoding &encoding = NSUTF8StringEncoding)
+{
+  return [NSString stringWithCString:string.c_str() encoding:encoding];
+}
+
+static inline facebook::react::ColorComponents _ColorComponentsFromUIColor(UIColor *color)
+{
+  CGFloat rgba[4];
+  RCTGetRGBAColorComponents(color.CGColor, rgba);
+  return {(float)rgba[0], (float)rgba[1], (float)rgba[2], (float)rgba[3]};
+}
+
+facebook::react::ColorComponents RCTPlatformColorComponentsFromSemanticItems(std::vector<std::string> &semanticItems)
+{
+  for (const auto &semanticCString : semanticItems) {
+    if (@available(iOS 11.0, *)) {
+      NSString *semanticNSString = _NSStringFromCString(semanticCString);
+      UIColor *uiColor = [UIColor colorNamed:semanticNSString];
+      if (uiColor != nil) {
+        return _ColorComponentsFromUIColor(uiColor);
+      }
+      uiColor = _UIColorFromSemanticString(semanticNSString);
+      if (uiColor != nil) {
+        return _ColorComponentsFromUIColor(uiColor);
+      }
+    }
+  }
+
+  return {0, 0, 0, 0};
+}
+
+NS_ASSUME_NONNULL_END

package/ReactCommon/react/renderer/imagemanager/BUCK

@@ -64,8 +64,8 @@ rn_xplat_cxx_library(
     ],
     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/imagemanager/platform/ios/RCTSyncImageManager.mm

@@ -92,7 +92,7 @@ using namespace facebook::react;
 
   auto result = dispatch_group_wait(imageWaitGroup, dispatch_time(DISPATCH_TIME_NOW, 2 * NSEC_PER_SEC));
   if (result != 0) {
-    RCTLogError(@"Getting an image timed out");
+    RCTLogError(@"Image timed out in test environment for url: %@", loaderRequest.imageURL);
   }
   return imageRequest;
 }