react-native 0.71.4 → 0.72.0-rc.0

package/Libraries/DOM/Nodes/ReadOnlyElement.js

@@ -0,0 +1,89 @@
+/**
+ * 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
+ */
+
+// flowlint unsafe-getters-setters:off
+
+import type HTMLCollection from '../OldStyleCollections/HTMLCollection';
+
+import ReadOnlyNode from './ReadOnlyNode';
+
+export default class ReadOnlyElement extends ReadOnlyNode {
+  get childElementCount(): number {
+    throw new TypeError('Unimplemented');
+  }
+
+  get children(): HTMLCollection<ReadOnlyElement> {
+    throw new TypeError('Unimplemented');
+  }
+
+  get clientHeight(): number {
+    throw new TypeError('Unimplemented');
+  }
+
+  get clientLeft(): number {
+    throw new TypeError('Unimplemented');
+  }
+
+  get clientTop(): number {
+    throw new TypeError('Unimplemented');
+  }
+
+  get clientWidth(): number {
+    throw new TypeError('Unimplemented');
+  }
+
+  get firstElementChild(): ReadOnlyElement | null {
+    throw new TypeError('Unimplemented');
+  }
+
+  get id(): string {
+    throw new TypeError('Unimplemented');
+  }
+
+  get lastElementChild(): ReadOnlyElement | null {
+    throw new TypeError('Unimplemented');
+  }
+
+  get nextElementSibling(): ReadOnlyElement | null {
+    throw new TypeError('Unimplemented');
+  }
+
+  get previousElementSibling(): ReadOnlyElement | null {
+    throw new TypeError('Unimplemented');
+  }
+
+  get scrollHeight(): number {
+    throw new TypeError('Unimplemented');
+  }
+
+  get scrollLeft(): number {
+    throw new TypeError('Unimplemented');
+  }
+
+  get scrollTop(): number {
+    throw new TypeError('Unimplemented');
+  }
+
+  get scrollWidth(): number {
+    throw new TypeError('Unimplemented');
+  }
+
+  get tagName(): string {
+    throw new TypeError('Unimplemented');
+  }
+
+  getBoundingClientRect(): DOMRect {
+    throw new TypeError('Unimplemented');
+  }
+
+  getClientRects(): DOMRectList {
+    throw new TypeError('Unimplemented');
+  }
+}

package/Libraries/DOM/Nodes/ReadOnlyNode.js

