react-native-tvos 0.73.7-1 → 0.74.0-0

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

@@ -12,7 +12,6 @@
 #include <react/renderer/core/DynamicPropsUtilities.h>
 #include <react/renderer/core/PropsParserContext.h>
 #include <react/renderer/core/ShadowNodeFragment.h>
-#include <react/renderer/core/TraitCast.h>
 #include <react/renderer/debug/SystraceSection.h>
 #include <react/renderer/uimanager/SurfaceRegistryBinding.h>
 #include <react/renderer/uimanager/UIManagerBinding.h>
@@ -37,7 +36,6 @@ namespace facebook::react {
 // "key function" for the ShadowNodeWrapper class -- this allow for RTTI to work
 // properly across dynamic library boundaries (i.e. dynamic_cast that is used by
 // isHostObject method)
-ShadowNodeWrapper::~ShadowNodeWrapper() = default;
 ShadowNodeListWrapper::~ShadowNodeListWrapper() = default;
 
 static std::unique_ptr<LeakChecker> constructLeakCheckerIfNeeded(
@@ -63,12 +61,12 @@ UIManager::~UIManager() {
                << ").";
 }
 
-ShadowNode::Shared UIManager::createNode(
+std::shared_ptr<ShadowNode> UIManager::createNode(
     Tag tag,
     const std::string& name,
     SurfaceId surfaceId,
-    const RawProps& rawProps,
-    const InstanceHandle::Shared& instanceHandle) const {
+    RawProps rawProps,
+    InstanceHandle::Shared instanceHandle) const {
   SystraceSection s("UIManager::createNode", "componentName", name);
 
   auto& componentDescriptor = componentDescriptorRegistry_->at(name);
@@ -77,11 +75,10 @@ ShadowNode::Shared UIManager::createNode(
 
   PropsParserContext propsParserContext{surfaceId, *contextContainer_.get()};
 
-  const auto fragment =
-      ShadowNodeFamilyFragment{tag, surfaceId, instanceHandle};
-  auto family = componentDescriptor.createFamily(fragment);
-  const auto props =
-      componentDescriptor.cloneProps(propsParserContext, nullptr, rawProps);
+  auto family = componentDescriptor.createFamily(
+      {tag, surfaceId, std::move(instanceHandle)});
+  const auto props = componentDescriptor.cloneProps(
+      propsParserContext, nullptr, std::move(rawProps));
   const auto state = componentDescriptor.createInitialState(props, family);
 
   auto shadowNode = componentDescriptor.createShadowNode(
@@ -110,10 +107,10 @@ ShadowNode::Shared UIManager::createNode(
   return shadowNode;
 }
 
-ShadowNode::Shared UIManager::cloneNode(
+std::shared_ptr<ShadowNode> UIManager::cloneNode(
     const ShadowNode& shadowNode,
     const ShadowNode::SharedListOfShared& children,
-    const RawProps* rawProps) const {
+    RawProps rawProps) const {
   SystraceSection s(
       "UIManager::cloneNode", "componentName", shadowNode.getComponentName());
 
@@ -124,7 +121,7 @@ ShadowNode::Shared UIManager::cloneNode(
   auto& family = shadowNode.getFamily();
   auto props = ShadowNodeFragment::propsPlaceholder();
 
-  if (rawProps != nullptr) {
+  if (!rawProps.isEmpty()) {
     if (family.nativeProps_DEPRECATED != nullptr) {
       // Values in `rawProps` patch (take precedence over)
       // `nativeProps_DEPRECATED`. For example, if both `nativeProps_DEPRECATED`
@@ -132,7 +129,7 @@ ShadowNode::Shared UIManager::cloneNode(
       // was previously in `nativeProps_DEPRECATED`.
       family.nativeProps_DEPRECATED =
           std::make_unique<folly::dynamic>(mergeDynamicProps(
-              *family.nativeProps_DEPRECATED, (folly::dynamic)*rawProps));
+              *family.nativeProps_DEPRECATED, (folly::dynamic)rawProps));
 
       props = componentDescriptor.cloneProps(
           propsParserContext,
@@ -140,7 +137,7 @@ ShadowNode::Shared UIManager::cloneNode(
           RawProps(*family.nativeProps_DEPRECATED));
     } else {
       props = componentDescriptor.cloneProps(
-          propsParserContext, shadowNode.getProps(), *rawProps);
+          propsParserContext, shadowNode.getProps(), std::move(rawProps));
     }
   }
 
@@ -175,8 +172,8 @@ void UIManager::completeSurface(
           return std::make_shared<RootShadowNode>(
               oldRootShadowNode,
               ShadowNodeFragment{
-                  /* .props = */ ShadowNodeFragment::propsPlaceholder(),
-                  /* .children = */ rootChildren,
+                  .props = ShadowNodeFragment::propsPlaceholder(),
+                  .children = rootChildren,
               });
         },
         commitOptions);
@@ -260,6 +257,12 @@ ShadowNode::Shared UIManager::getNewestCloneOfShadowNode(
     return nullptr;
   }
 
+  // If the given shadow node is of the same family as the root shadow node,
+  // return the latest root shadow node
+  if (ShadowNode::sameFamily(*ancestorShadowNode, shadowNode)) {
+    return ancestorShadowNode;
+  }
+
   auto ancestors = shadowNode.getFamily().getAncestors(*ancestorShadowNode);
 
   if (ancestors.empty()) {
@@ -298,6 +301,48 @@ ShadowNode::Shared UIManager::getNewestParentOfShadowNode(
       parentOfParentPair.second);
 }
 
+ShadowNode::Shared UIManager::getNewestPositionedAncestorOfShadowNode(
+    const ShadowNode& shadowNode) const {
+  auto rootShadowNode = ShadowNode::Shared{};
+  shadowTreeRegistry_.visit(
+      shadowNode.getSurfaceId(), [&](const ShadowTree& shadowTree) {
+        rootShadowNode = shadowTree.getCurrentRevision().rootShadowNode;
+      });
+
+  if (!rootShadowNode) {
+    return nullptr;
+  }
+
+  auto ancestors = shadowNode.getFamily().getAncestors(*rootShadowNode);
+
+  if (ancestors.empty()) {
+    return nullptr;
+  }
+
+  for (auto it = ancestors.rbegin(); it != ancestors.rend(); it++) {
+    const auto layoutableAncestorShadowNode =
+        dynamic_cast<const LayoutableShadowNode*>(&(it->first.get()));
+    if (layoutableAncestorShadowNode == nullptr) {
+      return nullptr;
+    }
+    if (layoutableAncestorShadowNode->getLayoutMetrics().positionType !=
+        PositionType::Static) {
+      // We have found our nearest positioned ancestor, now to get a shared
+      // pointer of it
+      it++;
+      if (it != ancestors.rend()) {
+        return it->first.get().getChildren().at(it->second);
+      }
+      // else the positioned ancestor is the root which we return outside of the
+      // loop
+    }
+  }
+
+  // If there is no positioned ancestor then we just consider the root
+  // to be one
+  return rootShadowNode;
+}
+
 std::string UIManager::getTextContentInNewestCloneOfShadowNode(
     const ShadowNode& shadowNode) const {
   auto newestCloneOfShadowNode = getNewestCloneOfShadowNode(shadowNode);
@@ -393,7 +438,7 @@ LayoutMetrics UIManager::getRelativeLayoutMetrics(
   }
 
   auto layoutableAncestorShadowNode =
-      traitCast<const LayoutableShadowNode*>(ancestorShadowNode);
+      dynamic_cast<const LayoutableShadowNode*>(ancestorShadowNode);
 
   if (layoutableAncestorShadowNode == nullptr) {
     return EmptyLayoutMetrics;
@@ -459,7 +504,7 @@ void UIManager::dispatchCommand(
 
 void UIManager::setNativeProps_DEPRECATED(
     const ShadowNode::Shared& shadowNode,
-    const RawProps& rawProps) const {
+    RawProps rawProps) const {
   auto& family = shadowNode->getFamily();
   if (family.nativeProps_DEPRECATED) {
     // Values in `rawProps` patch (take precedence over)
@@ -476,6 +521,8 @@ void UIManager::setNativeProps_DEPRECATED(
 
   shadowTreeRegistry_.visit(
       family.getSurfaceId(), [&](const ShadowTree& shadowTree) {
+        // The lambda passed to `commit` may be executed multiple times.
+        // We need to create fresh copy of the `RawProps` object each time.
         shadowTree.commit(
             [&](RootShadowNode const& oldRootShadowNode) {
               auto rootNode = oldRootShadowNode.cloneTree(
@@ -488,7 +535,7 @@ void UIManager::setNativeProps_DEPRECATED(
                     auto props = componentDescriptor.cloneProps(
                         propsParserContext,
                         getNewestCloneOfShadowNode(*shadowNode)->getProps(),
-                        rawProps);
+                        RawProps(rawProps));
 
                     return oldShadowNode.clone({/* .props = */ props});
                   });

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

@@ -96,6 +96,9 @@ class UIManager final : public ShadowTreeDelegate {
   ShadowNode::Shared getNewestParentOfShadowNode(
       const ShadowNode& shadowNode) const;
 
+  ShadowNode::Shared getNewestPositionedAncestorOfShadowNode(
+      const ShadowNode& shadowNode) const;
+
   std::string getTextContentInNewestCloneOfShadowNode(
       const ShadowNode& shadowNode) const;
 
@@ -130,17 +133,17 @@ class UIManager final : public ShadowTreeDelegate {
       const RootShadowNode::Shared& oldRootShadowNode,
       const RootShadowNode::Unshared& newRootShadowNode) const override;
 
-  ShadowNode::Shared createNode(
+  std::shared_ptr<ShadowNode> createNode(
       Tag tag,
       const std::string& componentName,
       SurfaceId surfaceId,
-      const RawProps& props,
-      const InstanceHandle::Shared& instanceHandle) const;
+      RawProps props,
+      InstanceHandle::Shared instanceHandle) const;
 
-  ShadowNode::Shared cloneNode(
+  std::shared_ptr<ShadowNode> cloneNode(
       const ShadowNode& shadowNode,
-      const ShadowNode::SharedListOfShared& children = nullptr,
-      const RawProps* rawProps = nullptr) const;
+      const ShadowNode::SharedListOfShared& children,
+      RawProps rawProps) const;
 
   void appendChild(
       const ShadowNode::Shared& parentShadowNode,
@@ -183,7 +186,7 @@ class UIManager final : public ShadowTreeDelegate {
 
   void setNativeProps_DEPRECATED(
       const ShadowNode::Shared& shadowNode,
-      const RawProps& rawProps) const;
+      RawProps rawProps) const;
 
   void sendAccessibilityEvent(
       const ShadowNode::Shared& shadowNode,

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

@@ -36,14 +36,6 @@ class UIManagerAnimationDelegate {
   virtual void setComponentDescriptorRegistry(
       const SharedComponentDescriptorRegistry& componentDescriptorRegistry) = 0;
 
-  /**
-   * Set Animation flags for dropping delete and create mutations
-   *
-   * @param reduceDeleteCreateMutation
-   */
-  virtual void setReduceDeleteCreateMutation(
-      bool reduceDeleteCreateMutation) = 0;
-
   /**
    * Only needed on Android to drive animations.
    */

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

@@ -12,7 +12,6 @@
 #include <react/debug/react_native_assert.h>
 #include <react/renderer/components/view/PointerEvent.h>
 #include <react/renderer/core/LayoutableShadowNode.h>
-#include <react/renderer/core/TraitCast.h>
 #include <react/renderer/debug/SystraceSection.h>
 #include <react/renderer/runtimescheduler/RuntimeSchedulerBinding.h>
 #include <react/renderer/uimanager/primitives.h>
@@ -99,23 +98,30 @@ void UIManagerBinding::dispatchEvent(
 
   if (eventPayload.getType() == EventPayloadType::PointerEvent) {
     auto pointerEvent = static_cast<const PointerEvent&>(eventPayload);
-    auto dispatchCallback = [this](
-                                jsi::Runtime& runtime,
-                                const EventTarget* eventTarget,
+    auto dispatchCallback = [this, &runtime](
+                                const ShadowNode& targetNode,
                                 const std::string& type,
                                 ReactEventPriority priority,
                                 const EventPayload& eventPayload) {
-      this->dispatchEventToJS(
-          runtime, eventTarget, type, priority, eventPayload);
+      auto eventTarget = targetNode.getEventEmitter()->getEventTarget();
+      if (eventTarget != nullptr) {
+        eventTarget->retain(runtime);
+        this->dispatchEventToJS(
+            runtime, eventTarget.get(), type, priority, eventPayload);
+        eventTarget->release(runtime);
+      }
     };
-    pointerEventsProcessor_.interceptPointerEvent(
-        runtime,
-        eventTarget,
-        type,
-        priority,
-        pointerEvent,
-        dispatchCallback,
-        *uiManager_);
+    auto targetNode = PointerEventsProcessor::getShadowNodeFromEventTarget(
+        runtime, eventTarget);
+    if (targetNode != nullptr) {
+      pointerEventsProcessor_.interceptPointerEvent(
+          targetNode,
+          type,
+          priority,
+          pointerEvent,
+          dispatchCallback,
+          *uiManager_);
+    }
   } else {
     dispatchEventToJS(runtime, eventTarget, type, priority, eventPayload);
   }
@@ -155,15 +161,14 @@ void UIManagerBinding::dispatchEventToJS(
     LOG(WARNING) << "instanceHandle is null, event will be dropped";
   }
 
-  auto& eventHandlerWrapper =
-      static_cast<const EventHandlerWrapper&>(*eventHandler_);
-
   currentEventPriority_ = priority;
-  eventHandlerWrapper.callback.call(
-      runtime,
-      {std::move(instanceHandle),
-       jsi::String::createFromUtf8(runtime, type),
-       std::move(payload)});
+  if (eventHandler_) {
+    eventHandler_->call(
+        runtime,
+        std::move(instanceHandle),
+        jsi::String::createFromUtf8(runtime, type),
+        std::move(payload));
+  }
   currentEventPriority_ = ReactEventPriority::Default;
 }
 
@@ -231,23 +236,27 @@ jsi::Value UIManagerBinding::get(
             const jsi::Value& /*thisValue*/,
             const jsi::Value* arguments,
             size_t count) -> jsi::Value {
-          validateArgumentCount(runtime, methodName, paramCount, count);
+          try {
+            validateArgumentCount(runtime, methodName, paramCount, count);
+
+            auto instanceHandle =
+                instanceHandleFromValue(runtime, arguments[4], arguments[0]);
+            if (!instanceHandle) {
+              react_native_assert(false);
+              return jsi::Value::undefined();
+            }
 
-          auto instanceHandle =
-              instanceHandleFromValue(runtime, arguments[4], arguments[0]);
-          if (!instanceHandle) {
-            react_native_assert(false);
-            return jsi::Value::undefined();
+            return valueFromShadowNode(
+                runtime,
+                uiManager->createNode(
+                    tagFromValue(arguments[0]),
+                    stringFromValue(runtime, arguments[1]),
+                    surfaceIdFromValue(runtime, arguments[2]),
+                    RawProps(runtime, arguments[3]),
+                    std::move(instanceHandle)));
+          } catch (const std::logic_error& ex) {
+            LOG(FATAL) << "logic_error in createNode: " << ex.what();
           }
-
-          return valueFromShadowNode(
-              runtime,
-              uiManager->createNode(
-                  tagFromValue(arguments[0]),
-                  stringFromValue(runtime, arguments[1]),
-                  surfaceIdFromValue(runtime, arguments[2]),
-                  RawProps(runtime, arguments[3]),
-                  instanceHandle));
         });
   }
 
@@ -268,7 +277,9 @@ jsi::Value UIManagerBinding::get(
           return valueFromShadowNode(
               runtime,
               uiManager->cloneNode(
-                  *shadowNodeFromValue(runtime, arguments[0])));
+                  *shadowNodeFromValue(runtime, arguments[0]),
+                  nullptr,
+                  RawProps()));
         });
   }
 
@@ -314,6 +325,12 @@ jsi::Value UIManagerBinding::get(
               arguments[3].getObject(runtime).getFunction(runtime);
           auto targetNode =
               uiManager->findNodeAtPoint(node, Point{locationX, locationY});
+
+          if (!targetNode) {
+            onSuccessFunction.call(runtime, jsi::Value::null());
+            return jsi::Value::undefined();
+          }
+
           auto& eventTarget = targetNode->getEventEmitter()->eventTarget_;
 
           EventEmitter::DispatchMutex().lock();
@@ -327,25 +344,29 @@ jsi::Value UIManagerBinding::get(
         });
   }
 
-  // Semantic: Clones the node with *same* props and *empty* children.
+  // Semantic: Clones the node with *same* props and *given* children.
   if (methodName == "cloneNodeWithNewChildren") {
-    auto paramCount = 1;
+    auto paramCount = 2;
     return jsi::Function::createFromHostFunction(
         runtime,
         name,
         paramCount,
-        [uiManager, methodName, paramCount](
+        [uiManager, methodName](
             jsi::Runtime& runtime,
             const jsi::Value& /*thisValue*/,
             const jsi::Value* arguments,
             size_t count) -> jsi::Value {
-          validateArgumentCount(runtime, methodName, paramCount, count);
+          // TODO: re-enable when passChildrenWhenCloningPersistedNodes is
+          // rolled out
+          // validateArgumentCount(runtime, methodName, paramCount, count);
 
           return valueFromShadowNode(
               runtime,
               uiManager->cloneNode(
                   *shadowNodeFromValue(runtime, arguments[0]),
-                  ShadowNode::emptySharedShadowNodeSharedList()));
+                  count > 1 ? shadowNodeListFromValue(runtime, arguments[1])
+                            : ShadowNode::emptySharedShadowNodeSharedList(),
+                  RawProps()));
         });
   }
 
@@ -363,37 +384,40 @@ jsi::Value UIManagerBinding::get(
             size_t count) -> jsi::Value {
           validateArgumentCount(runtime, methodName, paramCount, count);
 
-          const auto& rawProps = RawProps(runtime, arguments[1]);
           return valueFromShadowNode(
               runtime,
               uiManager->cloneNode(
                   *shadowNodeFromValue(runtime, arguments[0]),
                   nullptr,
-                  &rawProps));
+                  RawProps(runtime, arguments[1])));
         });
   }
 
-  // Semantic: Clones the node with *given* props and *empty* children.
+  // Semantic: Clones the node with *given* props and *given* children.
   if (methodName == "cloneNodeWithNewChildrenAndProps") {
-    auto paramCount = 2;
+    auto paramCount = 3;
     return jsi::Function::createFromHostFunction(
         runtime,
         name,
         paramCount,
-        [uiManager, methodName, paramCount](
+        [uiManager, methodName](
             jsi::Runtime& runtime,
             const jsi::Value& /*thisValue*/,
             const jsi::Value* arguments,
             size_t count) -> jsi::Value {
-          validateArgumentCount(runtime, methodName, paramCount, count);
+          // TODO: re-enable when passChildrenWhenCloningPersistedNodes is
+          // rolled out
+          // validateArgumentCount(runtime, methodName, paramCount, count);
 
-          const auto& rawProps = RawProps(runtime, arguments[1]);
+          bool hasChildrenArg = count == 3;
           return valueFromShadowNode(
               runtime,
               uiManager->cloneNode(
                   *shadowNodeFromValue(runtime, arguments[0]),
-                  ShadowNode::emptySharedShadowNodeSharedList(),
-                  &rawProps));
+                  hasChildrenArg
+                      ? shadowNodeListFromValue(runtime, arguments[1])
+                      : ShadowNode::emptySharedShadowNodeSharedList(),
+                  RawProps(runtime, arguments[hasChildrenArg ? 2 : 1])));
         });
   }
 
@@ -417,6 +441,7 @@ jsi::Value UIManagerBinding::get(
         });
   }
 
+  // TODO: remove when passChildrenWhenCloningPersistedNodes is rolled out
   if (methodName == "createChildSet") {
     return jsi::Function::createFromHostFunction(
         runtime,
@@ -432,6 +457,7 @@ jsi::Value UIManagerBinding::get(
         });
   }
 
+  // TODO: remove when passChildrenWhenCloningPersistedNodes is rolled out
   if (methodName == "appendChildToSet") {
     auto paramCount = 2;
     return jsi::Function::createFromHostFunction(
@@ -475,17 +501,14 @@ jsi::Value UIManagerBinding::get(
           if (!uiManager->backgroundExecutor_ ||
               (runtimeSchedulerBinding &&
                runtimeSchedulerBinding->getIsSynchronous())) {
-            auto weakShadowNodeList =
-                weakShadowNodeListFromValue(runtime, arguments[1]);
             auto shadowNodeList =
-                shadowNodeListFromWeakList(weakShadowNodeList);
-            if (shadowNodeList) {
-              uiManager->completeSurface(
-                  surfaceId,
-                  shadowNodeList,
-                  {/* .enableStateReconciliation = */ true,
-                   /* .mountSynchronously = */ false});
-            }
+                shadowNodeListFromValue(runtime, arguments[1]);
+            uiManager->completeSurface(
+                surfaceId,
+                shadowNodeList,
+                {.enableStateReconciliation = true,
+                 .mountSynchronously = false,
+                 .shouldYield = nullptr});
           } else {
             auto weakShadowNodeList =
                 weakShadowNodeListFromValue(runtime, arguments[1]);
@@ -539,7 +562,7 @@ jsi::Value UIManagerBinding::get(
           auto eventHandler =
               arguments[0].getObject(runtime).getFunction(runtime);
           eventHandler_ =
-              std::make_unique<EventHandlerWrapper>(std::move(eventHandler));
+              std::make_unique<jsi::Function>(std::move(eventHandler));
           return jsi::Value::undefined();
         });
   }
@@ -682,7 +705,7 @@ jsi::Value UIManagerBinding::get(
           auto newestCloneOfShadowNode =
               uiManager->getNewestCloneOfShadowNode(*shadowNode);
 
-          auto layoutableShadowNode = traitCast<LayoutableShadowNode const*>(
+          auto layoutableShadowNode = dynamic_cast<const LayoutableShadowNode*>(
               newestCloneOfShadowNode.get());
           Point originRelativeToParent = layoutableShadowNode != nullptr
               ? layoutableShadowNode->getLayoutMetrics().frame.origin
@@ -1097,52 +1120,52 @@ jsi::Value UIManagerBinding::get(
 
           auto newestCloneOfShadowNode =
               uiManager->getNewestCloneOfShadowNode(*shadowNode);
-          auto newestParentOfShadowNode =
-              uiManager->getNewestParentOfShadowNode(*shadowNode);
+          auto newestPositionedAncestorOfShadowNode =
+              uiManager->getNewestPositionedAncestorOfShadowNode(*shadowNode);
           // The node is no longer part of an active shadow tree, or it is the
           // root node
           if (newestCloneOfShadowNode == nullptr ||
-              newestParentOfShadowNode == nullptr) {
+              newestPositionedAncestorOfShadowNode == nullptr) {
             return jsi::Value::undefined();
           }
 
           // If the node is not displayed (itself or any of its ancestors has
           // "display: none"), this returns an empty layout metrics object.
-          auto layoutMetrics = uiManager->getRelativeLayoutMetrics(
-              *shadowNode, nullptr, {/* .includeTransform = */ false});
-
-          if (layoutMetrics == EmptyLayoutMetrics) {
-            return jsi::Value::undefined();
-          }
-
-          auto layoutableShadowNode = traitCast<LayoutableShadowNode const*>(
-              newestCloneOfShadowNode.get());
-          // This should never happen
-          if (layoutableShadowNode == nullptr) {
+          auto shadowNodeLayoutMetricsRelativeToRoot =
+              uiManager->getRelativeLayoutMetrics(
+                  *shadowNode, nullptr, {/* .includeTransform = */ false});
+          if (shadowNodeLayoutMetricsRelativeToRoot == EmptyLayoutMetrics) {
             return jsi::Value::undefined();
           }
 
-          auto layoutableParentShadowNode =
-              traitCast<LayoutableShadowNode const*>(
-                  newestParentOfShadowNode.get());
-          // This should never happen
-          if (layoutableParentShadowNode == nullptr) {
+          auto positionedAncestorLayoutMetricsRelativeToRoot =
+              uiManager->getRelativeLayoutMetrics(
+                  *newestPositionedAncestorOfShadowNode,
+                  nullptr,
+                  {/* .includeTransform = */ false});
+          if (positionedAncestorLayoutMetricsRelativeToRoot ==
+              EmptyLayoutMetrics) {
             return jsi::Value::undefined();
           }
 
-          auto originRelativeToParentOuterBorder =
-              layoutableShadowNode->getLayoutMetrics().frame.origin;
+          auto shadowNodeOriginRelativeToRoot =
+              shadowNodeLayoutMetricsRelativeToRoot.frame.origin;
+          auto positionedAncestorOriginRelativeToRoot =
+              positionedAncestorLayoutMetricsRelativeToRoot.frame.origin;
 
           // On the Web, offsets are computed from the inner border of the
           // parent.
-          auto offsetTop = originRelativeToParentOuterBorder.y -
-              layoutableParentShadowNode->getLayoutMetrics().borderWidth.top;
-          auto offsetLeft = originRelativeToParentOuterBorder.x -
-              layoutableParentShadowNode->getLayoutMetrics().borderWidth.left;
+          auto offsetTop = shadowNodeOriginRelativeToRoot.y -
+              positionedAncestorOriginRelativeToRoot.y -
+              positionedAncestorLayoutMetricsRelativeToRoot.borderWidth.top;
+          auto offsetLeft = shadowNodeOriginRelativeToRoot.x -
+              positionedAncestorOriginRelativeToRoot.x -
+              positionedAncestorLayoutMetricsRelativeToRoot.borderWidth.left;
 
           return jsi::Array::createWithElements(
               runtime,
-              (*newestParentOfShadowNode).getInstanceHandle(runtime),
+              (*newestPositionedAncestorOfShadowNode)
+                  .getInstanceHandle(runtime),
               jsi::Value{runtime, (double)offsetTop},
               jsi::Value{runtime, (double)offsetLeft});
         });
@@ -1197,7 +1220,7 @@ jsi::Value UIManagerBinding::get(
             return jsi::Value::undefined();
           }
 
-          auto layoutableShadowNode = traitCast<LayoutableShadowNode const*>(
+          auto layoutableShadowNode = dynamic_cast<LayoutableShadowNode const*>(
               newestCloneOfShadowNode.get());
           // This should never happen
           if (layoutableShadowNode == nullptr) {
@@ -1268,7 +1291,7 @@ jsi::Value UIManagerBinding::get(
           }
 
           auto layoutableShadowNode =
-              traitCast<YogaLayoutableShadowNode const*>(
+              dynamic_cast<YogaLayoutableShadowNode const*>(
                   newestCloneOfShadowNode.get());
           // This should never happen
           if (layoutableShadowNode == nullptr) {

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

@@ -84,7 +84,7 @@ class UIManagerBinding : public jsi::HostObject {
       const EventPayload& payload) const;
 
   std::shared_ptr<UIManager> uiManager_;
-  std::unique_ptr<const EventHandler> eventHandler_;
+  std::unique_ptr<jsi::Function> eventHandler_;
   mutable PointerEventsProcessor pointerEventsProcessor_;
   mutable ReactEventPriority currentEventPriority_;
 };