react-native-tvos 0.82.1-0 → 0.83.0-0

package/ReactCommon/react/renderer/element/ComponentBuilder.h

@@ -24,23 +24,23 @@ namespace facebook::react {
  */
 class ComponentBuilder final {
  public:
-  ComponentBuilder(
-      ComponentDescriptorRegistry::Shared componentDescriptorRegistry);
+  ComponentBuilder(ComponentDescriptorRegistry::Shared componentDescriptorRegistry);
 
   /*
    * Copyable and movable.
    */
-  ComponentBuilder(const ComponentBuilder& componentBuilder) = default;
-  ComponentBuilder(ComponentBuilder&& componentBuilder) noexcept = default;
-  ComponentBuilder& operator=(const ComponentBuilder& other) = default;
-  ComponentBuilder& operator=(ComponentBuilder&& other) = default;
+  ComponentBuilder(const ComponentBuilder &componentBuilder) = default;
+  ComponentBuilder(ComponentBuilder &&componentBuilder) noexcept = default;
+  ComponentBuilder &operator=(const ComponentBuilder &other) = default;
+  ComponentBuilder &operator=(ComponentBuilder &&other) = default;
 
   /*
    * Builds a `ShadowNode` tree with given `Element` tree using stored
    * `ComponentDescriptorRegistry`.
    */
   template <typename ShadowNodeT>
-  std::shared_ptr<ShadowNodeT> build(Element<ShadowNodeT> element) const {
+  std::shared_ptr<ShadowNodeT> build(Element<ShadowNodeT> element) const
+  {
     return std::static_pointer_cast<ShadowNodeT>(build(element.fragment_));
   }
 
@@ -48,8 +48,7 @@ class ComponentBuilder final {
   /*
    * Internal, type-erased version of `build`.
    */
-  std::shared_ptr<ShadowNode> build(
-      const ElementFragment& elementFragment) const;
+  std::shared_ptr<ShadowNode> build(const ElementFragment &elementFragment) const;
 
   ComponentDescriptorRegistry::Shared componentDescriptorRegistry_;
 };

package/ReactCommon/react/renderer/element/Element.h

@@ -37,13 +37,13 @@ class Element final {
   using ConcreteShadowNode = ShadowNodeT;
   using ConcreteUnsharedShadowNode = std::shared_ptr<ConcreteShadowNode>;
 
-  using ConcreteReferenceCallback =
-      std::function<void(const std::shared_ptr<const ShadowNodeT>& shadowNode)>;
+  using ConcreteReferenceCallback = std::function<void(const std::shared_ptr<const ShadowNodeT> &shadowNode)>;
 
   /*
    * Constructs an `Element`.
    */
-  Element() {
+  Element()
+  {
     fragment_.componentHandle = ShadowNodeT::Handle();
     fragment_.componentName = ShadowNodeT::Name();
     fragment_.props = ShadowNodeT::defaultSharedProps();
@@ -52,14 +52,16 @@ class Element final {
   /*
    * Converts to `ElementFragment` object.
    */
-  operator ElementFragment() {
+  operator ElementFragment()
+  {
     return fragment_;
   }
 
   /*
    * Sets `tag`.
    */
-  Element& tag(Tag tag) {
+  Element &tag(Tag tag)
+  {
     fragment_.tag = tag;
     return *this;
   }
@@ -67,7 +69,8 @@ class Element final {
   /*
    * Sets `surfaceId`.
    */
-  Element& surfaceId(SurfaceId surfaceId) {
+  Element &surfaceId(SurfaceId surfaceId)
+  {
     fragment_.surfaceId = surfaceId;
     return *this;
   }
@@ -75,7 +78,8 @@ class Element final {
   /*
    * Sets `props`.
    */
-  Element& props(SharedConcreteProps props) {
+  Element &props(SharedConcreteProps props)
+  {
     fragment_.props = props;
     return *this;
   }
@@ -83,7 +87,8 @@ class Element final {
   /*
    * Sets `props` using callback.
    */
-  Element& props(std::function<SharedConcreteProps()> callback) {
+  Element &props(std::function<SharedConcreteProps()> callback)
+  {
     fragment_.props = callback();
     return *this;
   }
@@ -91,12 +96,10 @@ class Element final {
   /*
    * Sets `state` using callback.
    */
-  Element& stateData(std::function<void(ConcreteStateData&)> callback) {
-    fragment_.stateCallback =
-        [callback = std::move(callback)](
-            const State::Shared& state) -> StateData::Shared {
-      auto stateData =
-          static_cast<const ConcreteState*>(state.get())->getData();
+  Element &stateData(std::function<void(ConcreteStateData &)> callback)
+  {
+    fragment_.stateCallback = [callback = std::move(callback)](const State::Shared &state) -> StateData::Shared {
+      auto stateData = static_cast<const ConcreteState *>(state.get())->getData();
       callback(stateData);
       return std::make_shared<ConcreteStateData>(stateData);
     };
@@ -106,10 +109,11 @@ class Element final {
   /*
    * Sets children.
    */
-  Element& children(std::vector<ElementFragment> children) {
+  Element &children(std::vector<ElementFragment> children)
+  {
     auto fragments = ElementFragment::List{};
     fragments.reserve(children.size());
-    for (const auto& child : children) {
+    for (const auto &child : children) {
       fragments.push_back(child);
     }
     fragment_.children = fragments;
@@ -120,15 +124,13 @@ class Element final {
    * Calls the callback during component construction with a pointer to the
    * component which is being constructed.
    */
-  Element& reference(
-      std::function<void(const ConcreteUnsharedShadowNode& shadowNode)>
-          callback) {
-    fragment_.referenceCallback =
-        [callback = std::move(callback)](
-            const std::shared_ptr<const ShadowNode>& shadowNode) {
-          callback(std::const_pointer_cast<ConcreteShadowNode>(
-              std::static_pointer_cast<const ConcreteShadowNode>(shadowNode)));
-        };
+  Element &reference(std::function<void(const ConcreteUnsharedShadowNode &shadowNode)> callback)
+  {
+    fragment_.referenceCallback = [callback =
+                                       std::move(callback)](const std::shared_ptr<const ShadowNode> &shadowNode) {
+      callback(
+          std::const_pointer_cast<ConcreteShadowNode>(std::static_pointer_cast<const ConcreteShadowNode>(shadowNode)));
+    };
     return *this;
   }
 
@@ -136,22 +138,22 @@ class Element final {
    * During component construction, assigns a given pointer to a component
    * that is being constructed.
    */
-  Element& reference(ConcreteUnsharedShadowNode& outShadowNode) {
-    fragment_.referenceCallback =
-        [&](const std::shared_ptr<const ShadowNode>& shadowNode) {
-          outShadowNode = std::const_pointer_cast<ConcreteShadowNode>(
-              std::static_pointer_cast<const ConcreteShadowNode>(shadowNode));
-        };
+  Element &reference(ConcreteUnsharedShadowNode &outShadowNode)
+  {
+    fragment_.referenceCallback = [&](const std::shared_ptr<const ShadowNode> &shadowNode) {
+      outShadowNode =
+          std::const_pointer_cast<ConcreteShadowNode>(std::static_pointer_cast<const ConcreteShadowNode>(shadowNode));
+    };
     return *this;
   }
 
   /*
    * Calls the callback with a reference to a just constructed component.
    */
-  Element& finalize(
-      std::function<void(ConcreteShadowNode& shadowNode)> finalizeCallback) {
-    fragment_.finalizeCallback = [=](ShadowNode& shadowNode) {
-      return finalizeCallback(static_cast<ConcreteShadowNode&>(shadowNode));
+  Element &finalize(std::function<void(ConcreteShadowNode &shadowNode)> finalizeCallback)
+  {
+    fragment_.finalizeCallback = [=](ShadowNode &shadowNode) {
+      return finalizeCallback(static_cast<ConcreteShadowNode &>(shadowNode));
     };
     return *this;
   }

package/ReactCommon/react/renderer/element/ElementFragment.h

@@ -26,11 +26,9 @@ class ElementFragment final {
   using Shared = std::shared_ptr<ElementFragment>;
   using List = std::vector<ElementFragment>;
   using ListOfShared = std::vector<Shared>;
-  using ReferenceCallback =
-      std::function<void(const std::shared_ptr<ShadowNode>& shadowNode)>;
-  using FinalizeCallback = std::function<void(ShadowNode& shadowNode)>;
-  using StateCallback =
-      std::function<StateData::Shared(const State::Shared& state)>;
+  using ReferenceCallback = std::function<void(const std::shared_ptr<ShadowNode> &shadowNode)>;
+  using FinalizeCallback = std::function<void(ShadowNode &shadowNode)>;
+  using StateCallback = std::function<StateData::Shared(const State::Shared &state)>;
 
   /*
    * ComponentDescriptor part (describes the type)

package/ReactCommon/react/renderer/element/testUtils.h

@@ -19,29 +19,21 @@
 
 namespace facebook::react {
 
-inline ComponentBuilder simpleComponentBuilder(
-    std::shared_ptr<const ContextContainer> contextContainer = nullptr) {
+inline ComponentBuilder simpleComponentBuilder(std::shared_ptr<const ContextContainer> contextContainer = nullptr)
+{
   ComponentDescriptorProviderRegistry componentDescriptorProviderRegistry{};
   auto eventDispatcher = EventDispatcher::Shared{};
-  auto componentDescriptorRegistry =
-      componentDescriptorProviderRegistry.createComponentDescriptorRegistry(
-          ComponentDescriptorParameters{
-              eventDispatcher, std::move(contextContainer), nullptr});
+  auto componentDescriptorRegistry = componentDescriptorProviderRegistry.createComponentDescriptorRegistry(
+      ComponentDescriptorParameters{
+          .eventDispatcher = eventDispatcher, .contextContainer = std::move(contextContainer), .flavor = nullptr});
 
-  componentDescriptorProviderRegistry.add(
-      concreteComponentDescriptorProvider<RootComponentDescriptor>());
-  componentDescriptorProviderRegistry.add(
-      concreteComponentDescriptorProvider<ViewComponentDescriptor>());
-  componentDescriptorProviderRegistry.add(
-      concreteComponentDescriptorProvider<ScrollViewComponentDescriptor>());
-  componentDescriptorProviderRegistry.add(
-      concreteComponentDescriptorProvider<ParagraphComponentDescriptor>());
-  componentDescriptorProviderRegistry.add(
-      concreteComponentDescriptorProvider<TextComponentDescriptor>());
-  componentDescriptorProviderRegistry.add(
-      concreteComponentDescriptorProvider<RawTextComponentDescriptor>());
-  componentDescriptorProviderRegistry.add(
-      concreteComponentDescriptorProvider<ModalHostViewComponentDescriptor>());
+  componentDescriptorProviderRegistry.add(concreteComponentDescriptorProvider<RootComponentDescriptor>());
+  componentDescriptorProviderRegistry.add(concreteComponentDescriptorProvider<ViewComponentDescriptor>());
+  componentDescriptorProviderRegistry.add(concreteComponentDescriptorProvider<ScrollViewComponentDescriptor>());
+  componentDescriptorProviderRegistry.add(concreteComponentDescriptorProvider<ParagraphComponentDescriptor>());
+  componentDescriptorProviderRegistry.add(concreteComponentDescriptorProvider<TextComponentDescriptor>());
+  componentDescriptorProviderRegistry.add(concreteComponentDescriptorProvider<RawTextComponentDescriptor>());
+  componentDescriptorProviderRegistry.add(concreteComponentDescriptorProvider<ModalHostViewComponentDescriptor>());
 
   return ComponentBuilder{componentDescriptorRegistry};
 }

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

@@ -0,0 +1,23 @@
+/*
+ * 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.
+ */
+
+#include "BackgroundImage.h"
+
+namespace facebook::react {
+
+#ifdef RN_SERIALIZABLE_STATE
+folly::dynamic toDynamic(const BackgroundImage& backgroundImage) {
+  if (std::holds_alternative<LinearGradient>(backgroundImage)) {
+    return std::get<LinearGradient>(backgroundImage).toDynamic();
+  } else if (std::holds_alternative<RadialGradient>(backgroundImage)) {
+    return std::get<RadialGradient>(backgroundImage).toDynamic();
+  }
+  return folly::dynamic(nullptr);
+}
+#endif
+
+} // namespace facebook::react

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

@@ -7,13 +7,39 @@
 
 #pragma once
 
-#include <react/renderer/graphics/ColorComponents.h>
 #include <react/renderer/graphics/LinearGradient.h>
 #include <react/renderer/graphics/RadialGradient.h>
-#include <vector>
 
 namespace facebook::react {
 
 using BackgroundImage = std::variant<LinearGradient, RadialGradient>;
 
+#ifdef RN_SERIALIZABLE_STATE
+folly::dynamic toDynamic(const BackgroundImage &backgroundImage);
+#endif
+
+#if RN_DEBUG_STRING_CONVERTIBLE
+inline std::string toString(std::vector<BackgroundImage> &value)
+{
+  std::stringstream ss;
+
+  ss << "[";
+  for (size_t i = 0; i < value.size(); i++) {
+    if (i > 0) {
+      ss << ", ";
+    }
+
+    const auto &backgroundImage = value[i];
+    if (std::holds_alternative<LinearGradient>(backgroundImage)) {
+      std::get<LinearGradient>(backgroundImage).toString(ss);
+    } else if (std::holds_alternative<RadialGradient>(backgroundImage)) {
+      std::get<RadialGradient>(backgroundImage).toString(ss);
+    }
+  }
+  ss << "]";
+
+  return ss.str();
+}
+#endif
+
 }; // namespace facebook::react

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

@@ -0,0 +1,27 @@
+/*
+ * 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/ValueUnit.h>
+#include <optional>
+
+namespace facebook::react {
+
+struct BackgroundPosition {
+  std::optional<ValueUnit> top;
+  std::optional<ValueUnit> left;
+  std::optional<ValueUnit> right;
+  std::optional<ValueUnit> bottom;
+
+  BackgroundPosition() : top(ValueUnit{0.0f, UnitType::Point}), left(ValueUnit{0.0f, UnitType::Point}) {}
+
+  bool operator==(const BackgroundPosition &other) const = default;
+  bool operator!=(const BackgroundPosition &other) const = default;
+};
+
+} // namespace facebook::react

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

@@ -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.
+ */
+
+#pragma once
+
+namespace facebook::react {
+
+enum class BackgroundRepeatStyle {
+  Repeat,
+  Space,
+  Round,
+  NoRepeat,
+};
+
+struct BackgroundRepeat {
+  BackgroundRepeatStyle x{BackgroundRepeatStyle::Repeat};
+  BackgroundRepeatStyle y{BackgroundRepeatStyle::Repeat};
+
+  BackgroundRepeat() {}
+
+  bool operator==(const BackgroundRepeat &other) const = default;
+  bool operator!=(const BackgroundRepeat &other) const = default;
+};
+
+} // namespace facebook::react

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

@@ -0,0 +1,39 @@
+/*
+ * 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/ValueUnit.h>
+#include <variant>
+
+namespace facebook::react {
+
+struct BackgroundSizeLengthPercentage {
+  std::variant<std::monostate, ValueUnit> x;
+  std::variant<std::monostate, ValueUnit> y;
+
+  BackgroundSizeLengthPercentage() : x(std::monostate{}), y(std::monostate{}) {}
+
+  bool isXAuto() const
+  {
+    return std::holds_alternative<std::monostate>(x);
+  }
+  bool isYAuto() const
+  {
+    return std::holds_alternative<std::monostate>(y);
+  }
+
+  bool operator==(const BackgroundSizeLengthPercentage &other) const = default;
+  bool operator!=(const BackgroundSizeLengthPercentage &other) const = default;
+};
+
+enum class BackgroundSizeKeyword { Cover, Contain };
+
+// https://www.w3.org/TR/css-backgrounds-3/#background-size
+using BackgroundSize = std::variant<BackgroundSizeKeyword, BackgroundSizeLengthPercentage>;
+
+} // namespace facebook::react

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

@@ -31,8 +31,8 @@ enum class BlendMode {
   Luminosity,
 };
 
-inline std::optional<BlendMode> blendModeFromString(
-    std::string_view blendModeName) {
+inline std::optional<BlendMode> blendModeFromString(std::string_view blendModeName)
+{
   if (blendModeName == "normal") {
     return BlendMode::Normal;
   } else if (blendModeName == "multiply") {
@@ -70,7 +70,8 @@ inline std::optional<BlendMode> blendModeFromString(
   }
 }
 
-inline std::string toString(const BlendMode& blendMode) {
+inline std::string toString(const BlendMode &blendMode)
+{
   switch (blendMode) {
     case BlendMode::Normal:
       return "normal";

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

@@ -13,7 +13,7 @@
 namespace facebook::react {
 
 struct BoxShadow {
-  bool operator==(const BoxShadow& other) const = default;
+  bool operator==(const BoxShadow &other) const = default;
 
   Float offsetX{};
   Float offsetY{};
@@ -23,7 +23,8 @@ struct BoxShadow {
   bool inset{};
 
 #ifdef RN_SERIALIZABLE_STATE
-  folly::dynamic toDynamic() const {
+  folly::dynamic toDynamic() const
+  {
     folly::dynamic result = folly::dynamic::object();
     result["offsetX"] = offsetX;
     result["offsetY"] = offsetY;
@@ -37,7 +38,8 @@ struct BoxShadow {
 };
 
 #ifdef RN_SERIALIZABLE_STATE
-inline folly::dynamic toDynamic(const BoxShadow& boxShadow) {
+inline folly::dynamic toDynamic(const BoxShadow &boxShadow)
+{
   return boxShadow.toDynamic();
 }
 #endif

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

@@ -7,8 +7,24 @@
 
 #include "Color.h"
 
+#include <array>
+
 namespace facebook::react {
 
+std::string SharedColor::toString() const noexcept {
+  ColorComponents components = colorComponentsFromColor(*this);
+  std::array<char, 255> buffer{};
+  std::snprintf(
+      buffer.data(),
+      buffer.size(),
+      "rgba(%.0f, %.0f, %.0f, %g)",
+      components.red * 255.f,
+      components.green * 255.f,
+      components.blue * 255.f,
+      components.alpha);
+  return buffer.data();
+}
+
 bool isColorMeaningful(const SharedColor& color) noexcept {
   if (!color) {
     return false;
@@ -53,17 +69,20 @@ SharedColor colorFromRGBA(uint8_t r, uint8_t g, uint8_t b, uint8_t a) {
 }
 
 SharedColor clearColor() {
-  static SharedColor color = colorFromComponents(ColorComponents{0, 0, 0, 0});
+  static SharedColor color = colorFromComponents(
+      ColorComponents{.red = 0, .green = 0, .blue = 0, .alpha = 0});
   return color;
 }
 
 SharedColor blackColor() {
-  static SharedColor color = colorFromComponents(ColorComponents{0, 0, 0, 1});
+  static SharedColor color = colorFromComponents(
+      ColorComponents{.red = 0, .green = 0, .blue = 0, .alpha = 1});
   return color;
 }
 
 SharedColor whiteColor() {
-  static SharedColor color = colorFromComponents(ColorComponents{1, 1, 1, 1});
+  static SharedColor color = colorFromComponents(
+      ColorComponents{.red = 1, .green = 1, .blue = 1, .alpha = 1});
   return color;
 }
 

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

@@ -7,11 +7,12 @@
 
 #pragma once
 
-#include <functional>
-
 #include <react/renderer/graphics/ColorComponents.h>
 #include <react/renderer/graphics/HostPlatformColor.h>
 
+#include <functional>
+#include <string>
+
 #ifdef RN_SERIALIZABLE_STATE
 #include <folly/dynamic.h>
 #endif
@@ -32,31 +33,38 @@ class SharedColor {
 
   SharedColor(Color color) : color_(color) {}
 
-  Color& operator*() {
+  Color &operator*()
+  {
     return color_;
   }
 
-  const Color& operator*() const {
+  const Color &operator*() const
+  {
     return color_;
   }
 
-  bool operator==(const SharedColor& otherColor) const {
+  bool operator==(const SharedColor &otherColor) const
+  {
     return color_ == otherColor.color_;
   }
 
-  bool operator!=(const SharedColor& otherColor) const {
+  bool operator!=(const SharedColor &otherColor) const
+  {
     return color_ != otherColor.color_;
   }
 
-  operator bool() const {
+  operator bool() const
+  {
     return color_ != HostPlatformColor::UndefinedColor;
   }
 
+  std::string toString() const noexcept;
+
  private:
   Color color_;
 };
 
-bool isColorMeaningful(const SharedColor& color) noexcept;
+bool isColorMeaningful(const SharedColor &color) noexcept;
 SharedColor colorFromComponents(ColorComponents components);
 ColorComponents colorComponentsFromColor(SharedColor color);
 
@@ -71,7 +79,8 @@ SharedColor blackColor();
 SharedColor whiteColor();
 
 #ifdef RN_SERIALIZABLE_STATE
-inline folly::dynamic toDynamic(const SharedColor& sharedColor) {
+inline folly::dynamic toDynamic(const SharedColor &sharedColor)
+{
   return *sharedColor;
 }
 #endif
@@ -80,7 +89,8 @@ inline folly::dynamic toDynamic(const SharedColor& sharedColor) {
 
 template <>
 struct std::hash<facebook::react::SharedColor> {
-  size_t operator()(const facebook::react::SharedColor& color) const {
+  size_t operator()(const facebook::react::SharedColor &color) const
+  {
     return std::hash<facebook::react::Color>{}(*color);
   }
 };

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

@@ -0,0 +1,21 @@
+/*
+ * 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.
+ */
+
+#include "ColorStop.h"
+
+namespace facebook::react {
+
+#ifdef RN_SERIALIZABLE_STATE
+folly::dynamic ColorStop::toDynamic() const {
+  folly::dynamic result = folly::dynamic::object();
+  result["color"] = *color;
+  result["position"] = position.toDynamic();
+  return result;
+}
+#endif
+
+}; // namespace facebook::react

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

@@ -7,20 +7,38 @@
 
 #pragma once
 
+#include <react/renderer/debug/flags.h>
 #include <react/renderer/graphics/Color.h>
 #include <react/renderer/graphics/Float.h>
 #include <react/renderer/graphics/ValueUnit.h>
+#include <optional>
+#include <sstream>
 
 namespace facebook::react {
 
 struct ColorStop {
-  bool operator==(const ColorStop& other) const = default;
+  bool operator==(const ColorStop &other) const = default;
   SharedColor color;
   ValueUnit position;
+
+#ifdef RN_SERIALIZABLE_STATE
+  folly::dynamic toDynamic() const;
+#endif
+
+#if RN_DEBUG_STRING_CONVERTIBLE
+  void toString(std::stringstream &ss) const
+  {
+    ss << color.toString();
+    if (position.unit != UnitType::Undefined) {
+      ss << " ";
+      ss << position.toString();
+    }
+  }
+#endif
 };
 
 struct ProcessedColorStop {
-  bool operator==(const ProcessedColorStop& other) const = default;
+  bool operator==(const ProcessedColorStop &other) const = default;
   SharedColor color;
   std::optional<Float> position;
 };