react-native-windows 0.78.7 → 0.79.0-preview.1

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/nativemodule/dom/NativeDOM.cpp

@@ -10,6 +10,7 @@
 #include <react/renderer/dom/DOM.h>
 #include <react/renderer/uimanager/PointerEventsProcessor.h>
 #include <react/renderer/uimanager/UIManagerBinding.h>
+#include <react/renderer/uimanager/primitives.h>
 
 #ifdef RN_DISABLE_OSS_PLUGIN_HEADER
 #include "Plugins.h"
@@ -33,6 +34,19 @@ static RootShadowNode::Shared getCurrentShadowTreeRevision(
   return shadowTreeRevisionProvider->getCurrentRevision(surfaceId);
 }
 
+static RootShadowNode::Shared getCurrentShadowTreeRevision(
+    facebook::jsi::Runtime& runtime,
+    jsi::Value& nativeNodeReference) {
+  if (nativeNodeReference.isNumber()) {
+    return getCurrentShadowTreeRevision(
+        runtime, static_cast<SurfaceId>(nativeNodeReference.asNumber()));
+  }
+
+  return getCurrentShadowTreeRevision(
+      runtime,
+      shadowNodeFromValue(runtime, nativeNodeReference)->getSurfaceId());
+}
+
 static facebook::react::PointerEventsProcessor&
 getPointerEventsProcessorFromRuntime(facebook::jsi::Runtime& runtime) {
   return facebook::react::UIManagerBinding::getBinding(runtime)
@@ -58,81 +72,156 @@ getArrayOfInstanceHandlesFromShadowNodes(
   return nonNullInstanceHandles;
 }
 
+static bool isRootShadowNode(const ShadowNode& shadowNode) {
+  return shadowNode.getTraits().check(ShadowNodeTraits::Trait::RootNodeKind);
+}
+
 #pragma mark - NativeDOM
 
 NativeDOM::NativeDOM(std::shared_ptr<CallInvoker> jsInvoker)
     : NativeDOMCxxSpec(std::move(jsInvoker)) {}
 
-jsi::Value NativeDOM::getParentNode(
+#pragma mark - Methods from the Node interface (for ReadOnlyNode).
+
+double NativeDOM::compareDocumentPosition(
     jsi::Runtime& rt,
-    jsi::Value shadowNodeValue) {
-  auto shadowNode = shadowNodeFromValue(rt, shadowNodeValue);
-  auto currentRevision =
-      getCurrentShadowTreeRevision(rt, shadowNode->getSurfaceId());
+    jsi::Value nativeNodeReference,
+    jsi::Value otherNativeNodeReference) {
+  auto currentRevision = getCurrentShadowTreeRevision(rt, nativeNodeReference);
   if (currentRevision == nullptr) {
-    return jsi::Value::undefined();
+    return dom::DOCUMENT_POSITION_DISCONNECTED;
   }
 
-  auto parentShadowNode = dom::getParentNode(currentRevision, *shadowNode);
-  if (parentShadowNode == nullptr) {
-    return jsi::Value::undefined();
+  ShadowNode::Shared shadowNode;
+  ShadowNode::Shared otherShadowNode;
+
+  // Check if document references are used
+  if (nativeNodeReference.isNumber() || otherNativeNodeReference.isNumber()) {
+    if (nativeNodeReference.isNumber() && otherNativeNodeReference.isNumber()) {
+      // Both are documents (and equality is handled in JS directly).
+      return dom::DOCUMENT_POSITION_DISCONNECTED;
+    } else if (nativeNodeReference.isNumber()) {
+      // Only the first is a document
+      auto surfaceId = nativeNodeReference.asNumber();
+      shadowNode = currentRevision;
+      otherShadowNode = shadowNodeFromValue(rt, otherNativeNodeReference);
+
+      if (isRootShadowNode(*otherShadowNode)) {
+        // If the other is a root node, we just need to check if it is its
+        // documentElement
+        return (surfaceId == otherShadowNode->getSurfaceId())
+            ? dom::DOCUMENT_POSITION_CONTAINED_BY |
+                dom::DOCUMENT_POSITION_FOLLOWING
+            : dom::DOCUMENT_POSITION_DISCONNECTED;
+      } else {
+        // Otherwise, we'll use the root node to represent the document
+        // (the result should be the same)
+      }
+    } else {
+      // Only the second is a document
+      auto otherSurfaceId = otherNativeNodeReference.asNumber();
+      shadowNode = shadowNodeFromValue(rt, nativeNodeReference);
+      otherShadowNode = getCurrentShadowTreeRevision(rt, static_cast<SurfaceId>(otherSurfaceId));
+
+      if (isRootShadowNode(*shadowNode)) {
+        // If this is a root node, we just need to check if the other is its
+        // document.
+        return (otherSurfaceId == shadowNode->getSurfaceId())
+            ? dom::DOCUMENT_POSITION_CONTAINS | dom::DOCUMENT_POSITION_PRECEDING
+            : dom::DOCUMENT_POSITION_DISCONNECTED;
+      } else {
+        // Otherwise, we'll use the root node to represent the document
+        // (the result should be the same)
+      }
+    }
+  } else {
+    shadowNode = shadowNodeFromValue(rt, nativeNodeReference);
+    otherShadowNode = shadowNodeFromValue(rt, otherNativeNodeReference);
   }
 
-  return parentShadowNode->getInstanceHandle(rt);
+  return dom::compareDocumentPosition(
+      currentRevision, *shadowNode, *otherShadowNode);
 }
 
 std::vector<jsi::Value> NativeDOM::getChildNodes(
     jsi::Runtime& rt,
-    jsi::Value shadowNodeValue) {
-  auto shadowNode = shadowNodeFromValue(rt, shadowNodeValue);
-  auto currentRevision =
-      getCurrentShadowTreeRevision(rt, shadowNode->getSurfaceId());
+    jsi::Value nativeNodeReference) {
+  auto currentRevision = getCurrentShadowTreeRevision(rt, nativeNodeReference);
   if (currentRevision == nullptr) {
     return std::vector<jsi::Value>{};
   }
 
-  auto childNodes = dom::getChildNodes(currentRevision, *shadowNode);
+  // The only child node of the document is the root node.
+  if (nativeNodeReference.isNumber()) {
+    return getArrayOfInstanceHandlesFromShadowNodes({currentRevision}, rt);
+  }
+
+  auto childNodes = dom::getChildNodes(
+      currentRevision, *shadowNodeFromValue(rt, nativeNodeReference));
   return getArrayOfInstanceHandlesFromShadowNodes(childNodes, rt);
 }
 
-bool NativeDOM::isConnected(jsi::Runtime& rt, jsi::Value shadowNodeValue) {
-  auto shadowNode = shadowNodeFromValue(rt, shadowNodeValue);
+jsi::Value NativeDOM::getParentNode(
+    jsi::Runtime& rt,
+    jsi::Value nativeNodeReference) {
+  // The document does not have a parent node.
+  if (nativeNodeReference.isNumber()) {
+    return jsi::Value::undefined();
+  }
+
+  auto shadowNode = shadowNodeFromValue(rt, nativeNodeReference);
+  if (isRootShadowNode(*shadowNode)) {
+    // The parent of the root node is the document.
+    return jsi::Value{shadowNode->getSurfaceId()};
+  }
+
   auto currentRevision =
       getCurrentShadowTreeRevision(rt, shadowNode->getSurfaceId());
   if (currentRevision == nullptr) {
-    return false;
+    return jsi::Value::undefined();
   }
 
-  return dom::isConnected(currentRevision, *shadowNode);
+  auto parentShadowNode = dom::getParentNode(currentRevision, *shadowNode);
+  if (parentShadowNode == nullptr) {
+    return jsi::Value::undefined();
+  }
+
+  return parentShadowNode->getInstanceHandle(rt);
 }
 
-double NativeDOM::compareDocumentPosition(
-    jsi::Runtime& rt,
-    jsi::Value shadowNodeValue,
-    jsi::Value otherShadowNodeValue) {
-  auto shadowNode = shadowNodeFromValue(rt, shadowNodeValue);
-  auto otherShadowNode = shadowNodeFromValue(rt, otherShadowNodeValue);
-  auto currentRevision =
-      getCurrentShadowTreeRevision(rt, shadowNode->getSurfaceId());
-  if (otherShadowNode == nullptr || currentRevision == nullptr) {
-    return 0;
+bool NativeDOM::isConnected(jsi::Runtime& rt, jsi::Value nativeNodeReference) {
+  auto currentRevision = getCurrentShadowTreeRevision(rt, nativeNodeReference);
+  if (currentRevision == nullptr) {
+    return false;
   }
 
-  return dom::compareDocumentPosition(
-      currentRevision, *shadowNode, *otherShadowNode);
+  // The document is connected because we got a value for current revision.
+  if (nativeNodeReference.isNumber()) {
+    return true;
+  }
+
+  auto shadowNode = shadowNodeFromValue(rt, nativeNodeReference);
+  return dom::isConnected(currentRevision, *shadowNode);
 }
 
-std::string NativeDOM::getTextContent(
-    jsi::Runtime& rt,
-    jsi::Value shadowNodeValue) {
-  auto shadowNode = shadowNodeFromValue(rt, shadowNodeValue);
+#pragma mark - Methods from the Element interface (for ReactNativeElement).
+
+std::tuple<
+    /* topWidth: */ int,
+    /* rightWidth: */ int,
+    /* bottomWidth: */ int,
+    /* leftWidth: */ int>
+NativeDOM::getBorderWidth(jsi::Runtime& rt, jsi::Value nativeElementReference) {
+  auto shadowNode = shadowNodeFromValue(rt, nativeElementReference);
   auto currentRevision =
       getCurrentShadowTreeRevision(rt, shadowNode->getSurfaceId());
   if (currentRevision == nullptr) {
-    return "";
+    return {0, 0, 0, 0};
   }
 
-  return dom::getTextContent(currentRevision, *shadowNode);
+  auto borderWidth = dom::getBorderWidth(currentRevision, *shadowNode);
+  return std::tuple{
+      borderWidth.top, borderWidth.right, borderWidth.bottom, borderWidth.left};
 }
 
 std::tuple<
@@ -142,9 +231,9 @@ std::tuple<
     /* height: */ double>
 NativeDOM::getBoundingClientRect(
     jsi::Runtime& rt,
-    jsi::Value shadowNodeValue,
+    jsi::Value nativeElementReference,
     bool includeTransform) {
-  auto shadowNode = shadowNodeFromValue(rt, shadowNodeValue);
+  auto shadowNode = shadowNodeFromValue(rt, nativeElementReference);
   auto currentRevision =
       getCurrentShadowTreeRevision(rt, shadowNode->getSurfaceId());
   if (currentRevision == nullptr) {
@@ -157,31 +246,25 @@ NativeDOM::getBoundingClientRect(
   return std::tuple{domRect.x, domRect.y, domRect.width, domRect.height};
 }
 
-std::tuple<
-    /* offsetParent: */ jsi::Value,
-    /* top: */ double,
-    /* left: */ double>
-NativeDOM::getOffset(jsi::Runtime& rt, jsi::Value shadowNodeValue) {
-  auto shadowNode = shadowNodeFromValue(rt, shadowNodeValue);
+std::tuple</* width: */ int, /* height: */ int> NativeDOM::getInnerSize(
+    jsi::Runtime& rt,
+    jsi::Value nativeElementReference) {
+  auto shadowNode = shadowNodeFromValue(rt, nativeElementReference);
   auto currentRevision =
       getCurrentShadowTreeRevision(rt, shadowNode->getSurfaceId());
   if (currentRevision == nullptr) {
-    return {jsi::Value::undefined(), 0, 0};
+    return {0, 0};
   }
 
-  auto domOffset = dom::getOffset(currentRevision, *shadowNode);
-
-  return std::tuple{
-      domOffset.offsetParent == nullptr
-          ? jsi::Value::undefined()
-          : domOffset.offsetParent->getInstanceHandle(rt),
-      domOffset.top,
-      domOffset.left};
+  auto innerSize = dom::getInnerSize(currentRevision, *shadowNode);
+  return std::tuple{innerSize.width, innerSize.height};
 }
 
 std::tuple</* scrollLeft: */ double, /* scrollTop: */ double>
-NativeDOM::getScrollPosition(jsi::Runtime& rt, jsi::Value shadowNodeValue) {
-  auto shadowNode = shadowNodeFromValue(rt, shadowNodeValue);
+NativeDOM::getScrollPosition(
+    jsi::Runtime& rt,
+    jsi::Value nativeElementReference) {
+  auto shadowNode = shadowNodeFromValue(rt, nativeElementReference);
   auto currentRevision =
       getCurrentShadowTreeRevision(rt, shadowNode->getSurfaceId());
   if (currentRevision == nullptr) {
@@ -193,8 +276,8 @@ NativeDOM::getScrollPosition(jsi::Runtime& rt, jsi::Value shadowNodeValue) {
 }
 
 std::tuple</* scrollWidth: */ int, /* scrollHeight */ int>
-NativeDOM::getScrollSize(jsi::Runtime& rt, jsi::Value shadowNodeValue) {
-  auto shadowNode = shadowNodeFromValue(rt, shadowNodeValue);
+NativeDOM::getScrollSize(jsi::Runtime& rt, jsi::Value nativeElementReference) {
+  auto shadowNode = shadowNodeFromValue(rt, nativeElementReference);
   auto currentRevision =
       getCurrentShadowTreeRevision(rt, shadowNode->getSurfaceId());
   if (currentRevision == nullptr) {
@@ -205,82 +288,103 @@ NativeDOM::getScrollSize(jsi::Runtime& rt, jsi::Value shadowNodeValue) {
   return std::tuple{scrollSize.width, scrollSize.height};
 }
 
-std::tuple</* width: */ int, /* height: */ int> NativeDOM::getInnerSize(
+std::string NativeDOM::getTagName(
     jsi::Runtime& rt,
-    jsi::Value shadowNodeValue) {
-  auto shadowNode = shadowNodeFromValue(rt, shadowNodeValue);
-  auto currentRevision =
-      getCurrentShadowTreeRevision(rt, shadowNode->getSurfaceId());
-  if (currentRevision == nullptr) {
-    return {0, 0};
-  }
-
-  auto innerSize = dom::getInnerSize(currentRevision, *shadowNode);
-  return std::tuple{innerSize.width, innerSize.height};
+    jsi::Value nativeElementReference) {
+  auto shadowNode = shadowNodeFromValue(rt, nativeElementReference);
+  return dom::getTagName(*shadowNode);
 }
 
-std::tuple<
-    /* topWidth: */ int,
-    /* rightWidth: */ int,
-    /* bottomWidth: */ int,
-    /* leftWidth: */ int>
-NativeDOM::getBorderWidth(jsi::Runtime& rt, jsi::Value shadowNodeValue) {
-  auto shadowNode = shadowNodeFromValue(rt, shadowNodeValue);
+std::string NativeDOM::getTextContent(
+    jsi::Runtime& rt,
+    jsi::Value nativeNodeReference) {
+  auto shadowNode = shadowNodeFromValue(rt, nativeNodeReference);
   auto currentRevision =
       getCurrentShadowTreeRevision(rt, shadowNode->getSurfaceId());
   if (currentRevision == nullptr) {
-    return {0, 0, 0, 0};
+    return "";
   }
 
-  auto borderWidth = dom::getBorderWidth(currentRevision, *shadowNode);
-  return std::tuple{
-      borderWidth.top, borderWidth.right, borderWidth.bottom, borderWidth.left};
-}
-
-std::string NativeDOM::getTagName(
-    jsi::Runtime& rt,
-    jsi::Value shadowNodeValue) {
-  auto shadowNode = shadowNodeFromValue(rt, shadowNodeValue);
-  return dom::getTagName(*shadowNode);
+  return dom::getTextContent(currentRevision, *shadowNode);
 }
 
-#pragma mark - Pointer events
-
 bool NativeDOM::hasPointerCapture(
     jsi::Runtime& rt,
-    jsi::Value shadowNodeValue,
+    jsi::Value nativeElementReference,
     double pointerId) {
   bool isCapturing = getPointerEventsProcessorFromRuntime(rt).hasPointerCapture(
-      // [Windows] Cast to fix https://github.com/microsoft/react-native-windows/issues/14251
-      static_cast<PointerIdentifier>(pointerId), shadowNodeFromValue(rt, shadowNodeValue).get());
+      static_cast<PointerIdentifier>(pointerId),
+      shadowNodeFromValue(rt, nativeElementReference).get());
   return isCapturing;
 }
 
+void NativeDOM::releasePointerCapture(
+    jsi::Runtime& rt,
+    jsi::Value nativeElementReference,
+    double pointerId) {
+  getPointerEventsProcessorFromRuntime(rt).releasePointerCapture(
+      static_cast<PointerIdentifier>(pointerId),
+      shadowNodeFromValue(rt, nativeElementReference).get());
+}
+
 void NativeDOM::setPointerCapture(
     jsi::Runtime& rt,
-    jsi::Value shadowNodeValue,
+    jsi::Value nativeElementReference,
     double pointerId) {
   getPointerEventsProcessorFromRuntime(rt).setPointerCapture(
-      // [Windows] Cast to fix https://github.com/microsoft/react-native-windows/issues/14251
-      static_cast<PointerIdentifier>(pointerId), shadowNodeFromValue(rt, shadowNodeValue));
+      static_cast<PointerIdentifier>(pointerId),
+      shadowNodeFromValue(rt, nativeElementReference));
 }
 
-void NativeDOM::releasePointerCapture(
+#pragma mark - Methods from the HTMLElement interface (for ReactNativeElement).
+
+std::tuple<
+    /* offsetParent: */ jsi::Value,
+    /* top: */ double,
+    /* left: */ double>
+NativeDOM::getOffset(jsi::Runtime& rt, jsi::Value nativeElementReference) {
+  auto shadowNode = shadowNodeFromValue(rt, nativeElementReference);
+  auto currentRevision =
+      getCurrentShadowTreeRevision(rt, shadowNode->getSurfaceId());
+  if (currentRevision == nullptr) {
+    return {jsi::Value::undefined(), 0, 0};
+  }
+
+  auto domOffset = dom::getOffset(currentRevision, *shadowNode);
+
+  return std::tuple{
+      domOffset.offsetParent == nullptr
+          ? jsi::Value::undefined()
+          : domOffset.offsetParent->getInstanceHandle(rt),
+      domOffset.top,
+      domOffset.left};
+}
+
+#pragma mark - Special methods to handle the root node.
+
+jsi::Value NativeDOM::linkRootNode(
     jsi::Runtime& rt,
-    jsi::Value shadowNodeValue,
-    double pointerId) {
-  getPointerEventsProcessorFromRuntime(rt).releasePointerCapture(
-      // [Windows] Cast to fix https://github.com/microsoft/react-native-windows/issues/14251
-      static_cast<PointerIdentifier>(pointerId), shadowNodeFromValue(rt, shadowNodeValue).get());
+    SurfaceId surfaceId,
+    jsi::Value instanceHandle) {
+  auto currentRevision = getCurrentShadowTreeRevision(rt, surfaceId);
+  if (currentRevision == nullptr) {
+    return jsi::Value::undefined();
+  }
+
+  auto instanceHandleWrapper =
+      std::make_shared<InstanceHandle>(rt, instanceHandle, surfaceId);
+  currentRevision->setInstanceHandle(instanceHandleWrapper);
+
+  return valueFromShadowNode(rt, currentRevision);
 }
 
-#pragma mark - Legacy RN layout APIs
+#pragma mark - Legacy layout APIs (for ReactNativeElement).
 
 void NativeDOM::measure(
     jsi::Runtime& rt,
-    jsi::Value shadowNodeValue,
+    jsi::Value nativeElementReference,
     jsi::Function callback) {
-  auto shadowNode = shadowNodeFromValue(rt, shadowNodeValue);
+  auto shadowNode = shadowNodeFromValue(rt, nativeElementReference);
   auto currentRevision =
       getCurrentShadowTreeRevision(rt, shadowNode->getSurfaceId());
   if (currentRevision == nullptr) {
@@ -302,9 +406,9 @@ void NativeDOM::measure(
 
 void NativeDOM::measureInWindow(
     jsi::Runtime& rt,
-    jsi::Value shadowNodeValue,
+    jsi::Value nativeElementReference,
     jsi::Function callback) {
-  auto shadowNode = shadowNodeFromValue(rt, shadowNodeValue);
+  auto shadowNode = shadowNodeFromValue(rt, nativeElementReference);
   auto currentRevision =
       getCurrentShadowTreeRevision(rt, shadowNode->getSurfaceId());
   if (currentRevision == nullptr) {
@@ -323,13 +427,13 @@ void NativeDOM::measureInWindow(
 
 void NativeDOM::measureLayout(
     jsi::Runtime& rt,
-    jsi::Value shadowNodeValue,
-    jsi::Value relativeToShadowNodeValue,
+    jsi::Value nativeElementReference,
+    jsi::Value relativeToNativeElementReference,
     jsi::Function onFail,
     jsi::Function onSuccess) {
-  auto shadowNode = shadowNodeFromValue(rt, shadowNodeValue);
+  auto shadowNode = shadowNodeFromValue(rt, nativeElementReference);
   auto relativeToShadowNode =
-      shadowNodeFromValue(rt, relativeToShadowNodeValue);
+      shadowNodeFromValue(rt, relativeToNativeElementReference);
   auto currentRevision =
       getCurrentShadowTreeRevision(rt, shadowNode->getSurfaceId());
   if (currentRevision == nullptr) {

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/nativemodule/dom/NativeDOM.h

@@ -0,0 +1,129 @@
+/*
+ * 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.
+ */
+
+// [Windows #14654]
+
+#pragma once
+
+#include <string>
+
+#if __has_include("rncoreJSI.h") // Cmake headers on Android
+#include "rncoreJSI.h"
+#elif __has_include("FBReactNativeSpecJSI.h") // CocoaPod headers on Apple
+#include "FBReactNativeSpecJSI.h"
+#else
+#include <FBReactNativeSpec/FBReactNativeSpecJSI.h>
+#endif
+
+#include <react/renderer/core/ShadowNodeFamily.h>
+
+namespace facebook::react {
+
+class NativeDOM : public NativeDOMCxxSpec<NativeDOM> {
+ public:
+  NativeDOM(std::shared_ptr<CallInvoker> jsInvoker);
+
+#pragma mark - Methods from the Node interface (for ReadOnlyNode).
+
+  double compareDocumentPosition(
+      jsi::Runtime& rt,
+      jsi::Value nativeNodeReference,
+      jsi::Value otherNativeNodeReference);
+
+  std::vector<jsi::Value> getChildNodes(
+      jsi::Runtime& rt,
+      jsi::Value nativeNodeReference);
+
+  jsi::Value getParentNode(jsi::Runtime& rt, jsi::Value nativeNodeReference);
+
+  bool isConnected(jsi::Runtime& rt, jsi::Value nativeNodeReference);
+
+#pragma mark - Methods from the Element interface (for ReactNativeElement).
+
+  std::tuple<
+      /* topWidth: */ int,
+      /* rightWidth: */ int,
+      /* bottomWidth: */ int,
+      /* leftWidth: */ int>
+  getBorderWidth(jsi::Runtime& rt, jsi::Value nativeElementReference);
+
+  std::tuple<
+      /* x: */ double,
+      /* y: */ double,
+      /* width: */ double,
+      /* height: */ double>
+  getBoundingClientRect(
+      jsi::Runtime& rt,
+      jsi::Value nativeElementReference,
+      bool includeTransform);
+
+  std::tuple</* width: */ int, /* height: */ int> getInnerSize(
+      jsi::Runtime& rt,
+      jsi::Value nativeElementReference);
+
+  std::tuple</* scrollLeft: */ double, /* scrollTop: */ double>
+  getScrollPosition(jsi::Runtime& rt, jsi::Value nativeElementReference);
+
+  std::tuple</* scrollWidth: */ int, /* scrollHeight */ int> getScrollSize(
+      jsi::Runtime& rt,
+      jsi::Value nativeElementReference);
+
+  std::string getTagName(jsi::Runtime& rt, jsi::Value nativeElementReference);
+
+  std::string getTextContent(jsi::Runtime& rt, jsi::Value nativeNodeReference);
+
+  bool hasPointerCapture(
+      jsi::Runtime& rt,
+      jsi::Value nativeElementReference,
+      double pointerId);
+
+  void releasePointerCapture(
+      jsi::Runtime& rt,
+      jsi::Value nativeElementReference,
+      double pointerId);
+
+  void setPointerCapture(
+      jsi::Runtime& rt,
+      jsi::Value nativeElementReference,
+      double pointerId);
+
+#pragma mark - Methods from the HTMLElement interface (for ReactNativeElement).
+
+  std::tuple<
+      /* offsetParent: */ jsi::Value,
+      /* top: */ double,
+      /* left: */ double>
+  getOffset(jsi::Runtime& rt, jsi::Value nativeElementReference);
+
+#pragma mark - Special methods to handle the root node.
+
+  jsi::Value linkRootNode(
+      jsi::Runtime& rt,
+      SurfaceId surfaceId,
+      jsi::Value instanceHandle);
+
+#pragma mark - Legacy layout APIs (for ReactNativeElement).
+
+  void measure(
+      jsi::Runtime& rt,
+      jsi::Value nativeElementReference,
+      jsi::Function callback);
+
+  void measureInWindow(
+      jsi::Runtime& rt,
+      jsi::Value nativeElementReference,
+      jsi::Function callback);
+
+  void measureLayout(
+      jsi::Runtime& rt,
+      jsi::Value nativeElementReference,
+      jsi::Value relativeToNativeElementReference,
+      jsi::Function onFail,
+      jsi::Function onSuccess);
+};
+
+} // namespace facebook::react