react-native-tvos 0.75.3-0 → 0.76.0-0

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

@@ -366,3 +366,52 @@ TEST(FindNodeAtPointTest, overlappingViewsWithParentPointerEventsNone) {
   EXPECT_EQ(
             LayoutableShadowNode::findNodeAtPoint(parentShadowNode, {50, 50}), nullptr);
 }
+
+TEST(FindNodeAtPointTest, invertedList) {
+  auto builder = simpleComponentBuilder();
+  
+  // clang-format off
+  auto element =
+    Element<ScrollViewShadowNode>()
+      .props([] {
+        auto sharedProps = std::make_shared<ScrollViewProps>();
+        sharedProps->transform = Transform::VerticalInversion();
+        return sharedProps;
+      })
+      .tag(1)
+      .finalize([](ScrollViewShadowNode &shadowNode){
+        auto layoutMetrics = EmptyLayoutMetrics;
+        layoutMetrics.frame.size = {100, 200};
+        shadowNode.setLayoutMetrics(layoutMetrics);
+      })
+      .children({
+        Element<ViewShadowNode>()
+        .tag(2)
+        .finalize([](ViewShadowNode &shadowNode){
+          auto layoutMetrics = EmptyLayoutMetrics;
+          layoutMetrics.frame.origin = {0, 0};
+          layoutMetrics.frame.size = {100, 100};
+          shadowNode.setLayoutMetrics(layoutMetrics);
+        }),
+        Element<ViewShadowNode>()
+        .tag(3)
+        .finalize([](ViewShadowNode &shadowNode){
+          auto layoutMetrics = EmptyLayoutMetrics;
+          layoutMetrics.frame.origin = {0, 100};
+          layoutMetrics.frame.size = {100, 100};
+          shadowNode.setLayoutMetrics(layoutMetrics);
+        })
+    });
+  // clang-format on
+
+  auto parentShadowNode = builder.build(element);
+
+  EXPECT_EQ(
+      LayoutableShadowNode::findNodeAtPoint(parentShadowNode, {10, 10})
+          ->getTag(),
+      3);
+  EXPECT_EQ(
+      LayoutableShadowNode::findNodeAtPoint(parentShadowNode, {10, 105})
+          ->getTag(),
+      2);
+}

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