@@ -0,0 +1,167 @@
+/**
+ * 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
+ */
+
+// flowlint unsafe-getters-setters:off
+
+import type NodeList from '../OldStyleCollections/NodeList';
+import type ReadOnlyElement from './ReadOnlyElement';
+
+export default class ReadOnlyNode {
+  get childNodes(): NodeList<ReadOnlyNode> {
+    throw new TypeError('Unimplemented');
+  }
+
+  get firstChild(): ReadOnlyNode | null {
+    throw new TypeError('Unimplemented');
+  }
+
+  get isConnected(): boolean {
+    throw new TypeError('Unimplemented');
+  }
+
+  get lastChild(): ReadOnlyNode | null {
+    throw new TypeError('Unimplemented');
+  }
+
+  get nextSibling(): ReadOnlyNode | null {
+    throw new TypeError('Unimplemented');
+  }
+
+  get nodeName(): string {
+    throw new TypeError('Unimplemented');
+  }
+
+  get nodeType(): number {
+    throw new TypeError('Unimplemented');
+  }
+
+  get nodeValue(): string | null {
+    throw new TypeError('Unimplemented');
+  }
+
+  get parentElement(): ReadOnlyElement | null {
+    throw new TypeError('Unimplemented');
+  }
+
+  get parentNode(): ReadOnlyNode | null {
+    throw new TypeError('Unimplemented');
+  }
+
+  get previousSibling(): ReadOnlyNode | null {
+    throw new TypeError('Unimplemented');
+  }
+
+  get textContent(): string | null {
+    throw new TypeError('Unimplemented');
+  }
+
+  compareDocumentPosition(otherNode: ReadOnlyNode): number {
+    throw new TypeError('Unimplemented');
+  }
+
+  contains(otherNode: ReadOnlyNode): boolean {
+    throw new TypeError('Unimplemented');
+  }
+
+  getRootNode(): ReadOnlyNode {
+    throw new TypeError('Unimplemented');
+  }
+
+  hasChildNodes(): boolean {
+    throw new TypeError('Unimplemented');
+  }
+
+  /*
+   * Node types, as returned by the `nodeType` property.
+   */
+
+  /**
+   * Type of Element, HTMLElement and ReactNativeElement instances.
+   */
+  static ELEMENT_NODE: number = 1;
+  /**
+   * Currently Unused in React Native.
+   */
+  static ATTRIBUTE_NODE: number = 2;
+  /**
+   * Text nodes.
+   */
+  static TEXT_NODE: number = 3;
+  /**
+   * @deprecated Unused in React Native.
+   */
+  static CDATA_SECTION_NODE: number = 4;
+  /**
+   * @deprecated
+   */
+  static ENTITY_REFERENCE_NODE: number = 5;
+  /**
+   * @deprecated
+   */
+  static ENTITY_NODE: number = 6;
+  /**
+   * @deprecated Unused in React Native.
+   */
+  static PROCESSING_INSTRUCTION_NODE: number = 7;
+  /**
+   * @deprecated Unused in React Native.
+   */
+  static COMMENT_NODE: number = 8;
+  /**
+   * @deprecated Unused in React Native.
+   */
+  static DOCUMENT_NODE: number = 9;
+  /**
+   * @deprecated Unused in React Native.
+   */
+  static DOCUMENT_TYPE_NODE: number = 10;
+  /**
+   * @deprecated Unused in React Native.
+   */
+  static DOCUMENT_FRAGMENT_NODE: number = 11;
+  /**
+   * @deprecated
+   */
+  static NOTATION_NODE: number = 12;
+
+  /*
+   * Document position flags. Used to check the return value of
+   * `compareDocumentPosition()`.
+   */
+
+  /**
+   * Both nodes are in different documents.
+   */
+  static DOCUMENT_POSITION_DISCONNECTED: number = 1;
+  /**
+   * `otherNode` precedes the node in either a pre-order depth-first traversal of a tree containing both
+   * (e.g., as an ancestor or previous sibling or a descendant of a previous sibling or previous sibling of an ancestor)
+   * or (if they are disconnected) in an arbitrary but consistent ordering.
+   */
+  static DOCUMENT_POSITION_PRECEDING: number = 2;
+  /**
+   * `otherNode` follows the node in either a pre-order depth-first traversal of a tree containing both
+   * (e.g., as a descendant or following sibling or a descendant of a following sibling or following sibling of an ancestor)
+   * or (if they are disconnected) in an arbitrary but consistent ordering.
+   */
+  static DOCUMENT_POSITION_FOLLOWING: number = 4;
+  /**
+   * `otherNode` is an ancestor of the node.
+   */
+  static DOCUMENT_POSITION_CONTAINS: number = 8;
+  /**
+   * `otherNode` is a descendant of the node.
+   */
+  static DOCUMENT_POSITION_CONTAINED_BY: number = 16;
+  /**
+   * @deprecated Unused in React Native.
+   */
+  static DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC: number = 32;
+}

package/Libraries/DOM/OldStyleCollections/ArrayLikeUtils.js

