react-native 0.71.6 → 0.72.0-rc.1

package/ReactCommon/react/renderer/core/graphicsConversions.h

@@ -0,0 +1,260 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and 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 <butter/map.h>
+#include <glog/logging.h>
+#include <react/debug/react_native_expect.h>
+#include <react/renderer/core/PropsParserContext.h>
+#include <react/renderer/core/RawProps.h>
+#include <react/renderer/graphics/Color.h>
+#include <react/renderer/graphics/PlatformColorParser.h>
+#include <react/renderer/graphics/Point.h>
+#include <react/renderer/graphics/Rect.h>
+#include <react/renderer/graphics/RectangleCorners.h>
+#include <react/renderer/graphics/RectangleEdges.h>
+#include <react/renderer/graphics/Size.h>
+
+namespace facebook {
+namespace react {
+
+#pragma mark - Color
+
+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;
+    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_expect(length == 3 || length == 4);
+    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(colorComponents);
+}
+
+#ifdef ANDROID
+inline int toAndroidRepr(const SharedColor &color) {
+  return *color;
+}
+inline folly::dynamic toDynamic(const SharedColor &color) {
+  return *color;
+}
+#endif
+
+inline std::string toString(const SharedColor &value) {
+  ColorComponents components = colorComponentsFromColor(value);
+  auto ratio = 255.f;
+  return "rgba(" + folly::to<std::string>(round(components.red * ratio)) +
+      ", " + folly::to<std::string>(round(components.green * ratio)) + ", " +
+      folly::to<std::string>(round(components.blue * ratio)) + ", " +
+      folly::to<std::string>(round(components.alpha * ratio)) + ")";
+}
+
+#pragma mark - Geometry
+
+inline void fromRawValue(
+    const PropsParserContext &context,
+    const RawValue &value,
+    Point &result) {
+  if (value.hasType<butter::map<std::string, Float>>()) {
+    auto map = (butter::map<std::string, Float>)value;
+    for (const auto &pair : map) {
+      if (pair.first == "x") {
+        result.x = pair.second;
+      } else if (pair.first == "y") {
+        result.y = pair.second;
+      }
+    }
+    return;
+  }
+
+  react_native_expect(value.hasType<std::vector<Float>>());
+  if (value.hasType<std::vector<Float>>()) {
+    auto array = (std::vector<Float>)value;
+    react_native_expect(array.size() == 2);
+    if (array.size() >= 2) {
+      result = {array.at(0), array.at(1)};
+    } else {
+      result = {0, 0};
+      LOG(ERROR) << "Unsupported Point vector size: " << array.size();
+    }
+  } else {
+    LOG(ERROR) << "Unsupported Point type";
+  }
+}
+
+inline void fromRawValue(
+    const PropsParserContext &context,
+    const RawValue &value,
+    Size &result) {
+  if (value.hasType<butter::map<std::string, Float>>()) {
+    auto map = (butter::map<std::string, Float>)value;
+    for (const auto &pair : map) {
+      if (pair.first == "width") {
+        result.width = pair.second;
+      } else if (pair.first == "height") {
+        result.height = pair.second;
+      } else {
+        LOG(ERROR) << "Unsupported Size map key: " << pair.first;
+        react_native_expect(false);
+      }
+    }
+    return;
+  }
+
+  react_native_expect(value.hasType<std::vector<Float>>());
+  if (value.hasType<std::vector<Float>>()) {
+    auto array = (std::vector<Float>)value;
+    react_native_expect(array.size() == 2);
+    if (array.size() >= 2) {
+      result = {array.at(0), array.at(1)};
+    } else {
+      result = {0, 0};
+      LOG(ERROR) << "Unsupported Size vector size: " << array.size();
+    }
+  } else {
+    LOG(ERROR) << "Unsupported Size type";
+  }
+}
+
+inline void fromRawValue(
+    const PropsParserContext &context,
+    const RawValue &value,
+    EdgeInsets &result) {
+  if (value.hasType<Float>()) {
+    auto number = (Float)value;
+    result = {number, number, number, number};
+    return;
+  }
+
+  if (value.hasType<butter::map<std::string, Float>>()) {
+    auto map = (butter::map<std::string, Float>)value;
+    for (const auto &pair : map) {
+      if (pair.first == "top") {
+        result.top = pair.second;
+      } else if (pair.first == "left") {
+        result.left = pair.second;
+      } else if (pair.first == "bottom") {
+        result.bottom = pair.second;
+      } else if (pair.first == "right") {
+        result.right = pair.second;
+      } else {
+        LOG(ERROR) << "Unsupported EdgeInsets map key: " << pair.first;
+        react_native_expect(false);
+      }
+    }
+    return;
+  }
+
+  react_native_expect(value.hasType<std::vector<Float>>());
+  if (value.hasType<std::vector<Float>>()) {
+    auto array = (std::vector<Float>)value;
+    react_native_expect(array.size() == 4);
+    if (array.size() >= 4) {
+      result = {array.at(0), array.at(1), array.at(2), array.at(3)};
+    } else {
+      result = {0, 0, 0, 0};
+      LOG(ERROR) << "Unsupported EdgeInsets vector size: " << array.size();
+    }
+  } else {
+    LOG(ERROR) << "Unsupported EdgeInsets type";
+  }
+}
+
+inline void fromRawValue(
+    const PropsParserContext &context,
+    const RawValue &value,
+    CornerInsets &result) {
+  if (value.hasType<Float>()) {
+    auto number = (Float)value;
+    result = {number, number, number, number};
+    return;
+  }
+
+  if (value.hasType<butter::map<std::string, Float>>()) {
+    auto map = (butter::map<std::string, Float>)value;
+    for (const auto &pair : map) {
+      if (pair.first == "topLeft") {
+        result.topLeft = pair.second;
+      } else if (pair.first == "topRight") {
+        result.topRight = pair.second;
+      } else if (pair.first == "bottomLeft") {
+        result.bottomLeft = pair.second;
+      } else if (pair.first == "bottomRight") {
+        result.bottomRight = pair.second;
+      } else {
+        LOG(ERROR) << "Unsupported CornerInsets map key: " << pair.first;
+        react_native_expect(false);
+      }
+    }
+    return;
+  }
+
+  react_native_expect(value.hasType<std::vector<Float>>());
+  if (value.hasType<std::vector<Float>>()) {
+    auto array = (std::vector<Float>)value;
+    react_native_expect(array.size() == 4);
+    if (array.size() >= 4) {
+      result = {array.at(0), array.at(1), array.at(2), array.at(3)};
+    } else {
+      LOG(ERROR) << "Unsupported CornerInsets vector size: " << array.size();
+    }
+  }
+
+  // Error case - we should only here if all other supported cases fail
+  // In dev we would crash on assert before this point
+  result = {0, 0, 0, 0};
+  LOG(ERROR) << "Unsupported CornerInsets type";
+}
+
+inline std::string toString(const Point &point) {
+  return "{" + folly::to<std::string>(point.x) + ", " +
+      folly::to<std::string>(point.y) + "}";
+}
+
+inline std::string toString(const Size &size) {
+  return "{" + folly::to<std::string>(size.width) + ", " +
+      folly::to<std::string>(size.height) + "}";
+}
+
+inline std::string toString(const Rect &rect) {
+  return "{" + toString(rect.origin) + ", " + toString(rect.size) + "}";
+}
+
+inline std::string toString(const EdgeInsets &edgeInsets) {
+  return "{" + folly::to<std::string>(edgeInsets.left) + ", " +
+      folly::to<std::string>(edgeInsets.top) + ", " +
+      folly::to<std::string>(edgeInsets.right) + ", " +
+      folly::to<std::string>(edgeInsets.bottom) + "}";
+}
+
+inline std::string toString(const CornerInsets &cornerInsets) {
+  return "{" + folly::to<std::string>(cornerInsets.topLeft) + ", " +
+      folly::to<std::string>(cornerInsets.topRight) + ", " +
+      folly::to<std::string>(cornerInsets.bottomLeft) + ", " +
+      folly::to<std::string>(cornerInsets.bottomRight) + "}";
+}
+
+} // namespace react
+} // namespace facebook

