react-native-tvos 0.81.4-0 → 0.82.0-0

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

@@ -74,10 +74,15 @@ class ConcreteState : public State {
    * function for cases where a new value of data does not depend on an old
    * value.
    */
-  void updateState(Data&& newData) const {
-    updateState([data{std::move(newData)}](const Data& oldData) -> SharedData {
-      return std::make_shared<const Data>(data);
-    });
+  void updateState(
+      Data&& newData,
+      EventQueue::UpdateMode updateMode =
+          EventQueue::UpdateMode::Asynchronous) const {
+    updateState(
+        [data{std::move(newData)}](const Data& /*oldData*/) -> SharedData {
+          return std::make_shared<const Data>(data);
+        },
+        updateMode);
   }
 
   /*
@@ -89,7 +94,9 @@ class ConcreteState : public State {
    * return `nullptr`.
    */
   void updateState(
-      std::function<StateData::Shared(const Data& oldData)> callback) const {
+      std::function<StateData::Shared(const Data& oldData)> callback,
+      EventQueue::UpdateMode updateMode =
+          EventQueue::UpdateMode::Asynchronous) const {
     auto family = family_.lock();
 
     if (!family) {
@@ -104,7 +111,7 @@ class ConcreteState : public State {
           return callback(*static_cast<const Data*>(oldData.get()));
         }};
 
-    family->dispatchRawState(std::move(stateUpdate));
+    family->dispatchRawState(std::move(stateUpdate), updateMode);
   }
 
 #if defined(RN_SERIALIZABLE_STATE)

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

@@ -36,7 +36,7 @@ std::optional<double> DynamicEventPayload::extractValue(
   if (dynamic.type() == folly::dynamic::Type::DOUBLE) {
     return dynamic.asDouble();
   } else if (dynamic.type() == folly::dynamic::Type::INT64) {
-    return dynamic.asInt();
+    return static_cast<double>(dynamic.asInt());
   }
   return std::nullopt;
 }

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

@@ -31,7 +31,7 @@ enum class NullValueStrategy {
    * In case key is missing in source, value from patch will be ignored.
    *
    * Example:
-   * source:   {"key 1": "value 1"}
+   * source:   {"key": "value 1"}
    * patch:    {"key": "new value 1", "key 2": "new value 2"}
    * returned: {"key": "new value 1"}
    */

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

@@ -41,8 +41,10 @@ void EventDispatcher::experimental_flushSync() const {
   eventQueue_.experimental_flushSync();
 }
 
-void EventDispatcher::dispatchStateUpdate(StateUpdate&& stateUpdate) const {
-  eventQueue_.enqueueStateUpdate(std::move(stateUpdate));
+void EventDispatcher::dispatchStateUpdate(
+    StateUpdate&& stateUpdate,
+    EventQueue::UpdateMode updateMode) const {
+  eventQueue_.enqueueStateUpdate(std::move(stateUpdate), updateMode);
 }
 
 void EventDispatcher::dispatchUniqueEvent(RawEvent&& rawEvent) const {

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

@@ -56,7 +56,9 @@ class EventDispatcher {
   /*
    * Dispatches a state update with given priority.
    */
-  void dispatchStateUpdate(StateUpdate&& stateUpdate) const;
+  void dispatchStateUpdate(
+      StateUpdate&& stateUpdate,
+      EventQueue::UpdateMode updateMode) const;
 
 #pragma mark - Event listeners
   /*

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

@@ -20,10 +20,6 @@ EventQueue::EventQueue(
       eventBeat_(std::move(eventBeat)) {
   eventBeat_->setBeatCallback(
       [this](jsi::Runtime& runtime) { onBeat(runtime); });
-
-  if (ReactNativeFeatureFlags::enableSynchronousStateUpdates()) {
-    eventBeat_->unstable_setInduceCallback([this]() { flushStateUpdates(); });
-  }
 }
 
 void EventQueue::enqueueEvent(RawEvent&& rawEvent) const {
@@ -65,7 +61,9 @@ void EventQueue::enqueueUniqueEvent(RawEvent&& rawEvent) const {
   enqueueEvent(std::move(rawEvent));
 }
 
-void EventQueue::enqueueStateUpdate(StateUpdate&& stateUpdate) const {
+void EventQueue::enqueueStateUpdate(
+    StateUpdate&& stateUpdate,
+    UpdateMode updateMode) const {
   {
     std::scoped_lock lock(queueMutex_);
     if (!stateUpdateQueue_.empty()) {
@@ -77,7 +75,11 @@ void EventQueue::enqueueStateUpdate(StateUpdate&& stateUpdate) const {
     stateUpdateQueue_.push_back(std::move(stateUpdate));
   }
 
-  onEnqueue();
+  if (updateMode == UpdateMode::unstable_Immediate) {
+    flushStateUpdates();
+  } else {
+    onEnqueue();
+  }
 }
 
 void EventQueue::onEnqueue() const {
@@ -89,9 +91,7 @@ void EventQueue::experimental_flushSync() const {
 }
 
 void EventQueue::onBeat(jsi::Runtime& runtime) const {
-  if (!ReactNativeFeatureFlags::enableSynchronousStateUpdates()) {
-    flushStateUpdates();
-  }
+  flushStateUpdates();
   flushEvents(runtime);
 }
 

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

@@ -25,6 +25,18 @@ namespace facebook::react {
  */
 class EventQueue {
  public:
+  /* The update mode is used to inform how to apply changes. */
+  enum class UpdateMode {
+    /** Apply the update off the main thread. */
+    Asynchronous,
+    /**
+     * Apply the update on the main thread.
+     * The immediate update mode will **immediately** block the executing thread
+     * applying updates.
+     */
+    unstable_Immediate,
+  };
+
   EventQueue(
       EventQueueProcessor eventProcessor,
       std::unique_ptr<EventBeat> eventBeat);
@@ -46,7 +58,9 @@ class EventQueue {
    * Enqueues and (probably later) dispatch a given state update.
    * Can be called on any thread.
    */
-  void enqueueStateUpdate(StateUpdate&& stateUpdate) const;
+  void enqueueStateUpdate(
+      StateUpdate&& stateUpdate,
+      UpdateMode updateMode = UpdateMode::Asynchronous) const;
 
   /*
    * Experimental API exposed to support EventEmitter::experimental_flushSync.

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

@@ -44,8 +44,7 @@ RawProps::RawProps(folly::dynamic dynamic) noexcept {
   dynamic_ = std::move(dynamic);
 }
 
-RawProps::RawProps(const RawProps& other) noexcept {
-  mode_ = other.mode_;
+RawProps::RawProps(const RawProps& other) noexcept : mode_(other.mode_) {
   if (mode_ == Mode::JSI) {
     runtime_ = other.runtime_;
     value_ = jsi::Value(*runtime_, other.value_);

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

@@ -50,7 +50,7 @@ class RawProps final {
    */
   RawProps(jsi::Runtime& runtime, const jsi::Value& value) noexcept;
 
-  explicit RawProps(const RawProps& rawProps) noexcept;
+  explicit RawProps(const RawProps& other) noexcept;
   RawProps(RawProps&& other) noexcept = default;
 
   RawProps& operator=(const RawProps& other) noexcept = delete;

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

@@ -164,7 +164,7 @@ void RawPropsParser::preparse(const RawProps& rawProps) const noexcept {
         }
 
         rawProps.keyIndexToValueIndex_[keyIndex] = valueIndex;
-        rawProps.values_.push_back(RawValue{pair.second});
+        rawProps.values_.emplace_back(pair.second);
         valueIndex++;
       }
       break;

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

@@ -273,12 +273,8 @@ class RawValue {
     }
 
     for (const auto& item : dynamic) {
-      if (!checkValueType(item, (T*)nullptr)) {
-        return false;
-      }
-
       // Note: We test only one element.
-      break;
+      return checkValueType(item, (T*)nullptr);
     }
 
     return true;
@@ -294,7 +290,6 @@ class RawValue {
     }
 
     jsi::Object asObject = value.getObject(*runtime);
-
     if (!asObject.isArray(*runtime)) {
       return false;
     }
@@ -303,12 +298,8 @@ class RawValue {
     size_t size = array.size(*runtime);
     for (size_t i = 0; i < size; i++) {
       jsi::Value itemValue = array.getValueAtIndex(*runtime, i);
-      if (!checkValueType(runtime, itemValue, (T*)nullptr)) {
-        return false;
-      }
-
       // Note: We test only one element.
-      break;
+      return checkValueType(runtime, itemValue, (T*)nullptr);
     }
 
     return true;
@@ -324,12 +315,8 @@ class RawValue {
 
     for (const auto& item : dynamic.items()) {
       react_native_assert(item.first.isString());
-      if (!checkValueType(item.second, (T*)nullptr)) {
-        return false;
-      }
-
       // Note: We test only one element.
-      break;
+      return checkValueType(item.second, (T*)nullptr);
     }
 
     return true;
@@ -352,12 +339,8 @@ class RawValue {
       jsi::String propertyName =
           propertyNames.getValueAtIndex(*runtime, i).getString(*runtime);
       jsi::Value propertyValue = asObject.getProperty(*runtime, propertyName);
-      if (!checkValueType(runtime, propertyValue, (T*)nullptr)) {
-        return false;
-      }
-
       // Note: We test only one element.
-      break;
+      return checkValueType(runtime, propertyValue, (T*)nullptr);
     }
 
     return true;
@@ -394,7 +377,8 @@ class RawValue {
 
   static int
   castValue(jsi::Runtime* /*runtime*/, const jsi::Value& value, int* /*type*/) {
-    double number = value.asNumber();
+    // Casting directly from double to int loses precision, go via int64
+    auto number = static_cast<int64_t>(value.asNumber());
     return static_cast<int>(number);
   }
 

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

@@ -163,7 +163,8 @@ std::shared_ptr<ShadowNode> ShadowNode::clone(
   }
 }
 
-ContextContainer::Shared ShadowNode::getContextContainer() const {
+std::shared_ptr<const ContextContainer> ShadowNode::getContextContainer()
+    const {
   return family_->componentDescriptor_.getContextContainer();
 }
 

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

@@ -45,12 +45,16 @@ class ShadowNode : public Sealable,
   using ListOfShared [[deprecated(
       "Use std::vector<std::shared_ptr<const ShadowNode>> instead")]] =
       std::vector<std::shared_ptr<const ShadowNode>>;
-  using ListOfWeak = std::vector<std::weak_ptr<const ShadowNode>>;
+  // TODO(T223558094): delete this in the next version.
+  using ListOfWeak [[deprecated(
+      "Use std::vector<std::weak_ptr<const ShadowNode>> instead")]] =
+      std::vector<std::weak_ptr<const ShadowNode>>;
   using SharedListOfShared =
       std::shared_ptr<const std::vector<std::shared_ptr<const ShadowNode>>>;
   using UnsharedListOfShared =
       std::shared_ptr<std::vector<std::shared_ptr<const ShadowNode>>>;
-  using UnsharedListOfWeak = std::shared_ptr<ListOfWeak>;
+  using UnsharedListOfWeak =
+      std::shared_ptr<std::vector<std::weak_ptr<const ShadowNode>>>;
 
   using AncestorList = std::vector<std::pair<
       std::reference_wrapper<const ShadowNode> /* parentNode */,
@@ -164,7 +168,7 @@ class ShadowNode : public Sealable,
   /*
    * Returns the `ContextContainer` used by this ShadowNode.
    */
-  ContextContainer::Shared getContextContainer() const;
+  std::shared_ptr<const ContextContainer> getContextContainer() const;
 
   /*
    * Returns a state associated with the particular node.

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

@@ -173,13 +173,15 @@ std::shared_ptr<const State> ShadowNodeFamily::getMostRecentStateIfObsolete(
   return mostRecentState_;
 }
 
-void ShadowNodeFamily::dispatchRawState(StateUpdate&& stateUpdate) const {
+void ShadowNodeFamily::dispatchRawState(
+    StateUpdate&& stateUpdate,
+    EventQueue::UpdateMode updateMode) const {
   auto eventDispatcher = eventDispatcher_.lock();
   if (!eventDispatcher) {
     return;
   }
 
-  eventDispatcher->dispatchStateUpdate(std::move(stateUpdate));
+  eventDispatcher->dispatchStateUpdate(std::move(stateUpdate), updateMode);
 }
 
 } // namespace facebook::react

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

@@ -108,7 +108,9 @@ class ShadowNodeFamily final : public jsi::NativeState {
   /*
    * Dispatches a state update with given priority.
    */
-  void dispatchRawState(StateUpdate&& stateUpdate) const;
+  void dispatchRawState(
+      StateUpdate&& stateUpdate,
+      EventQueue::UpdateMode updateMode) const;
 
   /*
    * Holds currently applied native props. `nullptr` if setNativeProps API is

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

@@ -12,11 +12,11 @@
 #include <react/debug/flags.h>
 #include <react/renderer/core/ConcreteShadowNode.h>
 #include <react/renderer/core/PropsParserContext.h>
+#include <react/renderer/core/RawProps.h>
+#include <react/renderer/core/RawPropsParser.h>
 #include <react/renderer/core/ShadowNode.h>
 #include <react/renderer/core/propsConversions.h>
 
-#include "TestComponent.h"
-
 using namespace facebook;
 using namespace facebook::react;
 

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

@@ -0,0 +1,26 @@
+/*
+ * 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 <memory>
+
+#include <gtest/gtest.h>
+#include <hermes/hermes.h>
+#include <react/renderer/core/RawValue.h>
+
+using namespace facebook;
+using namespace facebook::react;
+
+TEST(RawValueTest, intValueDoesNotOverflow) {
+  auto runtime = facebook::hermes::makeHermesRuntime();
+  auto rawValue = RawValue(*runtime, jsi::Value(*runtime, 4294967040.0));
+  EXPECT_EQ((int64_t)rawValue, 4294967040);
+  EXPECT_EQ((int)rawValue, static_cast<int>(4294967040));
+
+  rawValue = RawValue(folly::dynamic(4294967040.0));
+  EXPECT_EQ((int64_t)rawValue, 4294967040);
+  EXPECT_EQ((int)rawValue, static_cast<int>(4294967040));
+}

package/ReactCommon/react/renderer/css/CSSHexColor.h

@@ -34,9 +34,9 @@ constexpr uint8_t hexToNumeric(std::string_view hex, HexColorType hexType) {
   }
 
   if (hexType == HexColorType::Short) {
-    return result * 16 + result;
+    return static_cast<uint8_t>(result * 16 + result);
   } else {
-    return result;
+    return static_cast<uint8_t>(result);
   }
 }
 

package/ReactCommon/react/renderer/css/tests/CSSSyntaxParserTest.cpp

@@ -492,7 +492,7 @@ TEST(CSSSyntaxParser, solidus_or_whitespace) {
 
   auto delimValue1 = parser.consumeComponentValue<bool>(
       CSSDelimiter::SolidusOrWhitespace,
-      [](const CSSPreservedToken& token) { return true; });
+      [](const CSSPreservedToken& /*token*/) { return true; });
 
   EXPECT_FALSE(delimValue1);
 }
@@ -549,8 +549,8 @@ TEST(CSSSyntaxParser, component_value_not_consumed_on_visitor_failure) {
   EXPECT_TRUE(visitor2Attempted);
 
   bool visitor3Attempted = false;
-  bool visitor3Ret =
-      parser.consumeComponentValue<bool>([&](const CSSPreservedToken& token) {
+  bool visitor3Ret = parser.consumeComponentValue<bool>(
+      [&](const CSSPreservedToken& /*token*/) {
         visitor3Attempted = true;
         return true;
       });

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

@@ -101,6 +101,9 @@ inline std::string toString(const std::string& value) {
 inline std::string toString(const int& value) {
   return std::to_string(value);
 }
+inline std::string toString(const unsigned int& value) {
+  return std::to_string(value);
+}
 inline std::string toString(const bool& value) {
   return value ? "true" : "false";
 }
@@ -116,6 +119,19 @@ std::string toString(const std::optional<T>& value) {
   return toString(value.value());
 }
 
+template <typename T>
+std::string toString(const std::vector<T>& value) {
+  std::string result = "[";
+  for (size_t i = 0; i < value.size(); i++) {
+    result += toString(value[i]);
+    if (i < value.size() - 1) {
+      result += ", ";
+    }
+  }
+  result += "]";
+  return result;
+}
+
 /*
  * *Informal* `DebugStringConvertible` interface.
  *

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

@@ -156,6 +156,23 @@ Rect getScrollableContentBounds(
 
 } // namespace
 
+std::shared_ptr<const ShadowNode> getElementById(
+    const std::shared_ptr<const ShadowNode>& shadowNode,
+    const std::string& id) {
+  if (shadowNode->getProps()->nativeId == id) {
+    return shadowNode;
+  }
+
+  for (const auto& childNode : shadowNode->getChildren()) {
+    auto result = getElementById(childNode, id);
+    if (result != nullptr) {
+      return result;
+    }
+  }
+
+  return nullptr;
+}
+
 std::shared_ptr<const ShadowNode> getParentNode(
     const RootShadowNode::Shared& currentRevision,
     const ShadowNode& shadowNode) {

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

@@ -64,6 +64,10 @@ std::shared_ptr<const ShadowNode> getParentNode(
     const RootShadowNode::Shared& currentRevision,
     const ShadowNode& shadowNode);
 
+std::shared_ptr<const ShadowNode> getElementById(
+    const std::shared_ptr<const ShadowNode>& currentRevision,
+    const std::string& id);
+
 std::vector<std::shared_ptr<const ShadowNode>> getChildNodes(
     const RootShadowNode::Shared& currentRevision,
     const ShadowNode& shadowNode);

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

@@ -20,7 +20,7 @@
 namespace facebook::react {
 
 inline ComponentBuilder simpleComponentBuilder(
-    ContextContainer::Shared contextContainer = nullptr) {
+    std::shared_ptr<const ContextContainer> contextContainer = nullptr) {
   ComponentDescriptorProviderRegistry componentDescriptorProviderRegistry{};
   auto eventDispatcher = EventDispatcher::Shared{};
   auto componentDescriptorRegistry =

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

@@ -21,5 +21,25 @@ struct BoxShadow {
   Float spreadDistance{};
   SharedColor color{};
   bool inset{};
+
+#ifdef RN_SERIALIZABLE_STATE
+  folly::dynamic toDynamic() const {
+    folly::dynamic result = folly::dynamic::object();
+    result["offsetX"] = offsetX;
+    result["offsetY"] = offsetY;
+    result["blurRadius"] = blurRadius;
+    result["spreadDistance"] = spreadDistance;
+    result["color"] = *color;
+    result["inset"] = inset;
+    return result;
+  }
+#endif
 };
+
+#ifdef RN_SERIALIZABLE_STATE
+inline folly::dynamic toDynamic(const BoxShadow& boxShadow) {
+  return boxShadow.toDynamic();
+}
+#endif
+
 } // namespace facebook::react

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

@@ -28,22 +28,22 @@ ColorComponents colorComponentsFromColor(SharedColor sharedColor) {
 }
 
 // Read alpha channel in [0, 255] range
-uint8_t alphaFromColor(SharedColor color) {
+uint8_t alphaFromColor(SharedColor color) noexcept {
   return static_cast<uint8_t>(std::round(alphaFromHostPlatformColor(*color)));
 }
 
 // Read red channel in [0, 255] range
-uint8_t redFromColor(SharedColor color) {
+uint8_t redFromColor(SharedColor color) noexcept {
   return static_cast<uint8_t>(std::round(redFromHostPlatformColor(*color)));
 }
 
 // Read green channel in [0, 255] range
-uint8_t greenFromColor(SharedColor color) {
+uint8_t greenFromColor(SharedColor color) noexcept {
   return static_cast<uint8_t>(std::round(greenFromHostPlatformColor(*color)));
 }
 
 // Read blue channel in [0, 255] range
-uint8_t blueFromColor(SharedColor color) {
+uint8_t blueFromColor(SharedColor color) noexcept {
   return static_cast<uint8_t>(std::round(blueFromHostPlatformColor(*color)));
 }
 

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

@@ -8,7 +8,6 @@
 #pragma once
 
 #include <functional>
-#include <limits>
 
 #include <react/renderer/graphics/ColorComponents.h>
 #include <react/renderer/graphics/HostPlatformColor.h>
@@ -61,10 +60,10 @@ 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);
+uint8_t alphaFromColor(SharedColor color) noexcept;
+uint8_t redFromColor(SharedColor color) noexcept;
+uint8_t greenFromColor(SharedColor color) noexcept;
+uint8_t blueFromColor(SharedColor color) noexcept;
 SharedColor colorFromRGBA(uint8_t r, uint8_t g, uint8_t b, uint8_t a);
 
 SharedColor clearColor();

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

@@ -29,22 +29,6 @@ enum class FilterType {
   DropShadow
 };
 
-struct DropShadowParams {
-  bool operator==(const DropShadowParams& other) const = default;
-
-  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) {
   if (filterName == "blur") {
     return FilterType::Blur;
@@ -96,4 +80,51 @@ inline std::string toString(const FilterType& filterType) {
   }
 }
 
+struct DropShadowParams {
+  bool operator==(const DropShadowParams& other) const = default;
+
+  Float offsetX{};
+  Float offsetY{};
+  Float standardDeviation{};
+  SharedColor color{};
+
+#ifdef RN_SERIALIZABLE_STATE
+  folly::dynamic toDynamic() const {
+    folly::dynamic result = folly::dynamic::object();
+    result["offsetX"] = offsetX;
+    result["offsetY"] = offsetY;
+    result["standardDeviation"] = standardDeviation;
+    result["color"] = *color;
+    return result;
+  }
+#endif
+};
+
+struct FilterFunction {
+  bool operator==(const FilterFunction& other) const = default;
+
+  FilterType type{};
+  std::variant<Float, DropShadowParams> parameters{};
+
+#ifdef RN_SERIALIZABLE_STATE
+  folly::dynamic toDynamic() const {
+    folly::dynamic result = folly::dynamic::object();
+    std::string typeKey = toString(type);
+    if (std::holds_alternative<Float>(parameters)) {
+      result[typeKey] = std::get<Float>(parameters);
+    } else if (std::holds_alternative<DropShadowParams>(parameters)) {
+      const auto& dropShadowParams = std::get<DropShadowParams>(parameters);
+      result[typeKey] = dropShadowParams.toDynamic();
+    }
+    return result;
+  }
+#endif
+};
+
+#ifdef RN_SERIALIZABLE_STATE
+inline folly::dynamic toDynamic(const FilterFunction& filterFunction) {
+  return filterFunction.toDynamic();
+}
+#endif
+
 } // namespace facebook::react