react-native-windows 0.72.14 → 0.73.0-preview.1

package/Libraries/Core/__mocks__/NativeExceptionsManager.js

@@ -0,0 +1,20 @@
+/**
+ * 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
+ * @oncall react_native
+ */
+
+import typeof NativeExceptionsManager from '../NativeExceptionsManager';
+
+export default ({
+  reportFatalException: jest.fn(),
+  reportSoftException: jest.fn(),
+  updateExceptionMessage: jest.fn(),
+  dismissRedbox: jest.fn(),
+  reportException: jest.fn(),
+}: NativeExceptionsManager);

package/Libraries/Core/setUpDeveloperTools.js

@@ -10,7 +10,7 @@
 
 import Platform from '../Utilities/Platform';
 
-declare var console: typeof console & {_isPolyfilled: boolean, ...};
+declare var console: {[string]: $FlowFixMe};
 
 /**
  * Sets up developer tools for React Native.
@@ -74,4 +74,8 @@ if (__DEV__) {
   }
 
   require('./setUpReactRefresh');
+
+  global[
+    `${global.__METRO_GLOBAL_PREFIX__ ?? ''}__loadBundleAsync`
+  ] = require('./Devtools/loadBundleFromServer');
 }

package/Libraries/Core/setUpIntersectionObserver.js

@@ -0,0 +1,16 @@
+/**
+ * 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 {polyfillGlobal} from '../Utilities/PolyfillFunctions';
+
+polyfillGlobal(
+  'IntersectionObserver',
+  () => require('../IntersectionObserver/IntersectionObserver').default,
+);

package/Libraries/Core/setUpMutationObserver.js

@@ -0,0 +1,16 @@
+/**
+ * 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 {polyfillGlobal} from '../Utilities/PolyfillFunctions';
+
+polyfillGlobal(
+  'MutationObserver',
+  () => require('../MutationObserver/MutationObserver').default,
+);

package/Libraries/Core/setUpPerformance.js

@@ -19,18 +19,11 @@ if (NativePerformance) {
 } else {
   if (!global.performance) {
     // $FlowExpectedError[cannot-write]
-    global.performance = ({}: {now?: () => number});
-  }
-
-  /**
-   * Returns a double, measured in milliseconds.
-   * https://developer.mozilla.org/en-US/docs/Web/API/Performance/now
-   */
-  if (typeof global.performance.now !== 'function') {
-    // $FlowExpectedError[cannot-write]
-    global.performance.now = function () {
-      const performanceNow = global.nativePerformanceNow || Date.now;
-      return performanceNow();
-    };
+    global.performance = ({
+      now: function () {
+        const performanceNow = global.nativePerformanceNow || Date.now;
+        return performanceNow();
+      },
+    }: {now?: () => number});
   }
 }

package/Libraries/Core/setUpPerformanceObserver.js

@@ -0,0 +1,16 @@
+/**
+ * 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 {polyfillGlobal} from '../Utilities/PolyfillFunctions';
+
+polyfillGlobal(
+  'PerformanceObserver',
+  () => require('../WebPerformance/PerformanceObserver').default,
+);

package/Libraries/Core/setUpRegeneratorRuntime.js

@@ -22,8 +22,10 @@ let hasNativeGenerator;
 try {
   // If this function was lowered by regenerator-transform, it will try to
   // access `global.regeneratorRuntime` which doesn't exist yet and will throw.
-  hasNativeGenerator = hasNativeConstructor(function* () {},
-  'GeneratorFunction');
+  hasNativeGenerator = hasNativeConstructor(
+    function* () {},
+    'GeneratorFunction',
+  );
 } catch {
   // In this case, we know generators are not provided natively.
   hasNativeGenerator = false;

package/Libraries/DOM/Nodes/ReactNativeElement.js

@@ -5,40 +5,116 @@
  * LICENSE file in the root directory of this source tree.
  *
  * @format
- * @flow strict
+ * @flow strict-local
  */
 
 // flowlint unsafe-getters-setters:off
 
 import type {
   HostComponent,
+  INativeMethods,
+  InternalInstanceHandle,
   MeasureInWindowOnSuccessCallback,
   MeasureLayoutOnSuccessCallback,
   MeasureOnSuccessCallback,
+  ViewConfig,
 } from '../../Renderer/shims/ReactNativeTypes';
 import type {ElementRef} from 'react';
 