package/ReactCommon/react/renderer/core/propsConversions.h

@@ -13,9 +13,8 @@
 #include <react/renderer/core/PropsParserContext.h>
 #include <react/renderer/core/RawProps.h>
 #include <react/renderer/core/RawPropsKey.h>
+#include <react/renderer/core/graphicsConversions.h>
 #include <react/renderer/graphics/Color.h>
-#include <react/renderer/graphics/Geometry.h>
-#include <react/renderer/graphics/conversions.h>
 
 namespace facebook {
 namespace react {

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

@@ -6,7 +6,7 @@
  */
 
 #include <gtest/gtest.h>
-#include <hermes/API/hermes/hermes.h>
+#include <hermes/hermes.h>
 #include <jsi/jsi.h>
 #include <react/renderer/core/EventPipe.h>
 #include <react/renderer/core/EventQueueProcessor.h>
@@ -58,7 +58,7 @@ TEST_F(EventQueueProcessorTest, singleUnspecifiedEvent) {
   EXPECT_EQ(eventPriorities_[0], ReactEventPriority::Discrete);
 }
 
-TEST_F(EventQueueProcessorTest, continiousEvent) {
+TEST_F(EventQueueProcessorTest, continuousEvent) {
   eventProcessor_->flushEvents(
       *runtime_,
       {RawEvent(

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

@@ -67,6 +67,152 @@ TEST(LayoutableShadowNodeTest, relativeLayoutMetrics) {
   EXPECT_EQ(relativeLayoutMetrics.frame.origin.y, 20);
 }
 
+/*
+ * ┌───────────────────┐
+ * │<View displayNone> │
+ * │                   │
+ * └───────────────────┘
+ */
+TEST(LayoutableShadowNodeTest, relativeLayoutMetricsOnNodeWithDisplayNone) {
+  auto builder = simpleComponentBuilder();
+
+  // clang-format off
+  auto element =
+    Element<ViewShadowNode>()
+      .finalize([](ViewShadowNode &shadowNode){
+        auto layoutMetrics = EmptyLayoutMetrics;
+        layoutMetrics.frame.size = {100, 200};
+        layoutMetrics.frame.origin = {10, 20};
+        layoutMetrics.displayType = DisplayType::None;
+        shadowNode.setLayoutMetrics(layoutMetrics);
+    });
+  // clang-format on
+
+  auto shadowNode = builder.build(element);
+
+  auto relativeLayoutMetrics =
+      LayoutableShadowNode::computeRelativeLayoutMetrics(
+          shadowNode->getFamily(), *shadowNode, {});
+
+  // The node has display: none, so the relative layout is empty.
+  EXPECT_TRUE(relativeLayoutMetrics == EmptyLayoutMetrics);
+}
+
+/*
+ * ┌────────────────────┐
+ * │<View displayNone>  │
+ * │                    │
+ * │   ┌────────────────┴──┐
+ * │   │<View>             │
+ * └───┤                   │
+ *     │                   │
+ *     │                   │
+ *     └───────────────────┘
+ */
+TEST(
+    LayoutableShadowNodeTest,
+    relativeLayoutMetricsOnChildrenOfParentWithDisplayNone) {
+  auto builder = simpleComponentBuilder();
+
+  auto childShadowNode = std::shared_ptr<ViewShadowNode>{};
+  // clang-format off
+  auto element =
+    Element<ViewShadowNode>()
+      .finalize([](ViewShadowNode &shadowNode){
+        auto layoutMetrics = EmptyLayoutMetrics;
+        layoutMetrics.frame.origin = {10, 20};
+        layoutMetrics.frame.size = {100, 200};
+        layoutMetrics.displayType = DisplayType::None;
+        shadowNode.setLayoutMetrics(layoutMetrics);
+      })
+      .children({
+        Element<ViewShadowNode>()
+        .finalize([](ViewShadowNode &shadowNode){
+          auto layoutMetrics = EmptyLayoutMetrics;
+          layoutMetrics.frame.origin = {10, 20};
+          layoutMetrics.frame.size = {100, 200};
+          shadowNode.setLayoutMetrics(layoutMetrics);
+        })
+        .reference(childShadowNode)
+    });
+  // clang-format on
+
+  auto parentShadowNode = builder.build(element);
+
+  auto relativeLayoutMetrics =
+      LayoutableShadowNode::computeRelativeLayoutMetrics(
+          childShadowNode->getFamily(), *parentShadowNode, {});
+
+  // A parent node in the hierarchy has display: none, so the relative layout
+  // is empty.
+  EXPECT_TRUE(relativeLayoutMetrics == EmptyLayoutMetrics);
+}
+
+/*
+ * ┌────────────────────┐
+ * │<View displayNone>  │
+ * │                    │
+ * │   ┌────────────────┴──┐
+ * │   │<View ancestor>    │
+ * └───┤                   │
+ *     │                   │
+ *     │   ┌───────────────┴──┐
+ *     └───|<View descendant> |
+ *         |                  |
+ *         └──────────────────┘
+ */
+TEST(
+    LayoutableShadowNodeTest,
+    relativeLayoutMetricsOnOuterParentWithDisplayNone) {
+  auto builder = simpleComponentBuilder();
+
+  auto parentShadowNode = std::shared_ptr<ViewShadowNode>{};
+  auto childShadowNode = std::shared_ptr<ViewShadowNode>{};
+  // clang-format off
+  auto element =
+    Element<ViewShadowNode>()
+      .finalize([](ViewShadowNode &shadowNode){
+        auto layoutMetrics = EmptyLayoutMetrics;
+        layoutMetrics.frame.origin = {0, 0};
+        layoutMetrics.frame.size = {1000, 1000};
+        layoutMetrics.displayType = DisplayType::None;
+        shadowNode.setLayoutMetrics(layoutMetrics);
+      })
+      .children({
+        Element<ViewShadowNode>()
+        .finalize([](ViewShadowNode &shadowNode){
+          auto layoutMetrics = EmptyLayoutMetrics;
+          layoutMetrics.frame.origin = {50, 50};
+          layoutMetrics.frame.size = {200, 200};
+          shadowNode.setLayoutMetrics(layoutMetrics);
+        })
+        .children({
+          Element<ViewShadowNode>()
+            .finalize([](ViewShadowNode &shadowNode){
+              auto layoutMetrics = EmptyLayoutMetrics;
+              layoutMetrics.frame.origin = {10, 20};
+              layoutMetrics.frame.size = {100, 200};
+              shadowNode.setLayoutMetrics(layoutMetrics);
+            }).reference(childShadowNode)
+        })
+        .reference(parentShadowNode)
+    });
+  // clang-format on
+
+  auto outerParentShadowNode = builder.build(element);
+
+  auto relativeLayoutMetrics =
+      LayoutableShadowNode::computeRelativeLayoutMetrics(
+          childShadowNode->getFamily(), *parentShadowNode, {});
+
+  // The root view has display: none, but all the views between the descendant
+  // and the ancestor are visible, so we compute relative layout as usual.
+  EXPECT_EQ(relativeLayoutMetrics.frame.size.width, 100);
+  EXPECT_EQ(relativeLayoutMetrics.frame.size.height, 200);
+  EXPECT_EQ(relativeLayoutMetrics.frame.origin.x, 10);
+  EXPECT_EQ(relativeLayoutMetrics.frame.origin.y, 20);
+}
+
 /*
  * ┌──────────────┐
  * │<ScrollView>  │
@@ -316,7 +462,7 @@ TEST(LayoutableShadowNodeTest, relativeLayoutMetricsOnSameTransformedNode) {
  * │      └────────────────┘│
  * └────────────────────────┘
  */
-TEST(LayoutableShadowNodeTest, relativeLayourMetricsOnClonedNode) {
+TEST(LayoutableShadowNodeTest, relativeLayoutMetricsOnClonedNode) {
   auto builder = simpleComponentBuilder();
 
   auto childShadowNode = std::shared_ptr<ViewShadowNode>{};

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

@@ -131,7 +131,7 @@ class PropsMultiLookup : public Props {
             "floatValue",
             sourceProps.floatValue,
             17.5)),
-        // While this specific pattern is uncommon, it's a simplication of a
+        // While this specific pattern is uncommon, it's a simplification of a
         // pattern that does occur a lot: nested structs that access props we
         // have already accessed populating Props
         derivedFloatValue(

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

@@ -12,6 +12,7 @@
 #include <react/renderer/components/text/RawTextComponentDescriptor.h>
 #include <react/renderer/components/text/TextComponentDescriptor.h>
 #include <react/renderer/components/view/ViewComponentDescriptor.h>
+#include <react/renderer/core/TraitCast.h>
 
 #include <react/renderer/element/Element.h>
 #include <react/renderer/element/testUtils.h>
@@ -51,8 +52,13 @@ TEST(traitCastTest, testOne) {
   std::shared_ptr<ShadowNode> shadowNodeForTextShadowNode{textShadowNode};
 
   // Casting `nullptr` returns `nullptrs`.
-  EXPECT_FALSE(traitCast<LayoutableShadowNode const *>(nullptr));
-  EXPECT_FALSE(traitCast<YogaLayoutableShadowNode const *>(nullptr));
+  ShadowNode *nullShadowNode = nullptr;
+  EXPECT_FALSE(traitCast<LayoutableShadowNode const *>(nullShadowNode));
+  EXPECT_FALSE(traitCast<YogaLayoutableShadowNode const *>(nullShadowNode));
+  EXPECT_FALSE(traitCast<LayoutableShadowNode const *>(nullShadowNode));
+  EXPECT_FALSE(traitCast<LayoutableShadowNode *>(nullShadowNode));
+  EXPECT_FALSE(traitCast<LayoutableShadowNode>(
+      std::shared_ptr<ShadowNode>(nullShadowNode)));
 
   // `ViewShadowNode` is `LayoutableShadowNode` and `YogaLayoutableShadowNode`.
   EXPECT_TRUE(traitCast<LayoutableShadowNode const *>(viewShadowNode.get()));
@@ -62,6 +68,10 @@ TEST(traitCastTest, testOne) {
       traitCast<LayoutableShadowNode const &>(*viewShadowNode));
   EXPECT_NO_FATAL_FAILURE(
       traitCast<YogaLayoutableShadowNode const &>(*viewShadowNode));
+  EXPECT_NO_FATAL_FAILURE(
+      traitCast<YogaLayoutableShadowNode &>(*viewShadowNode));
+  EXPECT_TRUE(traitCast<LayoutableShadowNode *>(viewShadowNode.get()));
+  EXPECT_TRUE(traitCast<LayoutableShadowNode>(viewShadowNode));
 
   // `ScrollViewShadowNode` is `LayoutableShadowNode` and
   // `YogaLayoutableShadowNode`.

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

@@ -9,6 +9,7 @@
 
 #include <climits>
 #include <memory>
+#include <optional>
 #include <string>
 #include <unordered_set>
 #include <vector>
@@ -98,6 +99,14 @@ std::string toString(float const &value);
 std::string toString(double const &value);
 std::string toString(void const *value);
 
+template <typename T>
+std::string toString(const std::optional<T> &value) {
+  if (!value) {
+    return "null";
+  }
+  return toString(value.value());
+}
+
 /*
  * *Informal* `DebugStringConvertible` interface.
  *

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

@@ -14,6 +14,16 @@
 namespace facebook {
 namespace react {
 
+/**
+ * Allow providing an fbsystrace implementation that can short-circuit out
+ * quickly and can throttle too frequent events so we can get useful traces even
+ * if rendering etc. is spinning. For throttling we'll need file/line info so we
+ * use a macro.
+ */
+#if defined(WITH_LOOM_TRACE)
+#define SystraceSection                                         \
+  static constexpr const char systraceSectionFile[] = __FILE__; \
+  fbsystrace::FbSystraceSection<systraceSectionFile, __LINE__>
 /**
  * This is a convenience class to avoid lots of verbose profiling
  * #ifdefs.  If WITH_FBSYSTRACE is not defined, the optimizer will
@@ -23,7 +33,7 @@ namespace react {
  * different values in different files, there is no inconsistency in the sizes
  * of defined symbols.
  */
-#ifdef WITH_FBSYSTRACE
+#elif defined(WITH_FBSYSTRACE)
 struct ConcreteSystraceSection {
  public:
   template <typename... ConvertsToStringPiece>
@@ -41,8 +51,8 @@ struct DummySystraceSection {
  public:
   template <typename... ConvertsToStringPiece>
   explicit DummySystraceSection(
-      const char *name,
-      ConvertsToStringPiece &&...args) {}
+      __unused const char *name,
+      __unused ConvertsToStringPiece &&...args) {}
 };
 using SystraceSection = DummySystraceSection;
 #endif

package/ReactCommon/react/renderer/element/BUCK

@@ -32,6 +32,8 @@ rn_xplat_cxx_library(
         prefix = "react/renderer/element",
     ),
     compiler_flags_pedantic = True,
+    # TODO(145803035) Fix Android tests
+    fbandroid_tests_override = [],
     fbobjc_compiler_flags = APPLE_COMPILER_FLAGS,
     fbobjc_preprocessor_flags = get_preprocessor_flags_for_build_mode() + get_apple_inspector_flags(),
     force_static = True,

package/ReactCommon/react/renderer/element/CMakeLists.txt

@@ -0,0 +1,29 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+
+cmake_minimum_required(VERSION 3.13)
+set(CMAKE_VERBOSE_MAKEFILE on)
+
+add_compile_options(
+        -fexceptions
+        -frtti
+        -std=c++17
+        -Wall
+        -Wpedantic
+        -Wno-gnu-zero-variadic-macro-arguments
+        -DLOG_TAG=\"Fabric\")
+
+file(GLOB react_render_element_SRC CONFIGURE_DEPENDS *.cpp)
+add_library(react_render_element SHARED ${react_render_element_SRC})
+
+target_include_directories(react_render_element PUBLIC ${REACT_COMMON_DIR})
+
+target_link_libraries(react_render_element
+        folly_runtime
+        glog
+        react_render_core
+        react_render_componentregistry
+)
+

package/ReactCommon/react/renderer/graphics/BUCK

@@ -8,12 +8,13 @@ load(
     "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",
 )
 
+oncall("react_native")
+
 APPLE_COMPILER_FLAGS = get_apple_compiler_flags()
 
 rn_xplat_cxx_library(
@@ -51,36 +52,32 @@ rn_xplat_cxx_library(
     fbandroid_allow_jni_merging = True,
     fbandroid_deps = [
         FBJNI_TARGET,
-        react_native_target("jni/react/jni:jni"),
+        "//xplat/folly:dynamic",
     ],
     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_exported_headers = subdir_glob(
+        [
+            ("platform/ios/react/renderer/graphics", "*.h"),
+        ],
+        prefix = "react/renderer/graphics",
+    ),
     fbobjc_preprocessor_flags = get_preprocessor_flags_for_build_mode() + get_apple_inspector_flags(),
     force_static = True,
     ios_deps = [
         "//xplat/js/react-native-github:RCTCxxBridge",
         "//xplat/js/react-native-github:RCTImage",
     ],
-    ios_exported_headers = subdir_glob(
-        [
-            ("platform/ios", "*.h"),
-        ],
-        prefix = "react/renderer/graphics",
-    ),
     ios_frameworks = [
         "$SDKROOT/System/Library/Frameworks/CoreGraphics.framework",
         "$SDKROOT/System/Library/Frameworks/Foundation.framework",

package/ReactCommon/react/renderer/graphics/CMakeLists.txt

@@ -15,18 +15,14 @@ add_compile_options(
         -Wno-gnu-zero-variadic-macro-arguments
         -DLOG_TAG=\"Fabric\")
 
-file(GLOB react_render_graphics_SRC CONFIGURE_DEPENDS
-        *.cpp
-        platform/cxx/react/renderer/graphics/*.cpp)
-
-add_library(react_render_graphics
-        SHARED
-        ${react_render_graphics_SRC})
+file(GLOB react_render_graphics_SRC CONFIGURE_DEPENDS *.cpp)
+add_library(react_render_graphics SHARED ${react_render_graphics_SRC})
 
 target_include_directories(react_render_graphics
         PUBLIC
           ${REACT_COMMON_DIR}
-          ${CMAKE_CURRENT_SOURCE_DIR}/platform/cxx/
+          ${CMAKE_CURRENT_SOURCE_DIR}/platform/android/
         )
 
 target_link_libraries(react_render_graphics glog fb fbjni folly_runtime react_debug)
+