react-native-windows 0.74.12 → 0.75.0-preview.2

package/src/private/webapis/dom/nodes/specs/__mocks__/NativeDOMMock.js

@@ -0,0 +1,413 @@
+/**
+ * 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.
+ *
+ * @flow strict-local
+ * @format
+ * @oncall react_native
+ */
+
+import type {
+  InternalInstanceHandle,
+  Node,
+} from '../../../../../../../Libraries/Renderer/shims/ReactNativeTypes';
+import type {
+  MeasureInWindowOnSuccessCallback,
+  MeasureLayoutOnSuccessCallback,
+  MeasureOnSuccessCallback,
+} from '../NativeDOM';
+import typeof NativeDOM from '../NativeDOM';
+
+import {
+  ensureHostNode,
+  fromNode,
+  getAncestorsInCurrentTree,
+  getNodeInCurrentTree,
+} from '../../../../../../../Libraries/ReactNative/__mocks__/FabricUIManager';
+
+function* dfs(node: ?Node): Iterator<Node> {
+  if (node == null) {
+    return;
+  }
+
+  yield node;
+
+  for (const child of fromNode(node).children) {
+    yield* dfs(child);
+  }
+}
+
+function hasDisplayNone(node: Node): boolean {
+  const props = fromNode(node).props;
+  // Style is flattened when passed to native, so there's no style object.
+  // $FlowFixMe[prop-missing]
+  return props != null && props.display === 'none';
+}
+
+const NativeDOMMock: NativeDOM = {
+  getBoundingClientRect: jest.fn(
+    (
+      node: Node,
+      includeTransform: boolean,
+    ): [
+      /* x:*/ number,
+      /* y:*/ number,
+      /* width:*/ number,
+      /* height:*/ number,
+    ] => {
+      ensureHostNode(node);
+
+      const nodeInCurrentTree = getNodeInCurrentTree(node);
+      const currentProps =
+        nodeInCurrentTree != null ? fromNode(nodeInCurrentTree).props : null;
+      if (currentProps == null) {
+        return [0, 0, 0, 0];
+      }
+
+      const boundingClientRectForTests: ?{
+        x: number,
+        y: number,
+        width: number,
+        height: number,
+      } =
+        // $FlowExpectedError[prop-missing]
+        currentProps.__boundingClientRectForTests;
+
+      if (boundingClientRectForTests == null) {
+        return [0, 0, 0, 0];
+      }
+
+      const {x, y, width, height} = boundingClientRectForTests;
+      return [x, y, width, height];
+    },
+  ),
+
+  hasPointerCapture: jest.fn((node: Node, pointerId: number): boolean => false),
+
+  setPointerCapture: jest.fn((node: Node, pointerId: number): void => {}),
+
+  releasePointerCapture: jest.fn((node: Node, pointerId: number): void => {}),
+
+  getParentNode: jest.fn((node: Node): ?InternalInstanceHandle => {
+    const ancestors = getAncestorsInCurrentTree(node);
+    if (ancestors == null || ancestors.length - 2 < 0) {
+      return null;
+    }
+
+    const [parentOfParent, position] = ancestors[ancestors.length - 2];
+    const parentInCurrentTree = fromNode(parentOfParent).children[position];
+    return fromNode(parentInCurrentTree).instanceHandle;
+  }),
+
+  getChildNodes: jest.fn(
+    (node: Node): $ReadOnlyArray<InternalInstanceHandle> => {
+      const nodeInCurrentTree = getNodeInCurrentTree(node);
+
+      if (nodeInCurrentTree == null) {
+        return [];
+      }
+
+      return fromNode(nodeInCurrentTree).children.map(
+        child => fromNode(child).instanceHandle,
+      );
+    },
+  ),
+
+  isConnected: jest.fn((node: Node): boolean => {
+    return getNodeInCurrentTree(node) != null;
+  }),
+
+  getTextContent: jest.fn((node: Node): string => {
+    const nodeInCurrentTree = getNodeInCurrentTree(node);
+
+    let result = '';
+
+    if (nodeInCurrentTree == null) {
+      return result;
+    }
+
+    for (const childNode of dfs(nodeInCurrentTree)) {
+      if (fromNode(childNode).viewName === 'RCTRawText') {
+        const props = fromNode(childNode).props;
+        // $FlowExpectedError[prop-missing]
+        const maybeString: ?string = props.text;
+        if (typeof maybeString === 'string') {
+          result += maybeString;
+        }
+      }
+    }
+    return result;
+  }),
+
+  compareDocumentPosition: jest.fn((node: Node, otherNode: Node): number => {
+    /* eslint-disable no-bitwise */
+    const ReadOnlyNode = require('../../ReadOnlyNode').default;
+
+    // Quick check for node vs. itself
+    if (fromNode(node).reactTag === fromNode(otherNode).reactTag) {
+      return 0;
+    }
+
+    if (fromNode(node).rootTag !== fromNode(otherNode).rootTag) {
+      return ReadOnlyNode.DOCUMENT_POSITION_DISCONNECTED;
+    }
+
+    const ancestors = getAncestorsInCurrentTree(node);
+    if (ancestors == null) {
+      return ReadOnlyNode.DOCUMENT_POSITION_DISCONNECTED;
+    }
+
+    const otherAncestors = getAncestorsInCurrentTree(otherNode);
+    if (otherAncestors == null) {
+      return ReadOnlyNode.DOCUMENT_POSITION_DISCONNECTED;
+    }
+
+    // Consume all common ancestors
+    let i = 0;
+    while (
+      i < ancestors.length &&
+      i < otherAncestors.length &&
+      ancestors[i][1] === otherAncestors[i][1]
+    ) {
+      i++;
+    }
+
+    if (i === ancestors.length) {
+      return (
+        ReadOnlyNode.DOCUMENT_POSITION_CONTAINED_BY |
+        ReadOnlyNode.DOCUMENT_POSITION_FOLLOWING
+      );
+    }
+
+    if (i === otherAncestors.length) {
+      return (
+        ReadOnlyNode.DOCUMENT_POSITION_CONTAINS |
+        ReadOnlyNode.DOCUMENT_POSITION_PRECEDING
+      );
+    }
+
+    if (ancestors[i][1] > otherAncestors[i][1]) {
+      return ReadOnlyNode.DOCUMENT_POSITION_PRECEDING;
+    }
+
+    return ReadOnlyNode.DOCUMENT_POSITION_FOLLOWING;
+  }),
+
+  getOffset: jest.fn(
+    (
+      node: Node,
+    ): [
+      /* offsetParent: */ ?InternalInstanceHandle,
+      /* offsetTop: */ number,
+      /* offsetLeft: */ number,
+    ] => {
+      const ancestors = getAncestorsInCurrentTree(node);
+      if (ancestors == null) {
+        return [null, 0, 0];
+      }
+
+      const [parent, position] = ancestors[ancestors.length - 1];
+      const nodeInCurrentTree = fromNode(parent).children[position];
+
+      const currentProps =
+        nodeInCurrentTree != null ? fromNode(nodeInCurrentTree).props : null;
+      if (currentProps == null || hasDisplayNone(nodeInCurrentTree)) {
+        return [null, 0, 0];
+      }
+
+      const offsetForTests: ?{
+        top: number,
+        left: number,
+      } =
+        // $FlowExpectedError[prop-missing]
+        currentProps.__offsetForTests;
+
+      if (offsetForTests == null) {
+        return [null, 0, 0];
+      }
+
+      let currentIndex = ancestors.length - 1;
+      while (currentIndex >= 0 && !hasDisplayNone(ancestors[currentIndex][0])) {
+        currentIndex--;
+      }
+
+      if (currentIndex >= 0) {
+        // The node or one of its ancestors have display: none
+        return [null, 0, 0];
+      }
+
+      return [
+        fromNode(parent).instanceHandle,
+        offsetForTests.top,
+        offsetForTests.left,
+      ];
+    },
+  ),
+
+  getScrollPosition: jest.fn(
+    (node: Node): [/* scrollLeft: */ number, /* scrollTop: */ number] => {
+      ensureHostNode(node);
+
+      const nodeInCurrentTree = getNodeInCurrentTree(node);
+      const currentProps =
+        nodeInCurrentTree != null ? fromNode(nodeInCurrentTree).props : null;
+      if (currentProps == null) {
+        return [0, 0];
+      }
+
+      const scrollForTests: ?{
+        scrollLeft: number,
+        scrollTop: number,
+        ...
+      } =
+        // $FlowExpectedError[prop-missing]
+        currentProps.__scrollForTests;
+
+      if (scrollForTests == null) {
+        return [0, 0];
+      }
+
+      const {scrollLeft, scrollTop} = scrollForTests;
+      return [scrollLeft, scrollTop];
+    },
+  ),
+
+  getScrollSize: jest.fn(
+    (node: Node): [/* scrollLeft: */ number, /* scrollTop: */ number] => {
+      ensureHostNode(node);
+
+      const nodeInCurrentTree = getNodeInCurrentTree(node);
+      const currentProps =
+        nodeInCurrentTree != null ? fromNode(nodeInCurrentTree).props : null;
+      if (currentProps == null) {
+        return [0, 0];
+      }
+
+      const scrollForTests: ?{
+        scrollWidth: number,
+        scrollHeight: number,
+        ...
+      } =
+        // $FlowExpectedError[prop-missing]
+        currentProps.__scrollForTests;
+
+      if (scrollForTests == null) {
+        return [0, 0];
+      }
+
+      const {scrollWidth, scrollHeight} = scrollForTests;
+      return [scrollWidth, scrollHeight];
+    },
+  ),
+
+  getInnerSize: jest.fn(
+    (node: Node): [/* width: */ number, /* height: */ number] => {
+      ensureHostNode(node);
+
+      const nodeInCurrentTree = getNodeInCurrentTree(node);
+      const currentProps =
+        nodeInCurrentTree != null ? fromNode(nodeInCurrentTree).props : null;
+      if (currentProps == null) {
+        return [0, 0];
+      }
+
+      const innerSizeForTests: ?{
+        width: number,
+        height: number,
+        ...
+      } =
+        // $FlowExpectedError[prop-missing]
+        currentProps.__innerSizeForTests;
+
+      if (innerSizeForTests == null) {
+        return [0, 0];
+      }
+
+      const {width, height} = innerSizeForTests;
+      return [width, height];
+    },
+  ),
+
+  getBorderWidth: jest.fn(
+    (
+      node: Node,
+    ): [
+      /* topWidth: */ number,
+      /* rightWidth: */ number,
+      /* bottomWidth: */ number,
+      /* leftWidth: */ number,
+    ] => {
+      ensureHostNode(node);
+
+      const nodeInCurrentTree = getNodeInCurrentTree(node);
+      const currentProps =
+        nodeInCurrentTree != null ? fromNode(nodeInCurrentTree).props : null;
+      if (currentProps == null) {
+        return [0, 0, 0, 0];
+      }
+
+      const borderSizeForTests: ?{
+        topWidth?: number,
+        rightWidth?: number,
+        bottomWidth?: number,
+        leftWidth?: number,
+        ...
+      } =
+        // $FlowExpectedError[prop-missing]
+        currentProps.__borderSizeForTests;
+
+      if (borderSizeForTests == null) {
+        return [0, 0, 0, 0];
+      }
+
+      const {
+        topWidth = 0,
+        rightWidth = 0,
+        bottomWidth = 0,
+        leftWidth = 0,
+      } = borderSizeForTests;
+      return [topWidth, rightWidth, bottomWidth, leftWidth];
+    },
+  ),
+
+  getTagName: jest.fn((node: Node): string => {
+    ensureHostNode(node);
+    return 'RN:' + fromNode(node).viewName;
+  }),
+
+  /**
+   * Legacy layout APIs
+   */
+
+  measure: jest.fn((node: Node, callback: MeasureOnSuccessCallback): void => {
+    ensureHostNode(node);
+
+    callback(10, 10, 100, 100, 0, 0);
+  }),
+
+  measureInWindow: jest.fn(
+    (node: Node, callback: MeasureInWindowOnSuccessCallback): void => {
+      ensureHostNode(node);
+
+      callback(10, 10, 100, 100);
+    },
+  ),
+
+  measureLayout: jest.fn(
+    (
+      node: Node,
+      relativeNode: Node,
+      onFail: () => void,
+      onSuccess: MeasureLayoutOnSuccessCallback,
+    ): void => {
+      ensureHostNode(node);
+      ensureHostNode(relativeNode);
+
+      onSuccess(1, 1, 100, 100);
+    },
+  ),
+};
+
+export default NativeDOMMock;

