@office-iss/react-native-win32 0.0.0-canary.297 → 0.0.0-canary.299

package/src/private/webapis/mutationobserver/MutationObserver.js

@@ -16,7 +16,6 @@ import type MutationRecord from './MutationRecord';
 import ReactNativeElement from '../dom/nodes/ReactNativeElement';
 import {setPlatformObject} from '../webidl/PlatformObjects';
 import * as MutationObserverManager from './internals/MutationObserverManager';
-import nullthrows from 'nullthrows';
 
 export type MutationObserverCallback = (
   mutationRecords: $ReadOnlyArray<MutationRecord>,
@@ -118,15 +117,11 @@ export default class MutationObserver {
 
     const mutationObserverId = this._getOrCreateMutationObserverId();
 
-    const didStartObserving = MutationObserverManager.observe({
+    MutationObserverManager.observe({
       mutationObserverId,
       target,
       subtree: Boolean(options?.subtree),
     });
-
-    if (didStartObserving && !MutationObserverManager.unobserveAll) {
-      this._observationTargets.add(target);
-    }
   }
 
   /**
@@ -139,17 +134,7 @@ export default class MutationObserver {
       return;
     }
 
-    if (MutationObserverManager.unobserveAll) {
-      MutationObserverManager.unobserveAll(mutationObserverId);
-    } else if (MutationObserverManager.unobserve) {
-      for (const target of this._observationTargets.keys()) {
-        nullthrows(MutationObserverManager.unobserve)(
-          mutationObserverId,
-          target,
-        );
-      }
-      this._observationTargets.clear();
-    }
+    MutationObserverManager.unobserveAll(mutationObserverId);
 
     MutationObserverManager.unregisterObserver(mutationObserverId);
     this._mutationObserverId = null;

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

@@ -41,14 +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.
-// TODO: remove this code when NativeMutationObserver.unobserveAll is available in all apps
-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.
@@ -91,10 +83,10 @@ export function observe({
   mutationObserverId: MutationObserverId,
   target: ReactNativeElement,
   subtree: boolean,
-}): boolean {
+}): void {
   if (NativeMutationObserver == null) {
     warnNoNativeMutationObserver();
-    return false;
+    return;
   }
 
   const registeredObserver =
@@ -103,19 +95,13 @@ 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;
-  }
-
-  // We need to keep this temporarily until the changes in the native module have propagated.
-  // After that, we don't need to keep this mapping that can cause memory leaks.
-  if (!nativeUnobserveAll) {
-    targetToShadowNodeMap.set(target, targetShadowNode);
+    return;
   }
 
   if (!isConnected) {
@@ -136,65 +122,25 @@ export function observe({
     targetShadowNode,
     subtree,
   });
-
-  return true;
 }
 
-const nativeUnobserve = NativeMutationObserver?.unobserve;
-
-// TODO: delete in the next version, when NativeMutationObserver.unobserveAll is available in all apps
-export const unobserve: ?(
-  mutationObserverId: number,
-  target: ReactNativeElement,
-) => void = nativeUnobserve
-  ? function unobserve(
-      mutationObserverId: number,
-      target: ReactNativeElement,
-    ): void {
-      if (NativeMutationObserver == null) {
-        warnNoNativeMutationObserver();
-        return;
-      }
-
-      const registeredObserver =
-        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',
-        );
-        return;
-      }
-
-      nativeUnobserve(mutationObserverId, targetShadowNode);
-    }
-  : null;
-
-const nativeUnobserveAll = NativeMutationObserver?.unobserveAll;
+export function unobserveAll(mutationObserverId: number): void {
+  if (NativeMutationObserver == null) {
+    warnNoNativeMutationObserver();
+    return;
+  }
 
-// TODO: clean up as a regular export in the next version, when NativeMutationObserver.unobserveAll is available in all apps
-export const unobserveAll: ?(mutationObserverId: number) => void =
-  nativeUnobserveAll
-    ? function unobserveAll(mutationObserverId: MutationObserverId): void {
-        const registeredObserver =
-          registeredMutationObservers.get(mutationObserverId);
-        if (registeredObserver == null) {
-          console.error(
-            `MutationObserverManager: could not stop observing target because MutationObserver with ID ${mutationObserverId} was not registered.`,
-          );
-          return;
-        }
+  const registeredObserver =
+    registeredMutationObservers.get(mutationObserverId);
+  if (registeredObserver == null) {
+    console.error(
+      `MutationObserverManager: could not disconnect MutationObserver with ID ${mutationObserverId} because it was not registered.`,
+    );
+    return;
+  }
 
-        nativeUnobserveAll(mutationObserverId);
-      }
-    : null;
+  NativeMutationObserver.unobserveAll(mutationObserverId);
+}
 
 /**
  * This function is called from native when there are `MutationObserver`

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

@@ -36,13 +36,7 @@ export type NativeMutationObserverObserveOptions = {
 
 export interface Spec extends TurboModule {
   +observe: (options: NativeMutationObserverObserveOptions) => void;
-  // TODO: remove in the next version
-  +unobserve?: (
-    mutationObserverId: number,
-    targetShadowNode: ShadowNode,
-  ) => void;
-  // TODO: remove optionality in the next version
-  +unobserveAll?: (mutationObserverId: number) => 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/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
@@ -18,6 +18,7 @@ import type {
 import type {DetailType, PerformanceMarkOptions} from './UserTiming';
 
 import DOMException from '../errors/DOMException';
+import structuredClone from '../structuredClone/structuredClone';
 import {setPlatformObject} from '../webidl/PlatformObjects';
 import {EventCounts} from './EventTiming';
 import {
@@ -38,12 +39,17 @@ declare var global: {
 const getCurrentTimeStamp: () => DOMHighResTimeStamp =
   NativePerformance?.now ?? global.nativePerformanceNow ?? (() => Date.now());
 
-export type PerformanceMeasureOptions = {
-  detail?: DetailType,
-  start?: DOMHighResTimeStamp,
-  duration?: DOMHighResTimeStamp,
-  end?: DOMHighResTimeStamp,
-};
+export type PerformanceMeasureOptions =
+  | {
+      detail?: DetailType,
+      start?: DOMHighResTimeStamp | string,
+      duration?: DOMHighResTimeStamp,
+    }
+  | {
+      detail?: DetailType,
+      start?: DOMHighResTimeStamp | string,
+      end?: DOMHighResTimeStamp | string,
+    };
 
 const ENTRY_TYPES_AVAILABLE_FROM_TIMELINE: $ReadOnlyArray<PerformanceEntryType> =
   ['mark', 'measure'];
@@ -111,11 +117,39 @@ export default class Performance {
     markName: string,
     markOptions?: PerformanceMarkOptions,
   ): PerformanceMark {
+    if (markName == null) {
+      throw new TypeError(
+        `Failed to execute 'mark' on 'Performance': 1 argument required, but only 0 present.`,
+      );
+    }
+
+    let resolvedDetail;
+    if (markOptions?.detail != null) {
+      resolvedDetail = structuredClone(markOptions.detail);
+    }
+
     let computedStartTime;
     if (NativePerformance?.markWithResult) {
+      let resolvedStartTime;
+
+      const startTime = markOptions?.startTime;
+      if (startTime !== undefined) {
+        resolvedStartTime = Number(startTime);
+        if (resolvedStartTime < 0) {
+          throw new TypeError(
+            `Failed to execute 'mark' on 'Performance': '${markName}' cannot have a negative start time.`,
+          );
+        } else if (!Number.isFinite(resolvedStartTime)) {
+          throw new TypeError(
+            `Failed to execute 'mark' on 'Performance': Failed to read the 'startTime' property from 'PerformanceMarkOptions': The provided double value is non-finite.`,
+          );
+        }
+      }
+
+      // $FlowExpectedError[not-a-function]
       computedStartTime = NativePerformance.markWithResult(
         markName,
-        markOptions?.startTime,
+        resolvedStartTime,
       );
     } else {
       warnNoNativePerformance();
@@ -124,7 +158,7 @@ export default class Performance {
 
     return new PerformanceMark(markName, {
       startTime: computedStartTime,
-      detail: markOptions?.detail,
+      detail: resolvedDetail,
     });
   }
 
@@ -142,66 +176,135 @@ export default class Performance {
     startMarkOrOptions?: string | PerformanceMeasureOptions,
     endMark?: string,
   ): PerformanceMeasure {
-    let options;
-    let startMarkName,
-      endMarkName = endMark,
-      duration,
-      startTime = 0,
-      endTime = 0;
-
-    if (typeof startMarkOrOptions === 'string') {
-      startMarkName = startMarkOrOptions;
-      options = {};
-    } else if (startMarkOrOptions !== undefined) {
-      options = startMarkOrOptions;
-      if (endMark !== undefined) {
-        throw new TypeError(
-          "Performance.measure: Can't have both options and endMark",
-        );
-      }
-      if (options.start === undefined && options.end === undefined) {
-        throw new TypeError(
-          'Performance.measure: Must have at least one of start/end specified in options',
-        );
+    let resolvedStartTime: number | void;
+    let resolvedStartMark: string | void;
+    let resolvedEndTime: number | void;
+    let resolvedEndMark: string | void;
+    let resolvedDuration: number | void;
+    let resolvedDetail: mixed;
+
+    if (startMarkOrOptions != null) {
+      switch (typeof startMarkOrOptions) {
+        case 'object': {
+          if (endMark != null) {
+            throw new TypeError(
+              `Failed to execute 'measure' on 'Performance': If a non-empty PerformanceMeasureOptions object was passed, |end_mark| must not be passed.`,
+            );
+          }
+
+          const start = startMarkOrOptions.start;
+          switch (typeof start) {
+            case 'number': {
+              resolvedStartTime = start;
+              break;
+            }
+            case 'string': {
+              resolvedStartMark = start;
+              break;
+            }
+            case 'undefined': {
+              break;
+            }
+            default: {
+              resolvedStartMark = String(start);
+            }
+          }
+
+          const end = startMarkOrOptions.end;
+          switch (typeof end) {
+            case 'number': {
+              resolvedEndTime = end;
+              break;
+            }
+            case 'string': {
+              resolvedEndMark = end;
+              break;
+            }
+            case 'undefined': {
+              break;
+            }
+            default: {
+              resolvedEndMark = String(end);
+            }
+          }
+
+          const duration = startMarkOrOptions.duration;
+          switch (typeof duration) {
+            case 'number': {
+              resolvedDuration = duration;
+              break;
+            }
+            case 'undefined':
+              break;
+            default: {
+              resolvedDuration = Number(duration);
+              if (!Number.isFinite(resolvedDuration)) {
+                throw new TypeError(
+                  `Failed to execute 'measure' on 'Performance': Failed to read the 'duration' property from 'PerformanceMeasureOptions': The provided double value is non-finite.`,
+                );
+              }
+            }
+          }
+
+          if (
+            resolvedDuration != null &&
+            (resolvedEndMark != null || resolvedEndTime != null)
+          ) {
+            throw new TypeError(
+              `Failed to execute 'measure' on 'Performance': If a non-empty PerformanceMeasureOptions object was passed, it must not have all of its 'start', 'duration', and 'end' properties defined`,
+            );
+          }
+
+          const detail = startMarkOrOptions.detail;
+          if (detail != null) {
+            resolvedDetail = structuredClone(detail);
+          }
+
+          break;
+        }
+        case 'string': {
+          resolvedStartMark = startMarkOrOptions;
+
+          if (endMark !== undefined) {
+            resolvedEndMark = String(endMark);
+          }
+          break;
+        }
+        default: {
+          resolvedStartMark = String(startMarkOrOptions);
+        }
       }
-      if (
-        options.start !== undefined &&
-        options.end !== undefined &&
-        options.duration !== undefined
-      ) {
-        throw new TypeError(
-          "Performance.measure: Can't have both start/end and duration explicitly in options",
-        );
-      }
-
-      if (typeof options.start === 'number') {
-        startTime = options.start;
-      } else {
-        startMarkName = options.start;
-      }
-
-      if (typeof options.end === 'number') {
-        endTime = options.end;
-      } else {
-        endMarkName = options.end;
-      }
-
-      duration = options.duration ?? duration;
     }
 
-    let computedStartTime = startTime;
-    let computedDuration = duration;
+    let computedStartTime = 0;
+    let computedDuration = 0;
 
-    if (NativePerformance?.measureWithResult) {
+    if (NativePerformance?.measure) {
+      try {
+        [computedStartTime, computedDuration] = NativePerformance.measure(
+          measureName,
+          resolvedStartTime,
+          resolvedEndTime,
+          resolvedDuration,
+          resolvedStartMark,
+          resolvedEndMark,
+        );
+      } catch (error) {
+        throw new DOMException(
+          "Failed to execute 'measure' on 'Performance': " + error.message,
+          'SyntaxError',
+        );
+      }
+    } else if (NativePerformance?.measureWithResult) {
       try {
         [computedStartTime, computedDuration] =
           NativePerformance.measureWithResult(
             measureName,
-            startTime,
-            endTime,
-            duration,
-            startMarkName,
-            endMarkName,
+            resolvedStartTime ?? 0,
+            resolvedEndTime ?? 0,
+            resolvedDuration,
+            resolvedStartMark,
+            resolvedEndMark,
           );
       } catch (error) {
         throw new DOMException(
@@ -216,7 +319,7 @@ export default class Performance {
     const measure = new PerformanceMeasure(measureName, {
       startTime: computedStartTime,
       duration: computedDuration ?? 0,
-      detail: options?.detail,
+      detail: resolvedDetail,
     });
 
     return measure;

package/src/private/webapis/performance/PerformanceEntry.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
@@ -29,10 +29,14 @@ export type PerformanceEntryJSON = {
 };
 
 export class PerformanceEntry {
-  #name: string;
-  #entryType: PerformanceEntryType;
-  #startTime: DOMHighResTimeStamp;
-  #duration: DOMHighResTimeStamp;
+  // We don't use private fields because they're significantly slower to
+  // initialize on construction and to access.
+  // We also need these to be protected so they can be initialized in subclasses
+  // where we avoid calling `super()` for performance reasons.
+  __name: string;
+  __entryType: PerformanceEntryType;
+  __startTime: DOMHighResTimeStamp;
+  __duration: DOMHighResTimeStamp;
 
   constructor(init: {
     name: string,
@@ -40,34 +44,34 @@ export class PerformanceEntry {
     startTime: DOMHighResTimeStamp,
     duration: DOMHighResTimeStamp,
   }) {
-    this.#name = init.name;
-    this.#entryType = init.entryType;
-    this.#startTime = init.startTime;
-    this.#duration = init.duration;
+    this.__name = init.name;
+    this.__entryType = init.entryType;
+    this.__startTime = init.startTime;
+    this.__duration = init.duration;
   }
 
   get name(): string {
-    return this.#name;
+    return this.__name;
   }
 
   get entryType(): PerformanceEntryType {
-    return this.#entryType;
+    return this.__entryType;
   }
 
   get startTime(): DOMHighResTimeStamp {
-    return this.#startTime;
+    return this.__startTime;
   }
 
   get duration(): DOMHighResTimeStamp {
-    return this.#duration;
+    return this.__duration;
   }
 
   toJSON(): PerformanceEntryJSON {
     return {
-      name: this.#name,
-      entryType: this.#entryType,
-      startTime: this.#startTime,
-      duration: this.#duration,
+      name: this.__name,
+      entryType: this.__entryType,
+      startTime: this.__startTime,
+      duration: this.__duration,
     };
   }
 }

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 {