react-native-tvos 0.84.1-0 → 0.85.0-0

package/ReactCommon/react/renderer/components/view/tests/ConversionsTest.cpp

@@ -9,6 +9,7 @@
 
 #include <react/renderer/components/view/BoxShadowPropsConversions.h>
 #include <react/renderer/components/view/FilterPropsConversions.h>
+#include <react/renderer/components/view/conversions.h>
 
 namespace facebook::react {
 
@@ -239,4 +240,218 @@ TEST(ConversionsTest, unprocessed_filter_objects_multiple_objects) {
   EXPECT_TRUE(filters.empty());
 }
 
+TEST(ConversionsTest, unprocessed_filter_objects_unknown_type) {
+  RawValue value{
+      folly::dynamic::array(folly::dynamic::object("unknown-filter", 5))};
+
+  std::vector<FilterFunction> filters;
+  parseUnprocessedFilter(
+      PropsParserContext{-1, ContextContainer{}}, value, filters);
+
+  EXPECT_TRUE(filters.empty());
+}
+
+TEST(ConversionsTest, unprocessed_transform_css_string) {
+  Transform result;
+  parseUnprocessedTransformString(
+      "rotate(45deg) scale(2) translateX(10px)", result);
+
+  EXPECT_EQ(result.operations.size(), 3);
+
+  // rotate(45deg) -> Rotate, z = 45 * PI / 180
+  EXPECT_EQ(result.operations[0].type, TransformOperationType::Rotate);
+  EXPECT_NEAR(
+      result.operations[0].z.value,
+      static_cast<float>(45.0 * M_PI / 180.0),
+      0.001f);
+
+  // scale(2) -> Scale, x=2, y=2
+  EXPECT_EQ(result.operations[1].type, TransformOperationType::Scale);
+  EXPECT_EQ(result.operations[1].x.value, 2.0f);
+  EXPECT_EQ(result.operations[1].y.value, 2.0f);
+
+  // translateX(10px) -> Translate, x=10
+  EXPECT_EQ(result.operations[2].type, TransformOperationType::Translate);
+  EXPECT_EQ(result.operations[2].x.value, 10.0f);
+  EXPECT_EQ(result.operations[2].x.unit, UnitType::Point);
+  EXPECT_EQ(result.operations[2].y.value, 0.0f);
+}
+
+TEST(ConversionsTest, unprocessed_transform_css_translate_percent) {
+  Transform result;
+  parseUnprocessedTransformString("translate(10px, 50%)", result);
+
+  EXPECT_EQ(result.operations.size(), 1);
+  EXPECT_EQ(result.operations[0].type, TransformOperationType::Translate);
+  EXPECT_EQ(result.operations[0].x.value, 10.0f);
+  EXPECT_EQ(result.operations[0].x.unit, UnitType::Point);
+  EXPECT_EQ(result.operations[0].y.value, 50.0f);
+  EXPECT_EQ(result.operations[0].y.unit, UnitType::Percent);
+}
+
+TEST(ConversionsTest, unprocessed_transform_css_perspective) {
+  Transform result;
+  parseUnprocessedTransformString("perspective(500px)", result);
+
+  EXPECT_EQ(result.operations.size(), 1);
+  EXPECT_EQ(result.operations[0].type, TransformOperationType::Perspective);
+  EXPECT_EQ(result.operations[0].x.value, 500.0f);
+}
+
+TEST(ConversionsTest, unprocessed_transform_css_invalid_string) {
+  Transform result;
+  parseUnprocessedTransformString("not-a-transform", result);
+
+  EXPECT_TRUE(result.operations.empty());
+}
+
+TEST(ConversionsTest, unprocessed_transform_rawvalue_string) {
+  RawValue value{folly::dynamic("rotate(45deg) scale(2)")};
+  Transform result;
+  parseUnprocessedTransform(
+      PropsParserContext{-1, ContextContainer{}}, value, result);
+
+  EXPECT_EQ(result.operations.size(), 2);
+  EXPECT_EQ(result.operations[0].type, TransformOperationType::Rotate);
+  EXPECT_EQ(result.operations[1].type, TransformOperationType::Scale);
+}
+
+TEST(ConversionsTest, unprocessed_transform_rawvalue_array) {
+  RawValue value{folly::dynamic::array(
+      folly::dynamic::object("rotate", "45deg"),
+      folly::dynamic::object("scale", 2))};
+  Transform result;
+  parseUnprocessedTransform(
+      PropsParserContext{-1, ContextContainer{}}, value, result);
+
+  EXPECT_EQ(result.operations.size(), 2);
+  EXPECT_EQ(result.operations[0].type, TransformOperationType::Rotate);
+  EXPECT_EQ(result.operations[1].type, TransformOperationType::Scale);
+  EXPECT_EQ(result.operations[1].x.value, 2.0f);
+}
+
+TEST(ConversionsTest, unprocessed_transform_rawvalue_matrix) {
+  RawValue value{folly::dynamic::array(
+      folly::dynamic::object(
+          "matrix",
+          folly::dynamic::array(
+              1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1)))};
+  Transform result;
+  parseUnprocessedTransform(
+      PropsParserContext{-1, ContextContainer{}}, value, result);
+
+  EXPECT_EQ(result.operations.size(), 1);
+  EXPECT_EQ(result.operations[0].type, TransformOperationType::Arbitrary);
+}
+
+TEST(ConversionsTest, unprocessed_transform_rawvalue_translate_percent) {
+  RawValue value{
+      folly::dynamic::array(folly::dynamic::object("translateX", "50%"))};
+  Transform result;
+  parseUnprocessedTransform(
+      PropsParserContext{-1, ContextContainer{}}, value, result);
+
+  EXPECT_EQ(result.operations.size(), 1);
+  EXPECT_EQ(result.operations[0].type, TransformOperationType::Translate);
+  EXPECT_EQ(result.operations[0].x.value, 50.0f);
+  EXPECT_EQ(result.operations[0].x.unit, UnitType::Percent);
+}
+
+TEST(ConversionsTest, unprocessed_transform_origin_css_top_left) {
+  TransformOrigin result;
+  parseUnprocessedTransformOriginString("top left", result);
+
+  EXPECT_EQ(result.xy[0].value, 0.0f);
+  EXPECT_EQ(result.xy[0].unit, UnitType::Percent);
+  EXPECT_EQ(result.xy[1].value, 0.0f);
+  EXPECT_EQ(result.xy[1].unit, UnitType::Percent);
+  EXPECT_EQ(result.z, 0.0f);
+}
+
+TEST(ConversionsTest, unprocessed_transform_origin_css_center) {
+  TransformOrigin result;
+  parseUnprocessedTransformOriginString("center", result);
+
+  EXPECT_EQ(result.xy[0].value, 50.0f);
+  EXPECT_EQ(result.xy[0].unit, UnitType::Percent);
+  EXPECT_EQ(result.xy[1].value, 50.0f);
+  EXPECT_EQ(result.xy[1].unit, UnitType::Percent);
+  EXPECT_EQ(result.z, 0.0f);
+}
+
+TEST(ConversionsTest, unprocessed_transform_origin_css_right_bottom) {
+  TransformOrigin result;
+  parseUnprocessedTransformOriginString("right bottom", result);
+
+  EXPECT_EQ(result.xy[0].value, 100.0f);
+  EXPECT_EQ(result.xy[0].unit, UnitType::Percent);
+  EXPECT_EQ(result.xy[1].value, 100.0f);
+  EXPECT_EQ(result.xy[1].unit, UnitType::Percent);
+  EXPECT_EQ(result.z, 0.0f);
+}
+
+TEST(ConversionsTest, unprocessed_transform_origin_css_length_percent) {
+  TransformOrigin result;
+  parseUnprocessedTransformOriginString("10px 50%", result);
+
+  EXPECT_EQ(result.xy[0].value, 10.0f);
+  EXPECT_EQ(result.xy[0].unit, UnitType::Point);
+  EXPECT_EQ(result.xy[1].value, 50.0f);
+  EXPECT_EQ(result.xy[1].unit, UnitType::Percent);
+  EXPECT_EQ(result.z, 0.0f);
+}
+
+TEST(ConversionsTest, unprocessed_transform_origin_processed_array) {
+  RawValue value{folly::dynamic::array("50%", "50%", 0)};
+
+  TransformOrigin result;
+  parseProcessedTransformOrigin(
+      PropsParserContext{-1, ContextContainer{}}, value, result);
+
+  EXPECT_EQ(result.xy[0].value, 50.0f);
+  EXPECT_EQ(result.xy[0].unit, UnitType::Percent);
+  EXPECT_EQ(result.xy[1].value, 50.0f);
+  EXPECT_EQ(result.xy[1].unit, UnitType::Percent);
+  EXPECT_EQ(result.z, 0.0f);
+}
+
+TEST(ConversionsTest, unprocessed_transform_origin_rawvalue_string) {
+  RawValue value{folly::dynamic("top left")};
+  TransformOrigin result;
+  parseUnprocessedTransformOrigin(
+      PropsParserContext{-1, ContextContainer{}}, value, result);
+
+  EXPECT_EQ(result.xy[0].value, 0.0f);
+  EXPECT_EQ(result.xy[0].unit, UnitType::Percent);
+  EXPECT_EQ(result.xy[1].value, 0.0f);
+  EXPECT_EQ(result.xy[1].unit, UnitType::Percent);
+  EXPECT_EQ(result.z, 0.0f);
+}
+
+TEST(ConversionsTest, unprocessed_transform_origin_rawvalue_array) {
+  RawValue value{folly::dynamic::array(10, "50%", 5)};
+  TransformOrigin result;
+  parseUnprocessedTransformOrigin(
+      PropsParserContext{-1, ContextContainer{}}, value, result);
+
+  EXPECT_EQ(result.xy[0].value, 10.0f);
+  EXPECT_EQ(result.xy[0].unit, UnitType::Point);
+  EXPECT_EQ(result.xy[1].value, 50.0f);
+  EXPECT_EQ(result.xy[1].unit, UnitType::Percent);
+  EXPECT_EQ(result.z, 5.0f);
+}
+
+TEST(ConversionsTest, unprocessed_transform_origin_rawvalue_string_with_z) {
+  RawValue value{folly::dynamic("center center 15px")};
+  TransformOrigin result;
+  parseUnprocessedTransformOrigin(
+      PropsParserContext{-1, ContextContainer{}}, value, result);
+
+  EXPECT_EQ(result.xy[0].value, 50.0f);
+  EXPECT_EQ(result.xy[0].unit, UnitType::Percent);
+  EXPECT_EQ(result.xy[1].value, 50.0f);
+  EXPECT_EQ(result.xy[1].unit, UnitType::Percent);
+  EXPECT_EQ(result.z, 15.0f);
+}
+
 } // namespace facebook::react

