react-native-tvos 0.77.1-0 → 0.78.0-0

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

@@ -8,6 +8,7 @@
 #pragma once
 
 #include <unordered_map>
+#include <variant>
 
 #include <folly/dynamic.h>
 #include <jsi/JSIDynamic.h>
@@ -54,38 +55,52 @@ class RawValue {
   /*
    * Constructors.
    */
-  RawValue() noexcept : dynamic_(nullptr) {}
+  RawValue() noexcept : value_(folly::dynamic(nullptr)) {}
 
-  RawValue(RawValue&& other) noexcept : dynamic_(std::move(other.dynamic_)) {}
+  RawValue(RawValue&& other) noexcept : value_(std::move(other.value_)) {}
 
   RawValue& operator=(RawValue&& other) noexcept {
     if (this != &other) {
-      dynamic_ = std::move(other.dynamic_);
+      value_ = std::move(other.value_);
     }
     return *this;
   }
 
-  explicit RawValue(const folly::dynamic& dynamic) noexcept
-      : dynamic_(dynamic) {}
+  explicit RawValue(jsi::Runtime& runtime, const jsi::Value& value) noexcept
+      : value_(std::make_pair(&runtime, jsi::Value(runtime, value))) {}
+
+  explicit RawValue(jsi::Runtime& runtime, jsi::Value&& value) noexcept
+      : value_(std::make_pair(&runtime, std::move(value))) {}
+
+  explicit RawValue(const folly::dynamic& dynamic) noexcept : value_(dynamic) {}
 
   explicit RawValue(folly::dynamic&& dynamic) noexcept
-      : dynamic_(std::move(dynamic)) {}
+      : value_(std::move(dynamic)) {}
 
  private:
   friend class RawProps;
   friend class RawPropsParser;
   friend class UIManagerBinding;
 
-  /*
-   * Copy constructor and copy assignment operator would be private and only for
-   * internal use, but it's needed for user-code that does `auto val =
-   * (butter::map<std::string, RawValue>)rawVal;`
-   */
-  RawValue(const RawValue& other) noexcept : dynamic_(other.dynamic_) {}
+  RawValue(const RawValue& other) {
+    if (std::holds_alternative<folly::dynamic>(other.value_)) {
+      auto& dynamic = std::get<folly::dynamic>(other.value_);
+      value_ = dynamic;
+    } else {
+      const auto& [runtime, value] = std::get<JsiValuePair>(other.value_);
+      value_ = std::make_pair(runtime, jsi::Value(*runtime, value));
+    }
+  }
 
-  RawValue& operator=(const RawValue& other) noexcept {
+  RawValue& operator=(const RawValue& other) {
     if (this != &other) {
-      dynamic_ = other.dynamic_;
+      if (std::holds_alternative<folly::dynamic>(other.value_)) {
+        auto& dynamic = std::get<folly::dynamic>(other.value_);
+        value_ = dynamic;
+      } else {
+        const auto& [runtime, value] = std::get<JsiValuePair>(other.value_);
+        value_ = std::make_pair(runtime, jsi::Value(*runtime, value));
+      }
     }
     return *this;
   }
@@ -96,30 +111,54 @@ class RawValue {
    */
   template <typename T>
   explicit operator T() const {
-    return castValue(dynamic_, (T*)nullptr);
+    if (std::holds_alternative<folly::dynamic>(value_)) {
+      auto& dynamic = std::get<folly::dynamic>(value_);
+      return castValue(dynamic, (T*)nullptr);
+    } else {
+      const auto& [runtime, value] = std::get<JsiValuePair>(value_);
+      return castValue(runtime, value, (T*)nullptr);
+    }
   }
 
-  inline explicit operator folly::dynamic() const noexcept {
-    return dynamic_;
+  inline explicit operator folly::dynamic() const {
+    if (std::holds_alternative<folly::dynamic>(value_)) {
+      return std::get<folly::dynamic>(value_);
+    } else {
+      const auto& [runtime, value] = std::get<JsiValuePair>(value_);
+      return jsi::dynamicFromValue(*runtime, value);
+    }
   }
 
   /*
    * Checks if the stored value has specified type.
    */
   template <typename T>
-  bool hasType() const noexcept {
-    return checkValueType(dynamic_, (T*)nullptr);
+  bool hasType() const {
+    if (std::holds_alternative<folly::dynamic>(value_)) {
+      auto& dynamic = std::get<folly::dynamic>(value_);
+      return checkValueType(dynamic, (T*)nullptr);
+    } else {
+      const auto& [runtime, value] = std::get<JsiValuePair>(value_);
+      return checkValueType(runtime, value, (T*)nullptr);
+    }
   }
 
   /*
    * Checks if the stored value is *not* `null`.
    */
-  bool hasValue() const noexcept {
-    return !dynamic_.isNull();
+  bool hasValue() const {
+    if (std::holds_alternative<folly::dynamic>(value_)) {
+      auto& dynamic = std::get<folly::dynamic>(value_);
+      return !dynamic.isNull();
+    } else {
+      const auto& [runtime, value] = std::get<JsiValuePair>(value_);
+      return !value.isNull() && !value.isUndefined();
+    }
   }
 
  private:
-  folly::dynamic dynamic_;
+  using JsiValuePair = std::pair<jsi::Runtime*, jsi::Value>;
+  std::variant<folly::dynamic, JsiValuePair> value_;
 
   static bool checkValueType(
       const folly::dynamic& /*dynamic*/,
@@ -127,42 +166,104 @@ class RawValue {
     return true;
   }
 
+  static bool checkValueType(
+      jsi::Runtime* /*runtime*/,
+      const jsi::Value& /*value*/,
+      RawValue* /*type*/) noexcept {
+    return true;
+  }
+
   static bool checkValueType(
       const folly::dynamic& dynamic,
       bool* /*type*/) noexcept {
     return dynamic.isBool();
   }
 
+  static bool checkValueType(
+      jsi::Runtime* /*runtime*/,
+      const jsi::Value& value,
+      bool* /*type*/) noexcept {
+    return value.isBool();
+  }
+
   static bool checkValueType(
       const folly::dynamic& dynamic,
       int* /*type*/) noexcept {
     return dynamic.isNumber();
   }
 
+  static bool checkValueType(
+      jsi::Runtime* /*runtime*/,
+      const jsi::Value& value,
+      int* /*type*/) noexcept {
+    return value.isNumber();
+  }
+
   static bool checkValueType(
       const folly::dynamic& dynamic,
       int64_t* /*type*/) noexcept {
     return dynamic.isNumber();
   }
 
+  static bool checkValueType(
+      jsi::Runtime* /*runtime*/,
+      const jsi::Value& value,
+      int64_t* /*type*/) noexcept {
+    return value.isNumber();
+  }
+
   static bool checkValueType(
       const folly::dynamic& dynamic,
       float* /*type*/) noexcept {
     return dynamic.isNumber();
   }
 
+  static bool checkValueType(
+      jsi::Runtime* /*runtime*/,
+      const jsi::Value& value,
+      float* /*type*/) noexcept {
+    return value.isNumber();
+  }
+
   static bool checkValueType(
       const folly::dynamic& dynamic,
       double* /*type*/) noexcept {
     return dynamic.isNumber();
   }
 
+  static bool checkValueType(
+      jsi::Runtime* /*runtime*/,
+      const jsi::Value& value,
+      double* /*type*/) noexcept {
+    return value.isNumber();
+  }
+
   static bool checkValueType(
       const folly::dynamic& dynamic,
       std::string* /*type*/) noexcept {
     return dynamic.isString();
   }
 
+  static bool checkValueType(
+      jsi::Runtime* /*runtime*/,
+      const jsi::Value& value,
+      std::string* /*type*/) noexcept {
+    return value.isString();
+  }
+
+  static bool checkValueType(
+      const folly::dynamic& /*dynamic*/,
+      JsiValuePair* /*type*/) noexcept {
+    return false;
+  }
+
+  static bool checkValueType(
+      jsi::Runtime* /*runtime*/,
+      const jsi::Value& /*value*/,
+      JsiValuePair* /*type*/) noexcept {
+    return true;
+  }
+
   template <typename T>
   static bool checkValueType(
       const folly::dynamic& dynamic,
@@ -183,6 +284,36 @@ class RawValue {
     return true;
   }
 
+  template <typename T>
+  static bool checkValueType(
+      jsi::Runtime* runtime,
+      const jsi::Value& value,
+      std::vector<T>* /*type*/) noexcept {
+    if (!value.isObject()) {
+      return false;
+    }
+
+    jsi::Object asObject = value.getObject(*runtime);
+
+    if (!asObject.isArray(*runtime)) {
+      return false;
+    }
+
+    jsi::Array array = asObject.getArray(*runtime);
+    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 true;
+  }
+
   template <typename T>
   static bool checkValueType(
       const folly::dynamic& dynamic,
@@ -204,6 +335,34 @@ class RawValue {
     return true;
   }
 
+  template <typename T>
+  static bool checkValueType(
+      jsi::Runtime* runtime,
+      const jsi::Value& value,
+      std::unordered_map<std::string, T>* /*type*/) {
+    if (!value.isObject()) {
+      return false;
+    }
+
+    jsi::Object asObject = value.getObject(*runtime);
+
+    auto propertyNames = asObject.getPropertyNames(*runtime);
+    size_t size = propertyNames.size(*runtime);
+    for (size_t i = 0; i < size; i++) {
+      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 true;
+  }
+
   // Casts
   static RawValue castValue(
       const folly::dynamic& dynamic,
@@ -211,32 +370,98 @@ class RawValue {
     return RawValue(dynamic);
   }
 
+  static RawValue castValue(
+      jsi::Runtime* runtime,
+      const jsi::Value& value,
+      RawValue* /*type*/) noexcept {
+    return RawValue(*runtime, value);
+  }
+
   static bool castValue(const folly::dynamic& dynamic, bool* /*type*/) {
     return dynamic.getBool();
   }
 
+  static bool castValue(
+      jsi::Runtime* /*runtime*/,
+      const jsi::Value& value,
+      bool* /*type*/) {
+    return value.asBool();
+  }
+
   static int castValue(const folly::dynamic& dynamic, int* /*type*/) {
     return static_cast<int>(dynamic.asInt());
   }
 
+  static int
+  castValue(jsi::Runtime* /*runtime*/, const jsi::Value& value, int* /*type*/) {
+    double number = value.asNumber();
+    return static_cast<int>(number);
+  }
+
   static int64_t castValue(const folly::dynamic& dynamic, int64_t* /*type*/) {
     return dynamic.asInt();
   }
 
+  static int64_t castValue(
+      jsi::Runtime* /*runtime*/,
+      const jsi::Value& value,
+      int64_t* /*type*/) {
+    double number = value.asNumber();
+    return static_cast<int64_t>(number);
+  }
+
   static float castValue(const folly::dynamic& dynamic, float* /*type*/) {
     return static_cast<float>(dynamic.asDouble());
   }
 
+  static float castValue(
+      jsi::Runtime* /*runtime*/,
+      const jsi::Value& value,
+      float* /*type*/) {
+    double number = value.asNumber();
+    return static_cast<float>(number);
+  }
+
   static double castValue(const folly::dynamic& dynamic, double* /*type*/) {
     return dynamic.asDouble();
   }
 
+  static double castValue(
+      jsi::Runtime* /*runtime*/,
+      const jsi::Value& value,
+      double* /*type*/) {
+    return value.asNumber();
+  }
+
   static std::string castValue(
       const folly::dynamic& dynamic,
       std::string* /*type*/) {
     return dynamic.getString();
   }
 
+  static std::string castValue(
+      jsi::Runtime* runtime,
+      const jsi::Value& value,
+      std::string* /*type*/) {
+    jsi::String stringValue = value.asString(*runtime);
+    return stringValue.utf8(*runtime);
+  }
+
+  static JsiValuePair castValue(
+      const folly::dynamic& /*dynamic*/,
+      JsiValuePair* /*type*/) {
+    react_native_assert(false);
+    throw std::runtime_error(
+        "Cannot cast dynamic to a jsi::Value type. Please use the 'useRawPropsJsiValue' feature flag to enable jsi::Value support for RawValues.");
+  }
+
+  static JsiValuePair castValue(
+      jsi::Runtime* runtime,
+      const jsi::Value& value,
+      JsiValuePair* /*type*/) {
+    return {runtime, jsi::Value(*runtime, value)};
+  }
+
   template <typename T>
   static std::vector<T> castValue(
       const folly::dynamic& dynamic,
@@ -250,6 +475,26 @@ class RawValue {
     return result;
   }
 
+  template <typename T>
+  static std::vector<T> castValue(
+      jsi::Runtime* runtime,
+      const jsi::Value& value,
+      std::vector<T>* /*type*/) {
+    react_native_assert(value.isObject());
+    jsi::Object object = value.getObject(*runtime);
+    react_native_assert(object.isArray(*runtime));
+    jsi::Array array = object.getArray(*runtime);
+    size_t size = array.size(*runtime);
+    std::vector<T> result;
+    result.reserve(size);
+    for (size_t i = 0; i < size; i++) {
+      jsi::Value itemValue = array.getValueAtIndex(*runtime, i);
+      T item = castValue(runtime, itemValue, (T*)nullptr);
+      result.push_back(std::move(item));
+    }
+    return result;
+  }
+
   template <typename T>
   static std::vector<std::vector<T>> castValue(
       const folly::dynamic& dynamic,
@@ -263,6 +508,27 @@ class RawValue {
     return result;
   }
 
+  template <typename T>
+  static std::vector<std::vector<T>> castValue(
+      jsi::Runtime* runtime,
+      const jsi::Value& value,
+      std::vector<std::vector<T>>* /*type*/) {
+    react_native_assert(value.isObject());
+    jsi::Object object = value.getObject(*runtime);
+    react_native_assert(object.isArray(*runtime));
+    jsi::Array array = std::move(object).getArray(*runtime);
+    size_t size = array.size(*runtime);
+    std::vector<std::vector<T>> result;
+    result.reserve(size);
+    for (size_t i = 0; i < size; i++) {
+      jsi::Value itemValue = array.getValueAtIndex(*runtime, i);
+      std::vector<T> item =
+          castValue(runtime, itemValue, (std::vector<T>*)nullptr);
+      result.push_back(std::move(item));
+    }
+    return result;
+  }
+
   template <typename T>
   static std::unordered_map<std::string, T> castValue(
       const folly::dynamic& dynamic,
@@ -275,6 +541,33 @@ class RawValue {
     }
     return result;
   }
+
+  template <typename T>
+  static std::unordered_map<std::string, T> castValue(
+      jsi::Runtime* runtime,
+      const jsi::Value& value,
+      std::unordered_map<std::string, T>* /*type*/) {
+    react_native_assert(value.isObject());
+    jsi::Object object = value.getObject(*runtime);
+    jsi::Array propertyNames = object.getPropertyNames(*runtime);
+    size_t size = propertyNames.size(*runtime);
+    std::unordered_map<std::string, T> result;
+    for (size_t i = 0; i < size; i++) {
+      jsi::Value propertyNameValue = propertyNames.getValueAtIndex(*runtime, i);
+      jsi::String propertyName = propertyNameValue.getString(*runtime);
+      jsi::Value propertyValue = object.getProperty(*runtime, propertyName);
+      if (propertyValue.isUndefined()) {
+        // Skip undefined values to mimic JSIDynamic::dynamicFromValue behavior.
+        // Null values are allowed in the map.
+        continue;
+      }
+
+      std::string propertyNameString = propertyName.utf8(*runtime);
+      T property = castValue(runtime, propertyValue, (T*)nullptr);
+      result.emplace(propertyNameString, std::move(property));
+    }
+    return result;
+  }
 };
 
 } // namespace facebook::react

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

@@ -16,7 +16,7 @@ using namespace facebook::react;
   `merge_patch` is used for props forwarding on Android to enable Background
   Executor and will be removed once JNI layer is reimplmeneted.
  */
-TEST(DynamicPropsUtilitiesTest, handleNestedObjects) {
+TEST(DynamicPropsUtilitiesTest, mergeDynamicPropsHandlesNestedObjects) {
   dynamic map1 = dynamic::object;
   map1["style"] = dynamic::object("backgroundColor", "red");
 
@@ -36,7 +36,7 @@ TEST(DynamicPropsUtilitiesTest, handleNestedObjects) {
   EXPECT_EQ(result["height"], 100);
 }
 
-TEST(DynamicPropsUtilitiesTest, handleEmptyObject) {
+TEST(DynamicPropsUtilitiesTest, mergeDynamicPropsHandlesEmptyObject) {
   dynamic map1 = dynamic::object;
 
   dynamic map2 = dynamic::object;
@@ -53,7 +53,7 @@ TEST(DynamicPropsUtilitiesTest, handleEmptyObject) {
   EXPECT_EQ(result["height"], 100);
 }
 
-TEST(DynamicPropsUtilitiesTest, handleNullValue) {
+TEST(DynamicPropsUtilitiesTest, mergeDynamicPropsHandleNullValue) {
   dynamic map1 = dynamic::object;
   map1["height"] = 100;
 
@@ -65,7 +65,9 @@ TEST(DynamicPropsUtilitiesTest, handleNullValue) {
   EXPECT_TRUE(result["height"].isNull());
 }
 
-TEST(DynamicPropsUtilitiesTest, testNullValueStrategyIgnore) {
+TEST(
+    DynamicPropsUtilitiesTest,
+    mergeDynamicPropsFollowsNullValueStrategyIgnore) {
   dynamic map1 = dynamic::object;
   map1["height"] = 100;
 
@@ -78,3 +80,92 @@ TEST(DynamicPropsUtilitiesTest, testNullValueStrategyIgnore) {
   EXPECT_EQ(result["height"], 101);
   EXPECT_TRUE(result["width"].isNull());
 }
+
+TEST(DynamicPropsUtilitiesTest, diffDynamicPropsReturnsCorrectDiff) {
+  dynamic lhs = dynamic::object;
+  lhs["a"] = 1;
+  lhs["b"] = "2";
+
+  dynamic rhs = dynamic::object;
+  rhs["a"] = 3;
+  rhs["c"] = true;
+
+  auto result = diffDynamicProps(lhs, rhs);
+
+  EXPECT_TRUE(result.isObject());
+  EXPECT_EQ(result.size(), 3);
+  EXPECT_EQ(result["a"], 3);
+  EXPECT_EQ(result["b"], nullptr);
+  EXPECT_EQ(result["c"], true);
+}
+
+TEST(DynamicPropsUtilitiesTest, diffDynamicPropsHandlesInsertions) {
+  dynamic lhs = dynamic::object;
+  lhs["a"] = 1;
+
+  dynamic rhs = dynamic::object;
+  rhs["a"] = 1;
+  rhs["b"] = 2;
+
+  auto result = diffDynamicProps(lhs, rhs);
+
+  EXPECT_TRUE(result.isObject());
+  EXPECT_EQ(result.size(), 1);
+  EXPECT_EQ(result["b"], 2);
+}
+
+TEST(DynamicPropsUtilitiesTest, diffDynamicPropsHandlesUpdates) {
+  dynamic lhs = dynamic::object;
+  lhs["a"] = 1;
+  lhs["b"] = 2;
+
+  dynamic rhs = dynamic::object;
+  rhs["a"] = 3;
+  rhs["b"] = 4;
+
+  auto result = diffDynamicProps(lhs, rhs);
+
+  EXPECT_TRUE(result.isObject());
+  EXPECT_EQ(result.size(), 2);
+  EXPECT_EQ(result["a"], 3);
+  EXPECT_EQ(result["b"], 4);
+}
+
+TEST(DynamicPropsUtilitiesTest, diffDynamicPropsHandlesDeletions) {
+  dynamic lhs = dynamic::object;
+  lhs["a"] = 1;
+  lhs["b"] = 2;
+
+  dynamic rhs = dynamic::object;
+  rhs["a"] = 1;
+
+  auto result = diffDynamicProps(lhs, rhs);
+
+  EXPECT_TRUE(result.isObject());
+  EXPECT_EQ(result.size(), 1);
+  EXPECT_EQ(result["b"], nullptr);
+}
+
+TEST(
+    DynamicPropsUtilitiesTest,
+    diffDynamicPropsReturnsEmptyObjectForNonObjectLHS) {
+  dynamic lhs = dynamic::array;
+  dynamic rhs = dynamic::object;
+
+  auto result = diffDynamicProps(lhs, rhs);
+
+  EXPECT_TRUE(result.isObject());
+  EXPECT_EQ(result.size(), 0);
+}
+
+TEST(
+    DynamicPropsUtilitiesTest,
+    diffDynamicPropsReturnsEmptyObjectForNonObjectRHS) {
+  dynamic lhs = dynamic::object;
+  dynamic rhs = dynamic::array;
+
+  auto result = diffDynamicProps(lhs, rhs);
+
+  EXPECT_TRUE(result.isObject());
+  EXPECT_EQ(result.size(), 0);
+}

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

@@ -15,14 +15,29 @@
 
 #include <react/renderer/debug/DebugStringConvertible.h>
 #include <react/renderer/debug/DebugStringConvertibleItem.h>
+#include <react/utils/FloatComparison.h>
 
 namespace facebook::react {
 
 #if RN_DEBUG_STRING_CONVERTIBLE
 
+inline SharedDebugStringConvertible debugStringConvertibleItem(
+    const std::string& name,
+    float value,
+    float defaultValue = {}) {
+  if (floatEquality(value, defaultValue)) {
+    return nullptr;
+  }
+
+  return std::make_shared<DebugStringConvertibleItem>(
+      name, facebook::react::toString(value));
+}
+
 template <typename T>
-inline SharedDebugStringConvertible
-debugStringConvertibleItem(std::string name, T value, T defaultValue = {}) {
+inline SharedDebugStringConvertible debugStringConvertibleItem(
+    const std::string& name,
+    T value,
+    T defaultValue = {}) {
   if (value == defaultValue) {
     return nullptr;
   }
@@ -33,7 +48,7 @@ debugStringConvertibleItem(std::string name, T value, T defaultValue = {}) {
 
 template <typename T>
 inline SharedDebugStringConvertible debugStringConvertibleItem(
-    std::string name,
+    const std::string& name,
     std::optional<T> value,
     T defaultValue = {}) {
   if (!value.has_value()) {
@@ -54,7 +69,7 @@ inline SharedDebugStringConvertibleList operator+(
 }
 
 inline SharedDebugStringConvertible debugStringConvertibleItem(
-    std::string name,
+    const std::string& name,
     DebugStringConvertible value,
     std::string defaultValue) {
   return debugStringConvertibleItem(

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

@@ -23,4 +23,10 @@ target_include_directories(react_render_graphics
           ${CMAKE_CURRENT_SOURCE_DIR}/platform/android/
         )
 
-target_link_libraries(react_render_graphics glog fb fbjni folly_runtime react_debug react_utils)
+target_link_libraries(react_render_graphics
+        glog
+        fbjni
+        folly_runtime
+        react_debug
+        react_utils
+)