react-native-windows 0.72.14 → 0.73.0-preview.1

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

@@ -0,0 +1,1509 @@
+/*
+ * 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 "UIManagerBinding.h"
+
+#include <glog/logging.h>
+#include <jsi/JSIDynamic.h>
+#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>
+
+#include <utility>
+
+#include "bindingUtils.h"
+
+namespace facebook::react {
+
+void UIManagerBinding::createAndInstallIfNeeded(
+    jsi::Runtime& runtime,
+    const std::shared_ptr<UIManager>& uiManager) {
+  auto uiManagerModuleName = "nativeFabricUIManager";
+
+  auto uiManagerValue =
+      runtime.global().getProperty(runtime, uiManagerModuleName);
+  if (uiManagerValue.isUndefined()) {
+    // The global namespace does not have an instance of the binding;
+    // we need to create, install and return it.
+    auto uiManagerBinding = std::make_shared<UIManagerBinding>(uiManager);
+    auto object = jsi::Object::createFromHostObject(runtime, uiManagerBinding);
+    runtime.global().setProperty(
+        runtime, uiManagerModuleName, std::move(object));
+  }
+}
+
+std::shared_ptr<UIManagerBinding> UIManagerBinding::getBinding(
+    jsi::Runtime& runtime) {
+  auto uiManagerModuleName = "nativeFabricUIManager";
+
+  auto uiManagerValue =
+      runtime.global().getProperty(runtime, uiManagerModuleName);
+  if (uiManagerValue.isUndefined()) {
+    return nullptr;
+  }
+
+  auto uiManagerObject = uiManagerValue.asObject(runtime);
+  return uiManagerObject.getHostObject<UIManagerBinding>(runtime);
+}
+
+UIManagerBinding::UIManagerBinding(std::shared_ptr<UIManager> uiManager)
+    : uiManager_(std::move(uiManager)) {}
+
+UIManagerBinding::~UIManagerBinding() {
+  LOG(WARNING) << "UIManagerBinding::~UIManagerBinding() was called (address: "
+               << this << ").";
+}
+
+jsi::Value UIManagerBinding::getInspectorDataForInstance(
+    jsi::Runtime& runtime,
+    const EventEmitter& eventEmitter) const {
+  auto eventTarget = eventEmitter.eventTarget_;
+  EventEmitter::DispatchMutex().lock();
+
+  if (!runtime.global().hasProperty(runtime, "__fbBatchedBridge") ||
+      !eventTarget) {
+    return jsi::Value::undefined();
+  }
+
+  eventTarget->retain(runtime);
+  auto instanceHandle = eventTarget->getInstanceHandle(runtime);
+  eventTarget->release(runtime);
+  EventEmitter::DispatchMutex().unlock();
+
+  if (instanceHandle.isUndefined()) {
+    return jsi::Value::undefined();
+  }
+
+  return callMethodOfModule(
+      runtime,
+      "ReactFabric",
+      "getInspectorDataForInstance",
+      {std::move(instanceHandle)});
+}
+
+void UIManagerBinding::dispatchEvent(
+    jsi::Runtime& runtime,
+    const EventTarget* eventTarget,
+    const std::string& type,
+    ReactEventPriority priority,
+    const EventPayload& eventPayload) const {
+  SystraceSection s("UIManagerBinding::dispatchEvent", "type", type);
+
+  if (eventPayload.getType() == EventPayloadType::PointerEvent) {
+    auto pointerEvent = static_cast<const PointerEvent&>(eventPayload);
+    auto dispatchCallback = [this](
+                                jsi::Runtime& runtime,
+                                const EventTarget* eventTarget,
+                                const std::string& type,
+                                ReactEventPriority priority,
+                                const EventPayload& eventPayload) {
+      this->dispatchEventToJS(
+          runtime, eventTarget, type, priority, eventPayload);
+    };
+    pointerEventsProcessor_.interceptPointerEvent(
+        runtime,
+        eventTarget,
+        type,
+        priority,
+        pointerEvent,
+        dispatchCallback,
+        *uiManager_);
+  } else {
+    dispatchEventToJS(runtime, eventTarget, type, priority, eventPayload);
+  }
+}
+
+void UIManagerBinding::dispatchEventToJS(
+    jsi::Runtime& runtime,
+    const EventTarget* eventTarget,
+    const std::string& type,
+    ReactEventPriority priority,
+    const EventPayload& eventPayload) const {
+  auto payload = eventPayload.asJSIValue(runtime);
+
+  // If a payload is null, the factory has decided to cancel the event
+  if (payload.isNull()) {
+    return;
+  }
+
+  auto instanceHandle = eventTarget != nullptr
+    ? [&]() {
+      auto instanceHandle = eventTarget->getInstanceHandle(runtime);
+      if (instanceHandle.isUndefined()) {
+        return jsi::Value::null();
+      }
+
+      // Mixing `target` into `payload`.
+      if (!payload.isObject()) {
+        LOG(ERROR) << "payload for dispatchEvent is not an object: " << eventTarget->getTag();
+      }
+      react_native_assert(payload.isObject());
+      payload.asObject(runtime).setProperty(runtime, "target", eventTarget->getTag());
+      return instanceHandle;
+    }()
+    : jsi::Value::null();
+
+  if (instanceHandle.isNull()) {
+    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)});
+  currentEventPriority_ = ReactEventPriority::Default;
+}
+
+void UIManagerBinding::invalidate() const {
+  uiManager_->setDelegate(nullptr);
+}
+
+static void validateArgumentCount(
+    jsi::Runtime& runtime,
+    const std::string& methodName,
+    size_t expected,
+    size_t actual) {
+  if (actual < expected) {
+    throw jsi::JSError(
+        runtime,
+        methodName + " requires " + std::to_string(expected) +
+            " arguments, but only " + std::to_string(actual) + " were passed");
+  }
+}
+
+jsi::Value UIManagerBinding::get(
+    jsi::Runtime& runtime,
+    const jsi::PropNameID& name) {
+  auto methodName = name.utf8(runtime);
+  SystraceSection s("UIManagerBinding::get", "name", methodName);
+
+  // Convert shared_ptr<UIManager> to a raw ptr
+  // Why? Because:
+  // 1) UIManagerBinding strongly retains UIManager. The JS VM
+  //    strongly retains UIManagerBinding (through the JSI).
+  //    These functions are JSI functions and are only called via
+  //    the JS VM; if the JS VM is torn down, those functions can't
+  //    execute and these lambdas won't execute.
+  // 2) The UIManager is only deallocated when all references to it
+  //    are deallocated, including the UIManagerBinding. That only
+  //    happens when the JS VM is deallocated. So, the raw pointer
+  //    is safe.
+  //
+  // Even if it's safe, why not just use shared_ptr anyway as
+  //  extra insurance?
+  // 1) Using shared_ptr or weak_ptr when they're not needed is
+  //    a pessimisation. It's more instructions executed without
+  //    any additional value in this case.
+  // 2) How and when exactly these lambdas is deallocated is
+  //    complex. Adding shared_ptr to them which causes the UIManager
+  //    to potentially live longer is unnecessary, complicated cognitive
+  //    overhead.
+  // 3) There is a strong suspicion that retaining UIManager from
+  //    these C++ lambdas, which are retained by an object that is held onto
+  //    by the JSI, caused some crashes upon deallocation of the
+  //    Scheduler and JS VM. This could happen if, for instance, C++
+  //    semantics cause these lambda to not be deallocated until
+  //    a CPU tick (or more) after the JS VM is deallocated.
+  UIManager* uiManager = uiManager_.get();
+
+  // Semantic: Creates a new node with given pieces.
+  if (methodName == "createNode") {
+    auto paramCount = 5;
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        name,
+        paramCount,
+        [uiManager, methodName, paramCount](
+            jsi::Runtime& runtime,
+            const jsi::Value& /*thisValue*/,
+            const jsi::Value* arguments,
+            size_t count) -> jsi::Value {
+          validateArgumentCount(runtime, methodName, paramCount, count);
+
+          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]),
+                  instanceHandle));
+        });
+  }
+
+  // Semantic: Clones the node with *same* props and *same* children.
+  if (methodName == "cloneNode") {
+    auto paramCount = 1;
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        name,
+        paramCount,
+        [uiManager, methodName, paramCount](
+            jsi::Runtime& runtime,
+            const jsi::Value& /*thisValue*/,
+            const jsi::Value* arguments,
+            size_t count) -> jsi::Value {
+          validateArgumentCount(runtime, methodName, paramCount, count);
+
+          return valueFromShadowNode(
+              runtime,
+              uiManager->cloneNode(
+                  *shadowNodeFromValue(runtime, arguments[0])));
+        });
+  }
+
+  if (methodName == "setIsJSResponder") {
+    auto paramCount = 3;
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        name,
+        paramCount,
+        [uiManager, methodName, paramCount](
+            jsi::Runtime& runtime,
+            const jsi::Value& /*thisValue*/,
+            const jsi::Value* arguments,
+            size_t count) -> jsi::Value {
+          validateArgumentCount(runtime, methodName, paramCount, count);
+
+          uiManager->setIsJSResponder(
+              shadowNodeFromValue(runtime, arguments[0]),
+              arguments[1].getBool(),
+              arguments[2].getBool());
+
+          return jsi::Value::undefined();
+        });
+  }
+
+  if (methodName == "findNodeAtPoint") {
+    auto paramCount = 4;
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        name,
+        paramCount,
+        [uiManager, methodName, paramCount](
+            jsi::Runtime& runtime,
+            const jsi::Value& /*thisValue*/,
+            const jsi::Value* arguments,
+            size_t count) {
+          validateArgumentCount(runtime, methodName, paramCount, count);
+
+          auto node = shadowNodeFromValue(runtime, arguments[0]);
+          auto locationX = (Float)arguments[1].getNumber();
+          auto locationY = (Float)arguments[2].getNumber();
+          auto onSuccessFunction =
+              arguments[3].getObject(runtime).getFunction(runtime);
+          auto targetNode =
+              uiManager->findNodeAtPoint(node, Point{locationX, locationY});
+          auto& eventTarget = targetNode->getEventEmitter()->eventTarget_;
+
+          EventEmitter::DispatchMutex().lock();
+          eventTarget->retain(runtime);
+          auto instanceHandle = eventTarget->getInstanceHandle(runtime);
+          eventTarget->release(runtime);
+          EventEmitter::DispatchMutex().unlock();
+
+          onSuccessFunction.call(runtime, std::move(instanceHandle));
+          return jsi::Value::undefined();
+        });
+  }
+
+  // Semantic: Clones the node with *same* props and *empty* children.
+  if (methodName == "cloneNodeWithNewChildren") {
+    auto paramCount = 1;
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        name,
+        paramCount,
+        [uiManager, methodName, paramCount](
+            jsi::Runtime& runtime,
+            const jsi::Value& /*thisValue*/,
+            const jsi::Value* arguments,
+            size_t count) -> jsi::Value {
+          validateArgumentCount(runtime, methodName, paramCount, count);
+
+          return valueFromShadowNode(
+              runtime,
+              uiManager->cloneNode(
+                  *shadowNodeFromValue(runtime, arguments[0]),
+                  ShadowNode::emptySharedShadowNodeSharedList()));
+        });
+  }
+
+  // Semantic: Clones the node with *given* props and *same* children.
+  if (methodName == "cloneNodeWithNewProps") {
+    auto paramCount = 2;
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        name,
+        paramCount,
+        [uiManager, methodName, paramCount](
+            jsi::Runtime& runtime,
+            const jsi::Value& /*thisValue*/,
+            const jsi::Value* arguments,
+            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));
+        });
+  }
+
+  // Semantic: Clones the node with *given* props and *empty* children.
+  if (methodName == "cloneNodeWithNewChildrenAndProps") {
+    auto paramCount = 2;
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        name,
+        paramCount,
+        [uiManager, methodName, paramCount](
+            jsi::Runtime& runtime,
+            const jsi::Value& /*thisValue*/,
+            const jsi::Value* arguments,
+            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]),
+                  ShadowNode::emptySharedShadowNodeSharedList(),
+                  &rawProps));
+        });
+  }
+
+  if (methodName == "appendChild") {
+    auto paramCount = 2;
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        name,
+        paramCount,
+        [uiManager, methodName, paramCount](
+            jsi::Runtime& runtime,
+            const jsi::Value& /*thisValue*/,
+            const jsi::Value* arguments,
+            size_t count) -> jsi::Value {
+          validateArgumentCount(runtime, methodName, paramCount, count);
+
+          uiManager->appendChild(
+              shadowNodeFromValue(runtime, arguments[0]),
+              shadowNodeFromValue(runtime, arguments[1]));
+          return jsi::Value::undefined();
+        });
+  }
+
+  if (methodName == "createChildSet") {
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        name,
+        0,
+        [](jsi::Runtime& runtime,
+           const jsi::Value& /*thisValue*/,
+           const jsi::Value* /*arguments*/,
+           size_t /*count*/) -> jsi::Value {
+          auto shadowNodeList = std::make_shared<ShadowNode::ListOfShared>(
+              ShadowNode::ListOfShared({}));
+          return valueFromShadowNodeList(runtime, shadowNodeList);
+        });
+  }
+
+  if (methodName == "appendChildToSet") {
+    auto paramCount = 2;
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        name,
+        paramCount,
+        [methodName, paramCount](
+            jsi::Runtime& runtime,
+            const jsi::Value& /*thisValue*/,
+            const jsi::Value* arguments,
+            size_t count) -> jsi::Value {
+          validateArgumentCount(runtime, methodName, paramCount, count);
+
+          auto shadowNodeList = shadowNodeListFromValue(runtime, arguments[0]);
+          auto shadowNode = shadowNodeFromValue(runtime, arguments[1]);
+          shadowNodeList->push_back(shadowNode);
+          return jsi::Value::undefined();
+        });
+  }
+
+  if (methodName == "completeRoot") {
+    auto paramCount = 2;
+    std::weak_ptr<UIManager> weakUIManager = uiManager_;
+    // Enhanced version of the method that uses `backgroundExecutor` and
+    // captures a shared pointer to `UIManager`.
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        name,
+        paramCount,
+        [weakUIManager, uiManager, methodName, paramCount](
+            jsi::Runtime& runtime,
+            const jsi::Value& /*thisValue*/,
+            const jsi::Value* arguments,
+            size_t count) -> jsi::Value {
+          validateArgumentCount(runtime, methodName, paramCount, count);
+
+          auto runtimeSchedulerBinding =
+              RuntimeSchedulerBinding::getBinding(runtime);
+          auto surfaceId = surfaceIdFromValue(runtime, arguments[0]);
+          ShadowTree::CommitOptions options = {/* .enableStateReconciliation = */ true, /* .mountSynchronously = */ false};
+
+          if (!uiManager->backgroundExecutor_ ||
+              (runtimeSchedulerBinding &&
+               runtimeSchedulerBinding->getIsSynchronous())) {
+            auto weakShadowNodeList =
+                weakShadowNodeListFromValue(runtime, arguments[1]);
+            auto shadowNodeList =
+                shadowNodeListFromWeakList(weakShadowNodeList);
+            if (shadowNodeList) {
+              uiManager->completeSurface(
+                  surfaceId,
+                  shadowNodeList,
+                  options);
+            }
+          } else {
+            auto weakShadowNodeList =
+                weakShadowNodeListFromValue(runtime, arguments[1]);
+            static std::atomic_uint_fast8_t completeRootEventCounter{0};
+            static std::atomic_uint_fast32_t mostRecentSurfaceId{0};
+            completeRootEventCounter += 1;
+            mostRecentSurfaceId = surfaceId;
+            uiManager->backgroundExecutor_(
+                [weakUIManager,
+                 weakShadowNodeList,
+                 surfaceId,
+                 eventCount = completeRootEventCounter.load()] {
+                  auto shouldYield = [=]() -> bool {
+                    // If `completeRootEventCounter` was incremented, another
+                    // `completeSurface` call has been scheduled and current
+                    // `completeSurface` should yield to it.
+                    return completeRootEventCounter > eventCount &&
+                        mostRecentSurfaceId == surfaceId;
+                  };
+                  auto shadowNodeList =
+                      shadowNodeListFromWeakList(weakShadowNodeList);
+                  auto strongUIManager = weakUIManager.lock();
+                  ShadowTree::CommitOptions options = {/* .enableStateReconciliation = */ true, /* .mountSynchronously = */ false, /* .shouldYield = */ shouldYield};
+                  if (shadowNodeList && strongUIManager) {
+                    strongUIManager->completeSurface(
+                        surfaceId,
+                        shadowNodeList,
+                        options);
+                  }
+                });
+          }
+
+          return jsi::Value::undefined();
+        });
+  }
+
+  if (methodName == "registerEventHandler") {
+    auto paramCount = 1;
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        name,
+        paramCount,
+        [this, methodName, paramCount](
+            jsi::Runtime& runtime,
+            const jsi::Value& /*thisValue*/,
+            const jsi::Value* arguments,
+            size_t count) -> jsi::Value {
+          validateArgumentCount(runtime, methodName, paramCount, count);
+
+          auto eventHandler =
+              arguments[0].getObject(runtime).getFunction(runtime);
+          eventHandler_ =
+              std::make_unique<EventHandlerWrapper>(std::move(eventHandler));
+          return jsi::Value::undefined();
+        });
+  }
+
+  if (methodName == "getRelativeLayoutMetrics") {
+    auto paramCount = 2;
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        name,
+        paramCount,
+        [uiManager, methodName, paramCount](
+            jsi::Runtime& runtime,
+            const jsi::Value& /*thisValue*/,
+            const jsi::Value* arguments,
+            size_t count) -> jsi::Value {
+          validateArgumentCount(runtime, methodName, paramCount, count);
+          LayoutableShadowNode::LayoutInspectingPolicy policy = {/* .includeTransform = */ true};
+
+          auto layoutMetrics = uiManager->getRelativeLayoutMetrics(
+              *shadowNodeFromValue(runtime, arguments[0]),
+              shadowNodeFromValue(runtime, arguments[1]).get(),
+              policy);
+          auto frame = layoutMetrics.frame;
+          auto result = jsi::Object(runtime);
+          result.setProperty(runtime, "left", frame.origin.x);
+          result.setProperty(runtime, "top", frame.origin.y);
+          result.setProperty(runtime, "width", frame.size.width);
+          result.setProperty(runtime, "height", frame.size.height);
+          return result;
+        });
+  }
+
+  if (methodName == "dispatchCommand") {
+    auto paramCount = 3;
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        name,
+        paramCount,
+        [uiManager, methodName, paramCount](
+            jsi::Runtime& runtime,
+            const jsi::Value& /*thisValue*/,
+            const jsi::Value* arguments,
+            size_t count) -> jsi::Value {
+          validateArgumentCount(runtime, methodName, paramCount, count);
+
+          auto shadowNode = shadowNodeFromValue(runtime, arguments[0]);
+          if (shadowNode) {
+            uiManager->dispatchCommand(
+                shadowNode,
+                stringFromValue(runtime, arguments[1]),
+                commandArgsFromValue(runtime, arguments[2]));
+          }
+          return jsi::Value::undefined();
+        });
+  }
+
+  if (methodName == "setNativeProps") {
+    auto paramCount = 2;
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        name,
+        paramCount,
+        [uiManager, methodName, paramCount](
+            jsi::Runtime& runtime,
+            const jsi::Value&,
+            const jsi::Value* arguments,
+            size_t count) -> jsi::Value {
+          validateArgumentCount(runtime, methodName, paramCount, count);
+
+          uiManager->setNativeProps_DEPRECATED(
+              shadowNodeFromValue(runtime, arguments[0]),
+              RawProps(runtime, arguments[1]));
+
+          return jsi::Value::undefined();
+        });
+  }
+
+  // Legacy API
+  if (methodName == "measureLayout") {
+    auto paramCount = 4;
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        name,
+        paramCount,
+        [uiManager, methodName, paramCount](
+            jsi::Runtime& runtime,
+            const jsi::Value& /*thisValue*/,
+            const jsi::Value* arguments,
+            size_t count) {
+          validateArgumentCount(runtime, methodName, paramCount, count);
+
+          LayoutableShadowNode::LayoutInspectingPolicy policy = {/* .includeTransform = */ false};
+
+          auto layoutMetrics = uiManager->getRelativeLayoutMetrics(
+              *shadowNodeFromValue(runtime, arguments[0]),
+              shadowNodeFromValue(runtime, arguments[1]).get(),
+              policy);
+
+          if (layoutMetrics == EmptyLayoutMetrics) {
+            auto onFailFunction =
+                arguments[2].getObject(runtime).getFunction(runtime);
+            onFailFunction.call(runtime);
+            return jsi::Value::undefined();
+          }
+
+          auto onSuccessFunction =
+              arguments[3].getObject(runtime).getFunction(runtime);
+          auto frame = layoutMetrics.frame;
+
+          onSuccessFunction.call(
+              runtime,
+              {jsi::Value{runtime, (double)frame.origin.x},
+               jsi::Value{runtime, (double)frame.origin.y},
+               jsi::Value{runtime, (double)frame.size.width},
+               jsi::Value{runtime, (double)frame.size.height}});
+          return jsi::Value::undefined();
+        });
+  }
+
+  if (methodName == "measure") {
+    auto paramCount = 2;
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        name,
+        paramCount,
+        [uiManager, methodName, paramCount](
+            jsi::Runtime& runtime,
+            const jsi::Value& /*thisValue*/,
+            const jsi::Value* arguments,
+            size_t count) {
+          validateArgumentCount(runtime, methodName, paramCount, count);
+
+          LayoutableShadowNode::LayoutInspectingPolicy policy = {/* .includeTransform = */ false};
+
+          auto shadowNode = shadowNodeFromValue(runtime, arguments[0]);
+          auto layoutMetrics = uiManager->getRelativeLayoutMetrics(
+              *shadowNode, nullptr, policy);
+          auto onSuccessFunction =
+              arguments[1].getObject(runtime).getFunction(runtime);
+
+          if (layoutMetrics == EmptyLayoutMetrics) {
+            onSuccessFunction.call(runtime, {0, 0, 0, 0, 0, 0});
+            return jsi::Value::undefined();
+          }
+          auto newestCloneOfShadowNode =
+              uiManager->getNewestCloneOfShadowNode(*shadowNode);
+
+          auto layoutableShadowNode = traitCast<LayoutableShadowNode const*>(
+              newestCloneOfShadowNode.get());
+          Point originRelativeToParent = layoutableShadowNode != nullptr
+              ? layoutableShadowNode->getLayoutMetrics().frame.origin
+              : Point();
+
+          auto frame = layoutMetrics.frame;
+          onSuccessFunction.call(
+              runtime,
+              {jsi::Value{runtime, (double)originRelativeToParent.x},
+               jsi::Value{runtime, (double)originRelativeToParent.y},
+               jsi::Value{runtime, (double)frame.size.width},
+               jsi::Value{runtime, (double)frame.size.height},
+               jsi::Value{runtime, (double)frame.origin.x},
+               jsi::Value{runtime, (double)frame.origin.y}});
+          return jsi::Value::undefined();
+        });
+  }
+
+  if (methodName == "measureInWindow") {
+    auto paramCount = 2;
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        name,
+        paramCount,
+        [uiManager, methodName, paramCount](
+            jsi::Runtime& runtime,
+            const jsi::Value& /*thisValue*/,
+            const jsi::Value* arguments,
+            size_t count) {
+          validateArgumentCount(runtime, methodName, paramCount, count);
+
+          LayoutableShadowNode::LayoutInspectingPolicy policy = {/* .includeTransform = */ false, /* .includeViewportOffset = */ true};
+
+          auto layoutMetrics = uiManager->getRelativeLayoutMetrics(
+              *shadowNodeFromValue(runtime, arguments[0]),
+              nullptr,
+              policy);
+
+          auto onSuccessFunction =
+              arguments[1].getObject(runtime).getFunction(runtime);
+
+          if (layoutMetrics == EmptyLayoutMetrics) {
+            onSuccessFunction.call(runtime, {0, 0, 0, 0});
+            return jsi::Value::undefined();
+          }
+
+          auto frame = layoutMetrics.frame;
+          onSuccessFunction.call(
+              runtime,
+              {jsi::Value{runtime, (double)frame.origin.x},
+               jsi::Value{runtime, (double)frame.origin.y},
+               jsi::Value{runtime, (double)frame.size.width},
+               jsi::Value{runtime, (double)frame.size.height}});
+          return jsi::Value::undefined();
+        });
+  }
+
+  if (methodName == "sendAccessibilityEvent") {
+    auto paramCount = 2;
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        name,
+        paramCount,
+        [uiManager, methodName, paramCount](
+            jsi::Runtime& runtime,
+            const jsi::Value& /*thisValue*/,
+            const jsi::Value* arguments,
+            size_t count) -> jsi::Value {
+          validateArgumentCount(runtime, methodName, paramCount, count);
+
+          uiManager->sendAccessibilityEvent(
+              shadowNodeFromValue(runtime, arguments[0]),
+              stringFromValue(runtime, arguments[1]));
+
+          return jsi::Value::undefined();
+        });
+  }
+
+  if (methodName == "configureNextLayoutAnimation") {
+    auto paramCount = 3;
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        name,
+        paramCount,
+        [uiManager, methodName, paramCount](
+            jsi::Runtime& runtime,
+            const jsi::Value& /*thisValue*/,
+            const jsi::Value* arguments,
+            size_t count) -> jsi::Value {
+          validateArgumentCount(runtime, methodName, paramCount, count);
+
+          uiManager->configureNextLayoutAnimation(
+              runtime,
+              // TODO: pass in JSI value instead of folly::dynamic to RawValue
+              RawValue(commandArgsFromValue(runtime, arguments[0])),
+              arguments[1],
+              arguments[2]);
+          return jsi::Value::undefined();
+        });
+  }
+
+  if (methodName == "unstable_getCurrentEventPriority") {
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        name,
+        0,
+        [this](
+            jsi::Runtime& /*runtime*/,
+            const jsi::Value& /*thisValue*/,
+            const jsi::Value* /*arguments*/,
+            size_t /*count*/) -> jsi::Value {
+          return {serialize(currentEventPriority_)};
+        });
+  }
+
+  if (methodName == "unstable_DefaultEventPriority") {
+    return {serialize(ReactEventPriority::Default)};
+  }
+
+  if (methodName == "unstable_DiscreteEventPriority") {
+    return {serialize(ReactEventPriority::Discrete)};
+  }
+
+  if (methodName == "findShadowNodeByTag_DEPRECATED") {
+    auto paramCount = 1;
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        name,
+        paramCount,
+        [uiManager, methodName, paramCount](
+            jsi::Runtime& runtime,
+            const jsi::Value&,
+            const jsi::Value* arguments,
+            size_t count) -> jsi::Value {
+          validateArgumentCount(runtime, methodName, paramCount, count);
+
+          auto shadowNode = uiManager->findShadowNodeByTag_DEPRECATED(
+              tagFromValue(arguments[0]));
+
+          if (!shadowNode) {
+            return jsi::Value::null();
+          }
+
+          return valueFromShadowNode(runtime, shadowNode);
+        });
+  }
+
+  /**
+   * DOM traversal and layout APIs
+   */
+
+  if (methodName == "getBoundingClientRect") {
+    // This is a React Native implementation of
+    // `Element.prototype.getBoundingClientRect` (see
+    // https://developer.mozilla.org/en-US/docs/Web/API/Element/getBoundingClientRect).
+
+    // This is similar to `measureInWindow`, except it's explicitly synchronous
+    // (returns the result instead of passing it to a callback).
+
+    // It allows indicating whether to include transforms so it can also be used
+    // to implement methods like
+    // [`offsetWidth`](https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/offsetWidth)
+    // and
+    // [`offsetHeight`](https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/offsetHeight).
+
+    // getBoundingClientRect(shadowNode: ShadowNode, includeTransform: boolean):
+    //   [
+    //     /* x: */ number,
+    //     /* y: */ number,
+    //     /* width: */ number,
+    //     /* height: */ number
+    //   ]
+    auto paramCount = 2;
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        name,
+        paramCount,
+        [uiManager, methodName, paramCount](
+            jsi::Runtime& runtime,
+            const jsi::Value& /*thisValue*/,
+            const jsi::Value* arguments,
+            size_t count) -> jsi::Value {
+          validateArgumentCount(runtime, methodName, paramCount, count);
+
+          bool includeTransform = arguments[1].getBool();
+          LayoutableShadowNode::LayoutInspectingPolicy policy = {/* .includeTransform = */ includeTransform, /* .includeViewportOffset = */ true};
+
+          auto layoutMetrics = uiManager->getRelativeLayoutMetrics(
+              *shadowNodeFromValue(runtime, arguments[0]),
+              nullptr,
+              policy);
+
+          if (layoutMetrics == EmptyLayoutMetrics) {
+            return jsi::Value::undefined();
+          }
+
+          auto frame = layoutMetrics.frame;
+          return jsi::Array::createWithElements(
+              runtime,
+              jsi::Value{runtime, (double)frame.origin.x},
+              jsi::Value{runtime, (double)frame.origin.y},
+              jsi::Value{runtime, (double)frame.size.width},
+              jsi::Value{runtime, (double)frame.size.height});
+        });
+  }
+
+  if (methodName == "getParentNode") {
+    // This is a React Native implementation of `Node.prototype.parentNode`
+    // (see https://developer.mozilla.org/en-US/docs/Web/API/Node/parentNode).
+
+    // If a version of the given shadow node is present in the current revision
+    // of an active shadow tree, it returns the instance handle of its parent.
+    // Otherwise, it returns null.
+
+    // getParent(shadowNode: ShadowNode): ?InstanceHandle
+    auto paramCount = 1;
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        name,
+        paramCount,
+        [uiManager, methodName, paramCount](
+            jsi::Runtime& runtime,
+            const jsi::Value& /*thisValue*/,
+            const jsi::Value* arguments,
+            size_t count) -> jsi::Value {
+          validateArgumentCount(runtime, methodName, paramCount, count);
+
+          auto shadowNode = shadowNodeFromValue(runtime, arguments[0]);
+          auto parentShadowNode =
+              uiManager->getNewestParentOfShadowNode(*shadowNode);
+
+          // shadowNode is a RootShadowNode
+          if (!parentShadowNode) {
+            return jsi::Value::null();
+          }
+
+          return (*parentShadowNode).getInstanceHandle(runtime);
+        });
+  }
+
+  if (methodName == "getChildNodes") {
+    // This is a React Native implementation of `Node.prototype.childNodes`
+    // (see https://developer.mozilla.org/en-US/docs/Web/API/Node/childNodes).
+
+    // If a version of the given shadow node is present in the current revision
+    // of an active shadow tree, it returns an array of instance handles of its
+    // children. Otherwise, it returns an empty array.
+
+    // getChildren(shadowNode: ShadowNode): Array<InstanceHandle>
+    auto paramCount = 1;
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        name,
+        paramCount,
+        [uiManager, methodName, paramCount](
+            jsi::Runtime& runtime,
+            const jsi::Value& /*thisValue*/,
+            const jsi::Value* arguments,
+            size_t count) -> jsi::Value {
+          validateArgumentCount(runtime, methodName, paramCount, count);
+
+          auto shadowNode = shadowNodeFromValue(runtime, arguments[0]);
+
+          auto newestCloneOfShadowNode =
+              uiManager->getNewestCloneOfShadowNode(*shadowNode);
+
+          // There's no version of this node in the current shadow tree
+          if (newestCloneOfShadowNode == nullptr) {
+            return jsi::Array(runtime, 0);
+          }
+
+          auto childShadowNodes = newestCloneOfShadowNode->getChildren();
+          return getArrayOfInstanceHandlesFromShadowNodes(
+              childShadowNodes, runtime);
+        });
+  }
+
+  if (methodName == "isConnected") {
+    // This is a React Native implementation of `Node.prototype.isConnected`
+    // (see https://developer.mozilla.org/en-US/docs/Web/API/Node/isConnected).
+
+    // Indicates whether a version of the given shadow node is present in
+    // the current revision of an active shadow tree.
+
+    // isConnected(shadowNode: ShadowNode): boolean
+    auto paramCount = 1;
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        name,
+        paramCount,
+        [uiManager, methodName, paramCount](
+            jsi::Runtime& runtime,
+            const jsi::Value& /*thisValue*/,
+            const jsi::Value* arguments,
+            size_t count) -> jsi::Value {
+          validateArgumentCount(runtime, methodName, paramCount, count);
+
+          auto shadowNode = shadowNodeFromValue(runtime, arguments[0]);
+
+          auto newestCloneOfShadowNode =
+              uiManager->getNewestCloneOfShadowNode(*shadowNode);
+
+          return jsi::Value(newestCloneOfShadowNode != nullptr);
+        });
+  }
+
+  if (methodName == "compareDocumentPosition") {
+    // This is a React Native implementation of
+    // `Node.prototype.compareDocumentPosition` (see
+    // https://developer.mozilla.org/en-US/docs/Web/API/Node/compareDocumentPosition).
+
+    // It uses the version of the shadow nodes that are present in the current
+    // revision of the shadow tree (if any). If any of the nodes is not present,
+    // it just indicates they are disconnected.
+
+    // compareDocumentPosition(shadowNode: ShadowNode, otherShadowNode:
+    // ShadowNode): number
+    auto paramCount = 2;
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        name,
+        paramCount,
+        [uiManager, methodName, paramCount](
+            jsi::Runtime& runtime,
+            const jsi::Value& /*thisValue*/,
+            const jsi::Value* arguments,
+            size_t count) -> jsi::Value {
+          validateArgumentCount(runtime, methodName, paramCount, count);
+
+          auto shadowNode = shadowNodeFromValue(runtime, arguments[0]);
+          auto otherShadowNode = shadowNodeFromValue(runtime, arguments[1]);
+
+          auto documentPosition =
+              uiManager->compareDocumentPosition(*shadowNode, *otherShadowNode);
+
+          return jsi::Value(documentPosition);
+        });
+  }
+
+  if (methodName == "getTextContent") {
+    // This is a React Native implementation of
+    // `Element.prototype.textContent` (see
+    // https://developer.mozilla.org/en-US/docs/Web/API/Element/textContent).
+
+    // It uses the version of the shadow node that is present in the current
+    // revision of the shadow tree.
+    // If the version is present, is traverses all its children in DFS and
+    // concatenates all the text contents. Otherwise, it returns an empty
+    // string.
+
+    // This is also used to access the text content of text nodes, which does
+    // not need any traversal.
+
+    // getTextContent(shadowNode: ShadowNode): string
+    auto paramCount = 1;
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        name,
+        paramCount,
+        [uiManager, methodName, paramCount](
+            jsi::Runtime& runtime,
+            const jsi::Value& /*thisValue*/,
+            const jsi::Value* arguments,
+            size_t count) -> jsi::Value {
+          validateArgumentCount(runtime, methodName, paramCount, count);
+
+          auto shadowNode = shadowNodeFromValue(runtime, arguments[0]);
+
+          auto textContent =
+              uiManager->getTextContentInNewestCloneOfShadowNode(*shadowNode);
+
+          return jsi::Value(
+              runtime, jsi::String::createFromUtf8(runtime, textContent));
+        });
+  }
+
+  if (methodName == "getOffset") {
+    // This is a method to access the offset information for a shadow node, to
+    // implement these methods:
+    // * `HTMLElement.prototype.offsetParent`: see
+    // https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/offsetParent.
+    // * `HTMLElement.prototype.offsetTop`: see
+    // https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/offsetTop.
+    // * `HTMLElement.prototype.offsetLeft`: see
+    // https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/offsetLeft.
+
+    // It uses the version of the shadow node that is present in the current
+    // revision of the shadow tree. If the node is not present or is not
+    // displayed (because any of its ancestors or itself have 'display: none'),
+    // it returns undefined. Otherwise, it returns its parent (as all nodes in
+    // React Native are currently "positioned") and its offset relative to its
+    // parent.
+
+    // getOffset(shadowNode: ShadowNode):
+    //   ?[
+    //     /* parent: */ InstanceHandle,
+    //     /* top: */ number,
+    //     /* left: */ number,
+    //   ]
+    auto paramCount = 1;
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        name,
+        paramCount,
+        [uiManager, methodName, paramCount](
+            jsi::Runtime& runtime,
+            const jsi::Value& /*thisValue*/,
+            const jsi::Value* arguments,
+            size_t count) -> jsi::Value {
+          validateArgumentCount(runtime, methodName, paramCount, count);
+
+          auto shadowNode = shadowNodeFromValue(runtime, arguments[0]);
+
+          auto newestCloneOfShadowNode =
+              uiManager->getNewestCloneOfShadowNode(*shadowNode);
+          auto newestParentOfShadowNode =
+              uiManager->getNewestParentOfShadowNode(*shadowNode);
+          // The node is no longer part of an active shadow tree, or it is the
+          // root node
+          if (newestCloneOfShadowNode == nullptr ||
+              newestParentOfShadowNode == nullptr) {
+            return jsi::Value::undefined();
+          }
+
+          LayoutableShadowNode::LayoutInspectingPolicy policy = {/* .includeTransform = */ false};
+
+          // 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, policy);
+
+          if (layoutMetrics == EmptyLayoutMetrics) {
+            return jsi::Value::undefined();
+          }
+
+          auto layoutableShadowNode = traitCast<LayoutableShadowNode const*>(
+              newestCloneOfShadowNode.get());
+          // This should never happen
+          if (layoutableShadowNode == nullptr) {
+            return jsi::Value::undefined();
+          }
+
+          auto layoutableParentShadowNode =
+              traitCast<LayoutableShadowNode const*>(
+                  newestParentOfShadowNode.get());
+          // This should never happen
+          if (layoutableParentShadowNode == nullptr) {
+            return jsi::Value::undefined();
+          }
+
+          auto originRelativeToParentOuterBorder =
+              layoutableShadowNode->getLayoutMetrics().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;
+
+          return jsi::Array::createWithElements(
+              runtime,
+              (*newestParentOfShadowNode).getInstanceHandle(runtime),
+              jsi::Value{runtime, (double)offsetTop},
+              jsi::Value{runtime, (double)offsetLeft});
+        });
+  }
+
+  if (methodName == "getScrollPosition") {
+    // This is a method to access scroll information for a shadow node, to
+    // implement these methods:
+    // * `Element.prototype.scrollLeft`: see
+    // https://developer.mozilla.org/en-US/docs/Web/API/Element/scrollLeft.
+    // * `Element.prototype.scrollTop`: see
+    // https://developer.mozilla.org/en-US/docs/Web/API/Element/scrollTop.
+
+    // It uses the version of the shadow node that is present in the current
+    // revision of the shadow tree. If the node is not present or is not
+    // displayed (because any of its ancestors or itself have 'display: none'),
+    // it returns undefined. Otherwise, it returns the scroll position.
+
+    // getScrollPosition(shadowNode: ShadowNode):
+    //   ?[
+    //     /* scrollLeft: */ number,
+    //     /* scrollTop: */ number,
+    //   ]
+    auto paramCount = 1;
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        name,
+        paramCount,
+        [uiManager, methodName, paramCount](
+            jsi::Runtime& runtime,
+            const jsi::Value& /*thisValue*/,
+            const jsi::Value* arguments,
+            size_t count) -> jsi::Value {
+          validateArgumentCount(runtime, methodName, paramCount, count);
+
+          auto shadowNode = shadowNodeFromValue(runtime, arguments[0]);
+
+          auto newestCloneOfShadowNode =
+              uiManager->getNewestCloneOfShadowNode(*shadowNode);
+          // The node is no longer part of an active shadow tree, or it is the
+          // root node
+          if (newestCloneOfShadowNode == nullptr) {
+            return jsi::Value::undefined();
+          }
+
+          LayoutableShadowNode::LayoutInspectingPolicy policy = {/* .includeTransform = */ false};
+
+          // 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, policy);
+
+          if (layoutMetrics == EmptyLayoutMetrics) {
+            return jsi::Value::undefined();
+          }
+
+          auto layoutableShadowNode = traitCast<LayoutableShadowNode const*>(
+              newestCloneOfShadowNode.get());
+          // This should never happen
+          if (layoutableShadowNode == nullptr) {
+            return jsi::Value::undefined();
+          }
+
+          auto scrollPosition = layoutableShadowNode->getContentOriginOffset();
+
+          return jsi::Array::createWithElements(
+              runtime,
+              jsi::Value{
+                  runtime,
+                  scrollPosition.x == 0 ? 0 : (double)-scrollPosition.x},
+              jsi::Value{
+                  runtime,
+                  scrollPosition.y == 0 ? 0 : (double)-scrollPosition.y});
+        });
+  }
+
+  if (methodName == "getScrollSize") {
+    // This is a method to access the scroll information of a shadow node, to
+    // implement these methods:
+    // * `Element.prototype.scrollWidth`: see
+    // https://developer.mozilla.org/en-US/docs/Web/API/Element/scrollWidth.
+    // * `Element.prototype.scrollHeight`: see
+    // https://developer.mozilla.org/en-US/docs/Web/API/Element/scrollHeight.
+
+    // It uses the version of the shadow node that is present in the current
+    // revision of the shadow tree. If the node is not present or is not
+    // displayed (because any of its ancestors or itself have 'display: none'),
+    // it returns undefined. Otherwise, it returns the scroll size.
+
+    // getScrollSize(shadowNode: ShadowNode):
+    //   ?[
+    //     /* scrollWidth: */ number,
+    //     /* scrollHeight: */ number,
+    //   ]
+    auto paramCount = 1;
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        name,
+        paramCount,
+        [uiManager, methodName, paramCount](
+            jsi::Runtime& runtime,
+            const jsi::Value& /*thisValue*/,
+            const jsi::Value* arguments,
+            size_t count) -> jsi::Value {
+          validateArgumentCount(runtime, methodName, paramCount, count);
+
+          auto shadowNode = shadowNodeFromValue(runtime, arguments[0]);
+
+          auto newestCloneOfShadowNode =
+              uiManager->getNewestCloneOfShadowNode(*shadowNode);
+          // The node is no longer part of an active shadow tree, or it is the
+          // root node
+          if (newestCloneOfShadowNode == nullptr) {
+            return jsi::Value::undefined();
+          }
+
+          LayoutableShadowNode::LayoutInspectingPolicy policy = {/* .includeTransform = */ false};
+
+          // 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, policy);
+
+          if (layoutMetrics == EmptyLayoutMetrics ||
+              layoutMetrics.displayType == DisplayType::Inline) {
+            return jsi::Value::undefined();
+          }
+
+          auto layoutableShadowNode =
+              traitCast<YogaLayoutableShadowNode const*>(
+                  newestCloneOfShadowNode.get());
+          // This should never happen
+          if (layoutableShadowNode == nullptr) {
+            return jsi::Value::undefined();
+          }
+
+          Size scrollSize = getScrollSize(
+              layoutMetrics, layoutableShadowNode->getContentBounds());
+
+          return jsi::Array::createWithElements(
+              runtime,
+              jsi::Value{runtime, std::round(scrollSize.width)},
+              jsi::Value{runtime, std::round(scrollSize.height)});
+        });
+  }
+
+  if (methodName == "getInnerSize") {
+    // This is a method to access the inner size of a shadow node, to implement
+    // these methods:
+    // * `Element.prototype.clientWidth`: see
+    // https://developer.mozilla.org/en-US/docs/Web/API/Element/clientWidth.
+    // * `Element.prototype.clientHeight`: see
+    // https://developer.mozilla.org/en-US/docs/Web/API/Element/clientHeight.
+
+    // It uses the version of the shadow node that is present in the current
+    // revision of the shadow tree. If the node is not present, it is not
+    // displayed (because any of its ancestors or itself have 'display: none'),
+    // or it has an inline display, it returns undefined.
+    // Otherwise, it returns its inner size.
+
+    // getInnerSize(shadowNode: ShadowNode):
+    //   ?[
+    //     /* width: */ number,
+    //     /* height: */ number,
+    //   ]
+    auto paramCount = 1;
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        name,
+        paramCount,
+        [uiManager, methodName, paramCount](
+            jsi::Runtime& runtime,
+            const jsi::Value& /*thisValue*/,
+            const jsi::Value* arguments,
+            size_t count) -> jsi::Value {
+          validateArgumentCount(runtime, methodName, paramCount, count);
+
+          auto shadowNode = shadowNodeFromValue(runtime, arguments[0]);
+          LayoutableShadowNode::LayoutInspectingPolicy policy = {/* .includeTransform = */ false};
+          // 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, policy);
+
+          if (layoutMetrics == EmptyLayoutMetrics ||
+              layoutMetrics.displayType == DisplayType::Inline) {
+            return jsi::Value::undefined();
+          }
+
+          auto paddingFrame = layoutMetrics.getPaddingFrame();
+
+          return jsi::Array::createWithElements(
+              runtime,
+              jsi::Value{runtime, std::round(paddingFrame.size.width)},
+              jsi::Value{runtime, std::round(paddingFrame.size.height)});
+        });
+  }
+
+  if (methodName == "getBorderSize") {
+    // This is a method to access the border size of a shadow node, to implement
+    // these methods:
+    // * `Element.prototype.clientLeft`: see
+    // https://developer.mozilla.org/en-US/docs/Web/API/Element/clientLeft.
+    // * `Element.prototype.clientTop`: see
+    // https://developer.mozilla.org/en-US/docs/Web/API/Element/clientTop.
+
+    // It uses the version of the shadow node that is present in the current
+    // revision of the shadow tree. If the node is not present, it is not
+    // displayed (because any of its ancestors or itself have 'display: none'),
+    // or it has an inline display, it returns undefined.
+    // Otherwise, it returns its border size.
+
+    // getBorderSize(shadowNode: ShadowNode):
+    //   ?[
+    //     /* topWidth: */ number,
+    //     /* rightWidth: */ number,
+    //     /* bottomWidth: */ number,
+    //     /* leftWidth: */ number,
+    //   ]
+    auto paramCount = 1;
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        name,
+        paramCount,
+        [uiManager, methodName, paramCount](
+            jsi::Runtime& runtime,
+            const jsi::Value& /*thisValue*/,
+            const jsi::Value* arguments,
+            size_t count) -> jsi::Value {
+          validateArgumentCount(runtime, methodName, paramCount, count);
+
+          auto shadowNode = shadowNodeFromValue(runtime, arguments[0]);
+          LayoutableShadowNode::LayoutInspectingPolicy policy = {/* .includeTransform = */ false};
+          // 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, policy);
+
+          if (layoutMetrics == EmptyLayoutMetrics ||
+              layoutMetrics.displayType == DisplayType::Inline) {
+            return jsi::Value::undefined();
+          }
+
+          return jsi::Array::createWithElements(
+              runtime,
+              jsi::Value{runtime, std::round(layoutMetrics.borderWidth.top)},
+              jsi::Value{runtime, std::round(layoutMetrics.borderWidth.right)},
+              jsi::Value{runtime, std::round(layoutMetrics.borderWidth.bottom)},
+              jsi::Value{runtime, std::round(layoutMetrics.borderWidth.left)});
+        });
+  }
+
+  if (methodName == "getTagName") {
+    // This is a method to access the normalized tag name of a shadow node, to
+    // implement `Element.prototype.tagName` (see
+    // https://developer.mozilla.org/en-US/docs/Web/API/Element/tagName).
+
+    // getTagName(shadowNode: ShadowNode): string
+    auto paramCount = 1;
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        name,
+        paramCount,
+        [methodName, paramCount](
+            jsi::Runtime& runtime,
+            const jsi::Value& /*thisValue*/,
+            const jsi::Value* arguments,
+            size_t count) -> jsi::Value {
+          validateArgumentCount(runtime, methodName, paramCount, count);
+
+          auto shadowNode = shadowNodeFromValue(runtime, arguments[0]);
+
+          std::string canonicalComponentName = shadowNode->getComponentName();
+
+          // FIXME(T162807327): Remove Android-specific prefixes and unify
+          // shadow node implementations
+          if (canonicalComponentName == "AndroidTextInput") {
+            canonicalComponentName = "TextInput";
+          } else if (canonicalComponentName == "AndroidSwitch") {
+            canonicalComponentName = "Switch";
+          }
+
+          // Prefix with RN:
+          canonicalComponentName.insert(0, "RN:");
+
+          return jsi::String::createFromUtf8(runtime, canonicalComponentName);
+        });
+  }
+
+  /**
+   * Pointer Capture APIs
+   */
+  if (methodName == "hasPointerCapture") {
+    auto paramCount = 2;
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        name,
+        paramCount,
+        [this, methodName, paramCount](
+            jsi::Runtime& runtime,
+            const jsi::Value& /*thisValue*/,
+            const jsi::Value* arguments,
+            size_t count) -> jsi::Value {
+          validateArgumentCount(runtime, methodName, paramCount, count);
+          bool isCapturing = pointerEventsProcessor_.hasPointerCapture(
+              static_cast<int>(arguments[1].asNumber()),
+              shadowNodeFromValue(runtime, arguments[0]).get());
+          return jsi::Value(isCapturing);
+        });
+  }
+
+  if (methodName == "setPointerCapture") {
+    auto paramCount = 2;
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        name,
+        paramCount,
+        [this, methodName, paramCount](
+            jsi::Runtime& runtime,
+            const jsi::Value& /*thisValue*/,
+            const jsi::Value* arguments,
+            size_t count) -> jsi::Value {
+          validateArgumentCount(runtime, methodName, paramCount, count);
+          pointerEventsProcessor_.setPointerCapture(
+              static_cast<int>(arguments[1].asNumber()),
+              shadowNodeFromValue(runtime, arguments[0]));
+          return jsi::Value::undefined();
+        });
+  }
+
+  if (methodName == "releasePointerCapture") {
+    auto paramCount = 2;
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        name,
+        paramCount,
+        [this, methodName, paramCount](
+            jsi::Runtime& runtime,
+            const jsi::Value& /*thisValue*/,
+            const jsi::Value* arguments,
+            size_t count) -> jsi::Value {
+          validateArgumentCount(runtime, methodName, paramCount, count);
+          pointerEventsProcessor_.releasePointerCapture(
+              static_cast<int>(arguments[1].asNumber()),
+              shadowNodeFromValue(runtime, arguments[0]).get());
+          return jsi::Value::undefined();
+        });
+  }
+
+  return jsi::Value::undefined();
+}
+
+UIManager& UIManagerBinding::getUIManager() {
+  return *uiManager_;
+}
+
+} // namespace facebook::react