@office-iss/react-native-win32 0.80.0 → 0.81.0-preview.3

package/src/private/webapis/mutationobserver/internals/MutationObserverManager.js

@@ -41,13 +41,6 @@ const registeredMutationObservers: Map<
   $ReadOnly<{observer: MutationObserver, callback: MutationObserverCallback}>,
 > = new Map();
 
-// The mapping between ReactNativeElement and their corresponding shadow node
-// needs to be kept here because React removes the link when unmounting.
-const targetToShadowNodeMap: WeakMap<
-  ReactNativeElement,
-  ReturnType<typeof getNativeNodeReference>,
-> = new WeakMap();
-
 /**
  * Registers the given mutation observer and returns a unique ID for it,
  * which is required to start observing targets.
@@ -90,10 +83,10 @@ export function observe({
   mutationObserverId: MutationObserverId,
   target: ReactNativeElement,
   subtree: boolean,
-}): boolean {
+}): void {
   if (NativeMutationObserver == null) {
     warnNoNativeMutationObserver();
-    return false;
+    return;
   }
 
   const registeredObserver =
@@ -102,17 +95,15 @@ export function observe({
     console.error(
       `MutationObserverManager: could not start observing target because MutationObserver with ID ${mutationObserverId} was not registered.`,
     );
-    return false;
+    return;
   }
 
   const targetShadowNode = getNativeNodeReference(target);
   if (targetShadowNode == null) {
     // The target is disconnected. We can't observe it anymore.
-    return false;
+    return;
   }
 
-  targetToShadowNodeMap.set(target, targetShadowNode);
-
   if (!isConnected) {
     NativeMutationObserver.connect(
       notifyMutationObservers,
@@ -131,14 +122,9 @@ export function observe({
     targetShadowNode,
     subtree,
   });
-
-  return true;
 }
 
-export function unobserve(
-  mutationObserverId: number,
-  target: ReactNativeElement,
-): void {
+export function unobserveAll(mutationObserverId: number): void {
   if (NativeMutationObserver == null) {
     warnNoNativeMutationObserver();
     return;
@@ -148,20 +134,12 @@ export function unobserve(
     registeredMutationObservers.get(mutationObserverId);
   if (registeredObserver == null) {
     console.error(
-      `MutationObserverManager: could not stop observing target because MutationObserver with ID ${mutationObserverId} was not registered.`,
-    );
-    return;
-  }
-
-  const targetShadowNode = targetToShadowNodeMap.get(target);
-  if (targetShadowNode == null) {
-    console.error(
-      'MutationObserverManager: could not find registration data for target',
+      `MutationObserverManager: could not disconnect MutationObserver with ID ${mutationObserverId} because it was not registered.`,
     );
     return;
   }
 
-  NativeMutationObserver.unobserve(mutationObserverId, targetShadowNode);
+  NativeMutationObserver.unobserveAll(mutationObserverId);
 }
 
 /**

package/src/private/webapis/mutationobserver/specs/NativeMutationObserver.js

@@ -36,10 +36,7 @@ export type NativeMutationObserverObserveOptions = {
 
 export interface Spec extends TurboModule {
   +observe: (options: NativeMutationObserverObserveOptions) => void;
-  +unobserve: (
-    mutationObserverId: number,
-    targetShadowNode: ShadowNode,
-  ) => void;
+  +unobserveAll: (mutationObserverId: number) => void;
   +connect: (
     notifyMutationObservers: () => void,
     // We need this to retain the public instance before React removes the

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

@@ -4,8 +4,8 @@
  * 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
+ * @format
  */
 
 // flowlint unsafe-getters-setters:off

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

@@ -4,8 +4,8 @@
  * 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
+ * @format
  */
 
 // flowlint unsafe-getters-setters:off

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

@@ -6,11 +6,12 @@
  *
  * @flow strict
  * @format
- * @oncall react_native
  */
 
 // flowlint unsafe-getters-setters:off
 
+import {setPlatformObject} from '../webidl/PlatformObjects';
+
 type MemoryInfoLike = {
   jsHeapSizeLimit: ?number,
   totalJSHeapSize: ?number,
@@ -52,3 +53,5 @@ export default class MemoryInfo {
     return this.#usedJSHeapSize;
   }
 }
+
+setPlatformObject(MemoryInfo);

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

@@ -4,8 +4,8 @@
  * 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
+ * @format
  */
 
 // flowlint unsafe-getters-setters:off
@@ -17,6 +17,8 @@ import type {
 } from './PerformanceEntry';
 import type {DetailType, PerformanceMarkOptions} from './UserTiming';
 