@@ -0,0 +1,46 @@
+/**
+ * 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
+ */
+
+/**
+ * This definition is different from the current built-in type `$ArrayLike`
+ * provided by Flow, in that this is an interface and that one is an object.
+ *
+ * The difference is important because, when using objects, Flow thinks
+ * a `length` property would be copied over when using the spread operator,
+ * which is incorrect.
+ */
+export interface ArrayLike<T> extends Iterable<T> {
+  // This property should've been read-only as well, but Flow doesn't handle
+  // read-only indexers correctly (thinks reads are writes and fails).
+  [indexer: number]: T;
+  +length: number;
+}
+
+export function* createValueIterator<T>(arrayLike: ArrayLike<T>): Iterator<T> {
+  for (let i = 0; i < arrayLike.length; i++) {
+    yield arrayLike[i];
+  }
+}
+
+export function* createKeyIterator<T>(
+  arrayLike: ArrayLike<T>,
+): Iterator<number> {
+  for (let i = 0; i < arrayLike.length; i++) {
+    yield i;
+  }
+}
+
+export function* createEntriesIterator<T>(
+  arrayLike: ArrayLike<T>,
+): Iterator<[number, T]> {
+  for (let i = 0; i < arrayLike.length; i++) {
+    yield [i, arrayLike[i]];
+  }
+}

package/Libraries/DOM/OldStyleCollections/DOMRectList.js

@@ -0,0 +1,76 @@
+/**
+ * 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
+ */
+
+// flowlint unsafe-getters-setters:off
+
+import type DOMRectReadOnly from '../Geometry/DOMRectReadOnly';
+import type {ArrayLike} from './ArrayLikeUtils';
+
+import {createValueIterator} from './ArrayLikeUtils';
+
+// IMPORTANT: The Flow type definition for this module is defined in `DOMRectList.js.flow`
+// because Flow only supports indexers in classes in declaration files.
+
+// $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;
+
+  /**
+   * Use `createDOMRectList` to create instances of this class.
+   *
+   * @private This is not defined in the declaration file, so users will not see
+   *          the signature of the constructor.
+   */
+  constructor(elements: $ReadOnlyArray<DOMRectReadOnly>) {
+    for (let i = 0; i < elements.length; i++) {
+      Object.defineProperty(this, i, {
+        value: elements[i],
+        enumerable: true,
+        configurable: false,
+        writable: false,
+      });
+    }
+
+    this._length = elements.length;
+  }
+
+  get length(): number {
+    return this._length;
+  }
+
+  item(index: number): DOMRectReadOnly | null {
+    if (index < 0 || index >= this._length) {
+      return null;
+    }
+
+    // assigning to the interface allows us to access the indexer property in a
+    // type-safe way.
+    // eslint-disable-next-line consistent-this
+    const arrayLike: ArrayLike<DOMRectReadOnly> = this;
+    return arrayLike[index];
+  }
+
+  // $FlowIssue[unsupported-syntax] Flow does not support computed properties in classes.
+  [Symbol.iterator](): Iterator<DOMRectReadOnly> {
+    return createValueIterator(this);
+  }
+}
+
+/**
+ * This is an internal method to create instances of `DOMRectList`,
+ * which avoids leaking its constructor to end users.
+ * We can do that because the external definition of `DOMRectList` lives in
+ * `DOMRectList.js.flow`, not here.
+ */
+export function createDOMRectList(
+  elements: $ReadOnlyArray<DOMRectReadOnly>,
+): DOMRectList {
+  return new DOMRectList(elements);
+}

package/Libraries/DOM/OldStyleCollections/DOMRectList.js.flow

@@ -0,0 +1,27 @@
+/**
+ * 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
+ */
+
+import type {ArrayLike} from './ArrayLikeUtils';
+import type DOMRectReadOnly from '../Geometry/DOMRectReadOnly';
+
+declare export default class DOMRectList
+  implements Iterable<DOMRectReadOnly>, ArrayLike<DOMRectReadOnly>
+{
+  // This property should've been read-only as well, but Flow doesn't handle
+  // read-only indexers correctly (thinks reads are writes and fails).
+  [index: number]: DOMRectReadOnly;
+  +length: number;
+  item(index: number): DOMRectReadOnly | null;
+  @@iterator(): Iterator<DOMRectReadOnly>;
+}
+
+declare export function createDOMRectList(
+  domRects: $ReadOnlyArray<DOMRectReadOnly>,
+): DOMRectList;