package/src/private/webapis/dom/oldstylecollections/DOMRectList.js

@@ -20,7 +20,7 @@ import {createValueIterator} from './ArrayLikeUtils';
 
 // $FlowIssue[prop-missing] Flow doesn't understand [Symbol.iterator]() {} and thinks this class doesn't implement the Iterable interface.
 export default class DOMRectList implements Iterable<DOMRectReadOnly> {
-  _length: number;
+  #length: number;
 
   /**
    * Use `createDOMRectList` to create instances of this class.
@@ -38,15 +38,15 @@ export default class DOMRectList implements Iterable<DOMRectReadOnly> {
       });
     }
 
-    this._length = elements.length;
+    this.#length = elements.length;
   }
 
   get length(): number {
-    return this._length;
+    return this.#length;
   }
 
   item(index: number): DOMRectReadOnly | null {
-    if (index < 0 || index >= this._length) {
+    if (index < 0 || index >= this.#length) {
       return null;
     }
 

package/src/private/webapis/dom/oldstylecollections/HTMLCollection.js

@@ -19,7 +19,7 @@ import {createValueIterator} from './ArrayLikeUtils';
 
 // $FlowIssue[prop-missing] Flow doesn't understand [Symbol.iterator]() {} and thinks this class doesn't implement the Iterable<T> interface.
 export default class HTMLCollection<T> implements Iterable<T>, ArrayLike<T> {
-  _length: number;
+  #length: number;
 
   /**
    * Use `createHTMLCollection` to create instances of this class.
@@ -37,15 +37,15 @@ export default class HTMLCollection<T> implements Iterable<T>, ArrayLike<T> {
       });
     }
 
-    this._length = elements.length;
+    this.#length = elements.length;
   }
 
   get length(): number {
-    return this._length;
+    return this.#length;
   }
 
   item(index: number): T | null {
-    if (index < 0 || index >= this._length) {
+    if (index < 0 || index >= this.#length) {
       return null;
     }
 

package/src/private/webapis/dom/oldstylecollections/NodeList.js

@@ -23,7 +23,7 @@ import {
 
 // $FlowIssue[prop-missing] Flow doesn't understand [Symbol.iterator]() {} and thinks this class doesn't implement the Iterable<T> interface.
 export default class NodeList<T> implements Iterable<T>, ArrayLike<T> {
-  _length: number;
+  #length: number;
 
   /**
    * Use `createNodeList` to create instances of this class.
@@ -38,15 +38,15 @@ export default class NodeList<T> implements Iterable<T>, ArrayLike<T> {
         writable: false,
       });
     }
-    this._length = elements.length;
+    this.#length = elements.length;
   }
 
   get length(): number {
-    return this._length;
+    return this.#length;
   }
 
   item(index: number): T | null {
-    if (index < 0 || index >= this._length) {
+    if (index < 0 || index >= this.#length) {
       return null;
     }
 
@@ -70,7 +70,7 @@ export default class NodeList<T> implements Iterable<T>, ArrayLike<T> {
     // eslint-disable-next-line consistent-this
     const arrayLike: ArrayLike<T> = this;
 
-    for (let index = 0; index < this._length; index++) {
+    for (let index = 0; index < this.#length; index++) {
       if (thisArg == null) {
         callbackFn(arrayLike[index], index, this);
       } else {

package/src/private/webapis/idlecallbacks/specs/NativeIdleCallbacks.js

@@ -0,0 +1,34 @@
+/**
+ * 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.
+ *
+ * @flow strict
+ * @format
+ */
+
+import type {TurboModule} from '../../../../../Libraries/TurboModule/RCTExport';
+
+import * as TurboModuleRegistry from '../../../../../Libraries/TurboModule/TurboModuleRegistry';
+
+export type RequestIdleCallbackOptions = {
+  timeout?: number,
+};
+
+export type IdleDeadline = {
+  didTimeout: boolean,
+  timeRemaining: () => mixed,
+};
+
+export interface Spec extends TurboModule {
+  +requestIdleCallback: (
+    callback: (idleDeadline: IdleDeadline) => mixed,
+    options?: RequestIdleCallbackOptions,
+  ) => mixed;
+  +cancelIdleCallback: (handle: mixed) => void;
+}
+
+export default (TurboModuleRegistry.getEnforcing<Spec>(
+  'NativeIdleCallbacksCxx',
+): Spec);

package/src/private/webapis/microtasks/specs/NativeMicrotasks.js

@@ -0,0 +1,21 @@
+/**
+ * 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.
+ *
+ * @flow strict
+ * @format
+ */
+
+import type {TurboModule} from '../../../../../Libraries/TurboModule/RCTExport';
+
+import * as TurboModuleRegistry from '../../../../../Libraries/TurboModule/TurboModuleRegistry';
+
+export interface Spec extends TurboModule {
+  +queueMicrotask: (callback: () => mixed) => void;
+}
+
+export default (TurboModuleRegistry.getEnforcing<Spec>(
+  'NativeMicrotasksCxx',
+): Spec);

package/src/private/webapis/performance/EventCounts.js

@@ -8,8 +8,8 @@
  * @format
  */
 
-import NativePerformanceObserver from './NativePerformanceObserver';
 import {warnNoNativePerformanceObserver} from './PerformanceObserver';
+import NativePerformanceObserver from './specs/NativePerformanceObserver';
 
 type EventCountsForEachCallbackType =
   | (() => void)

package/src/private/webapis/performance/MemoryInfo.js

@@ -19,15 +19,15 @@ type MemoryInfoLike = {
 
 // Read-only object with JS memory information. This is returned by the performance.memory API.
 export default class MemoryInfo {
-  _jsHeapSizeLimit: ?number;
-  _totalJSHeapSize: ?number;
-  _usedJSHeapSize: ?number;
+  #jsHeapSizeLimit: ?number;
+  #totalJSHeapSize: ?number;
+  #usedJSHeapSize: ?number;
 
   constructor(memoryInfo: ?MemoryInfoLike) {
     if (memoryInfo != null) {
-      this._jsHeapSizeLimit = memoryInfo.jsHeapSizeLimit;
-      this._totalJSHeapSize = memoryInfo.totalJSHeapSize;
-      this._usedJSHeapSize = memoryInfo.usedJSHeapSize;
+      this.#jsHeapSizeLimit = memoryInfo.jsHeapSizeLimit;
+      this.#totalJSHeapSize = memoryInfo.totalJSHeapSize;
+      this.#usedJSHeapSize = memoryInfo.usedJSHeapSize;
     }
   }
 
@@ -35,20 +35,20 @@ export default class MemoryInfo {
    * The maximum size of the heap, in bytes, that is available to the context
    */
   get jsHeapSizeLimit(): ?number {
-    return this._jsHeapSizeLimit;
+    return this.#jsHeapSizeLimit;
   }
 
   /**
    * The total allocated heap size, in bytes
    */
   get totalJSHeapSize(): ?number {
-    return this._totalJSHeapSize;
+    return this.#totalJSHeapSize;
   }
 
   /**
    * The currently active segment of JS heap, in bytes.
    */
   get usedJSHeapSize(): ?number {
-    return this._usedJSHeapSize;
+    return this.#usedJSHeapSize;
   }
 }