@@ -353,7 +353,7 @@ TEST_P(ShadowNodeTest, testCloneTree) {
 TEST_P(ShadowNodeTest, handleRuntimeReferenceTransferOnClone) {
   auto nodeABRev1 = nodeAB_->clone({});
   auto wrappedShadowNode = std::make_shared<ShadowNodeWrapper>(nodeABRev1);
-  nodeABRev1->setRuntimeShadowNodeReference(&*wrappedShadowNode);
+  nodeABRev1->setRuntimeShadowNodeReference(wrappedShadowNode);
 
   auto nodeABRev2 = nodeABRev1->clone({});
 

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

@@ -15,7 +15,7 @@ add_compile_options(
         -DLOG_TAG=\"Fabric\")
 
 file(GLOB react_render_debug_SRC CONFIGURE_DEPENDS *.cpp)
-add_library(react_render_debug SHARED ${react_render_debug_SRC})
+add_library(react_render_debug OBJECT ${react_render_debug_SRC})
 
 target_include_directories(react_render_debug PUBLIC ${REACT_COMMON_DIR})
-target_link_libraries(react_render_debug folly_runtime)
+target_link_libraries(react_render_debug folly_runtime react_debug)

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

@@ -15,7 +15,7 @@ add_compile_options(
         -DLOG_TAG=\"Fabric\")
 
 file(GLOB react_render_dom_SRC CONFIGURE_DEPENDS *.cpp)
-add_library(react_render_dom STATIC ${react_render_dom_SRC})
+add_library(react_render_dom OBJECT ${react_render_dom_SRC})
 
 target_include_directories(react_render_dom PUBLIC ${REACT_COMMON_DIR})
 

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

@@ -15,7 +15,7 @@ add_compile_options(
         -DLOG_TAG=\"Fabric\")
 
 file(GLOB react_render_element_SRC CONFIGURE_DEPENDS *.cpp)
-add_library(react_render_element SHARED ${react_render_element_SRC})
+add_library(react_render_element OBJECT ${react_render_element_SRC})
 
 target_include_directories(react_render_element PUBLIC ${REACT_COMMON_DIR})
 

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

@@ -0,0 +1,46 @@
+/*
+ * 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 <react/renderer/graphics/Color.h>
+#include <react/renderer/graphics/Float.h>
+#include <optional>
+#include <string>
+
+namespace facebook::react {
+
+struct ColorStop {
+  bool operator==(const ColorStop& other) const = default;
+  SharedColor color;
+  std::optional<Float> position;
+};
+
+enum class GradientType {
+  LinearGradient,
+};
+
+struct GradientValue {
+  bool operator==(const GradientValue& other) const = default;
+
+  GradientType type;
+  Float startX;
+  Float startY;
+  Float endX;
+  Float endY;
+  std::vector<ColorStop> colorStops;
+};
+
+inline GradientType gradientTypeFromString(const std::string& gradientType) {
+  if (gradientType == "linearGradient") {
+    return GradientType::LinearGradient;
+  } else {
+    throw std::invalid_argument(std::string(gradientType));
+  }
+}
+
+}; // namespace facebook::react

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

@@ -0,0 +1,72 @@
+/*
+ * 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 <optional>
+#include <string_view>
+
+namespace facebook::react {
+
+enum class BlendMode {
+  Normal,
+  Multiply,
+  Screen,
+  Overlay,
+  Darken,
+  Lighten,
+  ColorDodge,
+  ColorBurn,
+  HardLight,
+  SoftLight,
+  Difference,
+  Exclusion,
+  Hue,
+  Saturation,
+  Color,
+  Luminosity,
+};
+
+inline std::optional<BlendMode> blendModeFromString(
+    std::string_view blendModeName) {
+  if (blendModeName == "normal") {
+    return BlendMode::Normal;
+  } else if (blendModeName == "multiply") {
+    return BlendMode::Multiply;
+  } else if (blendModeName == "screen") {
+    return BlendMode::Screen;
+  } else if (blendModeName == "overlay") {
+    return BlendMode::Overlay;
+  } else if (blendModeName == "darken") {
+    return BlendMode::Darken;
+  } else if (blendModeName == "lighten") {
+    return BlendMode::Lighten;
+  } else if (blendModeName == "color-dodge") {
+    return BlendMode::ColorDodge;
+  } else if (blendModeName == "color-burn") {
+    return BlendMode::ColorBurn;
+  } else if (blendModeName == "hard-light") {
+    return BlendMode::HardLight;
+  } else if (blendModeName == "soft-light") {
+    return BlendMode::SoftLight;
+  } else if (blendModeName == "difference") {
+    return BlendMode::Difference;
+  } else if (blendModeName == "exclusion") {
+    return BlendMode::Exclusion;
+  } else if (blendModeName == "hue") {
+    return BlendMode::Hue;
+  } else if (blendModeName == "saturation") {
+    return BlendMode::Saturation;
+  } else if (blendModeName == "color") {
+    return BlendMode::Color;
+  } else if (blendModeName == "luminosity") {
+    return BlendMode::Luminosity;
+  } else {
+    return std::nullopt;
+  }
+}
+} // namespace facebook::react

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

@@ -0,0 +1,25 @@
+/*
+ * 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 <react/renderer/graphics/Color.h>
+#include <react/renderer/graphics/Float.h>
+
+namespace facebook::react {
+
+struct BoxShadow {
+  bool operator==(const BoxShadow& other) const = default;
+
+  Float offsetX{};
+  Float offsetY{};
+  Float blurRadius{};
+  Float spreadDistance{};
+  SharedColor color{};
+  bool inset{};
+};
+} // namespace facebook::react

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

@@ -15,7 +15,7 @@ add_compile_options(
         -DLOG_TAG=\"Fabric\")
 
 file(GLOB react_render_graphics_SRC CONFIGURE_DEPENDS *.cpp)
-add_library(react_render_graphics SHARED ${react_render_graphics_SRC})
+add_library(react_render_graphics OBJECT ${react_render_graphics_SRC})
 
 target_include_directories(react_render_graphics
         PUBLIC

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

@@ -17,14 +17,41 @@ bool isColorMeaningful(const SharedColor& color) noexcept {
   return colorComponentsFromColor(color).alpha > 0;
 }
 
+// Create Color from float RGBA values in [0, 1] range
 SharedColor colorFromComponents(ColorComponents components) {
   return {hostPlatformColorFromComponents(components)};
 }
 
+// Read Color components in [0, 1] range
 ColorComponents colorComponentsFromColor(SharedColor sharedColor) {
   return colorComponentsFromHostPlatformColor(*sharedColor);
 }
 
+// Read alpha channel in [0, 255] range
+uint8_t alphaFromColor(SharedColor color) {
+  return static_cast<uint8_t>(std::round(alphaFromHostPlatformColor(*color)));
+}
+
+// Read red channel in [0, 255] range
+uint8_t redFromColor(SharedColor color) {
+  return static_cast<uint8_t>(std::round(redFromHostPlatformColor(*color)));
+}
+
+// Read green channel in [0, 255] range
+uint8_t greenFromColor(SharedColor color) {
+  return static_cast<uint8_t>(std::round(greenFromHostPlatformColor(*color)));
+}
+
+// Read blue channel in [0, 255] range
+uint8_t blueFromColor(SharedColor color) {
+  return static_cast<uint8_t>(std::round(blueFromHostPlatformColor(*color)));
+}
+
+// Create Color with RGBA values in [0, 255] range
+SharedColor colorFromRGBA(uint8_t r, uint8_t g, uint8_t b, uint8_t a) {
+  return {hostPlatformColorFromRGBA(r, g, b, a)};
+}
+
 SharedColor clearColor() {
   static SharedColor color = colorFromComponents(ColorComponents{0, 0, 0, 0});
   return color;

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

@@ -57,6 +57,12 @@ bool isColorMeaningful(const SharedColor& color) noexcept;
 SharedColor colorFromComponents(ColorComponents components);
 ColorComponents colorComponentsFromColor(SharedColor color);
 
+uint8_t alphaFromColor(SharedColor color);
+uint8_t redFromColor(SharedColor color);
+uint8_t greenFromColor(SharedColor color);
+uint8_t blueFromColor(SharedColor color);
+SharedColor colorFromRGBA(uint8_t r, uint8_t g, uint8_t b, uint8_t a);
+
 SharedColor clearColor();
 SharedColor blackColor();
 SharedColor whiteColor();

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

@@ -7,10 +7,12 @@
 
 #pragma once
 
+#include <react/renderer/graphics/Color.h>
 #include <react/renderer/graphics/Float.h>
 
 #include <string>
 #include <string_view>
+#include <variant>
 #include <vector>
 
 namespace facebook::react {
@@ -24,14 +26,24 @@ enum class FilterType {
   Invert,
   Opacity,
   Saturate,
-  Sepia
+  Sepia,
+  DropShadow
 };
 
-struct FilterPrimitive {
-  bool operator==(const FilterPrimitive& other) const = default;
+struct DropShadowParams {
+  bool operator==(const DropShadowParams& other) const = default;
 
-  FilterType type;
-  Float amount;
+  Float offsetX{};
+  Float offsetY{};
+  Float standardDeviation{};
+  SharedColor color{};
+};
+
+struct FilterFunction {
+  bool operator==(const FilterFunction& other) const = default;
+
+  FilterType type{};
+  std::variant<Float, DropShadowParams> parameters{};
 };
 
 inline FilterType filterTypeFromString(std::string_view filterName) {
@@ -53,6 +65,8 @@ inline FilterType filterTypeFromString(std::string_view filterName) {
     return FilterType::Saturate;
   } else if (filterName == "sepia") {
     return FilterType::Sepia;
+  } else if (filterName == "dropShadow") {
+    return FilterType::DropShadow;
   } else {
     throw std::invalid_argument(std::string(filterName));
   }

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

@@ -0,0 +1,31 @@
+/*
+ * 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 <optional>
+#include <string_view>
+
+namespace facebook::react {
+
+// https://www.w3.org/TR/compositing-1/#isolation
+enum class Isolation {
+  Auto,
+  Isolate,
+};
+
+inline std::optional<Isolation> isolationFromString(
+    std::string_view isolationSetting) {
+  if (isolationSetting == "auto") {
+    return Isolation::Auto;
+  } else if (isolationSetting == "isolate") {
+    return Isolation::Isolate;
+  } else {
+    return std::nullopt;
+  }
+}
+} // namespace facebook::react

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

@@ -47,6 +47,7 @@ Pod::Spec.new do |s|
                              "platform/cxx",
                              "platform/windows",
   s.header_dir             = "react/renderer/graphics"
+  s.framework = "UIKit"
 
   if ENV['USE_FRAMEWORKS']
     s.module_name            = "React_graphics"

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

@@ -11,6 +11,7 @@
 
 #include <glog/logging.h>
 #include <react/debug/react_native_assert.h>
+#include <react/utils/FloatComparison.h>
 
 namespace facebook::react {
 
@@ -305,11 +306,11 @@ Transform Transform::Interpolate(
 }
 
 bool Transform::isVerticalInversion(const Transform& transform) {
-  return transform.at(1, 1) == -1;
+  return facebook::react::floatEquality(transform.at(1, 1), -1.0f);
 }
 
 bool Transform::isHorizontalInversion(const Transform& transform) {
-  return transform.at(0, 0) == -1;
+  return facebook::react::floatEquality(transform.at(0, 0), -1.0f);
 }
 
 bool Transform::operator==(const Transform& rhs) const {

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

@@ -67,6 +67,17 @@ struct TransformOrigin {
     return xy[0].value != 0.0f || xy[0].unit != UnitType::Undefined ||
         xy[1].value != 0.0f || xy[1].unit != UnitType::Undefined || z != 0.0f;
   }
+
+#ifdef ANDROID
+
+  /**
+   * Convert to folly::dynamic.
+   */
+  operator folly::dynamic() const {
+    return folly::dynamic::array(xy[0].value, xy[1].value, z);
+  }
+
+#endif
 };
 
 /*

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

@@ -29,15 +29,16 @@ struct ValueUnit {
     return !(*this == other);
   }
 
-  constexpr float resolve(float referenceLength) {
+  constexpr float resolve(float referenceLength) const {
     switch (unit) {
       case UnitType::Point:
         return value;
       case UnitType::Percent:
         return value * referenceLength * 0.01f;
-      default:
+      case UnitType::Undefined:
         return 0.0f;
     }
+    return 0.0f;
   }
 };
 } // namespace facebook::react

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

@@ -19,6 +19,11 @@ static const facebook::react::Color UndefinedColor =
     std::numeric_limits<facebook::react::Color>::max();
 }
 
+inline Color
+hostPlatformColorFromRGBA(uint8_t r, uint8_t g, uint8_t b, uint8_t a) {
+  return (a & 0xff) << 24 | (r & 0xff) << 16 | (g & 0xff) << 8 | (b & 0xff);
+}
+
 inline Color hostPlatformColorFromComponents(ColorComponents components) {
   float ratio = 255;
   return ((int)round(components.alpha * ratio) & 0xff) << 24 |
@@ -36,4 +41,20 @@ inline ColorComponents colorComponentsFromHostPlatformColor(Color color) {
       (float)((color >> 24) & 0xff) / ratio};
 }
 
+inline float alphaFromHostPlatformColor(Color color) {
+  return static_cast<float>((color >> 24) & 0xff);
+}
+
+inline float redFromHostPlatformColor(Color color) {
+  return static_cast<float>((color >> 16) & 0xff);
+}
+
+inline float greenFromHostPlatformColor(Color color) {
+  return static_cast<float>((color >> 8) & 0xff);
+}
+
+inline float blueFromHostPlatformColor(Color color) {
+  return static_cast<uint8_t>((color >> 0) & 0xff);
+}
+
 } // namespace facebook::react

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

@@ -8,15 +8,27 @@
 #pragma once
 
 #include <fbjni/fbjni.h>
-#include <react/debug/react_native_expect.h>
+#include <folly/container/EvictingCacheMap.h>
 #include <react/renderer/core/RawValue.h>
 #include <react/renderer/graphics/Color.h>
 #include <react/renderer/graphics/fromRawValueShared.h>
 #include <react/utils/ContextContainer.h>
+#include <react/utils/hash_combine.h>
 #include <unordered_map>
+#include <vector>
 
 namespace facebook::react {
 
+static size_t hashGetColourArguments(
+    int32_t surfaceId,
+    const std::vector<std::string>& resourcePaths) {
+  std::size_t seed = surfaceId;
+  for (const auto& item : resourcePaths) {
+    facebook::react::hash_combine(seed, item);
+  }
+  return seed;
+}
+
 inline SharedColor parsePlatformColor(
     const ContextContainer& contextContainer,
     int32_t surfaceId,
@@ -25,29 +37,45 @@ inline SharedColor parsePlatformColor(
 
   if (value.hasType<
           std::unordered_map<std::string, std::vector<std::string>>>()) {
-    const auto& fabricUIManager =
-        contextContainer.at<jni::global_ref<jobject>>("FabricUIManager");
-    static auto getColorFromJava =
-        fabricUIManager->getClass()
-            ->getMethod<jint(jint, jni::JArrayClass<jni::JString>)>("getColor");
-
     auto map = (std::unordered_map<std::string, std::vector<std::string>>)value;
     auto& resourcePaths = map["resource_paths"];
 
-    auto javaResourcePaths =
-        jni::JArrayClass<jni::JString>::newArray(resourcePaths.size());
-    for (int i = 0; i < resourcePaths.size(); i++) {
-      javaResourcePaths->setElement(i, *jni::make_jstring(resourcePaths[i]));
+    // JNI calls are time consuming. Let's cache results here to avoid
+    // unnecessary calls.
+    static auto getColorCache =
+        folly::EvictingCacheMap<size_t, ColorComponents>(64);
+
+    auto hash = hashGetColourArguments(surfaceId, resourcePaths);
+    auto iterator = getColorCache.find(hash);
+
+    if (iterator != getColorCache.end()) {
+      colorComponents = iterator->second;
+    } else {
+      const auto& fabricUIManager =
+          contextContainer.at<jni::global_ref<jobject>>("FabricUIManager");
+      static auto getColorFromJava =
+          fabricUIManager->getClass()
+              ->getMethod<jint(jint, jni::JArrayClass<jni::JString>)>(
+                  "getColor");
+      auto javaResourcePaths =
+          jni::JArrayClass<jni::JString>::newArray(resourcePaths.size());
+
+      for (int i = 0; i < resourcePaths.size(); i++) {
+        javaResourcePaths->setElement(i, *jni::make_jstring(resourcePaths[i]));
+      }
+      auto color =
+          getColorFromJava(fabricUIManager, surfaceId, *javaResourcePaths);
+
+      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;
+
+      getColorCache.set(hash, colorComponents);
     }
-    auto color =
-        getColorFromJava(fabricUIManager, surfaceId, *javaResourcePaths);
-
-    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 {colorFromComponents(colorComponents)};

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

@@ -9,6 +9,7 @@
 
 #include <react/renderer/graphics/ColorComponents.h>
 #include <cmath>
+#include <cstdint>
 
 namespace facebook::react {
 
@@ -19,21 +20,43 @@ static const facebook::react::Color UndefinedColor =
     std::numeric_limits<facebook::react::Color>::max();
 }
 
+inline Color
+hostPlatformColorFromRGBA(uint8_t r, uint8_t g, uint8_t b, uint8_t a) {
+  return (a & 0xff) << 24 | (r & 0xff) << 16 | (g & 0xff) << 8 | (b & 0xff);
+}
+
 inline Color hostPlatformColorFromComponents(ColorComponents components) {
   float ratio = 255;
-  return ((int)std::round(components.alpha * ratio) & 0xff) << 24 |
-      ((int)std::round(components.red * ratio) & 0xff) << 16 |
-      ((int)std::round(components.green * ratio) & 0xff) << 8 |
-      ((int)std::round(components.blue * ratio) & 0xff);
+  return hostPlatformColorFromRGBA(
+      static_cast<uint8_t>(std::round(components.red * ratio)),
+      static_cast<uint8_t>(std::round(components.green * ratio)),
+      static_cast<uint8_t>(std::round(components.blue * ratio)),
+      static_cast<uint8_t>(std::round(components.alpha * ratio)));
+}
+
+inline float alphaFromHostPlatformColor(Color color) {
+  return static_cast<float>((color >> 24) & 0xff);
+}
+
+inline float redFromHostPlatformColor(Color color) {
+  return static_cast<float>((color >> 16) & 0xff);
+}
+
+inline float greenFromHostPlatformColor(Color color) {
+  return static_cast<float>((color >> 8) & 0xff);
+}
+
+inline float blueFromHostPlatformColor(Color color) {
+  return static_cast<uint8_t>((color >> 0) & 0xff);
 }
 
 inline ColorComponents colorComponentsFromHostPlatformColor(Color color) {
   float ratio = 255;
   return ColorComponents{
-      (float)((color >> 16) & 0xff) / ratio,
-      (float)((color >> 8) & 0xff) / ratio,
-      (float)((color >> 0) & 0xff) / ratio,
-      (float)((color >> 24) & 0xff) / ratio};
+      static_cast<float>(redFromHostPlatformColor(color)) / ratio,
+      static_cast<float>(greenFromHostPlatformColor(color)) / ratio,
+      static_cast<float>(blueFromHostPlatformColor(color)) / ratio,
+      static_cast<float>(alphaFromHostPlatformColor(color)) / ratio};
 }
 
 } // namespace facebook::react