package/Libraries/DOM/OldStyleCollections/HTMLCollection.js

@@ -0,0 +1,82 @@
+/**
+ * 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
+ */
+
+// flowlint unsafe-getters-setters:off
+
+import type {ArrayLike} from './ArrayLikeUtils';
+
+import {createValueIterator} from './ArrayLikeUtils';
+
+// IMPORTANT: The type definition for this module is defined in `HTMLCollection.js.flow`
+// because Flow only supports indexers in classes in declaration files.
+
+// $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;
+
+  /**
+   * Use `createHTMLCollection` to create instances of this class.
+   *
+   * @private This is not defined in the declaration file, so users will not see
+   *          the signature of the constructor.
+   */
+  constructor(elements: $ReadOnlyArray<T>) {
+    for (let i = 0; i < elements.length; i++) {
+      Object.defineProperty(this, i, {
+        value: elements[i],
+        enumerable: true,
+        configurable: false,
+        writable: false,
+      });
+    }
+
+    this._length = elements.length;
+  }
+
+  get length(): number {
+    return this._length;
+  }
+
+  item(index: number): T | null {
+    if (index < 0 || index >= this._length) {
+      return null;
+    }
+
+    // assigning to the interface allows us to access the indexer property in a
+    // type-safe way.
+    // eslint-disable-next-line consistent-this
+    const arrayLike: ArrayLike<T> = this;
+    return arrayLike[index];
+  }
+
+  /**
+   * @deprecated Unused in React Native.
+   */
+  namedItem(name: string): T | null {
+    return null;
+  }
+
+  // $FlowIssue[unsupported-syntax] Flow does not support computed properties in classes.
+  [Symbol.iterator](): Iterator<T> {
+    return createValueIterator(this);
+  }
+}
+
+/**
+ * This is an internal method to create instances of `HTMLCollection`,
+ * which avoids leaking its constructor to end users.
+ * We can do that because the external definition of `HTMLCollection` lives in
+ * `HTMLCollection.js.flow`, not here.
+ */
+export function createHTMLCollection<T>(
+  elements: $ReadOnlyArray<T>,
+): HTMLCollection<T> {
+  return new HTMLCollection(elements);
+}

package/Libraries/DOM/OldStyleCollections/HTMLCollection.js.flow

@@ -0,0 +1,27 @@
+/**
+ * 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
+ */
+
+import type {ArrayLike} from './ArrayLikeUtils';
+
+declare export default class HTMLCollection<+T>
+  implements Iterable<T>, ArrayLike<T>
+{
+  // This property should've been read-only as well, but Flow doesn't handle
+  // read-only indexers correctly (thinks reads are writes and fails).
+  [index: number]: T;
+  +length: number;
+  item(index: number): T | null;
+  namedItem(name: string): T | null;
+  @@iterator(): Iterator<T>;
+}
+
+declare export function createHTMLCollection<T>(
+  elements: $ReadOnlyArray<T>,
+): HTMLCollection<T>;

package/Libraries/DOM/OldStyleCollections/NodeList.js

