@depup/react-native 0.86.0-depup.49 → 0.87.0-depup.0

package/ReactCommon/react/renderer/uimanager/UIManager.cpp

@@ -76,20 +76,23 @@ std::shared_ptr<ShadowNode> UIManager::createNode(
       {.tag = tag,
        .surfaceId = surfaceId,
        .instanceHandle = std::move(instanceHandle)});
-  const auto props = componentDescriptor.cloneProps(
+  auto props = componentDescriptor.cloneProps(
       propsParserContext, nullptr, std::move(rawProps));
-  const auto state = componentDescriptor.createInitialState(props, family);
+  auto state = componentDescriptor.createInitialState(props, family);
+
+  // Add a "name" prop if this is the fallback component
+  if (fallbackDescriptor != nullptr &&
+      fallbackDescriptor->getComponentHandle() ==
+          componentDescriptor.getComponentHandle()) {
+    props = componentDescriptor.cloneProps(
+        propsParserContext,
+        props,
+        RawProps(folly::dynamic::object("name", name)));
+  }
 
   auto shadowNode = componentDescriptor.createShadowNode(
       ShadowNodeFragment{
-          .props = fallbackDescriptor != nullptr &&
-                  fallbackDescriptor->getComponentHandle() ==
-                      componentDescriptor.getComponentHandle()
-              ? componentDescriptor.cloneProps(
-                    propsParserContext,
-                    props,
-                    RawProps(folly::dynamic::object("name", name)))
-              : props,
+          .props = props,
           .children = ShadowNodeFragment::childrenPlaceholder(),
           .state = state,
       },
@@ -118,49 +121,51 @@ std::shared_ptr<ShadowNode> UIManager::cloneNode(
 
   auto& componentDescriptor = shadowNode.getComponentDescriptor();
   auto& family = shadowNode.getFamily();
-  auto props = ShadowNodeFragment::propsPlaceholder();
 
+  auto props = ShadowNodeFragment::propsPlaceholder();
   if (!rawProps.isEmpty()) {
-    if (family.nativeProps_DEPRECATED != nullptr) {
-      // 1. update the nativeProps_DEPRECATED props.
-      //
-      // In this step, we want the most recent value for the props
-      // managed by setNativeProps.
-      // Values in `rawProps` patch (take precedence over)
-      // `nativeProps_DEPRECATED`. For example, if both
-      // `nativeProps_DEPRECATED` and `rawProps` contain key 'A'.
-      // Value from `rawProps` overrides what was previously in
-      // `nativeProps_DEPRECATED`. Notice that the `nativeProps_DEPRECATED`
-      // patch will not get more props from `rawProps`: if the key is not
-      // present in `nativeProps_DEPRECATED`, it will not be added.
-      //
-      // The result of this operation is the new `nativeProps_DEPRECATED`.
-      family.nativeProps_DEPRECATED =
-          std::make_unique<folly::dynamic>(mergeDynamicProps(
-              *family.nativeProps_DEPRECATED, // source
-              (folly::dynamic)rawProps, // patch
-              NullValueStrategy::Ignore));
-
-      // 2. Compute the final set of props.
-      //
-      // This step takes the new props handled by `setNativeProps` and
-      // merges them in the `rawProps` managed by React.
-      // The new props handled by `nativeProps` now takes precedence
-      // on the props handled by React, as we want to make sure that
-      // all the props are applied to the component.
-      // We use these finalProps as source of truth for the component.
-      auto finalProps = mergeDynamicProps(
-          (folly::dynamic)rawProps, // source
-          *family.nativeProps_DEPRECATED, // patch
-          NullValueStrategy::Override);
-
-      // 3. Clone the props by using finalProps.
-      props = componentDescriptor.cloneProps(
-          propsParserContext, shadowNode.getProps(), RawProps(finalProps));
-    } else {
-      props = componentDescriptor.cloneProps(
-          propsParserContext, shadowNode.getProps(), std::move(rawProps));
+    std::optional<folly::dynamic> finalProps;
+    {
+      std::lock_guard<std::mutex> lock(family.nativePropsMutex);
+      if (family.nativeProps_DEPRECATED != nullptr) {
+        // 1. update the nativeProps_DEPRECATED props.
+        //
+        // In this step, we want the most recent value for the props
+        // managed by setNativeProps.
+        // Values in `rawProps` patch (take precedence over)
+        // `nativeProps_DEPRECATED`. For example, if both
+        // `nativeProps_DEPRECATED` and `rawProps` contain key 'A'.
+        // Value from `rawProps` overrides what was previously in
+        // `nativeProps_DEPRECATED`. Notice that the `nativeProps_DEPRECATED`
+        // patch will not get more props from `rawProps`: if the key is not
+        // present in `nativeProps_DEPRECATED`, it will not be added.
+        //
+        // The result of this operation is the new `nativeProps_DEPRECATED`.
+        family.nativeProps_DEPRECATED =
+            std::make_unique<folly::dynamic>(mergeDynamicProps(
+                *family.nativeProps_DEPRECATED, // source
+                (folly::dynamic)rawProps, // patch
+                NullValueStrategy::Ignore));
+
+        // 2. Compute the final set of props.
+        //
+        // This step takes the new props handled by `setNativeProps` and
+        // merges them in the `rawProps` managed by React.
+        // The new props handled by `nativeProps` now takes precedence
+        // on the props handled by React, as we want to make sure that
+        // all the props are applied to the component.
+        // We use these finalProps as source of truth for the component.
+        finalProps = mergeDynamicProps(
+            (folly::dynamic)rawProps, // source
+            *family.nativeProps_DEPRECATED, // patch
+            NullValueStrategy::Override);
+      }
     }
+
+    props = componentDescriptor.cloneProps(
+        propsParserContext,
+        shadowNode.getProps(),
+        finalProps ? RawProps(std::move(*finalProps)) : std::move(rawProps));
   }
 
   auto clonedShadowNode = componentDescriptor.cloneShadowNode(
@@ -210,7 +215,8 @@ void UIManager::completeSurface(
     // after we commit a specific one.
     lazyShadowTreeRevisionConsistencyManager_->updateCurrentRevision(surfaceId);
 
-    if (ReactNativeFeatureFlags::useSharedAnimatedBackend()) {
+    if (ReactNativeFeatureFlags::useSharedAnimatedBackend() &&
+        animationBackend_) {
       animationBackend_->clearRegistry(surfaceId);
     }
   }
@@ -275,10 +281,6 @@ ShadowTree::Unique UIManager::stopSurface(SurfaceId surfaceId) const {
   // Stop any ongoing layout animations.
   stopSurfaceForAnimationDelegate(surfaceId);
 
-  if (ReactNativeFeatureFlags::useSharedAnimatedBackend()) {
-    animationBackend_->clearRegistryOnSurfaceStop(surfaceId);
-  }
-
   // Waiting for all concurrent commits to be finished and unregistering the
   // `ShadowTree`.
   auto shadowTree = getShadowTreeRegistry().remove(surfaceId);
@@ -295,6 +297,18 @@ ShadowTree::Unique UIManager::stopSurface(SurfaceId surfaceId) const {
       leakChecker_->stopSurface(surfaceId);
     }
   }
+
+  if (ReactNativeFeatureFlags::useSharedAnimatedBackend()) {
+    runtimeExecutor_(
+        [surfaceId,
+         animationBackendWeak = std::weak_ptr<UIManagerAnimationBackend>(
+             animationBackend_)](jsi::Runtime& /*runtime*/) {
+          if (auto animationBackend = animationBackendWeak.lock()) {
+            animationBackend->clearRegistryOnSurfaceStop(surfaceId);
+          }
+        });
+  }
+
   return shadowTree;
 }
 
@@ -439,19 +453,22 @@ void UIManager::setNativeProps_DEPRECATED(
     const std::shared_ptr<const ShadowNode>& shadowNode,
     RawProps rawProps) const {
   auto& family = shadowNode->getFamily();
-  if (family.nativeProps_DEPRECATED) {
-    // Values in `rawProps` patch (take precedence over)
-    // `nativeProps_DEPRECATED`. For example, if both `nativeProps_DEPRECATED`
-    // and `rawProps` contain key 'A'. Value from `rawProps` overrides what
-    // was previously in `nativeProps_DEPRECATED`.
-    family.nativeProps_DEPRECATED =
-        std::make_unique<folly::dynamic>(mergeDynamicProps(
-            *family.nativeProps_DEPRECATED,
-            (folly::dynamic)rawProps,
-            NullValueStrategy::Override));
-  } else {
-    family.nativeProps_DEPRECATED =
-        std::make_unique<folly::dynamic>((folly::dynamic)rawProps);
+  {
+    std::lock_guard<std::mutex> lock(family.nativePropsMutex);
+    if (family.nativeProps_DEPRECATED) {
+      // Values in `rawProps` patch (take precedence over)
+      // `nativeProps_DEPRECATED`. For example, if both
+      // `nativeProps_DEPRECATED` and `rawProps` contain key 'A'. Value from
+      // `rawProps` overrides what was previously in `nativeProps_DEPRECATED`.
+      family.nativeProps_DEPRECATED =
+          std::make_unique<folly::dynamic>(mergeDynamicProps(
+              *family.nativeProps_DEPRECATED,
+              (folly::dynamic)rawProps,
+              NullValueStrategy::Override));
+    } else {
+      family.nativeProps_DEPRECATED =
+          std::make_unique<folly::dynamic>((folly::dynamic)rawProps);
+    }
   }
 
   shadowTreeRegistry_.visit(
@@ -530,30 +547,8 @@ std::shared_ptr<const ShadowNode> UIManager::findShadowNodeByTag_DEPRECATED(
   auto shadowNode = std::shared_ptr<const ShadowNode>{};
 
   shadowTreeRegistry_.enumerate([&](const ShadowTree& shadowTree, bool& stop) {
-    // Obtain a pointer to the root node. The flag-gated path uses
-    // getCurrentRevision() which keeps the root alive via shared_ptr for
-    // the entire traversal, fixing a use-after-free race condition.
-    RootShadowNode::Shared rootShadowNodeHolder;
-    const RootShadowNode* rootShadowNode = nullptr;
-    if (ReactNativeFeatureFlags::fixFindShadowNodeByTagRaceCondition()) {
-      rootShadowNodeHolder = shadowTree.getCurrentRevision().rootShadowNode;
-      rootShadowNode = rootShadowNodeHolder.get();
-    } else {
-      // TODO(T257154369): Remove after flag rollout.
-      // The public interface of `ShadowTree` discourages accessing a stored
-      // pointer to a root node because of the possible data race.
-      // To work around this, we ask for a commit and immediately cancel it
-      // returning `nullptr` instead of a new shadow tree.
-      // We don't want to add a way to access a stored pointer to a root
-      // node because this `findShadowNodeByTag` is deprecated. It is only
-      // added to make migration to the new architecture easier.
-      shadowTree.tryCommit(
-          [&](const RootShadowNode& oldRootShadowNode) {
-            rootShadowNode = &oldRootShadowNode;
-            return nullptr;
-          },
-          {/* default commit options */});
-    }
+    auto rootShadowNodeHolder = shadowTree.getCurrentRevision().rootShadowNode;
+    const auto* rootShadowNode = rootShadowNodeHolder.get();
 
     if (rootShadowNode != nullptr) {
       const auto& children = rootShadowNode->getChildren();
@@ -778,10 +773,10 @@ void UIManager::removeEventListener(
   }
 }
 
-void UIManager::setOnSurfaceStartCallback(
+void UIManager::addOnSurfaceStartCallback(
     UIManagerDelegate::OnSurfaceStartCallback&& callback) {
   if (delegate_ != nullptr) {
-    delegate_->uiManagerShouldSetOnSurfaceStartCallback(std::move(callback));
+    delegate_->uiManagerShouldAddOnSurfaceStartCallback(std::move(callback));
   }
 }
 

package/ReactCommon/react/renderer/uimanager/UIManager.h

@@ -223,8 +223,8 @@ class UIManager final : public ShadowTreeDelegate {
 
   void removeEventListener(const std::shared_ptr<const EventListener> &listener);
 
-#pragma mark - Set on surface start callback
-  void setOnSurfaceStartCallback(UIManagerDelegate::OnSurfaceStartCallback &&callback);
+#pragma mark - Add on surface start callback
+  void addOnSurfaceStartCallback(UIManagerDelegate::OnSurfaceStartCallback &&callback);
 
  private:
   friend class UIManagerBinding;

package/ReactCommon/react/renderer/uimanager/UIManagerDelegate.h

@@ -95,7 +95,7 @@ class UIManagerDelegate {
   virtual void uiManagerDidPromoteReactRevision(const ShadowTree &shadowTree) = 0;
 
   using OnSurfaceStartCallback = std::function<void(const ShadowTree &shadowTree)>;
-  virtual void uiManagerShouldSetOnSurfaceStartCallback(OnSurfaceStartCallback &&callback) = 0;
+  virtual void uiManagerShouldAddOnSurfaceStartCallback(OnSurfaceStartCallback &&callback) = 0;
 
   // View transition bitmap snapshot capture and application.
   virtual void uiManagerDidCaptureViewSnapshot(Tag tag, SurfaceId surfaceId) = 0;

package/ReactCommon/react/renderer/uimanager/tests/FabricUIManagerTest.cpp

@@ -8,10 +8,151 @@
 #include <memory>
 
 #include <gtest/gtest.h>
+#include <react/renderer/components/view/ViewShadowNode.h>
+#include <react/renderer/core/ShadowNodeFragment.h>
+#include <react/renderer/element/Element.h>
+#include <react/renderer/element/testUtils.h>
 #include <react/renderer/uimanager/UIManager.h>
 
-using namespace facebook::react;
+namespace facebook::react {
 
-TEST(UIManagerTest, testSomething) {
-  // TODO
+class FabricUIManagerTest : public ::testing::Test {
+ public:
+  FabricUIManagerTest() {
+    contextContainer_ = std::make_shared<ContextContainer>();
+
+    ComponentDescriptorProviderRegistry componentDescriptorProviderRegistry{};
+    auto componentDescriptorRegistry =
+        componentDescriptorProviderRegistry.createComponentDescriptorRegistry(
+            ComponentDescriptorParameters{
+                .eventDispatcher = EventDispatcher::Shared{},
+                .contextContainer = contextContainer_,
+                .flavor = nullptr});
+
+    componentDescriptorProviderRegistry.add(
+        concreteComponentDescriptorProvider<RootComponentDescriptor>());
+    componentDescriptorProviderRegistry.add(
+        concreteComponentDescriptorProvider<ViewComponentDescriptor>());
+
+    builder_ = std::make_unique<ComponentBuilder>(componentDescriptorRegistry);
+
+    RuntimeExecutor runtimeExecutor =
+        [](std::function<void(
+               facebook::jsi::Runtime & runtime)>&& /*callback*/) {};
+    uiManager_ =
+        std::make_unique<UIManager>(runtimeExecutor, contextContainer_);
+    uiManager_->setComponentDescriptorRegistry(componentDescriptorRegistry);
+
+    buildAndCommitTree();
+  }
+
+  void TearDown() override {
+    uiManager_->stopSurface(surfaceId_);
+  }
+
+ protected:
+  std::shared_ptr<RootShadowNode> buildTree() {
+    std::shared_ptr<RootShadowNode> rootNode;
+
+    // clang-format off
+    auto element =
+        Element<RootShadowNode>()
+          .tag(1)
+          .surfaceId(surfaceId_)
+          .reference(rootNode)
+          .props([] {
+            auto sharedProps = std::make_shared<RootProps>();
+            sharedProps->layoutConstraints = LayoutConstraints{
+                .minimumSize = {.width = 0, .height = 0},
+                .maximumSize = {.width = 500, .height = 500}};
+            return sharedProps;
+          })
+          .children({
+            Element<ViewShadowNode>()
+              .tag(viewTag_)
+              .surfaceId(surfaceId_)
+              .props([] {
+                auto sharedProps = std::make_shared<ViewShadowNodeProps>();
+                sharedProps->nativeId = "initial";
+                sharedProps->opacity = 1.0;
+                return sharedProps;
+              })
+          });
+    // clang-format on
+
+    builder_->build(element);
+    return rootNode;
+  }
+
+  void buildAndCommitTree() {
+    auto rootNode = buildTree();
+
+    auto shadowTree = std::make_unique<ShadowTree>(
+        surfaceId_,
+        LayoutConstraints{},
+        LayoutContext{},
+        *uiManager_,
+        *contextContainer_);
+
+    shadowTreePtr_ = shadowTree.get();
+
+    shadowTree->commit(
+        [&rootNode](const RootShadowNode& /*oldRootShadowNode*/) {
+          return std::static_pointer_cast<RootShadowNode>(rootNode);
+        },
+        {true});
+
+    uiManager_->startSurface(
+        std::move(shadowTree),
+        "test",
+        folly::dynamic::object,
+        DisplayMode::Visible);
+  }
+
+  std::shared_ptr<const ShadowNode> currentViewNode() const {
+    auto root = shadowTreePtr_->getCurrentRevision().rootShadowNode;
+    return root->getChildren().front();
+  }
+
+  const ViewProps& viewPropsInTree() const {
+    return static_cast<const ViewProps&>(*currentViewNode()->getProps());
+  }
+
+  SurfaceId surfaceId_{0};
+  Tag viewTag_{42};
+  std::shared_ptr<ContextContainer> contextContainer_;
+  std::unique_ptr<ComponentBuilder> builder_;
+  std::unique_ptr<UIManager> uiManager_;
+  ShadowTree* shadowTreePtr_{nullptr};
+};
+
+// Demonstrates the merge between props set by `setNativeProps_DEPRECATED`
+// (the legacy native-side prop override path) and props supplied by a
+// regular React re-render via `cloneNode`. The native override must
+// survive a React render that does not touch the overridden key, and
+// other React-supplied keys must still apply.
+TEST_F(FabricUIManagerTest, SetNativePropsMergesWithReactRender) {
+  ASSERT_EQ(viewPropsInTree().nativeId, "initial");
+  ASSERT_FLOAT_EQ(viewPropsInTree().opacity, 1.0);
+
+  // Native override on `opacity` only. The committed tree picks up the new
+  // opacity and leaves the unrelated `nativeId` untouched.
+  uiManager_->setNativeProps_DEPRECATED(
+      currentViewNode(), RawProps(folly::dynamic::object("opacity", 0.5)));
+  EXPECT_EQ(viewPropsInTree().nativeId, "initial");
+  EXPECT_FLOAT_EQ(viewPropsInTree().opacity, 0.5);
+
+  // Simulate a React re-render that updates `nativeID` only. The native
+  // `opacity` override must survive (it is not present in rawProps and
+  // therefore not refreshed away by React), and the new `nativeID` must
+  // apply on top.
+  auto rerendered = uiManager_->cloneNode(
+      *currentViewNode(),
+      /*children=*/nullptr,
+      RawProps(folly::dynamic::object("nativeID", "from-react")));
+  auto& merged = static_cast<const ViewProps&>(*rerendered->getProps());
+  EXPECT_EQ(merged.nativeId, "from-react");
+  EXPECT_FLOAT_EQ(merged.opacity, 0.5);
 }
+
+} // namespace facebook::react

package/ReactCommon/react/renderer/uimanager/tests/FindShadowNodeByTagTest.cpp

@@ -11,8 +11,6 @@
 
 #include <gtest/gtest.h>
 #include <jsi/jsi.h>
-#include <react/featureflags/ReactNativeFeatureFlags.h>
-#include <react/featureflags/ReactNativeFeatureFlagsDefaults.h>
 #include <react/renderer/core/ShadowNodeFragment.h>
 #include <react/renderer/element/Element.h>
 #include <react/renderer/element/testUtils.h>
@@ -20,20 +18,9 @@
 
 namespace facebook::react {
 
-class FindShadowNodeByTagTestFeatureFlags
-    : public ReactNativeFeatureFlagsDefaults {
- public:
-  bool fixFindShadowNodeByTagRaceCondition() override {
-    return true;
-  }
-};
-
 class FindShadowNodeByTagTest : public ::testing::Test {
  public:
   FindShadowNodeByTagTest() {
-    ReactNativeFeatureFlags::override(
-        std::make_unique<FindShadowNodeByTagTestFeatureFlags>());
-
     contextContainer_ = std::make_shared<ContextContainer>();
 
     ComponentDescriptorProviderRegistry componentDescriptorProviderRegistry{};
@@ -66,7 +53,6 @@ class FindShadowNodeByTagTest : public ::testing::Test {
     if (!surfaceStopped_) {
       uiManager_->stopSurface(surfaceId_);
     }
-    ReactNativeFeatureFlags::dangerouslyReset();
   }
 
  protected:
@@ -99,7 +85,7 @@ class FindShadowNodeByTagTest : public ::testing::Test {
               .tag(viewTag_)
               .surfaceId(surfaceId_)
               .props([] {
-                auto sharedProps = std::make_shared<ViewShadowNodeProps>();
+                auto sharedProps = std::make_shared<ViewProps>();
                 auto& yogaStyle = sharedProps->yogaStyle;
                 yogaStyle.setDimension(
                     yoga::Dimension::Width,
@@ -167,43 +153,6 @@ TEST_F(FindShadowNodeByTagTest, FindNonExistentNode) {
   EXPECT_EQ(found, nullptr);
 }
 
-TEST_F(
-    FindShadowNodeByTagTest,
-    RawPointerFromTryCommitDanglesAfterSurfaceStop) {
-  // Observe root lifetime via weak_ptr
-  std::weak_ptr<const RootShadowNode> weakRoot;
-  {
-    auto rev = shadowTreePtr_->getCurrentRevision();
-    weakRoot = rev.rootShadowNode;
-  }
-  ASSERT_FALSE(weakRoot.expired());
-
-  // Simulate the old (buggy) pattern: capture raw pointer via tryCommit.
-  // This is exactly what findShadowNodeByTag_DEPRECATED used to do.
-  const RootShadowNode* rawPtr = nullptr;
-  shadowTreePtr_->tryCommit(
-      [&](const RootShadowNode& oldRoot) {
-        rawPtr = &oldRoot;
-        return nullptr; // cancel commit
-      },
-      {});
-  ASSERT_NE(rawPtr, nullptr);
-  ASSERT_EQ(rawPtr, weakRoot.lock().get());
-
-  // Stop the surface — releases all internal references (ShadowTree's
-  // currentRevision_ and MountingCoordinator's baseRevision_)
-  {
-    auto tree = uiManager_->stopSurface(surfaceId_);
-    surfaceStopped_ = true;
-    // tree goes out of scope here, destroying ShadowTree + MountingCoordinator
-  }
-
-  // Old root is now destroyed. rawPtr is dangling.
-  EXPECT_TRUE(weakRoot.expired())
-      << "Old root should be destroyed after surface stop, "
-         "proving that the raw pointer captured from tryCommit is dangling";
-}
-
 TEST_F(FindShadowNodeByTagTest, SharedPtrFromRevisionSurvivesSurfaceStop) {
   // The fixed pattern: getCurrentRevision() returns a shared_ptr copy
   auto revision = shadowTreePtr_->getCurrentRevision();

package/ReactCommon/react/renderer/uimanager/tests/PointerEventsProcessorTest.cpp

@@ -101,7 +101,7 @@ class PointerEventsProcessorTest : public ::testing::Test {
               .surfaceId(surfaceId_)
               .reference(nodeA_)
               .props([] {
-                auto sharedProps = std::make_shared<ViewShadowNodeProps>();
+                auto sharedProps = std::make_shared<ViewProps>();
                 auto &props = *sharedProps;
                 listenToAllPointerEvents(props);
                 auto &yogaStyle = props.yogaStyle;
@@ -119,7 +119,7 @@ class PointerEventsProcessorTest : public ::testing::Test {
                   .surfaceId(surfaceId_)
                   .reference(nodeAA_)
                   .props([] {
-                    auto sharedProps = std::make_shared<ViewShadowNodeProps>();
+                    auto sharedProps = std::make_shared<ViewProps>();
                     auto &props = *sharedProps;
                     listenToAllPointerEvents(props);
                     auto &yogaStyle = props.yogaStyle;
@@ -133,7 +133,7 @@ class PointerEventsProcessorTest : public ::testing::Test {
               .surfaceId(surfaceId_)
               .reference(nodeB_)
               .props([] {
-                auto sharedProps = std::make_shared<ViewShadowNodeProps>();
+                auto sharedProps = std::make_shared<ViewProps>();
                 auto &props = *sharedProps;
                 listenToAllPointerEvents(props);
                 auto &yogaStyle = props.yogaStyle;
@@ -151,7 +151,7 @@ class PointerEventsProcessorTest : public ::testing::Test {
                   .surfaceId(surfaceId_)
                   .reference(nodeBB_)
                   .props([] {
-                    auto sharedProps = std::make_shared<ViewShadowNodeProps>();
+                    auto sharedProps = std::make_shared<ViewProps>();
                     auto &props = *sharedProps;
                     listenToAllPointerEvents(props);
                     auto &yogaStyle = props.yogaStyle;