+import DOMException from '../errors/DOMException';
+import {setPlatformObject} from '../webidl/PlatformObjects';
 import {EventCounts} from './EventTiming';
 import {
   performanceEntryTypeToRaw,
@@ -191,15 +193,22 @@ export default class Performance {
     let computedDuration = duration;
 
     if (NativePerformance?.measureWithResult) {
-      [computedStartTime, computedDuration] =
-        NativePerformance.measureWithResult(
-          measureName,
-          startTime,
-          endTime,
-          duration,
-          startMarkName,
-          endMarkName,
+      try {
+        [computedStartTime, computedDuration] =
+          NativePerformance.measureWithResult(
+            measureName,
+            startTime,
+            endTime,
+            duration,
+            startMarkName,
+            endMarkName,
+          );
+      } catch (error) {
+        throw new DOMException(
+          "Failed to execute 'measure' on 'Performance': " + error.message,
+          'SyntaxError',
         );
+      }
     } else {
       warnNoNativePerformance();
     }
@@ -283,3 +292,5 @@ export default class Performance {
     ).map(rawToPerformanceEntry);
   }
 }
+
+setPlatformObject(Performance);

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

@@ -4,12 +4,14 @@
  * 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
+ * @format
  */
 
 // flowlint unsafe-getters-setters:off
 
+import {setPlatformObject} from '../webidl/PlatformObjects';
+
 export type DOMHighResTimeStamp = number;
 export type PerformanceEntryType =
   | 'mark'
@@ -70,4 +72,6 @@ export class PerformanceEntry {
   }
 }
 
+setPlatformObject(PerformanceEntry);
+
 export type PerformanceEntryList = $ReadOnlyArray<PerformanceEntry>;

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

@@ -4,8 +4,8 @@
  * 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