-import ReadOnlyElement from './ReadOnlyElement';
+import TextInputState from '../../Components/TextInput/TextInputState';
+import {getFabricUIManager} from '../../ReactNative/FabricUIManager';
+import {create as createAttributePayload} from '../../ReactNative/ReactFabricPublicInstance/ReactNativeAttributePayload';
+import warnForStyleProps from '../../ReactNative/ReactFabricPublicInstance/warnForStyleProps';
+import ReadOnlyElement, {getBoundingClientRect} from './ReadOnlyElement';
+import ReadOnlyNode from './ReadOnlyNode';
+import {
+  getPublicInstanceFromInternalInstanceHandle,
+  getShadowNode,
+} from './ReadOnlyNode';
+import nullthrows from 'nullthrows';
+
+const noop = () => {};
+
+export default class ReactNativeElement
+  extends ReadOnlyElement
+  implements INativeMethods
+{
+  // These need to be accessible from `ReactFabricPublicInstanceUtils`.
+  __nativeTag: number;
+  __internalInstanceHandle: InternalInstanceHandle;
+
+  _viewConfig: ViewConfig;
+
+  constructor(
+    tag: number,
+    viewConfig: ViewConfig,
+    internalInstanceHandle: InternalInstanceHandle,
+  ) {
+    super(internalInstanceHandle);
+
+    this.__nativeTag = tag;
+    this.__internalInstanceHandle = internalInstanceHandle;
+    this._viewConfig = viewConfig;
+  }
 
-export default class ReactNativeElement extends ReadOnlyElement {
   get offsetHeight(): number {
-    throw new TypeError('Unimplemented');
+    return Math.round(
+      getBoundingClientRect(this, {includeTransform: false}).height,
+    );
   }
 
   get offsetLeft(): number {
-    throw new TypeError('Unimplemented');
+    const node = getShadowNode(this);
+
+    if (node != null) {
+      const offset = nullthrows(getFabricUIManager()).getOffset(node);
+      if (offset != null) {
+        return Math.round(offset[2]);
+      }
+    }
+
+    return 0;
   }
 
   get offsetParent(): ReadOnlyElement | null {
-    throw new TypeError('Unimplemented');
+    const node = getShadowNode(this);
+
+    if (node != null) {
+      const offset = nullthrows(getFabricUIManager()).getOffset(node);
+      // For children of the root node we currently return offset data
+      // but a `null` parent because the root node is not accessible
+      // in JavaScript yet.
+      if (offset != null && offset[0] != null) {
+        const offsetParentInstanceHandle = offset[0];
+        const offsetParent = getPublicInstanceFromInternalInstanceHandle(
+          offsetParentInstanceHandle,
+        );
+        // $FlowExpectedError[incompatible-type] The value returned by `getOffset` is always an instance handle for `ReadOnlyElement`.
+        const offsetParentElement: ReadOnlyElement = offsetParent;
+        return offsetParentElement;
+      }
+    }
+
+    return null;
   }
 
   get offsetTop(): number {
-    throw new TypeError('Unimplemented');
+    const node = getShadowNode(this);
+
+    if (node != null) {
+      const offset = nullthrows(getFabricUIManager()).getOffset(node);
+      if (offset != null) {
+        return Math.round(offset[1]);
+      }
+    }
+
+    return 0;
   }
 
   get offsetWidth(): number {
-    throw new TypeError('Unimplemented');
+    return Math.round(
+      getBoundingClientRect(this, {includeTransform: false}).width,
+    );
   }
 
   /**
@@ -46,30 +122,71 @@ export default class ReactNativeElement extends ReadOnlyElement {
    */
 
   blur(): void {
-    throw new TypeError('Unimplemented');
+    // $FlowFixMe[incompatible-exact] Migrate all usages of `NativeMethods` to an interface to fix this.
+    TextInputState.blurTextInput(this);
   }
 
-  focus(): void {
-    throw new TypeError('Unimplemented');
+  focus() {
+    // $FlowFixMe[incompatible-exact] Migrate all usages of `NativeMethods` to an interface to fix this.
+    TextInputState.focusTextInput(this);
   }
 
-  measure(callback: MeasureOnSuccessCallback): void {
-    throw new TypeError('Unimplemented');
+  measure(callback: MeasureOnSuccessCallback) {
+    const node = getShadowNode(this);
+    if (node != null) {
+      nullthrows(getFabricUIManager()).measure(node, callback);
+    }
   }
 
-  measureInWindow(callback: MeasureInWindowOnSuccessCallback): void {
-    throw new TypeError('Unimplemented');
+  measureInWindow(callback: MeasureInWindowOnSuccessCallback) {
+    const node = getShadowNode(this);
+    if (node != null) {
+      nullthrows(getFabricUIManager()).measureInWindow(node, callback);
+    }
   }
 
   measureLayout(
     relativeToNativeNode: number | ElementRef<HostComponent<mixed>>,
     onSuccess: MeasureLayoutOnSuccessCallback,
     onFail?: () => void /* currently unused */,
-  ): void {
-    throw new TypeError('Unimplemented');
+  ) {
+    if (!(relativeToNativeNode instanceof ReadOnlyNode)) {
+      if (__DEV__) {
+        console.error(
+          'Warning: ref.measureLayout must be called with a ref to a native component.',
+        );
+      }
+
+      return;
+    }
+
+    const toStateNode = getShadowNode(this);
+    const fromStateNode = getShadowNode(relativeToNativeNode);
+
+    if (toStateNode != null && fromStateNode != null) {
+      nullthrows(getFabricUIManager()).measureLayout(
+        toStateNode,
+        fromStateNode,
+        onFail != null ? onFail : noop,
+        onSuccess != null ? onSuccess : noop,
+      );
+    }
   }
 
   setNativeProps(nativeProps: {...}): void {
-    throw new TypeError('Unimplemented');
+    if (__DEV__) {
+      warnForStyleProps(nativeProps, this._viewConfig.validAttributes);
+    }
+
+    const updatePayload = createAttributePayload(
+      nativeProps,
+      this._viewConfig.validAttributes,
+    );
+
+    const node = getShadowNode(this);
+
+    if (node != null && updatePayload != null) {
+      nullthrows(getFabricUIManager()).setNativeProps(node, updatePayload);
+    }
   }
 }

package/Libraries/DOM/Nodes/ReadOnlyCharacterData.js

@@ -0,0 +1,72 @@
+/**
+ * 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
+ */
+
+// flowlint unsafe-getters-setters:off
+
+import type ReadOnlyElement from './ReadOnlyElement';
+
+import {getFabricUIManager} from '../../ReactNative/FabricUIManager';
+import ReadOnlyNode, {getShadowNode} from './ReadOnlyNode';
+import {getElementSibling} from './Utilities/Traversal';
+import nullthrows from 'nullthrows';
+
+export default class ReadOnlyCharacterData extends ReadOnlyNode {
+  get nextElementSibling(): ReadOnlyElement | null {
+    return getElementSibling(this, 'next');
+  }
+
+  get previousElementSibling(): ReadOnlyElement | null {
+    return getElementSibling(this, 'previous');
+  }
+
+  get data(): string {
+    const shadowNode = getShadowNode(this);
+
+    if (shadowNode != null) {
+      return nullthrows(getFabricUIManager()).getTextContent(shadowNode);
+    }
+
+    return '';
+  }
+
+  get length(): number {
+    return this.data.length;
+  }
+
+  /**
+   * @override
+   */
+  get textContent(): string | null {
+    return this.data;
+  }
+
+  /**
+   * @override
+   */
+  get nodeValue(): string {
+    return this.data;
+  }
+
+  substringData(offset: number, count: number): string {
+    const data = this.data;
+    if (offset < 0) {
+      throw new TypeError(
+        `Failed to execute 'substringData' on 'CharacterData': The offset ${offset} is negative.`,
+      );
+    }
+    if (offset > data.length) {
+      throw new TypeError(
+        `Failed to execute 'substringData' on 'CharacterData': The offset ${offset} is greater than the node's length (${data.length}).`,
+      );
+    }
+    let adjustedCount = count < 0 || count > data.length ? data.length : count;
+    return data.slice(offset, offset + adjustedCount);
+  }
+}