react-native-tvos 0.76.5-0 → 0.77.0-0

package/ReactCommon/react/renderer/components/view/TouchEventEmitter.cpp

@@ -44,11 +44,11 @@ static jsi::Value touchEventPayload(
 
 void TouchEventEmitter::dispatchTouchEvent(
     std::string type,
-    const TouchEvent& event,
+    TouchEvent event,
     RawEvent::Category category) const {
   dispatchEvent(
       std::move(type),
-      [event](jsi::Runtime& runtime) {
+      [event = std::move(event)](jsi::Runtime& runtime) {
         return touchEventPayload(runtime, event);
       },
       category);
@@ -56,80 +56,92 @@ void TouchEventEmitter::dispatchTouchEvent(
 
 void TouchEventEmitter::dispatchPointerEvent(
     std::string type,
-    const PointerEvent& event,
+    PointerEvent event,
     RawEvent::Category category) const {
   dispatchEvent(
-      std::move(type), std::make_shared<PointerEvent>(event), category);
+      std::move(type),
+      std::make_shared<PointerEvent>(std::move(event)),
+      category);
 }
 
-void TouchEventEmitter::onTouchStart(const TouchEvent& event) const {
-  dispatchTouchEvent("touchStart", event, RawEvent::Category::ContinuousStart);
+void TouchEventEmitter::onTouchStart(TouchEvent event) const {
+  dispatchTouchEvent(
+      "touchStart", std::move(event), RawEvent::Category::ContinuousStart);
 }
 
-void TouchEventEmitter::onTouchMove(const TouchEvent& event) const {
-  dispatchUniqueEvent("touchMove", [event](jsi::Runtime& runtime) {
-    return touchEventPayload(runtime, event);
-  });
+void TouchEventEmitter::onTouchMove(TouchEvent event) const {
+  dispatchUniqueEvent(
+      "touchMove", [event = std::move(event)](jsi::Runtime& runtime) {
+        return touchEventPayload(runtime, event);
+      });
 }
 
-void TouchEventEmitter::onTouchEnd(const TouchEvent& event) const {
-  dispatchTouchEvent("touchEnd", event, RawEvent::Category::ContinuousEnd);
+void TouchEventEmitter::onTouchEnd(TouchEvent event) const {
+  dispatchTouchEvent(
+      "touchEnd", std::move(event), RawEvent::Category::ContinuousEnd);
 }
 
-void TouchEventEmitter::onTouchCancel(const TouchEvent& event) const {
-  dispatchTouchEvent("touchCancel", event, RawEvent::Category::ContinuousEnd);
+void TouchEventEmitter::onTouchCancel(TouchEvent event) const {
+  dispatchTouchEvent(
+      "touchCancel", std::move(event), RawEvent::Category::ContinuousEnd);
 }
 
-void TouchEventEmitter::onClick(const PointerEvent& event) const {
-  dispatchPointerEvent("click", event, RawEvent::Category::Discrete);
+void TouchEventEmitter::onClick(PointerEvent event) const {
+  dispatchPointerEvent("click", std::move(event), RawEvent::Category::Discrete);
 }
 
-void TouchEventEmitter::onPointerCancel(const PointerEvent& event) const {
+void TouchEventEmitter::onPointerCancel(PointerEvent event) const {
   dispatchPointerEvent(
-      "pointerCancel", event, RawEvent::Category::ContinuousEnd);
+      "pointerCancel", std::move(event), RawEvent::Category::ContinuousEnd);
 }
 
-void TouchEventEmitter::onPointerDown(const PointerEvent& event) const {
+void TouchEventEmitter::onPointerDown(PointerEvent event) const {
   dispatchPointerEvent(
-      "pointerDown", event, RawEvent::Category::ContinuousStart);
+      "pointerDown", std::move(event), RawEvent::Category::ContinuousStart);
 }
 
-void TouchEventEmitter::onPointerMove(const PointerEvent& event) const {
-  dispatchUniqueEvent("pointerMove", std::make_shared<PointerEvent>(event));
+void TouchEventEmitter::onPointerMove(PointerEvent event) const {
+  dispatchUniqueEvent(
+      "pointerMove", std::make_shared<PointerEvent>(std::move(event)));
 }
 
-void TouchEventEmitter::onPointerUp(const PointerEvent& event) const {
-  dispatchPointerEvent("pointerUp", event, RawEvent::Category::ContinuousEnd);
+void TouchEventEmitter::onPointerUp(PointerEvent event) const {
+  dispatchPointerEvent(
+      "pointerUp", std::move(event), RawEvent::Category::ContinuousEnd);
 }
 
-void TouchEventEmitter::onPointerEnter(const PointerEvent& event) const {
+void TouchEventEmitter::onPointerEnter(PointerEvent event) const {
   dispatchPointerEvent(
-      "pointerEnter", event, RawEvent::Category::ContinuousStart);
+      "pointerEnter", std::move(event), RawEvent::Category::ContinuousStart);
 }
 
-void TouchEventEmitter::onPointerLeave(const PointerEvent& event) const {
+void TouchEventEmitter::onPointerLeave(PointerEvent event) const {
   dispatchPointerEvent(
-      "pointerLeave", event, RawEvent::Category::ContinuousEnd);
+      "pointerLeave", std::move(event), RawEvent::Category::ContinuousEnd);
 }
 
-void TouchEventEmitter::onPointerOver(const PointerEvent& event) const {
+void TouchEventEmitter::onPointerOver(PointerEvent event) const {
   dispatchPointerEvent(
-      "pointerOver", event, RawEvent::Category::ContinuousStart);
+      "pointerOver", std::move(event), RawEvent::Category::ContinuousStart);
 }
 
-void TouchEventEmitter::onPointerOut(const PointerEvent& event) const {
+void TouchEventEmitter::onPointerOut(PointerEvent event) const {
   dispatchPointerEvent(
-      "pointerOut", event, RawEvent::Category::ContinuousStart);
+      "pointerOut", std::move(event), RawEvent::Category::ContinuousStart);
 }
 
-void TouchEventEmitter::onGotPointerCapture(const PointerEvent& event) const {
+void TouchEventEmitter::onGotPointerCapture(PointerEvent event) const {
   dispatchPointerEvent(
-      "gotPointerCapture", event, RawEvent::Category::ContinuousStart);
+      "gotPointerCapture",
+      std::move(event),
+      RawEvent::Category::ContinuousStart);
 }
 
-void TouchEventEmitter::onLostPointerCapture(const PointerEvent& event) const {
+void TouchEventEmitter::onLostPointerCapture(PointerEvent event) const {
   dispatchPointerEvent(
-      "lostPointerCapture", event, RawEvent::Category::ContinuousEnd);
+      "lostPointerCapture",
+      std::move(event),
+      RawEvent::Category::ContinuousEnd);
 }
 
 } // namespace facebook::react

package/ReactCommon/react/renderer/components/view/TouchEventEmitter.h

@@ -24,31 +24,31 @@ class TouchEventEmitter : public EventEmitter {
  public:
   using EventEmitter::EventEmitter;
 
-  void onTouchStart(const TouchEvent& event) const;
-  void onTouchMove(const TouchEvent& event) const;
-  void onTouchEnd(const TouchEvent& event) const;
-  void onTouchCancel(const TouchEvent& event) const;
-
-  void onClick(const PointerEvent& event) const;
-  void onPointerCancel(const PointerEvent& event) const;
-  void onPointerDown(const PointerEvent& event) const;
-  void onPointerMove(const PointerEvent& event) const;
-  void onPointerUp(const PointerEvent& event) const;
-  void onPointerEnter(const PointerEvent& event) const;
-  void onPointerLeave(const PointerEvent& event) const;
-  void onPointerOver(const PointerEvent& event) const;
-  void onPointerOut(const PointerEvent& event) const;
-  void onGotPointerCapture(const PointerEvent& event) const;
-  void onLostPointerCapture(const PointerEvent& event) const;
+  void onTouchStart(TouchEvent event) const;
+  void onTouchMove(TouchEvent event) const;
+  void onTouchEnd(TouchEvent event) const;
+  void onTouchCancel(TouchEvent event) const;
+
+  void onClick(PointerEvent event) const;
+  void onPointerCancel(PointerEvent event) const;
+  void onPointerDown(PointerEvent event) const;
+  void onPointerMove(PointerEvent event) const;
+  void onPointerUp(PointerEvent event) const;
+  void onPointerEnter(PointerEvent event) const;
+  void onPointerLeave(PointerEvent event) const;
+  void onPointerOver(PointerEvent event) const;
+  void onPointerOut(PointerEvent event) const;
+  void onGotPointerCapture(PointerEvent event) const;
+  void onLostPointerCapture(PointerEvent event) const;
 
  private:
   void dispatchTouchEvent(
       std::string type,
-      const TouchEvent& event,
+      TouchEvent event,
       RawEvent::Category category) const;
   void dispatchPointerEvent(
       std::string type,
-      const PointerEvent& event,
+      PointerEvent event,
       RawEvent::Category category) const;
 };
 

package/ReactCommon/react/renderer/components/view/ViewShadowNode.cpp

@@ -9,7 +9,6 @@
 #include <react/config/ReactNativeConfig.h>
 #include <react/renderer/components/view/HostPlatformViewTraitsInitializer.h>
 #include <react/renderer/components/view/primitives.h>
-#include <react/utils/CoreFeatures.h>
 
 namespace facebook::react {
 
@@ -70,7 +69,8 @@ void ViewShadowNode::initialize() noexcept {
       isColorMeaningful(viewProps.backgroundColor) || hasBorder() ||
       !viewProps.testId.empty() || !viewProps.boxShadow.empty() ||
       !viewProps.backgroundImage.empty() ||
-      HostPlatformViewTraitsInitializer::formsView(viewProps);
+      HostPlatformViewTraitsInitializer::formsView(viewProps) ||
+      viewProps.outlineWidth > 0;
 
   if (formsView) {
     traits_.set(ShadowNodeTraits::Trait::FormsView);

package/ReactCommon/react/renderer/components/view/YogaLayoutableShadowNode.cpp

@@ -17,7 +17,6 @@
 #include <react/renderer/core/LayoutConstraints.h>
 #include <react/renderer/core/LayoutContext.h>
 #include <react/renderer/debug/DebugStringConvertibleItem.h>
-#include <react/utils/CoreFeatures.h>
 #include <yoga/Yoga.h>
 #include <algorithm>
 #include <limits>
@@ -71,18 +70,18 @@ YogaLayoutableShadowNode::YogaLayoutableShadowNode(
     : LayoutableShadowNode(fragment, family, traits),
       yogaConfig_(FabricDefaultYogaLog),
       yogaNode_(&initializeYogaConfig(yogaConfig_)) {
-  yogaNode_.setContext(this);
+  YGNodeSetContext(&yogaNode_, this);
 
   if (getTraits().check(ShadowNodeTraits::Trait::MeasurableYogaNode)) {
     react_native_assert(
         getTraits().check(ShadowNodeTraits::Trait::LeafYogaNode));
 
-    yogaNode_.setMeasureFunc(
-        YogaLayoutableShadowNode::yogaNodeMeasureCallbackConnector);
+    YGNodeSetMeasureFunc(&yogaNode_, yogaNodeMeasureCallbackConnector);
   }
 
   if (getTraits().check(ShadowNodeTraits::Trait::BaselineYogaNode)) {
-    yogaNode_.setBaselineFunc(
+    YGNodeSetBaselineFunc(
+        &yogaNode_,
         YogaLayoutableShadowNode::yogaNodeBaselineCallbackConnector);
   }
 
@@ -108,12 +107,10 @@ YogaLayoutableShadowNode::YogaLayoutableShadowNode(
 // the ShadowTree being created on the JS thread. This assert can be
 // re-enabled after disabling background executor everywhere.
 #if 0
-  react_native_assert(
-      static_cast<const YogaLayoutableShadowNode&>(sourceShadowNode)
-              .yogaNode_.isDirty() == yogaNode_.isDirty() &&
+  react_native_assert(YGNodeIsDirty(&static_cast<const YogaLayoutableShadowNode&>(sourceShadowNode)
+              .yogaNode_) == YGNodeIsDirty(&yogaNode_) &&
       "Yoga node must inherit dirty flag.");
 #endif
-
   if (!getTraits().check(ShadowNodeTraits::Trait::LeafYogaNode)) {
     for (auto& child : getChildren()) {
       if (auto layoutableChild =
@@ -128,9 +125,10 @@ YogaLayoutableShadowNode::YogaLayoutableShadowNode(
       &static_cast<const YogaLayoutableShadowNode&>(sourceShadowNode)
            .yogaConfig_;
 
-  yogaNode_.setContext(this);
+  YGNodeSetContext(&yogaNode_, this);
   yogaNode_.setOwner(nullptr);
-  yogaNode_.setConfig(&initializeYogaConfig(yogaConfig_, previousConfig));
+  YGNodeSetConfig(
+      &yogaNode_, &initializeYogaConfig(yogaConfig_, previousConfig));
   updateYogaChildrenOwnersIfNeeded();
 
   // This is the only legit place where we can dirty cloned Yoga node.
@@ -170,7 +168,7 @@ void YogaLayoutableShadowNode::dirtyLayout() {
 }
 
 bool YogaLayoutableShadowNode::getIsLayoutClean() const {
-  return !yogaNode_.isDirty();
+  return !YGNodeIsDirty(&yogaNode_);
 }
 
 #pragma mark - Mutating Methods
@@ -178,8 +176,8 @@ bool YogaLayoutableShadowNode::getIsLayoutClean() const {
 void YogaLayoutableShadowNode::enableMeasurement() {
   ensureUnsealed();
 
-  yogaNode_.setMeasureFunc(
-      YogaLayoutableShadowNode::yogaNodeMeasureCallbackConnector);
+  YGNodeSetMeasureFunc(
+      &yogaNode_, YogaLayoutableShadowNode::yogaNodeMeasureCallbackConnector);
 }
 
 void YogaLayoutableShadowNode::appendYogaChild(
@@ -191,7 +189,7 @@ void YogaLayoutableShadowNode::appendYogaChild(
   ensureYogaChildrenLookFine();
 
   yogaLayoutableChildren_.push_back(childNode);
-  yogaNode_.insertChild(&childNode->yogaNode_, yogaNode_.getChildren().size());
+  yogaNode_.insertChild(&childNode->yogaNode_, YGNodeGetChildCount(&yogaNode_));
 
   ensureYogaChildrenLookFine();
 }
@@ -207,7 +205,7 @@ void YogaLayoutableShadowNode::adoptYogaChild(size_t index) {
   auto& childNode =
       dynamic_cast<const YogaLayoutableShadowNode&>(*getChildren().at(index));
 
-  if (childNode.yogaNode_.getOwner() == nullptr) {
+  if (YGNodeGetOwner(&childNode.yogaNode_) == nullptr) {
     // The child node is not owned.
     childNode.yogaNode_.setOwner(&yogaNode_);
     // At this point the child yoga node must be already inserted by the caller.
@@ -217,11 +215,6 @@ void YogaLayoutableShadowNode::adoptYogaChild(size_t index) {
     // TODO: At this point, React has wrong reference to the node. (T138668036)
     auto clonedChildNode = childNode.clone({});
 
-    if (ReactNativeFeatureFlags::
-            useRuntimeShadowNodeReferenceUpdateOnLayout()) {
-      childNode.transferRuntimeShadowNodeReference(clonedChildNode);
-    }
-
     // Replace the child node with a newly cloned one in the children list.
     replaceChild(childNode, clonedChildNode, index);
   }
@@ -304,15 +297,16 @@ void YogaLayoutableShadowNode::replaceChild(
 
   if (layoutableNewChild) {
     // Both children are layoutable, replace the old one with the new one
-    react_native_assert(layoutableNewChild->yogaNode_.getOwner() == nullptr);
+    react_native_assert(
+        YGNodeGetOwner(&layoutableNewChild->yogaNode_) == nullptr);
     layoutableNewChild->yogaNode_.setOwner(&yogaNode_);
-    *oldChildIter = layoutableNewChild;
     yogaNode_.replaceChild(&layoutableNewChild->yogaNode_, oldChildIndex);
+    *oldChildIter = layoutableNewChild;
   } else {
     // Layoutable child replaced with non layoutable child. Remove the previous
     // child from the layoutable children list.
-    yogaLayoutableChildren_.erase(oldChildIter);
     yogaNode_.removeChild(oldChildIndex);
+    yogaLayoutableChildren_.erase(oldChildIter);
   }
 
   ensureYogaChildrenLookFine();
@@ -320,12 +314,12 @@ void YogaLayoutableShadowNode::replaceChild(
 
 bool YogaLayoutableShadowNode::doesOwn(
     const YogaLayoutableShadowNode& child) const {
-  return child.yogaNode_.getOwner() == &yogaNode_;
+  return YGNodeGetOwner(&child.yogaNode_) == &yogaNode_;
 }
 
 void YogaLayoutableShadowNode::updateYogaChildrenOwnersIfNeeded() {
   for (auto& childYogaNode : yogaNode_.getChildren()) {
-    if (childYogaNode->getOwner() == &yogaNode_) {
+    if (YGNodeGetOwner(childYogaNode) == &yogaNode_) {
       childYogaNode->setOwner(
           reinterpret_cast<yoga::Node*>(0xBADC0FFEE0DDF00D));
     }
@@ -339,8 +333,8 @@ void YogaLayoutableShadowNode::updateYogaChildren() {
 
   ensureUnsealed();
 
-  bool isClean = !yogaNode_.isDirty() &&
-      getChildren().size() == yogaNode_.getChildren().size();
+  bool isClean = !YGNodeIsDirty(&yogaNode_) &&
+      getChildren().size() == YGNodeGetChildCount(&yogaNode_);
 
   auto oldYogaChildren =
       isClean ? yogaNode_.getChildren() : std::vector<yoga::Node*>{};
@@ -368,7 +362,7 @@ void YogaLayoutableShadowNode::updateYogaChildren() {
   }
 
   react_native_assert(
-      yogaLayoutableChildren_.size() == yogaNode_.getChildren().size());
+      yogaLayoutableChildren_.size() == YGNodeGetChildCount(&yogaNode_));
 
   yogaNode_.setDirty(!isClean);
 }
@@ -380,7 +374,7 @@ void YogaLayoutableShadowNode::updateYogaProps() {
   auto styleResult = applyAliasedProps(props.yogaStyle, props);
 
   // Resetting `dirty` flag only if `yogaStyle` portion of `Props` was changed.
-  if (!yogaNode_.isDirty() && (styleResult != yogaNode_.style())) {
+  if (!YGNodeIsDirty(&yogaNode_) && (styleResult != yogaNode_.style())) {
     yogaNode_.setDirty(true);
   }
 
@@ -393,6 +387,12 @@ void YogaLayoutableShadowNode::updateYogaProps() {
         !viewProps.filter.empty();
     YGNodeSetAlwaysFormsContainingBlock(&yogaNode_, alwaysFormsContainingBlock);
   }
+
+  if (YGNodeStyleGetDisplay(&yogaNode_) == YGDisplayContents) {
+    ShadowNode::traits_.set(ShadowNodeTraits::ForceFlattenView);
+  } else {
+    ShadowNode::traits_.unset(ShadowNodeTraits::ForceFlattenView);
+  }
 }
 
 /*static*/ yoga::Style YogaLayoutableShadowNode::applyAliasedProps(
@@ -529,10 +529,6 @@ YogaLayoutableShadowNode& YogaLayoutableShadowNode::cloneChildInPlace(
        ShadowNodeFragment::childrenPlaceholder(),
        childNode.getState()});
 
-  if (ReactNativeFeatureFlags::useRuntimeShadowNodeReferenceUpdateOnLayout()) {
-    childNode.transferRuntimeShadowNodeReference(clonedChildNode);
-  }
-
   replaceChild(childNode, clonedChildNode, layoutableChildIndex);
   return static_cast<YogaLayoutableShadowNode&>(*clonedChildNode);
 }
@@ -541,8 +537,10 @@ void YogaLayoutableShadowNode::setSize(Size size) const {
   ensureUnsealed();
 
   auto style = yogaNode_.style();
-  style.setDimension(yoga::Dimension::Width, yoga::value::points(size.width));
-  style.setDimension(yoga::Dimension::Height, yoga::value::points(size.height));
+  style.setDimension(
+      yoga::Dimension::Width, yoga::StyleLength::points(size.width));
+  style.setDimension(
+      yoga::Dimension::Height, yoga::StyleLength::points(size.height));
   yogaNode_.setStyle(style);
   yogaNode_.setDirty(true);
 }
@@ -552,19 +550,21 @@ void YogaLayoutableShadowNode::setPadding(RectangleEdges<Float> padding) const {
 
   auto style = yogaNode_.style();
 
-  auto leftPadding = yoga::value::points(padding.left);
-  auto topPadding = yoga::value::points(padding.top);
-  auto rightPadding = yoga::value::points(padding.right);
-  auto bottomPadding = yoga::value::points(padding.bottom);
+  auto leftPadding = yoga::StyleLength::points(padding.left);
+  auto topPadding = yoga::StyleLength::points(padding.top);
+  auto rightPadding = yoga::StyleLength::points(padding.right);
+  auto bottomPadding = yoga::StyleLength::points(padding.bottom);
 
   if (leftPadding != style.padding(yoga::Edge::Left) ||
       topPadding != style.padding(yoga::Edge::Top) ||
       rightPadding != style.padding(yoga::Edge::Right) ||
       bottomPadding != style.padding(yoga::Edge::Bottom)) {
-    style.setPadding(yoga::Edge::Top, yoga::value::points(padding.top));
-    style.setPadding(yoga::Edge::Left, yoga::value::points(padding.left));
-    style.setPadding(yoga::Edge::Right, yoga::value::points(padding.right));
-    style.setPadding(yoga::Edge::Bottom, yoga::value::points(padding.bottom));
+    style.setPadding(yoga::Edge::Top, yoga::StyleLength::points(padding.top));
+    style.setPadding(yoga::Edge::Left, yoga::StyleLength::points(padding.left));
+    style.setPadding(
+        yoga::Edge::Right, yoga::StyleLength::points(padding.right));
+    style.setPadding(
+        yoga::Edge::Bottom, yoga::StyleLength::points(padding.bottom));
     yogaNode_.setStyle(style);
     yogaNode_.setDirty(true);
   }
@@ -631,16 +631,16 @@ void YogaLayoutableShadowNode::layoutTree(
   auto ownerHeight = yogaFloatFromFloat(maximumSize.height);
 
   yogaStyle.setMaxDimension(
-      yoga::Dimension::Width, yoga::value::points(maximumSize.width));
+      yoga::Dimension::Width, yoga::StyleLength::points(maximumSize.width));
 
   yogaStyle.setMaxDimension(
-      yoga::Dimension::Height, yoga::value::points(maximumSize.height));
+      yoga::Dimension::Height, yoga::StyleLength::points(maximumSize.height));
 
   yogaStyle.setMinDimension(
-      yoga::Dimension::Width, yoga::value::points(minimumSize.width));
+      yoga::Dimension::Width, yoga::StyleLength::points(minimumSize.width));
 
   yogaStyle.setMinDimension(
-      yoga::Dimension::Height, yoga::value::points(minimumSize.height));
+      yoga::Dimension::Height, yoga::StyleLength::points(minimumSize.height));
 
   auto direction =
       yogaDirectionFromLayoutDirection(layoutConstraints.layoutDirection);
@@ -681,7 +681,7 @@ static EdgeInsets calculateOverflowInset(
 
 void YogaLayoutableShadowNode::layout(LayoutContext layoutContext) {
   // Reading data from a dirtied node does not make sense.
-  react_native_assert(!yogaNode_.isDirty());
+  react_native_assert(!YGNodeIsDirty(&yogaNode_));
 
   for (auto childYogaNode : yogaNode_.getChildren()) {
     auto& childNode = shadowNodeFromContext(childYogaNode);
@@ -697,7 +697,7 @@ void YogaLayoutableShadowNode::layout(LayoutContext layoutContext) {
 
       // We must copy layout metrics from Yoga node only once (when the parent
       // node exclusively ownes the child node).
-      react_native_assert(childYogaNode->getOwner() == &yogaNode_);
+      react_native_assert(YGNodeGetOwner(childYogaNode) == &yogaNode_);
 
       // We are about to mutate layout metrics of the node.
       childNode.ensureUnsealed();
@@ -725,7 +725,7 @@ void YogaLayoutableShadowNode::layout(LayoutContext layoutContext) {
     }
   }
 
-  if (yogaNode_.style().overflow() == yoga::Overflow::Visible) {
+  if (YGNodeStyleGetOverflow(&yogaNode_) == YGOverflowVisible) {
     // Note that the parent node's overflow layout is NOT affected by its
     // transform matrix. That transform matrix is applied on the parent node as
     // well as all of its child nodes, which won't cause changes on the
@@ -785,7 +785,7 @@ Rect YogaLayoutableShadowNode::getContentBounds() const {
 }
 
 /*static*/ void YogaLayoutableShadowNode::filterRawProps(RawProps& rawProps) {
-  if (CoreFeatures::excludeYogaFromRawProps) {
+  if (ReactNativeFeatureFlags::excludeYogaFromRawProps()) {
     // TODO: this shouldn't live in RawProps
     rawProps.filterYogaStylePropsInDynamicConversion();
   }
@@ -903,44 +903,44 @@ void YogaLayoutableShadowNode::swapLeftAndRightInYogaStyleProps() {
   if (yogaStyle.position(yoga::Edge::Left).isDefined()) {
     yogaStyle.setPosition(
         yoga::Edge::Start, yogaStyle.position(yoga::Edge::Left));
-    yogaStyle.setPosition(yoga::Edge::Left, yoga::value::undefined());
+    yogaStyle.setPosition(yoga::Edge::Left, yoga::StyleLength::undefined());
   }
 
   if (yogaStyle.position(yoga::Edge::Right).isDefined()) {
     yogaStyle.setPosition(
         yoga::Edge::End, yogaStyle.position(yoga::Edge::Right));
-    yogaStyle.setPosition(yoga::Edge::Right, yoga::value::undefined());
+    yogaStyle.setPosition(yoga::Edge::Right, yoga::StyleLength::undefined());
   }
 
   if (yogaStyle.padding(yoga::Edge::Left).isDefined()) {
     yogaStyle.setPadding(
         yoga::Edge::Start, yogaStyle.padding(yoga::Edge::Left));
-    yogaStyle.setPadding(yoga::Edge::Left, yoga::value::undefined());
+    yogaStyle.setPadding(yoga::Edge::Left, yoga::StyleLength::undefined());
   }
 
   if (yogaStyle.padding(yoga::Edge::Right).isDefined()) {
     yogaStyle.setPadding(yoga::Edge::End, yogaStyle.padding(yoga::Edge::Right));
-    yogaStyle.setPadding(yoga::Edge::Right, yoga::value::undefined());
+    yogaStyle.setPadding(yoga::Edge::Right, yoga::StyleLength::undefined());
   }
 
   if (yogaStyle.margin(yoga::Edge::Left).isDefined()) {
     yogaStyle.setMargin(yoga::Edge::Start, yogaStyle.margin(yoga::Edge::Left));
-    yogaStyle.setMargin(yoga::Edge::Left, yoga::value::undefined());
+    yogaStyle.setMargin(yoga::Edge::Left, yoga::StyleLength::undefined());
   }
 
   if (yogaStyle.margin(yoga::Edge::Right).isDefined()) {
     yogaStyle.setMargin(yoga::Edge::End, yogaStyle.margin(yoga::Edge::Right));
-    yogaStyle.setMargin(yoga::Edge::Right, yoga::value::undefined());
+    yogaStyle.setMargin(yoga::Edge::Right, yoga::StyleLength::undefined());
   }
 
   if (yogaStyle.border(yoga::Edge::Left).isDefined()) {
     yogaStyle.setBorder(yoga::Edge::Start, yogaStyle.border(yoga::Edge::Left));
-    yogaStyle.setBorder(yoga::Edge::Left, yoga::value::undefined());
+    yogaStyle.setBorder(yoga::Edge::Left, yoga::StyleLength::undefined());
   }
 
   if (yogaStyle.border(yoga::Edge::Right).isDefined()) {
     yogaStyle.setBorder(yoga::Edge::End, yogaStyle.border(yoga::Edge::Right));
-    yogaStyle.setBorder(yoga::Edge::Right, yoga::value::undefined());
+    yogaStyle.setBorder(yoga::Edge::Right, yoga::StyleLength::undefined());
   }
 
   yogaNode_.setStyle(yogaStyle);