@@ -0,0 +1,104 @@
+/**
+ * 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
+ */
+
+// flowlint unsafe-getters-setters:off
+
+import type {ArrayLike} from './ArrayLikeUtils';
+
+import {
+  createEntriesIterator,
+  createKeyIterator,
+  createValueIterator,
+} from './ArrayLikeUtils';
+
+// IMPORTANT: The Flow type definition for this module is defined in `NodeList.js.flow`
+// because Flow only supports indexers in classes in declaration files.
+
+// $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;
+
+  /**
+   * Use `createNodeList` to create instances of this class.
+   *
+   * @private This is not defined in the declaration file, so users will not see
+   *          the signature of the constructor.
+   */
+  constructor(elements: $ReadOnlyArray<T>) {
+    for (let i = 0; i < elements.length; i++) {
+      Object.defineProperty(this, i, {
+        value: elements[i],
+        writable: false,
+      });
+    }
+    this._length = elements.length;
+  }
+
+  get length(): number {
+    return this._length;
+  }
+
+  item(index: number): T | null {
+    if (index < 0 || index >= this._length) {
+      return null;
+    }
+
+    // assigning to the interface allows us to access the indexer property in a
+    // type-safe way.
+    // eslint-disable-next-line consistent-this
+    const arrayLike: ArrayLike<T> = this;
+    return arrayLike[index];
+  }
+
+  entries(): Iterator<[number, T]> {
+    return createEntriesIterator(this);
+  }
+
+  forEach<ThisType>(
+    callbackFn: (value: T, index: number, array: NodeList<T>) => mixed,
+    thisArg?: ThisType,
+  ): void {
+    // assigning to the interface allows us to access the indexer property in a
+    // type-safe way.
+    // eslint-disable-next-line consistent-this
+    const arrayLike: ArrayLike<T> = this;
+
+    for (let index = 0; index < this._length; index++) {
+      if (thisArg == null) {
+        callbackFn(arrayLike[index], index, this);
+      } else {
+        callbackFn.call(thisArg, arrayLike[index], index, this);
+      }
+    }
+  }
+
+  keys(): Iterator<number> {
+    return createKeyIterator(this);
+  }
+
+  values(): Iterator<T> {
+    return createValueIterator(this);
+  }
+
+  // $FlowIssue[unsupported-syntax] Flow does not support computed properties in classes.
+  [Symbol.iterator](): Iterator<T> {
+    return createValueIterator(this);
+  }
+}
+
+/**
+ * This is an internal method to create instances of `NodeList`,
+ * which avoids leaking its constructor to end users.
+ * We can do that because the external definition of `NodeList` lives in
+ * `NodeList.js.flow`, not here.
+ */
+export function createNodeList<T>(elements: $ReadOnlyArray<T>): NodeList<T> {
+  return new NodeList(elements);
+}

package/Libraries/DOM/OldStyleCollections/NodeList.js.flow

@@ -0,0 +1,31 @@
+/**
+ * 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
+ */
+
+import type {ArrayLike} from './ArrayLikeUtils';
+
+declare export default class NodeList<+T> implements Iterable<T>, ArrayLike<T> {
+  // This property should've been read-only as well, but Flow doesn't handle
+  // read-only indexers correctly (thinks reads are writes and fails).
+  [index: number]: T;
+  +length: number;
+  item(index: number): T | null;
+  entries(): Iterator<[number, T]>;
+  forEach<ThisType>(
+    callbackFn: (value: T, index: number, array: NodeList<T>) => mixed,
+    thisArg?: ThisType,
+  ): void;
+  keys(): Iterator<number>;
+  values(): Iterator<T>;
+  @@iterator(): Iterator<T>;
+}
+
+declare export function createNodeList<T>(
+  elements: $ReadOnlyArray<T>,
+): NodeList<T>;

package/Libraries/DevToolsSettings/DevToolsSettingsManager.android.js

@@ -0,0 +1,35 @@
+/**
+ * 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
+ */
+
+import DevSettings from '../Utilities/DevSettings';
+import NativeDevToolsSettingsManager from './NativeDevToolsSettingsManager';
+
+module.exports = {
+  setConsolePatchSettings(newSettings: string) {
+    NativeDevToolsSettingsManager?.setConsolePatchSettings(newSettings);
+  },
+  getConsolePatchSettings(): ?string {
+    return NativeDevToolsSettingsManager?.getConsolePatchSettings();
+  },
+  setProfilingSettings(newSettings: string) {
+    if (NativeDevToolsSettingsManager?.setProfilingSettings != null) {
+      NativeDevToolsSettingsManager.setProfilingSettings(newSettings);
+    }
+  },
+  getProfilingSettings(): ?string {
+    if (NativeDevToolsSettingsManager?.getProfilingSettings != null) {
+      return NativeDevToolsSettingsManager.getProfilingSettings();
+    }
+    return null;
+  },
+  reload(): void {
+    DevSettings?.reload();
+  },
+};