react-native-tvos 0.83.1-0 → 0.84.0-0rc0

package/ReactCommon/react/renderer/animations/LayoutAnimationKeyFrameManager.cpp

@@ -39,7 +39,7 @@ static std::string GetMutationInstructionString(
       ? mutation.newChildShadowView.tag
       : mutation.oldChildShadowView.tag;
   return getDebugName(mutation) + " [" + std::to_string(tag) + "]->[" +
-      std::to_string(mutation.parentShadowView.tag) + "] @" +
+      std::to_string(mutation.parentTag) + "] @" +
       std::to_string(mutation.index);
 }
 
@@ -1162,7 +1162,7 @@ void LayoutAnimationKeyFrameManager::queueFinalMutationsForCompletedKeyFrame(
     const AnimationKeyFrame& keyframe,
     ShadowViewMutation::List& mutationsList,
     bool interrupted,
-    const std::string& /*logPrefix*/) const {
+    [[maybe_unused]] const std::string& logPrefix) const {
   if (!keyframe.finalMutationsForKeyFrame.empty()) {
     // TODO: modularize this segment, it is repeated 2x in KeyFrameManager
     // as well.

package/ReactCommon/react/renderer/attributedstring/AttributedStringBox.h

@@ -71,6 +71,9 @@ struct std::hash<facebook::react::AttributedStringBox> {
         return std::hash<facebook::react::AttributedString>()(attributedStringBox.getValue());
       case facebook::react::AttributedStringBox::Mode::OpaquePointer:
         return std::hash<std::shared_ptr<void>>()(attributedStringBox.getOpaquePointer());
+      default:
+        react_native_assert(false && "Invalid AttributedStringBox::Mode");
+        return 0;
     }
   }
 };

package/ReactCommon/react/renderer/components/image/ImageProps.cpp

@@ -98,7 +98,7 @@ ImageProps::ImageProps(
                     rawProps,
                     "resizeMethod",
                     sourceProps.resizeMethod,
-                    {})),
+                    {"auto"})),
       resizeMultiplier(
           ReactNativeFeatureFlags::enableCppPropsIteratorSetter()
               ? sourceProps.resizeMultiplier
@@ -107,7 +107,7 @@ ImageProps::ImageProps(
                     rawProps,
                     "resizeMultiplier",
                     sourceProps.resizeMultiplier,
-                    {})),
+                    1)),
       shouldNotifyLoadEvents(
           ReactNativeFeatureFlags::enableCppPropsIteratorSetter()
               ? sourceProps.shouldNotifyLoadEvents

package/ReactCommon/react/renderer/components/image/ImageProps.h

@@ -33,8 +33,8 @@ class ImageProps final : public ViewProps {
   EdgeInsets capInsets{};
   SharedColor tintColor{};
   std::string internal_analyticTag{};
-  std::string resizeMethod{};
-  Float resizeMultiplier{};
+  std::string resizeMethod{"auto"};
+  Float resizeMultiplier{1.f};
   bool shouldNotifyLoadEvents{};
   SharedColor overlayColor{};
   Float fadeDuration{};

package/ReactCommon/react/renderer/components/image/ImageShadowNode.cpp

@@ -65,7 +65,12 @@ void ImageShadowNode::updateStateIfNeeded() {
       imageProps.fadeDuration,
       imageProps.progressiveRenderingEnabled,
       imageProps.loadingIndicatorSource,
-      imageProps.internal_analyticTag
+      imageProps.internal_analyticTag,
+      Size{
+          .width =
+              layoutMetrics_.frame.size.width * layoutMetrics_.pointScaleFactor,
+          .height = layoutMetrics_.frame.size.height *
+              layoutMetrics_.pointScaleFactor}
 #endif
   );
 
@@ -85,7 +90,9 @@ void ImageShadowNode::updateStateIfNeeded() {
          (uri.starts_with("content://") || uri.starts_with("file://")));
     // If we would resize but have no dimensions, skip creating the request
     if (shouldResize &&
-        (newImageSource.size.width == 0 || newImageSource.size.height == 0)) {
+        (newImageSource.size.width == 0 || newImageSource.size.height == 0 ||
+         layoutMetrics_.frame.size.width == 0 ||
+         layoutMetrics_.frame.size.height == 0)) {
       // Keep the old state - don't create a new image request
       return;
     }

package/ReactCommon/react/renderer/components/image/conversions.h

@@ -163,6 +163,11 @@ inline std::string toString(const ImageResizeMode &value)
       return "repeat";
     case ImageResizeMode::None:
       return "none";
+    default:
+      LOG(ERROR) << "Unsupported ImageResizeMode value: " << (int)value;
+      react_native_expect(false);
+      // "cover" is default in non-Fabric web and iOS
+      return "cover";
   }
 }
 

