@office-iss/react-native-win32 0.71.5 → 0.72.0-preview.1

package/Libraries/Core/setUpSegmentFetcher.js

@@ -11,7 +11,6 @@
 'use strict';
 
 export type FetchSegmentFunction = typeof __fetchSegment;
-export type GetSegmentFunction = typeof __getSegment;
 
 /**
  * Set up SegmentFetcher.
@@ -51,43 +50,3 @@ function __fetchSegment(
 }
 
 global.__fetchSegment = __fetchSegment;
-
-function __getSegment(
-  segmentId: number,
-  options: $ReadOnly<{
-    otaBuildNumber: ?string,
-    requestedModuleName: string,
-    segmentHash: string,
-  }>,
-  callback: (?Error, ?string) => void,
-) {
-  const SegmentFetcher =
-    require('./SegmentFetcher/NativeSegmentFetcher').default;
-
-  if (!SegmentFetcher.getSegment) {
-    throw new Error('SegmentFetcher.getSegment must be defined');
-  }
-
-  SegmentFetcher.getSegment(
-    segmentId,
-    options,
-    (
-      errorObject: ?{
-        message: string,
-        code: string,
-        ...
-      },
-      path: ?string,
-    ) => {
-      if (errorObject) {
-        const error = new Error(errorObject.message);
-        (error: any).code = errorObject.code; // flowlint-line unclear-type: off
-        callback(error);
-      }
-
-      callback(null, path);
-    },
-  );
-}
-
-global.__getSegment = __getSegment;

package/Libraries/Core/setUpTimers.js

@@ -61,7 +61,7 @@ if (global.RN$Bridgeless !== true) {
  * as the Promise.
  */
 if (hasPromiseQueuedToJSVM) {
-  // When promise queues to the JSVM microtasks queue, we shim the immedaite
+  // When promise queues to the JSVM microtasks queue, we shim the immediate
   // APIs via `queueMicrotask` to maintain the backward compatibility.
   polyfillGlobal(
     'setImmediate',
@@ -95,7 +95,7 @@ if (hasHermesPromiseQueuedToJSVM) {
   // Fast path for Hermes.
   polyfillGlobal('queueMicrotask', () => global.HermesInternal?.enqueueJob);
 } else {
-  // Polyfill it with promise (regardless it's polyfiled or native) otherwise.
+  // Polyfill it with promise (regardless it's polyfilled or native) otherwise.
   polyfillGlobal(
     'queueMicrotask',
     () => require('./Timers/queueMicrotask.js').default,

package/Libraries/DOM/Geometry/DOMRect.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.
+ *
+ * @flow strict
+ * @format
+ */
+
+/**
+ * The JSDoc comments in this file have been extracted from [DOMRect](https://developer.mozilla.org/en-US/docs/Web/API/DOMRect).
+ * Content by [Mozilla Contributors](https://developer.mozilla.org/en-US/docs/Web/API/DOMRect/contributors.txt),
+ * licensed under [CC-BY-SA 2.5](https://creativecommons.org/licenses/by-sa/2.5/).
+ */
+
+import DOMRectReadOnly, {type DOMRectLike} from './DOMRectReadOnly';
+
+// flowlint unsafe-getters-setters:off
+
+/**
+ * A `DOMRect` describes the size and position of a rectangle.
+ * The type of box represented by the `DOMRect` is specified by the method or property that returned it.
+ *
+ * This is a (mostly) spec-compliant version of `DOMRect` (https://developer.mozilla.org/en-US/docs/Web/API/DOMRect).
+ */
+export default class DOMRect extends DOMRectReadOnly {
+  /**
+   * The x coordinate of the `DOMRect`'s origin.
+   */
+  get x(): number {
+    return this.__getInternalX();
+  }
+
+  set x(x: ?number) {
+    this.__setInternalX(x);
+  }
+
+  /**
+   * The y coordinate of the `DOMRect`'s origin.
+   */
+  get y(): number {
+    return this.__getInternalY();
+  }
+
+  set y(y: ?number) {
+    this.__setInternalY(y);
+  }
+
+  /**
+   * The width of the `DOMRect`.
+   */
+  get width(): number {
+    return this.__getInternalWidth();
+  }
+
+  set width(width: ?number) {
+    this.__setInternalWidth(width);
+  }
+
+  /**
+   * The height of the `DOMRect`.
+   */
+  get height(): number {
+    return this.__getInternalHeight();
+  }
+
+  set height(height: ?number) {
+    this.__setInternalHeight(height);
+  }
+
+  /**
+   * Creates a new `DOMRect` object with a given location and dimensions.
+   */
+  static fromRect(rect?: ?DOMRectLike): DOMRect {
+    if (!rect) {
+      return new DOMRect();
+    }
+
+    return new DOMRect(rect.x, rect.y, rect.width, rect.height);
+  }
+}

package/Libraries/DOM/Geometry/DOMRectReadOnly.js

@@ -0,0 +1,188 @@
+/**
+ * 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
+ */
+
+/**
+ * The JSDoc comments in this file have been extracted from [DOMRectReadOnly](https://developer.mozilla.org/en-US/docs/Web/API/DOMRectReadOnly).
+ * Content by [Mozilla Contributors](https://developer.mozilla.org/en-US/docs/Web/API/DOMRectReadOnly/contributors.txt),
+ * licensed under [CC-BY-SA 2.5](https://creativecommons.org/licenses/by-sa/2.5/).
+ */
+
+// flowlint sketchy-null:off, unsafe-getters-setters:off
+
+export interface DOMRectLike {
+  x?: ?number;
+  y?: ?number;
+  width?: ?number;
+  height?: ?number;
+}
+
+function castToNumber(value: mixed): number {
+  return value ? Number(value) : 0;
+}
+
+/**
+ * The `DOMRectReadOnly` interface specifies the standard properties used by `DOMRect` to define a rectangle whose properties are immutable.
+ *
+ * This is a (mostly) spec-compliant version of `DOMRectReadOnly` (https://developer.mozilla.org/en-US/docs/Web/API/DOMRectReadOnly).
+ */
+export default class DOMRectReadOnly {
+  _x: number;
+  _y: number;
+  _width: number;
+  _height: number;
+
+  constructor(x: ?number, y: ?number, width: ?number, height: ?number) {
+    this.__setInternalX(x);
+    this.__setInternalY(y);
+    this.__setInternalWidth(width);
+    this.__setInternalHeight(height);
+  }
+
+  /**
+   * The x coordinate of the `DOMRectReadOnly`'s origin.
+   */
+  get x(): number {
+    return this._x;
+  }
+
+  /**
+   * The y coordinate of the `DOMRectReadOnly`'s origin.
+   */
+  get y(): number {
+    return this._y;
+  }
+
+  /**
+   * The width of the `DOMRectReadOnly`.
+   */
+  get width(): number {
+    return this._width;
+  }
+
+  /**
+   * The height of the `DOMRectReadOnly`.
+   */
+  get height(): number {
+    return this._height;
+  }
+
+  /**
+   * Returns the top coordinate value of the `DOMRect` (has the same value as `y`, or `y + height` if `height` is negative).
+   */
+  get top(): number {
+    const height = this._height;
+    const y = this._y;
+
+    if (height < 0) {
+      return y + height;
+    }
+
+    return y;
+  }
+
+  /**
+   * Returns the right coordinate value of the `DOMRect` (has the same value as ``x + width`, or `x` if `width` is negative).
+   */
+  get right(): number {
+    const width = this._width;
+    const x = this._x;
+
+    if (width < 0) {
+      return x;
+    }
+
+    return x + width;
+  }
+
+  /**
+   * Returns the bottom coordinate value of the `DOMRect` (has the same value as `y + height`, or `y` if `height` is negative).
+   */
+  get bottom(): number {
+    const height = this._height;
+    const y = this._y;
+
+    if (height < 0) {
+      return y;
+    }
+
+    return y + height;
+  }
+
+  /**
+   * Returns the left coordinate value of the `DOMRect` (has the same value as `x`, or `x + width` if `width` is negative).
+   */
+  get left(): number {
+    const width = this._width;
+    const x = this._x;
+
+    if (width < 0) {
+      return x + width;
+    }
+
+    return x;
+  }
+
+  toJSON(): {
+    x: number,
+    y: number,
+    width: number,
+    height: number,
+    top: number,
+    left: number,
+    bottom: number,
+    right: number,
+  } {
+    const {x, y, width, height, top, left, bottom, right} = this;
+    return {x, y, width, height, top, left, bottom, right};
+  }
+
+  /**
+   * Creates a new `DOMRectReadOnly` object with a given location and dimensions.
+   */
+  static fromRect(rect?: ?DOMRectLike): DOMRectReadOnly {
+    if (!rect) {
+      return new DOMRectReadOnly();
+    }
+
+    return new DOMRectReadOnly(rect.x, rect.y, rect.width, rect.height);
+  }
+
+  __getInternalX(): number {
+    return this._x;
+  }
+
+  __getInternalY(): number {
+    return this._y;
+  }
+
+  __getInternalWidth(): number {
+    return this._width;
+  }
+
+  __getInternalHeight(): number {
+    return this._height;
+  }
+
+  __setInternalX(x: ?number) {
+    this._x = castToNumber(x);
+  }
+
+  __setInternalY(y: ?number) {
+    this._y = castToNumber(y);
+  }
+
+  __setInternalWidth(width: ?number) {
+    this._width = castToNumber(width);
+  }
+
+  __setInternalHeight(height: ?number) {
+    this._height = castToNumber(height);
+  }
+}

package/Libraries/DOM/Nodes/ReactNativeElement.js

@@ -0,0 +1,75 @@
+/**
+ * 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 {
+  HostComponent,
+  MeasureInWindowOnSuccessCallback,
+  MeasureLayoutOnSuccessCallback,
+  MeasureOnSuccessCallback,
+} from '../../Renderer/shims/ReactNativeTypes';
+import type {ElementRef} from 'react';
+
+import ReadOnlyElement from './ReadOnlyElement';
+
+export default class ReactNativeElement extends ReadOnlyElement {
+  get offsetHeight(): number {
+    throw new TypeError('Unimplemented');
+  }
+
+  get offsetLeft(): number {
+    throw new TypeError('Unimplemented');
+  }
+
+  get offsetParent(): ReadOnlyElement | null {
+    throw new TypeError('Unimplemented');
+  }
+
+  get offsetTop(): number {
+    throw new TypeError('Unimplemented');
+  }
+
+  get offsetWidth(): number {
+    throw new TypeError('Unimplemented');
+  }
+
+  /**
+   * React Native compatibility methods
+   */
+
+  blur(): void {
+    throw new TypeError('Unimplemented');
+  }
+
+  focus(): void {
+    throw new TypeError('Unimplemented');
+  }
+
+  measure(callback: MeasureOnSuccessCallback): void {
+    throw new TypeError('Unimplemented');
+  }
+
+  measureInWindow(callback: MeasureInWindowOnSuccessCallback): void {
+    throw new TypeError('Unimplemented');
+  }
+
+  measureLayout(
+    relativeToNativeNode: number | ElementRef<HostComponent<mixed>>,
+    onSuccess: MeasureLayoutOnSuccessCallback,
+    onFail?: () => void /* currently unused */,
+  ): void {
+    throw new TypeError('Unimplemented');
+  }
+
+  setNativeProps(nativeProps: {...}): void {
+    throw new TypeError('Unimplemented');
+  }
+}

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]];
+  }
+}