@office-iss/react-native-win32 0.78.2 → 0.79.0-preview.1

package/src/private/webapis/dom/nodes/ReadOnlyNode.js

@@ -10,25 +10,32 @@
 
 // flowlint unsafe-getters-setters:off
 
-import type {
-  InternalInstanceHandle,
-  Node as ShadowNode,
-} from '../../../../../Libraries/Renderer/shims/ReactNativeTypes';
 import type NodeList from '../oldstylecollections/NodeList';
+import type {InstanceHandle} from './internals/NodeInternals';
+import type ReactNativeDocument from './ReactNativeDocument';
 import type ReadOnlyElement from './ReadOnlyElement';
 
+import * as ReactNativeFeatureFlags from '../../../featureflags/ReactNativeFeatureFlags';
 import {createNodeList} from '../oldstylecollections/NodeList';
+import {
+  getNativeNodeReference,
+  getOwnerDocument,
+  getPublicInstanceFromInstanceHandle,
+  setInstanceHandle,
+  setOwnerDocument,
+} from './internals/NodeInternals';
 import NativeDOM from './specs/NativeDOM';
 
-// We initialize this lazily to avoid a require cycle
-// (`ReadOnlyElement` also depends on `ReadOnlyNode`).
-let ReadOnlyElementClass: Class<ReadOnlyElement>;
-
 export default class ReadOnlyNode {
-  constructor(internalInstanceHandle: InternalInstanceHandle) {
+  constructor(
+    instanceHandle: InstanceHandle,
+    // This will be null for the document node itself.
+    ownerDocument: ReactNativeDocument | null,
+  ) {
     // This constructor is inlined in `ReactNativeElement` so if you modify
     // this make sure that their implementation stays in sync.
-    setInstanceHandle(this, internalInstanceHandle);
+    setOwnerDocument(this, ownerDocument);
+    setInstanceHandle(this, instanceHandle);
   }
 
   get childNodes(): NodeList<ReadOnlyNode> {
@@ -47,7 +54,7 @@ export default class ReadOnlyNode {
   }
 
   get isConnected(): boolean {
-    const shadowNode = getShadowNode(this);
+    const shadowNode = getNativeNodeReference(this);
 
     if (shadowNode == null) {
       return false;
@@ -104,15 +111,14 @@ export default class ReadOnlyNode {
     );
   }
 
+  get ownerDocument(): ReactNativeDocument | null {
+    return getOwnerDocument(this);
+  }
+
   get parentElement(): ReadOnlyElement | null {
     const parentNode = this.parentNode;
 
-    if (ReadOnlyElementClass == null) {
-      // We initialize this lazily to avoid a require cycle.
-      ReadOnlyElementClass = require('./ReadOnlyElement').default;
-    }
-
-    if (parentNode instanceof ReadOnlyElementClass) {
+    if (parentNode instanceof getReadOnlyElementClass()) {
       return parentNode;
     }
 
@@ -120,7 +126,7 @@ export default class ReadOnlyNode {
   }
 
   get parentNode(): ReadOnlyNode | null {
-    const shadowNode = getShadowNode(this);
+    const shadowNode = getNativeNodeReference(this);
 
     if (shadowNode == null) {
       return null;
@@ -132,9 +138,7 @@ export default class ReadOnlyNode {
       return null;
     }
 
-    return (
-      getPublicInstanceFromInternalInstanceHandle(parentInstanceHandle) ?? null
-    );
+    return getPublicInstanceFromInstanceHandle(parentInstanceHandle) ?? null;
   }
 
   get previousSibling(): ReadOnlyNode | null {
@@ -151,7 +155,7 @@ export default class ReadOnlyNode {
   /**
    * @abstract
    */
-  get textContent(): string | null {
+  get textContent(): string {
     throw new TypeError(
       '`textContent` is abstract and must be implemented in a subclass of `ReadOnlyNode`',
     );
@@ -163,8 +167,8 @@ export default class ReadOnlyNode {
       return 0;
     }
 
-    const shadowNode = getShadowNode(this);
-    const otherShadowNode = getShadowNode(otherNode);
+    const shadowNode = getNativeNodeReference(this);
+    const otherShadowNode = getNativeNodeReference(otherNode);
 
     if (shadowNode == null || otherShadowNode == null) {
       return ReadOnlyNode.DOCUMENT_POSITION_DISCONNECTED;
@@ -184,16 +188,25 @@ export default class ReadOnlyNode {
   }
 
   getRootNode(): ReadOnlyNode {
-    // eslint-disable-next-line consistent-this
-    let lastKnownParent: ReadOnlyNode = this;
-    let nextPossibleParent: ?ReadOnlyNode = this.parentNode;
-
-    while (nextPossibleParent != null) {
-      lastKnownParent = nextPossibleParent;
-      nextPossibleParent = nextPossibleParent.parentNode;
+    if (ReactNativeFeatureFlags.enableDOMDocumentAPI()) {
+      if (this.isConnected) {
+        // If this is the document node, then the root node is itself.
+        return this.ownerDocument ?? this;
+      }
+
+      return this;
+    } else {
+      // eslint-disable-next-line consistent-this
+      let lastKnownParent: ReadOnlyNode = this;
+      let nextPossibleParent: ?ReadOnlyNode = this.parentNode;
+
+      while (nextPossibleParent != null) {
+        lastKnownParent = nextPossibleParent;
+        nextPossibleParent = nextPossibleParent.parentNode;
+      }
+
+      return lastKnownParent;
     }
-
-    return lastKnownParent;
   }
 
   hasChildNodes(): boolean {
@@ -237,7 +250,7 @@ export default class ReadOnlyNode {
    */
   static COMMENT_NODE: number = 8;
   /**
-   * @deprecated Unused in React Native.
+   * Document nodes.
    */
   static DOCUMENT_NODE: number = 9;
   /**
@@ -288,41 +301,10 @@ export default class ReadOnlyNode {
   static DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC: number = 32;
 }
 
-const INSTANCE_HANDLE_KEY = Symbol('internalInstanceHandle');
-
-export function getInstanceHandle(node: ReadOnlyNode): InternalInstanceHandle {
-  // $FlowExpectedError[prop-missing]
-  return node[INSTANCE_HANDLE_KEY];
-}
-
-export function setInstanceHandle(
-  node: ReadOnlyNode,
-  instanceHandle: InternalInstanceHandle,
-): void {
-  // $FlowExpectedError[prop-missing]
-  node[INSTANCE_HANDLE_KEY] = instanceHandle;
-}
-
-let RendererProxy;
-function getRendererProxy() {
-  if (RendererProxy == null) {
-    // Lazy import Fabric here to avoid DOM Node APIs classes from having side-effects.
-    // With a static import we can't use these classes for Paper-only variants.
-    RendererProxy = require('../../../../../Libraries/ReactNative/RendererProxy');
-  }
-  return RendererProxy;
-}
-
-export function getShadowNode(node: ReadOnlyNode): ?ShadowNode {
-  return getRendererProxy().getNodeFromInternalInstanceHandle(
-    getInstanceHandle(node),
-  );
-}
-
 export function getChildNodes(
   node: ReadOnlyNode,
 ): $ReadOnlyArray<ReadOnlyNode> {
-  const shadowNode = getShadowNode(node);
+  const shadowNode = getNativeNodeReference(node);
 
   if (shadowNode == null) {
     return [];
@@ -330,9 +312,7 @@ export function getChildNodes(
 
   const childNodeInstanceHandles = NativeDOM.getChildNodes(shadowNode);
   return childNodeInstanceHandles
-    .map(instanceHandle =>
-      getPublicInstanceFromInternalInstanceHandle(instanceHandle),
-    )
+    .map(instanceHandle => getPublicInstanceFromInstanceHandle(instanceHandle))
     .filter(Boolean);
 }
 
@@ -355,13 +335,11 @@ function getNodeSiblingsAndPosition(
   return [siblings, position];
 }
 
-export function getPublicInstanceFromInternalInstanceHandle(
-  instanceHandle: InternalInstanceHandle,
-): ?ReadOnlyNode {
-  const mixedPublicInstance =
-    getRendererProxy().getPublicInstanceFromInternalInstanceHandle(
-      instanceHandle,
-    );
-  // $FlowExpectedError[incompatible-return] React defines public instances as "mixed" because it can't access the definition from React Native.
-  return mixedPublicInstance;
+let ReadOnlyElementClass;
+function getReadOnlyElementClass(): Class<ReadOnlyElement> {
+  if (ReadOnlyElementClass == null) {
+    // We initialize this lazily to avoid a require cycle.
+    ReadOnlyElementClass = require('./ReadOnlyElement').default;
+  }
+  return ReadOnlyElementClass;
 }

package/src/private/webapis/dom/nodes/internals/NodeInternals.js

@@ -0,0 +1,144 @@
+/**
+ * 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.
+ *
+ * @format
+ * @flow strict-local
+ */
+
+import type {InternalInstanceHandle} from '../../../../../../Libraries/Renderer/shims/ReactNativeTypes';
+import type ReactNativeDocument from '../ReactNativeDocument';
+import type ReadOnlyCharacterData from '../ReadOnlyCharacterData';
+import type ReadOnlyElement from '../ReadOnlyElement';
+import type ReadOnlyNode from '../ReadOnlyNode';
+import type {
+  NativeElementReference,
+  NativeNodeReference,
+  NativeTextReference,
+} from '../specs/NativeDOM';
+import type {ReactNativeDocumentElementInstanceHandle} from './ReactNativeDocumentElementInstanceHandle';
+import type {ReactNativeDocumentInstanceHandle} from './ReactNativeDocumentInstanceHandle';
+
+import {
+  getNativeElementReferenceFromReactNativeDocumentElementInstanceHandle,
+  getPublicInstanceFromReactNativeDocumentElementInstanceHandle,
+  isReactNativeDocumentElementInstanceHandle,
+} from './ReactNativeDocumentElementInstanceHandle';
+import {
+  getNativeNodeReferenceFromReactNativeDocumentInstanceHandle,
+  getPublicInstanceFromReactNativeDocumentInstanceHandle,
+  isReactNativeDocumentInstanceHandle,
+} from './ReactNativeDocumentInstanceHandle';
+
+export type InstanceHandle =
+  | InternalInstanceHandle // component managed by React
+  | ReactNativeDocumentElementInstanceHandle // root element managed by React Native
+  | ReactNativeDocumentInstanceHandle; // document node managed by React Native
+
+let RendererProxy;
+function getRendererProxy() {
+  if (RendererProxy == null) {
+    // Lazy import Fabric here to avoid DOM Node APIs classes from having side-effects.
+    // With a static import we can't use these classes for Paper-only variants.
+    RendererProxy = require('../../../../../../Libraries/ReactNative/RendererProxy');
+  }
+  return RendererProxy;
+}
+
+const INSTANCE_HANDLE_KEY = Symbol('internalInstanceHandle');
+const OWNER_DOCUMENT_KEY = Symbol('ownerDocument');
+
+export function getInstanceHandle(node: ReadOnlyNode): InstanceHandle {
+  // $FlowExpectedError[prop-missing]
+  return node[INSTANCE_HANDLE_KEY];
+}
+
+export function setInstanceHandle(
+  node: ReadOnlyNode,
+  instanceHandle: InstanceHandle,
+): void {
+  // $FlowExpectedError[prop-missing]
+  node[INSTANCE_HANDLE_KEY] = instanceHandle;
+}
+
+export function getOwnerDocument(
+  node: ReadOnlyNode,
+): ReactNativeDocument | null {
+  // $FlowExpectedError[prop-missing]
+  return node[OWNER_DOCUMENT_KEY] ?? null;
+}
+
+export function setOwnerDocument(
+  node: ReadOnlyNode,
+  ownerDocument: ReactNativeDocument | null,
+): void {
+  // $FlowExpectedError[prop-missing]
+  node[OWNER_DOCUMENT_KEY] = ownerDocument;
+}
+
+export function getPublicInstanceFromInstanceHandle(
+  instanceHandle: InstanceHandle,
+): ?ReadOnlyNode {
+  if (isReactNativeDocumentInstanceHandle(instanceHandle)) {
+    return getPublicInstanceFromReactNativeDocumentInstanceHandle(
+      instanceHandle,
+    );
+  }
+
+  if (isReactNativeDocumentElementInstanceHandle(instanceHandle)) {
+    return getPublicInstanceFromReactNativeDocumentElementInstanceHandle(
+      instanceHandle,
+    );
+  }
+
+  const mixedPublicInstance =
+    getRendererProxy().getPublicInstanceFromInternalInstanceHandle(
+      instanceHandle,
+    );
+
+  // $FlowExpectedError[incompatible-return] React defines public instances as "mixed" because it can't access the definition from React Native.
+  return mixedPublicInstance;
+}
+
+export function getNativeNodeReference(
+  node: ReadOnlyNode,
+): ?NativeNodeReference {
+  const instanceHandle = getInstanceHandle(node);
+
+  if (isReactNativeDocumentInstanceHandle(instanceHandle)) {
+    return getNativeNodeReferenceFromReactNativeDocumentInstanceHandle(
+      instanceHandle,
+    );
+  }
+
+  if (isReactNativeDocumentElementInstanceHandle(instanceHandle)) {
+    return getNativeElementReferenceFromReactNativeDocumentElementInstanceHandle(
+      instanceHandle,
+    );
+  }
+
+  // $FlowExpectedError[incompatible-return]
+  return getRendererProxy().getNodeFromInternalInstanceHandle(instanceHandle);
+}
+
+export function getNativeElementReference(
+  node: ReadOnlyElement,
+): ?NativeElementReference {
+  // $FlowExpectedError[incompatible-cast] We know ReadOnlyElement instances provide InternalInstanceHandle
+  const instanceHandle = getInstanceHandle(node) as InternalInstanceHandle;
+
+  // $FlowExpectedError[incompatible-return]
+  return getRendererProxy().getNodeFromInternalInstanceHandle(instanceHandle);
+}
+
+export function getNativeTextReference(
+  node: ReadOnlyCharacterData,
+): ?NativeTextReference {
+  // $FlowExpectedError[incompatible-cast] We know ReadOnlyText instances provide InternalInstanceHandle
+  const instanceHandle = getInstanceHandle(node) as InternalInstanceHandle;
+
+  // $FlowExpectedError[incompatible-return]
+  return getRendererProxy().getNodeFromInternalInstanceHandle(instanceHandle);
+}

package/src/private/webapis/dom/nodes/internals/ReactNativeDocumentElementInstanceHandle.js

@@ -0,0 +1,55 @@
+/**
+ * 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.
+ *
+ * @format
+ * @flow strict-local
+ */
+
+import type ReadOnlyNode from '../ReadOnlyNode';
+import type {NativeElementReference} from '../specs/NativeDOM';
+
+class ReactNativeDocumentElementInstanceHandleImpl {
+  publicInstance: ?ReadOnlyNode;
+  nativeElementReference: ?NativeElementReference;
+}
+
+export opaque type ReactNativeDocumentElementInstanceHandle = ReactNativeDocumentElementInstanceHandleImpl;
+
+export function createReactNativeDocumentElementInstanceHandle(): ReactNativeDocumentElementInstanceHandle {
+  return new ReactNativeDocumentElementInstanceHandleImpl();
+}
+
+export function getNativeElementReferenceFromReactNativeDocumentElementInstanceHandle(
+  instanceHandle: ReactNativeDocumentElementInstanceHandle,
+): ?NativeElementReference {
+  return instanceHandle.nativeElementReference;
+}
+
+export function setNativeElementReferenceForReactNativeDocumentElementInstanceHandle(
+  instanceHandle: ReactNativeDocumentElementInstanceHandle,
+  nativeElementReference: ?NativeElementReference,
+): void {
+  instanceHandle.nativeElementReference = nativeElementReference;
+}
+
+export function getPublicInstanceFromReactNativeDocumentElementInstanceHandle(
+  instanceHandle: ReactNativeDocumentElementInstanceHandle,
+): ?ReadOnlyNode {
+  return instanceHandle.publicInstance;
+}
+
+export function setPublicInstanceForReactNativeDocumentElementInstanceHandle(
+  instanceHandle: ReactNativeDocumentElementInstanceHandle,
+  publicInstance: ?ReadOnlyNode,
+): void {
+  instanceHandle.publicInstance = publicInstance;
+}
+
+export function isReactNativeDocumentElementInstanceHandle(
+  instanceHandle: mixed,
+): instanceHandle is ReactNativeDocumentElementInstanceHandle {
+  return instanceHandle instanceof ReactNativeDocumentElementInstanceHandleImpl;
+}

package/src/private/webapis/dom/nodes/internals/ReactNativeDocumentInstanceHandle.js

@@ -0,0 +1,44 @@
+/**
+ * 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.
+ *
+ * @format
+ * @flow strict-local
+ */
+
+import type {RootTag} from '../../../../../../Libraries/ReactNative/RootTag';
+import type ReactNativeDocument from '../ReactNativeDocument';
+import type {NativeNodeReference} from '../specs/NativeDOM';
+
+import * as RendererProxy from '../../../../../../Libraries/ReactNative/RendererProxy';
+
+export opaque type ReactNativeDocumentInstanceHandle = RootTag;
+
+export function createReactNativeDocumentInstanceHandle(
+  rootTag: RootTag,
+): ReactNativeDocumentInstanceHandle {
+  return rootTag;
+}
+
+export function getNativeNodeReferenceFromReactNativeDocumentInstanceHandle(
+  instanceHandle: ReactNativeDocumentInstanceHandle,
+): ?NativeNodeReference {
+  return instanceHandle;
+}
+
+export function getPublicInstanceFromReactNativeDocumentInstanceHandle(
+  instanceHandle: ReactNativeDocumentInstanceHandle,
+): ?ReactNativeDocument {
+  // $FlowExpectedError[incompatible-return] React defines public instances as "mixed" because it can't access the definition from React Native.
+  return RendererProxy.getPublicInstanceFromRootTag(Number(instanceHandle));
+}
+
+export function isReactNativeDocumentInstanceHandle(
+  instanceHandle: mixed,
+  // $FlowExpectedError[incompatible-type-guard]
+): instanceHandle is ReactNativeDocumentInstanceHandle {
+  // $FlowFixMe[incompatible-type-guard]
+  return typeof instanceHandle === 'number' && instanceHandle % 10 === 1;
+}