package/ReactCommon/react/renderer/components/text/BaseTextProps.cpp

@@ -524,7 +524,8 @@ void BaseTextProps::appendTextAttributesProps(
         : nullptr;
   }
 
-  if (textAttributes.opacity != oldProps->textAttributes.opacity) {
+  if (!floatEquality(
+          textAttributes.opacity, oldProps->textAttributes.opacity)) {
     result["opacity"] = textAttributes.opacity;
   }
 

package/ReactCommon/react/renderer/components/view/platform/android/react/renderer/components/view/HostPlatformViewProps.cpp

@@ -676,6 +676,10 @@ folly::dynamic HostPlatformViewProps::getDiffProps(
     result["removeClippedSubviews"] = removeClippedSubviews;
   }
 
+  if (collapsableChildren != oldProps->collapsableChildren) {
+    result["collapsableChildren"] = collapsableChildren;
+  }
+
   if (onLayout != oldProps->onLayout) {
     result["onLayout"] = onLayout;
   }
@@ -961,7 +965,7 @@ folly::dynamic HostPlatformViewProps::getDiffProps(
 
   if (accessibilityState != oldProps->accessibilityState) {
     updateAccessibilityStateProp(
-        result, oldProps->accessibilityState, accessibilityState);
+        result, accessibilityState, oldProps->accessibilityState);
   }
 
   if (accessibilityLabel != oldProps->accessibilityLabel) {

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

@@ -115,12 +115,32 @@ class ConcreteComponentDescriptor : public ComponentDescriptor {
     rawProps.parse(rawPropsParser_);
 
     auto shadowNodeProps = ShadowNodeT::Props(context, rawProps, props);
+#ifdef RN_SERIALIZABLE_STATE
+    bool fallbackToDynamicRawPropsAccumulation = true;
+    if (ReactNativeFeatureFlags::enableExclusivePropsUpdateAndroid() &&
+        ReactNativeFeatureFlags::enableAccumulatedUpdatesInRawPropsAndroid()) {
+      // When exclusive props update is enabled, we only apply Props 1.5 processing
+      // (raw props merging) when Props 2.0 is not available.
+      if (ReactNativeFeatureFlags::enablePropsUpdateReconciliationAndroid()) {
+        // Cast to base Props reference to safely call virtual method
+        const auto &baseProps = static_cast<const Props &>(*shadowNodeProps);
+        if (strcmp(ShadowNodeT::Name(), baseProps.getDiffPropsImplementationTarget()) == 0) {
+          // Props 2.0 supported for this component, Props 1.5 processing can be skipped
+          fallbackToDynamicRawPropsAccumulation = false;
+        }
+      }
+    }
+    if (fallbackToDynamicRawPropsAccumulation) {
+      ShadowNodeT::initializeDynamicProps(shadowNodeProps, rawProps, props);
+    }
+#endif
     // Use the new-style iterator
     // Note that we just check if `Props` has this flag set, no matter
     // the type of ShadowNode; it acts as the single global flag.
     if (ReactNativeFeatureFlags::enableCppPropsIteratorSetter()) {
 #ifdef RN_SERIALIZABLE_STATE
-      const auto &dynamic = shadowNodeProps->rawProps;
+      const auto &dynamic =
+          fallbackToDynamicRawPropsAccumulation ? shadowNodeProps->rawProps : static_cast<folly::dynamic>(rawProps);
 #else
       const auto &dynamic = static_cast<folly::dynamic>(rawProps);
 #endif

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

@@ -78,6 +78,20 @@ class ConcreteShadowNode : public BaseShadowNodeT {
         context, baseProps ? static_cast<const PropsT &>(*baseProps) : *defaultSharedProps(), rawProps);
   }
 
+#ifdef RN_SERIALIZABLE_STATE
+  static void initializeDynamicProps(
+      UnsharedConcreteProps props,
+      const RawProps &rawProps,
+      const Props::Shared &baseProps = nullptr)
+  {
+    if (baseProps) {
+      props->initializeDynamicProps(static_cast<const PropsT &>(*baseProps), rawProps);
+    } else {
+      props->initializeDynamicProps(*defaultSharedProps(), rawProps);
+    }
+  }
+#endif
+
   static const SharedConcreteProps &defaultSharedProps()
   {
     static const SharedConcreteProps defaultSharedProps = std::make_shared<const PropsT>();

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

@@ -8,12 +8,22 @@
 #include "DynamicEventPayload.h"
 
 #include <jsi/JSIDynamic.h>
+#include <react/renderer/core/DynamicPointerEvent.h>
 
 namespace facebook::react {
 
 DynamicEventPayload::DynamicEventPayload(folly::dynamic&& payload)
     : payload_(std::move(payload)) {}
 
+/* static */ SharedEventPayload DynamicEventPayload::create(
+    folly::dynamic&& payload) {
+  if (payload.find("pointerId") != payload.items().end()) {
+    return std::make_shared<DynamicPointerEvent>(std::move(payload));
+  } else {
+    return std::make_shared<DynamicEventPayload>(std::move(payload));
+  }
+}
+
 jsi::Value DynamicEventPayload::asJSIValue(jsi::Runtime& runtime) const {
   return jsi::valueFromDynamic(runtime, payload_);
 }

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

@@ -12,9 +12,14 @@
 
 namespace facebook::react {
 
+/*
+ * EventPayload sent from android native via JNI.
+ */
 struct DynamicEventPayload : public EventPayload {
   explicit DynamicEventPayload(folly::dynamic &&payload);
 
+  static SharedEventPayload create(folly::dynamic &&payload);
+
   /*
    * EventPayload implementations
    */
@@ -22,7 +27,7 @@ struct DynamicEventPayload : public EventPayload {
   EventPayloadType getType() const override;
   std::optional<double> extractValue(const std::vector<std::string> &path) const override;
 
- private:
+ protected:
   folly::dynamic payload_;
 };
 

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

@@ -0,0 +1,30 @@
+/*
+ * 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 "DynamicPointerEvent.h"
+
+#include <jsi/JSIDynamic.h>
+
+namespace facebook::react {
+
+DynamicPointerEvent::DynamicPointerEvent(folly::dynamic&& payload)
+    : DynamicEventPayload(std::move(payload)) {
+  const auto& hitPath = payload_["hitPathForEventListener"];
+  if (hitPath.type() == folly::dynamic::Type::ARRAY) {
+    hitPathForEventListener_ = std::vector<Tag>{};
+    for (const auto& item : hitPath) {
+      hitPathForEventListener_->push_back(static_cast<Tag>(item.asInt()));
+    }
+  }
+}
+
+const std::optional<std::vector<Tag>>&
+DynamicPointerEvent::getHitPathForEventListener() const {
+  return hitPathForEventListener_;
+}
+
+} // namespace facebook::react

package/ReactCommon/react/renderer/core/DynamicPointerEvent.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
+
+#include <folly/dynamic.h>
+#include <react/renderer/core/DynamicEventPayload.h>
+#include <react/renderer/core/EventPayload.h>
+#include <react/renderer/core/ReactPrimitives.h>
+
+namespace facebook::react {
+
+/*
+ * Payload of PointerEvent sent from android native via JNI.
+ */
+struct DynamicPointerEvent : public DynamicEventPayload {
+  explicit DynamicPointerEvent(folly::dynamic &&payload);
+
+  const std::optional<std::vector<Tag>> &getHitPathForEventListener() const;
+
+ private:
+  std::optional<std::vector<Tag>> hitPathForEventListener_;
+};
+
+} // namespace facebook::react

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

@@ -6,7 +6,7 @@
  */
 
 #include "EventDispatcher.h"
-#include <cxxreact/JSExecutor.h>
+
 #include <react/renderer/core/StateUpdate.h>
 
 #include "EventQueue.h"

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

@@ -10,21 +10,19 @@
 #include <cxxreact/TraceSection.h>
 #include <folly/dynamic.h>
 #include <jsi/jsi.h>
-
-#include "DynamicEventPayload.h"
-#include "RawEvent.h"
+#include <react/renderer/core/DynamicEventPayload.h>
+#include <react/renderer/core/RawEvent.h>
 
 namespace facebook::react {
-
 static bool hasPrefix(const std::string& str, const std::string& prefix) {
   return str.compare(0, prefix.length(), prefix) == 0;
 }
 
 // TODO(T29874519): Get rid of "top" prefix once and for all.
 /*
- * Replaces "on" with "top" if present. Or capitalizes the first letter and adds
- * "top" prefix. E.g. "eventName" becomes "topEventName", "onEventName" also
- * becomes "topEventName".
+ * Replaces "on" with "top" if present. Or capitalizes the first letter and
+ * adds "top" prefix. E.g. "eventName" becomes "topEventName", "onEventName"
+ * also becomes "topEventName".
  */
 /* static */ std::string EventEmitter::normalizeEventType(std::string type) {
   auto prefixedType = std::move(type);
@@ -61,7 +59,7 @@ void EventEmitter::dispatchEvent(
     RawEvent::Category category) const {
   dispatchEvent(
       std::move(type),
-      std::make_shared<DynamicEventPayload>(std::move(payload)),
+      DynamicEventPayload::create(std::move(payload)),
       category);
 }
 
@@ -69,8 +67,7 @@ void EventEmitter::dispatchUniqueEvent(
     std::string type,
     folly::dynamic&& payload) const {
   dispatchUniqueEvent(
-      std::move(type),
-      std::make_shared<DynamicEventPayload>(std::move(payload)));
+      std::move(type), DynamicEventPayload::create(std::move(payload)));
 }
 
 void EventEmitter::dispatchEvent(
@@ -139,10 +136,10 @@ void EventEmitter::setEnabled(bool enabled) const {
     }
   }
 
-  // Note: Initially, the state of `eventTarget_` and the value `enableCounter_`
-  // is mismatched intentionally (it's `non-null` and `0` accordingly). We need
-  // this to support an initial nebula state where the event target must be
-  // retained without any associated mounted node.
+  // Note: Initially, the state of `eventTarget_` and the value
+  // `enableCounter_` is mismatched intentionally (it's `non-null` and `0`
+  // accordingly). We need this to support an initial nebula state where the
+  // event target must be retained without any associated mounted node.
   bool shouldBeRetained = enableCounter_ > 0;
   if (shouldBeRetained != (eventTarget_ != nullptr)) {
     if (!shouldBeRetained) {

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

@@ -5,13 +5,13 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-#include <cxxreact/JSExecutor.h>
+#include "EventQueueProcessor.h"
+
 #include <logger/react_native_log.h>
 #include <react/featureflags/ReactNativeFeatureFlags.h>
+
 #include "EventEmitter.h"
 #include "EventLogger.h"
-#include "EventQueue.h"
-#include "ShadowNodeFamily.h"
 
 namespace facebook::react {
 

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

@@ -33,14 +33,8 @@ void Props::initialize(
       ? sourceProps.nativeId
       : convertRawProp(context, rawProps, "nativeID", sourceProps.nativeId, {});
 #ifdef RN_SERIALIZABLE_STATE
-  if (ReactNativeFeatureFlags::enableAccumulatedUpdatesInRawPropsAndroid()) {
-    auto& oldRawProps = sourceProps.rawProps;
-    auto newRawProps = rawProps.toDynamic(filterObjectKeys);
-    auto mergedRawProps = mergeDynamicProps(
-        oldRawProps, newRawProps, NullValueStrategy::Override);
-    this->rawProps = mergedRawProps;
-  } else {
-    this->rawProps = rawProps.toDynamic(filterObjectKeys);
+  if (!ReactNativeFeatureFlags::enableExclusivePropsUpdateAndroid()) {
+    initializeDynamicProps(sourceProps, rawProps, filterObjectKeys);
   }
 #endif
 }
@@ -57,6 +51,27 @@ void Props::setProp(
   }
 }
 
+#ifdef RN_SERIALIZABLE_STATE
+void Props::initializeDynamicProps(
+    const Props& sourceProps,
+    const RawProps& rawProps,
+    const std::function<bool(const std::string&)>& filterObjectKeys) {
+  if (ReactNativeFeatureFlags::enableAccumulatedUpdatesInRawPropsAndroid()) {
+    auto& oldRawProps = sourceProps.rawProps;
+    auto newRawProps = rawProps.toDynamic(filterObjectKeys);
+    auto mergedRawProps = mergeDynamicProps(
+        oldRawProps, newRawProps, NullValueStrategy::Override);
+    this->rawProps = mergedRawProps;
+  } else {
+    this->rawProps = rawProps.toDynamic(filterObjectKeys);
+  }
+}
+
+ComponentName Props::getDiffPropsImplementationTarget() const {
+  return "";
+}
+#endif
+
 #pragma mark - DebugStringConvertible
 
 #if RN_DEBUG_STRING_CONVERTIBLE

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

@@ -62,10 +62,12 @@ class Props : public virtual Sealable, public virtual DebugStringConvertible {
 #ifdef RN_SERIALIZABLE_STATE
   folly::dynamic rawProps = folly::dynamic::object();
 
-  virtual ComponentName getDiffPropsImplementationTarget() const
-  {
-    return "";
-  }
+  void initializeDynamicProps(
+      const Props &sourceProps,
+      const RawProps &rawProps,
+      [[maybe_unused]] const std::function<bool(const std::string &)> &filterObjectKeys = nullptr);
+
+  virtual ComponentName getDiffPropsImplementationTarget() const;
 
   virtual folly::dynamic getDiffProps(const Props *prevProps) const
   {

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

@@ -412,7 +412,6 @@ namespace {
 
 std::shared_ptr<ShadowNode> cloneMultipleRecursive(
     const ShadowNode& shadowNode,
-    const std::unordered_set<const ShadowNodeFamily*>& familiesToUpdate,
     const std::unordered_map<const ShadowNodeFamily*, int>& childrenCount,
     const std::function<std::shared_ptr<
         ShadowNode>(const ShadowNode&, const ShadowNodeFragment&)>& callback) {
@@ -430,16 +429,12 @@ std::shared_ptr<ShadowNode> cloneMultipleRecursive(
             std::make_shared<std::vector<std::shared_ptr<const ShadowNode>>>(
                 children);
       }
-      (*newChildren)[i] = cloneMultipleRecursive(
-          *children[i], familiesToUpdate, childrenCount, callback);
+      (*newChildren)[i] =
+          cloneMultipleRecursive(*children[i], childrenCount, callback);
     }
   }
 
-  ShadowNodeFragment fragment{.children = newChildren};
-  if (familiesToUpdate.contains(family)) {
-    return callback(shadowNode, fragment);
-  }
-  return shadowNode.clone(fragment);
+  return callback(shadowNode, {.children = newChildren});
 }
 
 } // namespace
@@ -479,8 +474,7 @@ std::shared_ptr<ShadowNode> ShadowNode::cloneMultiple(
     return nullptr;
   }
 
-  return cloneMultipleRecursive(
-      *this, familiesToUpdate, childrenCount, callback);
+  return cloneMultipleRecursive(*this, childrenCount, callback);
 }
 
 #pragma mark - DebugStringConvertible

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

@@ -342,3 +342,35 @@ TEST_F(ShadowNodeTest, cloneMultiple) {
   EXPECT_EQ(newNodeABA->getTag(), nodeABA_->getTag());
   EXPECT_EQ(newNodeABA.get(), nodeABA_.get());
 }
+
+TEST_F(ShadowNodeTest, cloneMultipleWithSingleFamily) {
+  auto newProps = std::make_shared<const TestProps>();
+  auto newRoot = nodeA_->cloneMultiple(
+      {&nodeAB_->getFamily()},
+      [&](const ShadowNode& oldShadowNode, const ShadowNodeFragment& fragment) {
+        return oldShadowNode.clone({
+            .props = newProps,
+            .children = fragment.children,
+            .state = fragment.state,
+        });
+      });
+
+  EXPECT_EQ(newRoot->getTag(), nodeA_->getTag());
+  // The callback is called for each cloned node, so the root props are also
+  // updated
+  EXPECT_EQ(newRoot->getProps(), newProps);
+
+  auto newNodeAA = newRoot->getChildren()[0];
+  EXPECT_EQ(newNodeAA->getTag(), nodeAA_->getTag());
+  EXPECT_EQ(newNodeAA->getProps(), nodeAA_->getProps());
+  // AA was cloned when its parent was cloned as it was shared
+  EXPECT_NE(newNodeAA.get(), nodeAA_.get());
+
+  auto newNodeAB = newRoot->getChildren()[1];
+  EXPECT_EQ(newNodeAB->getTag(), nodeAB_->getTag());
+  EXPECT_EQ(newNodeAB->getProps(), newProps);
+
+  auto newNodeABA = newNodeAB->getChildren()[0];
+  EXPECT_EQ(newNodeABA->getTag(), nodeABA_->getTag());
+  EXPECT_EQ(newNodeABA.get(), nodeABA_.get());
+}

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

@@ -277,7 +277,14 @@ struct CSSComponentValueVisitorDispatcher {
       return {};
     }
 
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wswitch-enum"
+#endif
     switch (parser.peek().type()) {
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
       case CSSTokenType::Function:
         if (auto ret = visitFunction(visitors...)) {
           return *ret;

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

@@ -15,3 +15,10 @@ target_include_directories(react_renderer_debug PUBLIC ${REACT_COMMON_DIR})
 target_link_libraries(react_renderer_debug folly_runtime react_debug)
 target_compile_reactnative_options(react_renderer_debug PRIVATE)
 target_compile_options(react_renderer_debug PRIVATE -Wpedantic)
+
+# Enable debug string convertible for Debug builds or when explicitly requested
+# This allows getRenderedOutput() to include props in tests
+# Set RN_ENABLE_DEBUG_STRING_CONVERTIBLE=ON to enable for Release builds
+if(${CMAKE_BUILD_TYPE} MATCHES Debug OR RN_ENABLE_DEBUG_STRING_CONVERTIBLE)
+  target_compile_definitions(react_renderer_debug PUBLIC RN_ENABLE_DEBUG_STRING_CONVERTIBLE)
+endif()

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

@@ -29,8 +29,9 @@
 // #define RN_SHADOW_TREE_INTROSPECTION 1
 
 // This enables certain object-to-string debug conversions to be compiled.
-// Enable if `REACT_NATIVE_DEBUG` is enabled.
-#ifdef REACT_NATIVE_DEBUG
+// Enable if either `REACT_NATIVE_DEBUG` or `RN_ENABLE_DEBUG_STRING_CONVERTIBLE`
+// is defined
+#if defined(REACT_NATIVE_DEBUG) || defined(RN_ENABLE_DEBUG_STRING_CONVERTIBLE)
 #define RN_DEBUG_STRING_CONVERTIBLE 1
 #else
 #define RN_DEBUG_STRING_CONVERTIBLE 0

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

@@ -105,6 +105,8 @@ inline std::string toString(const BlendMode &blendMode)
       return "color";
     case BlendMode::Luminosity:
       return "luminosity";
+    default:
+      abort();
   }
 }
 } // namespace facebook::react

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

@@ -79,6 +79,8 @@ inline std::string toString(const FilterType &filterType)
       return "sepia";
     case FilterType::DropShadow:
       return "dropShadow";
+    default:
+      abort();
   }
 }
 

package/ReactCommon/react/renderer/imagemanager/ImageManager.h

@@ -37,6 +37,9 @@ class ImageManager {
       Tag tag = {}) const;
 
  private:
+#ifdef ANDROID
+  std::shared_ptr<const ContextContainer> contextContainer_{};
+#endif
   void *self_{};
 };