package/ReactCommon/react/renderer/components/view/tests/LayoutTest.cpp

@@ -356,7 +356,7 @@ TEST_F(LayoutTest, overflowInsetTransformScaleTest) {
   auto layoutMetricsABC = viewShadowNodeABC_->getLayoutMetrics();
 
   // The frame of box ABC won't actually scale up. The transform matrix is
-  // purely cosmatic and should apply later in mounting phase.
+  // purely cosmetic and should apply later in mounting phase.
   EXPECT_EQ(layoutMetricsABC.frame.size.width, 110);
   EXPECT_EQ(layoutMetricsABC.frame.size.height, 20);
 

package/ReactCommon/react/renderer/components/virtualview/VirtualViewComponentDescriptor.h

@@ -13,7 +13,7 @@
 namespace facebook::react {
 
 /*
- * Descriptor for <VirtualView> component.
+ * Descriptor for <VirtualView2> component.
  */
 using VirtualViewComponentDescriptor = ConcreteComponentDescriptor<VirtualViewShadowNode>;
 } // namespace facebook::react

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

@@ -179,7 +179,7 @@ class ConcreteComponentDescriptor : public ComponentDescriptor {
 
   ShadowNodeFamily::Shared createFamily(const ShadowNodeFamilyFragment &fragment) const override
   {
-    auto eventEmitter = std::make_shared<const ConcreteEventEmitter>(
+    auto eventEmitter = std::make_shared<ConcreteEventEmitter>(
         std::make_shared<EventTarget>(fragment.instanceHandle, fragment.surfaceId), eventDispatcher_);
     auto family = std::make_shared<ShadowNodeFamily>(fragment, eventEmitter, eventDispatcher_, *this);
     eventEmitter->setShadowNodeFamily(family);

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

@@ -125,7 +125,7 @@ void EventEmitter::dispatchUniqueEvent(
       RawEvent::Category::Continuous));
 }
 
-void EventEmitter::setEnabled(bool enabled) const {
+void EventEmitter::setEnabled(bool enabled) {
   enableCounter_ += enabled ? 1 : -1;
 
   bool shouldBeEnabled = enableCounter_ > 0;
@@ -149,7 +149,7 @@ void EventEmitter::setEnabled(bool enabled) const {
 }
 
 void EventEmitter::setShadowNodeFamily(
-    std::weak_ptr<const ShadowNodeFamily> shadowNodeFamily) const {
+    std::weak_ptr<const ShadowNodeFamily> shadowNodeFamily) {
   shadowNodeFamily_ = std::move(shadowNodeFamily);
 }
 

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

@@ -21,7 +21,7 @@ namespace facebook::react {
 
 class EventEmitter;
 
-using SharedEventEmitter = std::shared_ptr<const EventEmitter>;
+using SharedEventEmitter = std::shared_ptr<EventEmitter>;
 
 /*
  * Base class for all particular typed event handlers.
@@ -31,7 +31,7 @@ using SharedEventEmitter = std::shared_ptr<const EventEmitter>;
  */
 class EventEmitter {
  public:
-  using Shared = std::shared_ptr<const EventEmitter>;
+  using Shared = std::shared_ptr<EventEmitter>;
 
   static std::string normalizeEventType(std::string type);
 
@@ -53,12 +53,12 @@ class EventEmitter {
    * a number of `disable` calls to release the event target.
    * `DispatchMutex` must be acquired before calling.
    */
-  void setEnabled(bool enabled) const;
+  void setEnabled(bool enabled);
 
   /*
    * Sets a weak reference to the cooresponding ShadowNodeFamily
    */
-  void setShadowNodeFamily(std::weak_ptr<const ShadowNodeFamily> shadowNodeFamily) const;
+  void setShadowNodeFamily(std::weak_ptr<const ShadowNodeFamily> shadowNodeFamily);
 
   const SharedEventTarget &getEventTarget() const;
 
@@ -106,12 +106,12 @@ class EventEmitter {
  private:
   friend class UIManagerBinding;
 
-  mutable SharedEventTarget eventTarget_;
-  mutable std::weak_ptr<const ShadowNodeFamily> shadowNodeFamily_;
+  SharedEventTarget eventTarget_;
+  std::weak_ptr<const ShadowNodeFamily> shadowNodeFamily_;
 
   EventDispatcher::Weak eventDispatcher_;
-  mutable int enableCounter_{0};
-  mutable bool isEnabled_{false};
+  int enableCounter_{0};
+  bool isEnabled_{false};
 };
 
 } // namespace facebook::react

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

@@ -20,7 +20,7 @@ namespace facebook::react {
 
 using EventPipe = std::function<void(
     jsi::Runtime &runtime,
-    const EventTarget *eventTarget,
+    EventTarget *eventTarget,
     const std::string &type,
     ReactEventPriority priority,
     const EventPayload &payload)>;

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

@@ -20,11 +20,11 @@ EventTarget::EventTarget(
       surfaceId_(surfaceId),
       strongInstanceHandle_(jsi::Value::null()) {}
 
-void EventTarget::setEnabled(bool enabled) const {
+void EventTarget::setEnabled(bool enabled) {
   enabled_ = enabled;
 }
 
-void EventTarget::retain(jsi::Runtime& runtime) const {
+void EventTarget::retain(jsi::Runtime& runtime) {
   if (!enabled_) {
     return;
   }
@@ -46,7 +46,7 @@ void EventTarget::retain(jsi::Runtime& runtime) const {
   // react_native_assert(!strongInstanceHandle_.isUndefined());
 }
 
-void EventTarget::release(jsi::Runtime& /*runtime*/) const {
+void EventTarget::release(jsi::Runtime& /*runtime*/) {
   // The method does not use `jsi::Runtime` reference.
   // It takes it only to ensure thread-safety (if the caller has the reference,
   // we are on a proper thread).

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

@@ -40,18 +40,18 @@ class EventTarget {
    * Sets the `enabled` flag that allows creating a strong instance handle from
    * a weak one.
    */
-  void setEnabled(bool enabled) const;
+  void setEnabled(bool enabled);
 
   /*
    * Retains an instance handler by creating a strong reference to it.
    * If the EventTarget is disabled, does nothing.
    */
-  void retain(jsi::Runtime &runtime) const;
+  void retain(jsi::Runtime &runtime);
 
   /*
    * Releases the instance handler by nulling a strong reference to it.
    */
-  void release(jsi::Runtime &runtime) const;
+  void release(jsi::Runtime &runtime);
 
   /*
    * Creates and returns the `instanceHandle`.
@@ -69,11 +69,11 @@ class EventTarget {
  private:
   const InstanceHandle::Shared instanceHandle_;
   const SurfaceId surfaceId_;
-  mutable bool enabled_{false}; // Protected by `EventEmitter::DispatchMutex()`.
-  mutable jsi::Value strongInstanceHandle_; // Protected by `jsi::Runtime &`.
-  mutable size_t retainCount_{0}; // Protected by `jsi::Runtime &`.
+  bool enabled_{false}; // Protected by `EventEmitter::DispatchMutex()`.
+  jsi::Value strongInstanceHandle_; // Protected by `jsi::Runtime &`.
+  size_t retainCount_{0}; // Protected by `jsi::Runtime &`.
 };
 
-using SharedEventTarget = std::shared_ptr<const EventTarget>;
+using SharedEventTarget = std::shared_ptr<EventTarget>;
 
 } // namespace facebook::react

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

@@ -36,11 +36,6 @@ inline bool operator==(const LayoutConstraints &lhs, const LayoutConstraints &rh
       std::tie(rhs.minimumSize, rhs.maximumSize, rhs.layoutDirection);
 }
 
-inline bool operator!=(const LayoutConstraints &lhs, const LayoutConstraints &rhs)
-{
-  return !(lhs == rhs);
-}
-
 } // namespace facebook::react
 
 namespace std {

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

@@ -77,9 +77,4 @@ inline bool operator==(const LayoutContext &lhs, const LayoutContext &rhs)
              rhs.viewportOffset);
 }
 
-inline bool operator!=(const LayoutContext &lhs, const LayoutContext &rhs)
-{
-  return !(lhs == rhs);
-}
-
 } // namespace facebook::react

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

@@ -86,8 +86,6 @@ struct LayoutMetrics {
   }
 
   bool operator==(const LayoutMetrics &rhs) const = default;
-
-  bool operator!=(const LayoutMetrics &rhs) const = default;
 };
 
 /*

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

@@ -11,7 +11,6 @@
 #include <cassert>
 #include <cstring>
 
-#include <react/debug/react_native_assert.h>
 #include <react/renderer/core/RawPropsPrimitives.h>
 
 namespace facebook::react {
@@ -20,34 +19,29 @@ void RawPropsKey::render(char* buffer, RawPropsPropNameLength* length)
     const noexcept {
   *length = 0;
 
-  // Prefix
+  constexpr size_t maxLength = kPropNameLengthHardCap - 1;
+
+  auto appendSegment = [&](const char* segment) {
+    auto copyLen = std::min(std::strlen(segment), maxLength - *length);
+    std::memcpy(buffer + *length, segment, copyLen);
+    *length += static_cast<RawPropsPropNameLength>(copyLen);
+  };
+
   if (prefix != nullptr) {
-    auto prefixLength =
-        static_cast<RawPropsPropNameLength>(std::strlen(prefix));
-    std::memcpy(buffer, prefix, prefixLength);
-    *length = prefixLength;
+    appendSegment(prefix);
   }
 
-  // Name
-  auto nameLength = static_cast<RawPropsPropNameLength>(std::strlen(name));
-  std::memcpy(buffer + *length, name, nameLength);
-  *length += nameLength;
+  appendSegment(name);
 
-  // Suffix
   if (suffix != nullptr) {
-    auto suffixLength =
-        static_cast<RawPropsPropNameLength>(std::strlen(suffix));
-    std::memcpy(buffer + *length, suffix, suffixLength);
-    *length += suffixLength;
+    appendSegment(suffix);
   }
-  react_native_assert(*length < kPropNameLengthHardCap);
 }
 
 RawPropsKey::operator std::string() const noexcept {
   auto buffer = std::array<char, kPropNameLengthHardCap>();
   RawPropsPropNameLength length = 0;
   render(buffer.data(), &length);
-  react_native_assert(length < kPropNameLengthHardCap);
   return std::string{buffer.data(), length};
 }
 
@@ -65,8 +59,4 @@ bool operator==(const RawPropsKey& lhs, const RawPropsKey& rhs) noexcept {
       areFieldsEqual(lhs.suffix, rhs.suffix);
 }
 
-bool operator!=(const RawPropsKey& lhs, const RawPropsKey& rhs) noexcept {
-  return !(lhs == rhs);
-}
-
 } // namespace facebook::react

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

@@ -35,6 +35,5 @@ class RawPropsKey final {
 };
 
 bool operator==(const RawPropsKey &lhs, const RawPropsKey &rhs) noexcept;
-bool operator!=(const RawPropsKey &lhs, const RawPropsKey &rhs) noexcept;
 
 } // namespace facebook::react

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

@@ -75,7 +75,7 @@ void RawPropsKeyMap::reindex() noexcept {
 
   buckets_.resize(kPropNameLengthHardCap);
 
-  auto length = RawPropsPropNameLength{0};
+  RawPropsPropNameLength length = 0;
   for (size_t i = 0; i < items_.size(); i++) {
     auto& item = items_[i];
     if (item.length != length) {
@@ -96,6 +96,9 @@ RawPropsValueIndex RawPropsKeyMap::at(
     RawPropsPropNameLength length) noexcept {
   react_native_assert(length > 0);
   react_native_assert(length < kPropNameLengthHardCap);
+  if (length == 0 || length >= kPropNameLengthHardCap) [[unlikely]] {
+    return kRawPropsValueIndexEmpty;
+  }
   // 1. Find the bucket.
   auto lower = int{buckets_[length - 1]};
   auto upper = int{buckets_[length]} - 1;

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

@@ -136,13 +136,7 @@ void RawPropsParser::preparse(const RawProps& rawProps) const noexcept {
         rawProps.keyIndexToValueIndex_[keyIndex] = valueIndex;
 
         auto value = object.getProperty(runtime, nameValue);
-        RawValue rawValue;
-        if (useRawPropsJsiValue_) {
-          rawValue = RawValue(runtime, std::move(value));
-        } else {
-          rawValue = RawValue(jsi::dynamicFromValue(runtime, value));
-        }
-        rawProps.values_.push_back(std::move(rawValue));
+        rawProps.values_.emplace_back(runtime, std::move(value));
         valueIndex++;
       }
 

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

@@ -7,7 +7,6 @@
 
 #pragma once
 
-#include <react/featureflags/ReactNativeFeatureFlags.h>
 #include <react/renderer/core/Props.h>
 #include <react/renderer/core/PropsParserContext.h>
 #include <react/renderer/core/RawProps.h>
@@ -27,11 +26,9 @@ class RawPropsParser final {
   /*
    * Default constructor.
    * To be used by `ConcreteComponentDescriptor` only.
-   * If `useRawPropsJsiValue` is `true`, the parser will use `jsi::Value`
-   * directly for RawValues instead of converting them to `folly::dynamic`.
    */
-  RawPropsParser(bool useRawPropsJsiValue = ReactNativeFeatureFlags::useRawPropsJsiValue())
-      : useRawPropsJsiValue_(useRawPropsJsiValue) {};
+  RawPropsParser() = default;
+  [[deprecated]] explicit RawPropsParser(bool /* ignored */) : RawPropsParser() {}
 
   /*
    * To be used by `ConcreteComponentDescriptor` only.
@@ -59,7 +56,6 @@ class RawPropsParser final {
   template <class ShadowNodeT>
   friend class ConcreteComponentDescriptor;
   friend class RawProps;
-  bool useRawPropsJsiValue_{false};
 
   /*
    * To be used by `RawProps` only.

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

@@ -405,8 +405,7 @@ class RawValue {
   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.");
+    throw std::runtime_error("Cannot cast dynamic to a jsi::Value type");
   }
 
   static JsiValuePair castValue(jsi::Runtime *runtime, const jsi::Value &value, JsiValuePair * /*type*/)