+ * @format
  */
 
 import type {
@@ -23,6 +23,7 @@ import {
 } from './internals/RawPerformanceEntry';
 import {warnNoNativePerformance} from './internals/Utilities';
 import NativePerformance from './specs/NativePerformance';
+import nullthrows from 'nullthrows';
 
 export {PerformanceEntry} from './PerformanceEntry';
 
@@ -130,14 +131,16 @@ export class PerformanceObserver {
       this.#nativeObserverHandle = this.#createNativeObserver();
     }
 
+    const observerHandle = nullthrows(this.#nativeObserverHandle);
+
     if (options.entryTypes) {
       this.#type = 'multiple';
-      NativePerformance.observe?.(this.#nativeObserverHandle, {
+      NativePerformance.observe?.(observerHandle, {
         entryTypes: options.entryTypes.map(performanceEntryTypeToRaw),
       });
     } else if (options.type) {
       this.#type = 'single';
-      NativePerformance.observe?.(this.#nativeObserverHandle, {
+      NativePerformance.observe?.(observerHandle, {
         type: performanceEntryTypeToRaw(options.type),
         buffered: options.buffered,
         durationThreshold: options.durationThreshold,
@@ -158,37 +161,38 @@ export class PerformanceObserver {
     NativePerformance.disconnect(this.#nativeObserverHandle);
   }
 
-  #createNativeObserver(): OpaqueNativeObserverHandle {
+  #createNativeObserver(): OpaqueNativeObserverHandle | null {
     if (!NativePerformance || !NativePerformance.createObserver) {
       warnNoNativePerformance();
-      return;
+      return null;
     }
 
     this.#calledAtLeastOnce = false;
 
-    return NativePerformance.createObserver(() => {
-      const rawEntries = NativePerformance.takeRecords?.(
-        this.#nativeObserverHandle,
-        true, // sort records
-      );
-      if (!rawEntries) {
-        return;
-      }
-
-      const entries = rawEntries.map(rawToPerformanceEntry);
-      const entryList = new PerformanceObserverEntryList(entries);
-
-      let droppedEntriesCount = 0;
-      if (!this.#calledAtLeastOnce) {
-        droppedEntriesCount =
-          NativePerformance.getDroppedEntriesCount?.(
-            this.#nativeObserverHandle,
-          ) ?? 0;
-        this.#calledAtLeastOnce = true;
-      }
-
-      this.#callback(entryList, this, {droppedEntriesCount});
-    });
+    const observerHandle: OpaqueNativeObserverHandle =
+      NativePerformance.createObserver(() => {
+        const rawEntries = NativePerformance.takeRecords?.(
+          observerHandle,
+          true, // sort records
+        );
+        if (!rawEntries) {
+          return;
+        }
+
+        const entries = rawEntries.map(rawToPerformanceEntry);
+        const entryList = new PerformanceObserverEntryList(entries);
+
+        let droppedEntriesCount = 0;
+        if (!this.#calledAtLeastOnce) {
+          droppedEntriesCount =
+            NativePerformance.getDroppedEntriesCount?.(observerHandle) ?? 0;
+          this.#calledAtLeastOnce = true;
+        }
+
+        this.#callback(entryList, this, {droppedEntriesCount});
+      });
+
+    return observerHandle;
   }
 
   #validateObserveOptions(options: PerformanceObserverInit): void {

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

@@ -6,11 +6,12 @@
  *
  * @flow strict
  * @format
- * @oncall react_native
  */
 
 // flowlint unsafe-getters-setters:off
 
+import {setPlatformObject} from '../webidl/PlatformObjects';
+
 type ReactNativeStartupTimingLike = {
   startTime: ?number,
   endTime: ?number,
@@ -89,3 +90,5 @@ export default class ReactNativeStartupTiming {
     return this.#executeJavaScriptBundleEntryPointEnd;
   }
 }
+
+setPlatformObject(ReactNativeStartupTiming);

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

@@ -0,0 +1,108 @@
+/**
+ * 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 {
+  DOMHighResTimeStamp,
+  PerformanceEntryJSON,
+} from './PerformanceEntry';
+
+import {PerformanceEntry} from './PerformanceEntry';
+
+export type PerformanceResourceTimingJSON = {
+  ...PerformanceEntryJSON,
+  fetchStart: DOMHighResTimeStamp,
+  requestStart: DOMHighResTimeStamp,
+  connectStart: DOMHighResTimeStamp,
+  connectEnd: DOMHighResTimeStamp,
+  responseStart: DOMHighResTimeStamp,
+  responseEnd: DOMHighResTimeStamp,
+  responseStatus: ?number,
+  ...
+};
+
+export class PerformanceResourceTiming extends PerformanceEntry {
+  #fetchStart: DOMHighResTimeStamp;
+  #requestStart: DOMHighResTimeStamp;
+  #connectStart: DOMHighResTimeStamp;
+  #connectEnd: DOMHighResTimeStamp;
+  #responseStart: DOMHighResTimeStamp;
+  #responseEnd: DOMHighResTimeStamp;
+  #responseStatus: ?number;
+
+  constructor(init: {
+    name: string,
+    startTime: DOMHighResTimeStamp,
+    duration: DOMHighResTimeStamp,
+    fetchStart: DOMHighResTimeStamp,
+    requestStart: DOMHighResTimeStamp,
+    connectStart: DOMHighResTimeStamp,
+    connectEnd: DOMHighResTimeStamp,
+    responseStart: DOMHighResTimeStamp,
+    responseEnd: DOMHighResTimeStamp,
+    responseStatus?: number,
+  }) {
+    super({
+      name: init.name,
+      entryType: 'resource',
+      startTime: init.startTime,
+      duration: init.duration,
+    });
+    this.#fetchStart = init.fetchStart;
+    this.#requestStart = init.requestStart;
+    this.#connectStart = init.connectStart;
+    this.#connectEnd = init.connectEnd;
+    this.#responseStart = init.responseStart;
+    this.#responseEnd = init.responseEnd;
+    this.#responseStatus = init.responseStatus;
+  }
+
+  get fetchStart(): DOMHighResTimeStamp {
+    return this.#fetchStart;
+  }
+
+  get requestStart(): DOMHighResTimeStamp {
+    return this.#requestStart;
+  }
+
+  get connectStart(): DOMHighResTimeStamp {
+    return this.#connectStart;
+  }
+
+  get connectEnd(): DOMHighResTimeStamp {
+    return this.#connectEnd;
+  }
+
+  get responseStart(): DOMHighResTimeStamp {
+    return this.#responseStart;
+  }
+
+  get responseEnd(): DOMHighResTimeStamp {
+    return this.#responseEnd;
+  }
+
+  get responseStatus(): ?number {
+    return this.#responseStatus;
+  }
+
+  toJSON(): PerformanceResourceTimingJSON {
+    return {
+      ...super.toJSON(),
+      fetchStart: this.#fetchStart,
+      requestStart: this.#requestStart,
+      connectStart: this.#connectStart,
+      connectEnd: this.#connectEnd,
+      responseStart: this.#responseStart,
+      responseEnd: this.#responseEnd,
+      responseStatus: this.#responseStatus,
+    };
+  }
+}

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

@@ -4,8 +4,8 @@
  * 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
+ * @format
  */
 
 // flowlint unsafe-getters-setters:off

package/src/private/webapis/performance/internals/RawPerformanceEntry.js

@@ -4,8 +4,8 @@
  * 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
+ * @format
  */
 
 import type {PerformanceEntryType} from '../PerformanceEntry';
@@ -17,6 +17,7 @@ import type {
 import {PerformanceEventTiming} from '../EventTiming';
 import {PerformanceLongTaskTiming} from '../LongTasks';
 import {PerformanceEntry} from '../PerformanceEntry';
+import {PerformanceResourceTiming} from '../ResourceTiming';
 import {PerformanceMark, PerformanceMeasure} from '../UserTiming';
 
 export const RawPerformanceEntryTypeValues = {
@@ -30,38 +31,52 @@ export const RawPerformanceEntryTypeValues = {
 export function rawToPerformanceEntry(
   entry: RawPerformanceEntry,
 ): PerformanceEntry {
-  if (entry.entryType === RawPerformanceEntryTypeValues.EVENT) {
-    return new PerformanceEventTiming({
-      name: entry.name,
-      startTime: entry.startTime,
-      duration: entry.duration,
-      processingStart: entry.processingStart,
-      processingEnd: entry.processingEnd,
-      interactionId: entry.interactionId,
-    });
-  } else if (entry.entryType === RawPerformanceEntryTypeValues.LONGTASK) {
-    return new PerformanceLongTaskTiming({
-      name: entry.name,
-      entryType: rawToPerformanceEntryType(entry.entryType),
-      startTime: entry.startTime,
-      duration: entry.duration,
-    });
-  } else if (entry.entryType === RawPerformanceEntryTypeValues.MARK) {
-    return new PerformanceMark(entry.name, {
-      startTime: entry.startTime,
-    });
-  } else if (entry.entryType === RawPerformanceEntryTypeValues.MEASURE) {
-    return new PerformanceMeasure(entry.name, {
-      startTime: entry.startTime,
-      duration: entry.duration,
-    });
-  } else {
-    return new PerformanceEntry({
-      name: entry.name,
-      entryType: rawToPerformanceEntryType(entry.entryType),
-      startTime: entry.startTime,
-      duration: entry.duration,
-    });
+  switch (entry.entryType) {
+    case RawPerformanceEntryTypeValues.EVENT:
+      return new PerformanceEventTiming({
+        name: entry.name,
+        startTime: entry.startTime,
+        duration: entry.duration,
+        processingStart: entry.processingStart,
+        processingEnd: entry.processingEnd,
+        interactionId: entry.interactionId,
+      });
+    case RawPerformanceEntryTypeValues.LONGTASK:
+      return new PerformanceLongTaskTiming({
+        name: entry.name,
+        entryType: rawToPerformanceEntryType(entry.entryType),
+        startTime: entry.startTime,
+        duration: entry.duration,
+      });
+    case RawPerformanceEntryTypeValues.MARK:
+      return new PerformanceMark(entry.name, {
+        startTime: entry.startTime,
+      });
+    case RawPerformanceEntryTypeValues.MEASURE:
+      return new PerformanceMeasure(entry.name, {
+        startTime: entry.startTime,
+        duration: entry.duration,
+      });
+    case RawPerformanceEntryTypeValues.RESOURCE:
+      return new PerformanceResourceTiming({
+        name: entry.name,
+        startTime: entry.startTime,
+        duration: entry.duration,
+        fetchStart: entry.fetchStart ?? 0,
+        requestStart: entry.requestStart ?? 0,
+        connectStart: entry.connectStart ?? 0,
+        connectEnd: entry.connectEnd ?? 0,
+        responseStart: entry.responseStart ?? 0,
+        responseEnd: entry.responseEnd ?? 0,
+        responseStatus: entry.responseStatus,
+      });
+    default:
+      return new PerformanceEntry({
+        name: entry.name,
+        entryType: rawToPerformanceEntryType(entry.entryType),
+        startTime: entry.startTime,
+        duration: entry.duration,
+      });
   }
 }
 
@@ -77,6 +92,8 @@ export function rawToPerformanceEntryType(
       return 'event';
     case RawPerformanceEntryTypeValues.LONGTASK:
       return 'longtask';
+    case RawPerformanceEntryTypeValues.RESOURCE:
+      return 'resource';
     default:
       throw new TypeError(
         `rawToPerformanceEntryType: unexpected performance entry type received: ${type}`,

package/src/private/webapis/performance/internals/Utilities.js

@@ -4,8 +4,8 @@
  * 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
+ * @format
  */
 
 import warnOnce from '../../../../../Libraries/Utilities/warnOnce';

package/src/private/webapis/performance/specs/NativePerformance.js

@@ -39,7 +39,7 @@ export type RawPerformanceEntry = {
   responseStatus?: number,
 };
 
-export type OpaqueNativeObserverHandle = mixed;
+export opaque type OpaqueNativeObserverHandle = mixed;
 
 export type NativeBatchedObserverCallback = () => void;
 export type NativePerformanceMarkResult = number;