react-native-tvos 0.76.6-0 → 0.77.0-0

package/ReactCommon/react/renderer/core/ShadowNode.cpp

@@ -20,6 +20,19 @@
 
 namespace facebook::react {
 
+/*
+ * Runtime shadow node reference updates should only run from one thread at all
+ * times to avoid having more than one shadow tree updating the current fiber
+ * tree simultaneously. This thread_local flag allows enabling the updates for
+ * choses threads.
+ */
+thread_local bool useRuntimeShadowNodeReferenceUpdateOnThread{false}; // NOLINT
+
+/* static */ void ShadowNode::setUseRuntimeShadowNodeReferenceUpdateOnThread(
+    bool isEnabled) {
+  useRuntimeShadowNodeReferenceUpdateOnThread = isEnabled;
+}
+
 ShadowNode::SharedListOfShared ShadowNode::emptySharedShadowNodeSharedList() {
   static const auto emptySharedShadowNodeSharedList =
       std::make_shared<ShadowNode::ListOfShared>();
@@ -78,7 +91,6 @@ ShadowNode::ShadowNode(
   react_native_assert(children_);
 
   traits_.set(ShadowNodeTraits::Trait::ChildrenAreShared);
-  traits_.set(fragment.traits.get());
 
   for (const auto& child : *children_) {
     child->family_->setParent(family_);
@@ -110,9 +122,7 @@ ShadowNode::ShadowNode(
 
   // State could have been progressed above by checking
   // `sourceShadowNode.getMostRecentState()`.
-  traits_.unset(ShadowNodeTraits::Trait::ClonedByNativeStateUpdate);
   traits_.set(ShadowNodeTraits::Trait::ChildrenAreShared);
-  traits_.set(fragment.traits.get());
 
   if (fragment.children) {
     for (const auto& child : *children_) {
@@ -136,8 +146,7 @@ ShadowNode::Unshared ShadowNode::clone(
           *this,
           {.props = props,
            .children = fragment.children,
-           .state = fragment.state,
-           .traits = fragment.traits});
+           .state = fragment.state});
       return clonedNode;
     } else {
       // TODO: We might need to merge fragment.priops with
@@ -282,6 +291,7 @@ void ShadowNode::cloneChildrenIfShared() {
 void ShadowNode::setMounted(bool mounted) const {
   if (mounted) {
     family_->setMostRecentState(getState());
+    family_->setMounted();
     hasBeenMounted_ = mounted;
   }
 
@@ -292,23 +302,6 @@ bool ShadowNode::getHasBeenPromoted() const {
   return hasBeenMounted_.load();
 }
 
-bool ShadowNode::progressStateIfNecessary() {
-  auto hasBeenPromoted = hasBeenMounted_.load();
-  if (!hasBeenPromoted && state_) {
-    ensureUnsealed();
-    auto mostRecentState = family_->getMostRecentStateIfObsolete(*state_);
-    if (mostRecentState) {
-      state_ = mostRecentState;
-      const auto& componentDescriptor = family_->componentDescriptor_;
-      // Must call ComponentDescriptor::adopt to trigger any side effect
-      // state may have. E.g. adjusting padding.
-      componentDescriptor.adopt(*this);
-      return true;
-    }
-  }
-  return false;
-}
-
 void ShadowNode::setRuntimeShadowNodeReference(
     const std::shared_ptr<ShadowNodeWrapper>& runtimeShadowNodeReference)
     const {
@@ -328,7 +321,8 @@ void ShadowNode::transferRuntimeShadowNodeReference(
 void ShadowNode::transferRuntimeShadowNodeReference(
     const Shared& destinationShadowNode,
     const ShadowNodeFragment& fragment) const {
-  if (fragment.runtimeShadowNodeReference &&
+  if (useRuntimeShadowNodeReferenceUpdateOnThread &&
+      fragment.runtimeShadowNodeReference &&
       ReactNativeFeatureFlags::useRuntimeShadowNodeReferenceUpdate()) {
     transferRuntimeShadowNodeReference(destinationShadowNode);
   }
@@ -341,8 +335,7 @@ const ShadowNodeFamily& ShadowNode::getFamily() const {
 ShadowNode::Unshared ShadowNode::cloneTree(
     const ShadowNodeFamily& shadowNodeFamily,
     const std::function<ShadowNode::Unshared(const ShadowNode& oldShadowNode)>&
-        callback,
-    ShadowNodeTraits traits) const {
+        callback) const {
   auto ancestors = shadowNodeFamily.getAncestors(*this);
 
   if (ancestors.empty()) {
@@ -370,8 +363,7 @@ ShadowNode::Unshared ShadowNode::cloneTree(
     children[childIndex] = childNode;
 
     childNode = parentNode.clone(
-        {.children = std::make_shared<ShadowNode::ListOfShared>(children),
-         .traits = traits});
+        {.children = std::make_shared<ShadowNode::ListOfShared>(children)});
   }
 
   return std::const_pointer_cast<ShadowNode>(childNode);
@@ -387,7 +379,8 @@ std::string ShadowNode::getDebugName() const {
 std::string ShadowNode::getDebugValue() const {
   return "r" + folly::to<std::string>(revision_) + "/sr" +
       folly::to<std::string>(state_ ? state_->getRevision() : 0) +
-      (getSealed() ? "/sealed" : "");
+      (getSealed() ? "/sealed" : "") +
+      (getProps()->nativeId.empty() ? "" : "/id=" + getProps()->nativeId);
 }
 
 SharedDebugStringConvertibleList ShadowNode::getDebugChildren() const {

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

@@ -61,6 +61,8 @@ class ShadowNode : public Sealable,
     return ShadowNodeTraits{};
   }
 
+  static void setUseRuntimeShadowNodeReferenceUpdateOnThread(bool isEnabled);
+
 #pragma mark - Constructors
 
   /*
@@ -102,8 +104,8 @@ class ShadowNode : public Sealable,
    */
   Unshared cloneTree(
       const ShadowNodeFamily& shadowNodeFamily,
-      const std::function<Unshared(const ShadowNode& oldShadowNode)>& callback,
-      ShadowNodeTraits traits = {}) const;
+      const std::function<Unshared(const ShadowNode& oldShadowNode)>& callback)
+      const;
 
 #pragma mark - Getters
 
@@ -178,17 +180,6 @@ class ShadowNode : public Sealable,
    */
   bool getHasBeenPromoted() const;
 
-  /*
-   * Applies the most recent state to the ShadowNode if following conditions are
-   * met:
-   * - ShadowNode has a state.
-   * - ShadowNode has not been mounted before.
-   * - ShadowNode's current state is obsolete.
-   *
-   * Returns true if the state was applied, false otherwise.
-   */
-  bool progressStateIfNecessary();
-
   /*
    * Bind the runtime reference to this `ShadowNode` with a weak pointer,
    * allowing to update the reference to this `ShadowNode` when cloned.

package/ReactCommon/react/renderer/core/ShadowNodeFamily.cpp

@@ -9,6 +9,7 @@
 #include "ShadowNode.h"
 
 #include <react/debug/react_native_assert.h>
+#include <react/featureflags/ReactNativeFeatureFlags.h>
 #include <react/renderer/core/ComponentDescriptor.h>
 #include <react/renderer/core/State.h>
 
@@ -30,7 +31,9 @@ ShadowNodeFamily::ShadowNodeFamily(
       eventEmitter_(std::move(eventEmitter)),
       componentDescriptor_(componentDescriptor),
       componentHandle_(componentDescriptor.getComponentHandle()),
-      componentName_(componentDescriptor.getComponentName()) {}
+      componentName_(componentDescriptor.getComponentName()),
+      isDeletionOfUnmountedViewsEnabled_(
+          ReactNativeFeatureFlags::enableDeletionOfUnmountedViews()) {}
 
 void ShadowNodeFamily::setParent(const ShadowNodeFamily::Shared& parent) const {
   react_native_assert(parent_.lock() == nullptr || parent_.lock() == parent);
@@ -58,10 +61,30 @@ ComponentName ShadowNodeFamily::getComponentName() const {
   return componentName_;
 }
 
+void ShadowNodeFamily::setMounted() const {
+  hasBeenMounted_ = true;
+}
+
 const ComponentDescriptor& ShadowNodeFamily::getComponentDescriptor() const {
   return componentDescriptor_;
 }
 
+void ShadowNodeFamily::onUnmountedFamilyDestroyed(
+    std::function<void(const ShadowNodeFamily& family)> callback) const {
+  onUnmountedFamilyDestroyedCallback_ = std::move(callback);
+}
+
+Tag ShadowNodeFamily::getTag() const {
+  return tag_;
+}
+
+ShadowNodeFamily::~ShadowNodeFamily() {
+  if (isDeletionOfUnmountedViewsEnabled_ && !hasBeenMounted_ &&
+      onUnmountedFamilyDestroyedCallback_ != nullptr) {
+    onUnmountedFamilyDestroyedCallback_(*this);
+  }
+}
+
 AncestorList ShadowNodeFamily::getAncestors(
     const ShadowNode& ancestorShadowNode) const {
   auto families = std::vector<const ShadowNodeFamily*>{};

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

@@ -25,7 +25,7 @@ class State;
  * `ShadowNodeFamily` instances.
  *
  * Do not use this class as a general purpose container to share information
- * about a `ShadowNodeFamily`. Pelase define specific purpose containers in
+ * about a `ShadowNodeFamily`. Please define specific purpose containers in
  * those cases.
  *
  */
@@ -87,12 +87,24 @@ class ShadowNodeFamily final {
 
   SharedEventEmitter getEventEmitter() const;
 
+  /**
+   * @param callback will be executed when an unmounted instance of
+   * ShadowNodeFamily is destroyed.
+   */
+  void onUnmountedFamilyDestroyed(
+      std::function<void(const ShadowNodeFamily& family)> callback) const;
+
   /*
    * Sets and gets the most recent state.
    */
   std::shared_ptr<const State> getMostRecentState() const;
   void setMostRecentState(const std::shared_ptr<const State>& state) const;
 
+  /**
+   * Mark this ShadowNodeFamily as mounted.
+   */
+  void setMounted() const;
+
   /*
    * Dispatches a state update with given priority.
    */
@@ -105,6 +117,17 @@ class ShadowNodeFamily final {
    */
   mutable std::unique_ptr<folly::dynamic> nativeProps_DEPRECATED;
 
+  /**
+   * @return tag for the ShadowNodeFamily.
+   */
+  Tag getTag() const;
+
+  /**
+   * Override destructor to call onUnmountedFamilyDestroyedCallback() for
+   * ShadowViews that were preallocated but never mounted on the screen.
+   */
+  ~ShadowNodeFamily();
+
  private:
   friend ShadowNode;
   friend State;
@@ -121,6 +144,9 @@ class ShadowNodeFamily final {
   mutable std::shared_ptr<const State> mostRecentState_;
   mutable std::shared_mutex mutex_;
 
+  mutable std::function<void(ShadowNodeFamily& family)>
+      onUnmountedFamilyDestroyedCallback_ = nullptr;
+
   /*
    * Deprecated.
    */
@@ -165,6 +191,17 @@ class ShadowNodeFamily final {
    * For optimization purposes only.
    */
   mutable bool hasParent_{false};
+
+  /*
+   * Determines if the ShadowNodeFamily was ever mounted on the screen.
+   */
+  mutable bool hasBeenMounted_{false};
+
+  /*
+   * Determines if Views that were never mounted on the screen should be deleted
+   * when the shadow node family is destroyed.
+   */
+  const bool isDeletionOfUnmountedViewsEnabled_;
 };
 
 } // namespace facebook::react

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

@@ -26,7 +26,6 @@ struct ShadowNodeFragment {
   const Props::Shared& props = propsPlaceholder();
   const ShadowNode::SharedListOfShared& children = childrenPlaceholder();
   const State::Shared& state = statePlaceholder();
-  const ShadowNodeTraits traits = {};
   const bool runtimeShadowNodeReference = true;
 
   /*

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

@@ -70,14 +70,14 @@ class ShadowNodeTraits {
     // to be cloned before the first mutation.
     ChildrenAreShared = 1 << 8,
 
-    // Indicates that the node was cloned because of native state update.
-    ClonedByNativeStateUpdate = 1 << 9,
-
     // Indicates that direct children of the node should not be collapsed
-    ChildrenFormStackingContext = 1 << 10,
+    ChildrenFormStackingContext = 1 << 9,
 
     // Inherits `YogaLayoutableShadowNode` and has a custom baseline function.
-    BaselineYogaNode = 1 << 11,
+    BaselineYogaNode = 1 << 10,
+
+    // Forces the node not to form a host view.
+    ForceFlattenView = 1 << 11,
   };
 
   /*

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

@@ -39,7 +39,7 @@ inline int toInt(const DisplayType& displayType) {
       return 0;
     case DisplayType::Flex:
       return 1;
-    case DisplayType::Inline:
+    case DisplayType::Contents:
       return 2;
   }
 }
@@ -50,8 +50,8 @@ inline std::string toString(const DisplayType& displayType) {
       return "none";
     case DisplayType::Flex:
       return "flex";
-    case DisplayType::Inline:
-      return "inline";
+    case DisplayType::Contents:
+      return "contents";
   }
 }
 

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

@@ -21,8 +21,10 @@
 namespace facebook::react {
 
 class MockEventLogger : public EventLogger {
-  EventTag onEventStart(std::string_view /*name*/, SharedEventTarget /*target*/)
-      override {
+  EventTag onEventStart(
+      std::string_view /*name*/,
+      SharedEventTarget /*target*/,
+      DOMHighResTimeStamp /*eventStartTimeStamp*/) override {
     return EMPTY_EVENT_TAG;
   }
   void onEventProcessingStart(EventTag /*tag*/) override {}

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

@@ -154,6 +154,8 @@ class ShadowNodeTest : public testing::TestWithParam<bool> {
   }
 
   void SetUp() override {
+    ShadowNode::setUseRuntimeShadowNodeReferenceUpdateOnThread(true);
+
     ReactNativeFeatureFlags::override(
         std::make_unique<ShadowNodeTestFeatureFlags>(GetParam()));
   }
@@ -244,26 +246,6 @@ TEST_P(ShadowNodeTest, handleCloneFunction) {
   EXPECT_EQ(nodeAB_->getProps(), nodeABClone->getProps());
 }
 
-TEST_P(ShadowNodeTest, handleCloningWithTraits) {
-  auto clonedWithoutTraits = nodeAB_->clone({});
-
-  EXPECT_FALSE(clonedWithoutTraits->getTraits().check(
-      ShadowNodeTraits::Trait::ClonedByNativeStateUpdate));
-
-  auto newTraits = ShadowNodeTraits();
-  newTraits.set(ShadowNodeTraits::Trait::ClonedByNativeStateUpdate);
-
-  auto clonedWithTraits = clonedWithoutTraits->clone({.traits = newTraits});
-
-  EXPECT_TRUE(clonedWithTraits->getTraits().check(
-      ShadowNodeTraits::Trait::ClonedByNativeStateUpdate));
-
-  auto clonedAgain = clonedWithTraits->clone({});
-
-  EXPECT_FALSE(clonedAgain->getTraits().check(
-      ShadowNodeTraits::Trait::ClonedByNativeStateUpdate));
-}
-
 TEST_P(ShadowNodeTest, handleState) {
   auto family = componentDescriptor_.createFamily(ShadowNodeFamilyFragment{
       /* .tag = */ 9,
@@ -319,37 +301,6 @@ TEST_P(ShadowNodeTest, handleState) {
       "Attempt to mutate a sealed object.");
 }
 
-TEST_P(ShadowNodeTest, testCloneTree) {
-  auto& family = nodeABA_->getFamily();
-  auto newTraits = ShadowNodeTraits();
-  newTraits.set(ShadowNodeTraits::Trait::ClonedByNativeStateUpdate);
-  auto rootNode = nodeA_->cloneTree(
-      family,
-      [newTraits](const ShadowNode& oldShadowNode) {
-        return oldShadowNode.clone({.traits = newTraits});
-      },
-      newTraits);
-
-  EXPECT_TRUE(rootNode->getTraits().check(
-      ShadowNodeTraits::Trait::ClonedByNativeStateUpdate));
-
-  EXPECT_FALSE(rootNode->getChildren()[0]->getTraits().check(
-      ShadowNodeTraits::Trait::ClonedByNativeStateUpdate));
-
-  const auto& firstLevelChild = *rootNode->getChildren()[1];
-
-  EXPECT_TRUE(firstLevelChild.getTraits().check(
-      ShadowNodeTraits::Trait::ClonedByNativeStateUpdate));
-
-  EXPECT_FALSE(firstLevelChild.getChildren()[1]->getTraits().check(
-      ShadowNodeTraits::Trait::ClonedByNativeStateUpdate));
-
-  const auto& secondLevelchild = *firstLevelChild.getChildren()[0];
-
-  EXPECT_TRUE(secondLevelchild.getTraits().check(
-      ShadowNodeTraits::Trait::ClonedByNativeStateUpdate));
-}
-
 TEST_P(ShadowNodeTest, handleRuntimeReferenceTransferOnClone) {
   auto nodeABRev1 = nodeAB_->clone({});
   auto wrappedShadowNode = std::make_shared<ShadowNodeWrapper>(nodeABRev1);

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

@@ -140,26 +140,26 @@ std::string toString(const std::optional<T>& value) {
  * types.
  */
 template <typename T>
-std::string getDebugName(const T& object) {
+std::string getDebugName(const T& /*object*/) {
   return "Node";
 }
 
 template <typename T>
-std::string getDebugValue(const T& object) {
+std::string getDebugValue(const T& /*object*/) {
   return "";
 }
 
 template <typename T>
 std::vector<T> getDebugChildren(
-    const T& object,
-    DebugStringConvertibleOptions options) {
+    const T& /*object*/,
+    DebugStringConvertibleOptions /*options*/) {
   return {};
 }
 
 template <typename T>
 std::vector<T> getDebugProps(
-    const T& object,
-    DebugStringConvertibleOptions options) {
+    const T& /*object*/,
+    DebugStringConvertibleOptions /*options*/) {
   return {};
 }
 
@@ -257,68 +257,68 @@ std::string getDebugDescription(
 // `int`
 inline std::string getDebugDescription(
     int number,
-    DebugStringConvertibleOptions options) {
+    DebugStringConvertibleOptions /*options*/) {
   return toString(number);
 }
 
 // `float`
 inline std::string getDebugDescription(
     float number,
-    DebugStringConvertibleOptions options) {
+    DebugStringConvertibleOptions /*options*/) {
   return toString(number);
 }
 
 // `double`
 inline std::string getDebugDescription(
     double number,
-    DebugStringConvertibleOptions options) {
+    DebugStringConvertibleOptions /*options*/) {
   return toString(number);
 }
 
 // `bool`
 inline std::string getDebugDescription(
     bool boolean,
-    DebugStringConvertibleOptions options) {
+    DebugStringConvertibleOptions /*options*/) {
   return toString(boolean);
 }
 
 // `void *`
 inline std::string getDebugDescription(
     void* pointer,
-    DebugStringConvertibleOptions options) {
+    DebugStringConvertibleOptions /*options*/) {
   return toString(pointer);
 }
 
 // `std::string`
 inline std::string getDebugDescription(
     const std::string& string,
-    DebugStringConvertibleOptions options) {
+    DebugStringConvertibleOptions /*options*/) {
   return string;
 }
 
 // `std::vector<T>`
 template <typename T, typename... Ts>
-std::string getDebugName(const std::vector<T, Ts...>& vector) {
+std::string getDebugName(const std::vector<T, Ts...>& /*vector*/) {
   return "List";
 }
 
 template <typename T, typename... Ts>
 std::vector<T, Ts...> getDebugChildren(
     const std::vector<T, Ts...>& vector,
-    DebugStringConvertibleOptions options) {
+    DebugStringConvertibleOptions /*options*/) {
   return vector;
 }
 
 // `std::array<T, Size>`
 template <typename T, size_t Size>
-std::string getDebugName(const std::array<T, Size>& array) {
+std::string getDebugName(const std::array<T, Size>& /*array*/) {
   return "List";
 }
 
 template <typename T, size_t Size>
 std::vector<T> getDebugChildren(
     const std::array<T, Size>& array,
-    DebugStringConvertibleOptions options) {
+    DebugStringConvertibleOptions /*options*/) {
   auto vector = std::vector<T>{};
   for (const auto& value : array) {
     vector.push_back(value);
@@ -328,14 +328,14 @@ std::vector<T> getDebugChildren(
 
 // `std::unordered_set<T>`
 template <typename T, typename... Ts>
-std::string getDebugName(const std::unordered_set<T, Ts...>& set) {
+std::string getDebugName(const std::unordered_set<T, Ts...>& /*set*/) {
   return "Set";
 }
 
 template <typename T, typename... Ts>
 std::vector<T> getDebugChildren(
     const std::unordered_set<T, Ts...>& set,
-    DebugStringConvertibleOptions options) {
+    DebugStringConvertibleOptions /*options*/) {
   auto vector = std::vector<T>{};
   vector.insert(vector.end(), set.begin(), set.end());
   return vector;

package/ReactCommon/react/renderer/debug/React-rendererdebug.podspec

@@ -24,6 +24,7 @@ header_search_paths = [
     "\"$(PODS_ROOT)/RCT-Folly\"",
     "\"$(PODS_ROOT)/boost\" \"$(PODS_ROOT)/RCT-Folly\"",
     "\"$(PODS_ROOT)/DoubleConversion\"",
+    "\"$(PODS_ROOT)/fast_float/include\"",
     "\"$(PODS_ROOT)/fmt/include\""
 ]
 
@@ -57,6 +58,7 @@ Pod::Spec.new do |s|
 
   s.dependency "RCT-Folly", folly_version
   s.dependency "DoubleConversion"
+  s.dependency "fast_float", "6.1.4"
   s.dependency "fmt", "9.1.0"
   add_dependency(s, "React-debug")
 end

package/ReactCommon/react/renderer/dom/DOM.cpp

@@ -211,7 +211,7 @@ uint_fast16_t compareDocumentPosition(
 
   auto otherAncestors =
       otherShadowNode.getFamily().getAncestors(*currentRevision);
-  if (ancestors.empty()) {
+  if (otherAncestors.empty()) {
     return DOCUMENT_POSITION_DISCONNECTED;
   }
 
@@ -380,8 +380,7 @@ DOMSizeRounded getScrollSize(
       *shadowNodeInCurrentRevision,
       {.includeTransform = false});
 
-  if (layoutMetrics == EmptyLayoutMetrics ||
-      layoutMetrics.displayType == DisplayType::Inline) {
+  if (layoutMetrics == EmptyLayoutMetrics) {
     return DOMSizeRounded{};
   }
 
@@ -417,8 +416,7 @@ DOMSizeRounded getInnerSize(
       *shadowNodeInCurrentRevision,
       {.includeTransform = false});
 
-  if (layoutMetrics == EmptyLayoutMetrics ||
-      layoutMetrics.displayType == DisplayType::Inline) {
+  if (layoutMetrics == EmptyLayoutMetrics) {
     return DOMSizeRounded{};
   }
 
@@ -445,8 +443,7 @@ DOMBorderWidthRounded getBorderWidth(
       *shadowNodeInCurrentRevision,
       {.includeTransform = false});
 
-  if (layoutMetrics == EmptyLayoutMetrics ||
-      layoutMetrics.displayType == DisplayType::Inline) {
+  if (layoutMetrics == EmptyLayoutMetrics) {
     return DOMBorderWidthRounded{};
   }
 

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

@@ -7,40 +7,12 @@
 
 #pragma once
 
-#include <react/renderer/graphics/Color.h>
-#include <react/renderer/graphics/Float.h>
-#include <optional>
-#include <string>
+#include <react/renderer/graphics/ColorComponents.h>
+#include <react/renderer/graphics/LinearGradient.h>
+#include <vector>
 
 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));
-  }
-}
+using BackgroundImage = std::variant<LinearGradient>;
 
 }; // namespace facebook::react