@office-iss/react-native-win32 0.76.2 → 0.77.0-preview.2

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

@@ -12,25 +12,21 @@
 
 import type {
   DOMHighResTimeStamp,
+  PerformanceEntryList,
   PerformanceEntryType,
 } from './PerformanceEntry';
-import type {PerformanceEntryList} from './PerformanceObserver';
 import type {DetailType, PerformanceMarkOptions} from './UserTiming';
 
-import warnOnce from '../../../../Libraries/Utilities/warnOnce';
 import {EventCounts} from './EventTiming';
 import MemoryInfo from './MemoryInfo';
-import {ALWAYS_LOGGED_ENTRY_TYPES} from './PerformanceEntry';
-import {warnNoNativePerformanceObserver} from './PerformanceObserver';
 import {
   performanceEntryTypeToRaw,
   rawToPerformanceEntry,
 } from './RawPerformanceEntry';
-import {RawPerformanceEntryTypeValues} from './RawPerformanceEntry';
 import ReactNativeStartupTiming from './ReactNativeStartupTiming';
 import NativePerformance from './specs/NativePerformance';
-import NativePerformanceObserver from './specs/NativePerformanceObserver';
 import {PerformanceMark, PerformanceMeasure} from './UserTiming';
+import {warnNoNativePerformance} from './Utilities';
 
 declare var global: {
   // This value is defined directly via JSI, if available.
@@ -40,24 +36,6 @@ declare var global: {
 const getCurrentTimeStamp: () => DOMHighResTimeStamp =
   NativePerformance?.now ?? global.nativePerformanceNow ?? (() => Date.now());
 
-// We want some of the performance entry types to be always logged,
-// even if they are not currently observed - this is either to be able to
-// retrieve them at any time via Performance.getEntries* or to refer by other entries
-// (such as when measures may refer to marks, even if the latter are not observed)
-if (NativePerformanceObserver?.setIsBuffered) {
-  NativePerformanceObserver?.setIsBuffered(
-    ALWAYS_LOGGED_ENTRY_TYPES.map(performanceEntryTypeToRaw),
-    true,
-  );
-}
-
-function warnNoNativePerformance() {
-  warnOnce(
-    'missing-native-performance',
-    'Missing native implementation of Performance',
-  );
-}
-
 export type PerformanceMeasureOptions = {
   detail?: DetailType,
   start?: DOMHighResTimeStamp,
@@ -65,6 +43,9 @@ export type PerformanceMeasureOptions = {
   end?: DOMHighResTimeStamp,
 };
 
+const ENTRY_TYPES_AVAILABLE_FROM_TIMELINE: $ReadOnlyArray<PerformanceEntryType> =
+  ['mark', 'measure'];
+
 /**
  * Partial implementation of the Performance interface for RN,
  * corresponding to the standard in
@@ -128,27 +109,33 @@ export default class Performance {
     markName: string,
     markOptions?: PerformanceMarkOptions,
   ): PerformanceMark {
-    const mark = new PerformanceMark(markName, markOptions);
-
-    if (NativePerformance?.mark) {
-      NativePerformance.mark(markName, mark.startTime);
+    let computedStartTime;
+    if (NativePerformance?.markWithResult) {
+      computedStartTime = NativePerformance.markWithResult(
+        markName,
+        markOptions?.startTime,
+      );
+    } else if (NativePerformance?.mark) {
+      computedStartTime = markOptions?.startTime ?? performance.now();
+      NativePerformance?.mark?.(markName, computedStartTime);
     } else {
       warnNoNativePerformance();
+      computedStartTime = performance.now();
     }
 
-    return mark;
+    return new PerformanceMark(markName, {
+      startTime: computedStartTime,
+      detail: markOptions?.detail,
+    });
   }
 
   clearMarks(markName?: string): void {
-    if (!NativePerformanceObserver?.clearEntries) {
-      warnNoNativePerformanceObserver();
+    if (!NativePerformance?.clearMarks) {
+      warnNoNativePerformance();
       return;
     }
 
-    NativePerformanceObserver?.clearEntries(
-      RawPerformanceEntryTypeValues.MARK,
-      markName,
-    );
+    NativePerformance.clearMarks(markName);
   }
 
   measure(
@@ -165,6 +152,7 @@ export default class Performance {
 
     if (typeof startMarkOrOptions === 'string') {
       startMarkName = startMarkOrOptions;
+      options = {};
     } else if (startMarkOrOptions !== undefined) {
       options = startMarkOrOptions;
       if (endMark !== undefined) {
@@ -202,15 +190,20 @@ export default class Performance {
       duration = options.duration ?? duration;
     }
 
-    const measure = new PerformanceMeasure(measureName, {
-      // FIXME(T196011255): this is incorrect, as we're only assigning the
-      // start/end if they're specified as a number, but not if they're
-      // specified as previous mark names.
-      startTime,
-      duration,
-    });
-
-    if (NativePerformance?.measure) {
+    let computedStartTime = startTime;
+    let computedDuration = duration;
+
+    if (NativePerformance?.measureWithResult) {
+      [computedStartTime, computedDuration] =
+        NativePerformance.measureWithResult(
+          measureName,
+          startTime,
+          endTime,
+          duration,
+          startMarkName,
+          endMarkName,
+        );
+    } else if (NativePerformance?.measure) {
       NativePerformance.measure(
         measureName,
         startTime,
@@ -223,19 +216,22 @@ export default class Performance {
       warnNoNativePerformance();
     }
 
+    const measure = new PerformanceMeasure(measureName, {
+      startTime: computedStartTime,
+      duration: computedDuration ?? 0,
+      detail: options?.detail,
+    });
+
     return measure;
   }
 
   clearMeasures(measureName?: string): void {
-    if (!NativePerformanceObserver?.clearEntries) {
-      warnNoNativePerformanceObserver();
+    if (!NativePerformance?.clearMeasures) {
+      warnNoNativePerformance();
       return;
     }
 
-    NativePerformanceObserver?.clearEntries(
-      RawPerformanceEntryTypeValues.MEASURE,
-      measureName,
-    );
+    NativePerformance?.clearMeasures(measureName);
   }
 
   /**
@@ -252,28 +248,28 @@ export default class Performance {
    * https://www.w3.org/TR/performance-timeline/#extensions-to-the-performance-interface
    */
   getEntries(): PerformanceEntryList {
-    if (!NativePerformanceObserver?.getEntries) {
-      warnNoNativePerformanceObserver();
+    if (!NativePerformance?.getEntries) {
+      warnNoNativePerformance();
       return [];
     }
-    return NativePerformanceObserver.getEntries().map(rawToPerformanceEntry);
+    return NativePerformance.getEntries().map(rawToPerformanceEntry);
   }
 
   getEntriesByType(entryType: PerformanceEntryType): PerformanceEntryList {
-    if (!ALWAYS_LOGGED_ENTRY_TYPES.includes(entryType)) {
-      console.warn(
-        `Performance.getEntriesByType: Only valid for ${JSON.stringify(
-          ALWAYS_LOGGED_ENTRY_TYPES,
-        )} entry types, got ${entryType}`,
-      );
+    if (
+      entryType != null &&
+      !ENTRY_TYPES_AVAILABLE_FROM_TIMELINE.includes(entryType)
+    ) {
+      console.warn('Deprecated API for given entry type.');
       return [];
     }
 
-    if (!NativePerformanceObserver?.getEntries) {
-      warnNoNativePerformanceObserver();
+    if (!NativePerformance?.getEntriesByType) {
+      warnNoNativePerformance();
       return [];
     }
-    return NativePerformanceObserver.getEntries(
+
+    return NativePerformance.getEntriesByType(
       performanceEntryTypeToRaw(entryType),
     ).map(rawToPerformanceEntry);
   }
@@ -283,24 +279,21 @@ export default class Performance {
     entryType?: PerformanceEntryType,
   ): PerformanceEntryList {
     if (
-      entryType !== undefined &&
-      !ALWAYS_LOGGED_ENTRY_TYPES.includes(entryType)
+      entryType != null &&
+      !ENTRY_TYPES_AVAILABLE_FROM_TIMELINE.includes(entryType)
     ) {
-      console.warn(
-        `Performance.getEntriesByName: Only valid for ${JSON.stringify(
-          ALWAYS_LOGGED_ENTRY_TYPES,
-        )} entry types, got ${entryType}`,
-      );
+      console.warn('Deprecated API for given entry type.');
       return [];
     }
 
-    if (!NativePerformanceObserver?.getEntries) {
-      warnNoNativePerformanceObserver();
+    if (!NativePerformance?.getEntriesByName) {
+      warnNoNativePerformance();
       return [];
     }
-    return NativePerformanceObserver.getEntries(
-      entryType != null ? performanceEntryTypeToRaw(entryType) : undefined,
+
+    return NativePerformance.getEntriesByName(
       entryName,
+      entryType != null ? performanceEntryTypeToRaw(entryType) : undefined,
     ).map(rawToPerformanceEntry);
   }
 }

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

@@ -21,11 +21,6 @@ export type PerformanceEntryJSON = {
   ...
 };
 
-export const ALWAYS_LOGGED_ENTRY_TYPES: $ReadOnlyArray<PerformanceEntryType> = [
-  'mark',
-  'measure',
-];
-
 export class PerformanceEntry {
   #name: string;
   #entryType: PerformanceEntryType;
@@ -69,3 +64,5 @@ export class PerformanceEntry {
     };
   }
 }
+
+export type PerformanceEntryList = $ReadOnlyArray<PerformanceEntry>;

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

@@ -10,20 +10,19 @@
 
 import type {
   DOMHighResTimeStamp,
+  PerformanceEntryList,
   PerformanceEntryType,
 } from './PerformanceEntry';
+import type {OpaqueNativeObserverHandle} from './specs/NativePerformance';
 
-import warnOnce from '../../../../Libraries/Utilities/warnOnce';
 import {PerformanceEventTiming} from './EventTiming';
-import {PerformanceEntry} from './PerformanceEntry';
 import {
   performanceEntryTypeToRaw,
   rawToPerformanceEntry,
   rawToPerformanceEntryType,
 } from './RawPerformanceEntry';
-import NativePerformanceObserver from './specs/NativePerformanceObserver';
-
-export type PerformanceEntryList = $ReadOnlyArray<PerformanceEntry>;
+import NativePerformance from './specs/NativePerformance';
+import {warnNoNativePerformance} from './Utilities';
 
 export {PerformanceEntry} from './PerformanceEntry';
 
@@ -56,99 +55,34 @@ export class PerformanceObserverEntryList {
   }
 }
 
+export type PerformanceObserverCallbackOptions = {
+  droppedEntriesCount: number,
+};
+
 export type PerformanceObserverCallback = (
   list: PerformanceObserverEntryList,
   observer: PerformanceObserver,
   // The number of buffered entries which got dropped from the buffer due to the buffer being full:
-  droppedEntryCount?: number,
+  options?: PerformanceObserverCallbackOptions,
 ) => void;
 
-export type PerformanceObserverInit =
-  | {
-      entryTypes: Array<PerformanceEntryType>,
-    }
-  | {
-      type: PerformanceEntryType,
-      durationThreshold?: DOMHighResTimeStamp,
-    };
-
-type PerformanceObserverConfig = {|
-  callback: PerformanceObserverCallback,
-  entryTypes: $ReadOnlySet<PerformanceEntryType>,
-  durationThreshold: ?number,
-|};
-
-const observerCountPerEntryType: Map<PerformanceEntryType, number> = new Map();
-const registeredObservers: Map<PerformanceObserver, PerformanceObserverConfig> =
-  new Map();
-let isOnPerformanceEntryCallbackSet: boolean = false;
-
-// This is a callback that gets scheduled and periodically called from the native side
-const onPerformanceEntry = () => {
-  if (!NativePerformanceObserver) {
-    return;
-  }
-  const entryResult = NativePerformanceObserver.popPendingEntries();
-  const rawEntries = entryResult?.entries ?? [];
-  const droppedEntriesCount = entryResult?.droppedEntriesCount;
-  if (rawEntries.length === 0) {
-    return;
-  }
-  const entries = rawEntries.map(rawToPerformanceEntry);
-  for (const [observer, observerConfig] of registeredObservers.entries()) {
-    const entriesForObserver: PerformanceEntryList = entries.filter(entry => {
-      if (!observerConfig.entryTypes.has(entry.entryType)) {
-        return false;
-      }
-
-      if (
-        entry.entryType === 'event' &&
-        observerConfig.durationThreshold != null
-      ) {
-        return entry.duration >= observerConfig.durationThreshold;
-      }
-
-      return true;
-    });
-    if (entriesForObserver.length !== 0) {
-      try {
-        observerConfig.callback(
-          new PerformanceObserverEntryList(entriesForObserver),
-          observer,
-          droppedEntriesCount,
-        );
-      } catch (error) {
-        console.error(error);
-      }
-    }
-  }
+export type PerformanceObserverInit = {
+  entryTypes?: Array<PerformanceEntryType>,
+  type?: PerformanceEntryType,
+  buffered?: boolean,
+  durationThreshold?: DOMHighResTimeStamp,
 };
 
-export function warnNoNativePerformanceObserver() {
-  warnOnce(
-    'missing-native-performance-observer',
-    'Missing native implementation of PerformanceObserver',
-  );
-}
-
-function applyDurationThresholds() {
-  const durationThresholds = Array.from(registeredObservers.values())
-    .map(observerConfig => observerConfig.durationThreshold)
-    .filter(Boolean);
-
-  return Math.min(...durationThresholds);
-}
-
 function getSupportedPerformanceEntryTypes(): $ReadOnlyArray<PerformanceEntryType> {
-  if (!NativePerformanceObserver) {
+  if (!NativePerformance) {
     return Object.freeze([]);
   }
-  if (!NativePerformanceObserver.getSupportedPerformanceEntryTypes) {
+  if (!NativePerformance.getSupportedPerformanceEntryTypes) {
     // fallback if getSupportedPerformanceEntryTypes is not defined on native side
     return Object.freeze(['mark', 'measure', 'event']);
   }
   return Object.freeze(
-    NativePerformanceObserver.getSupportedPerformanceEntryTypes().map(
+    NativePerformance.getSupportedPerformanceEntryTypes().map(
       rawToPerformanceEntryType,
     ),
   );
@@ -175,111 +109,86 @@ function getSupportedPerformanceEntryTypes(): $ReadOnlyArray<PerformanceEntryTyp
  * observer.observe({ type: "event" });
  */
 export class PerformanceObserver {
+  #nativeObserverHandle: OpaqueNativeObserverHandle | null = null;
   #callback: PerformanceObserverCallback;
   #type: 'single' | 'multiple' | void;
+  #calledAtLeastOnce = false;
 
   constructor(callback: PerformanceObserverCallback) {
     this.#callback = callback;
   }
 
   observe(options: PerformanceObserverInit): void {
-    if (!NativePerformanceObserver) {
-      warnNoNativePerformanceObserver();
+    if (!NativePerformance || NativePerformance.observe == null) {
+      warnNoNativePerformance();
       return;
     }
 
     this.#validateObserveOptions(options);
 
-    let requestedEntryTypes;
+    if (this.#nativeObserverHandle == null) {
+      this.#nativeObserverHandle = this.#createNativeObserver();
+    }
 
     if (options.entryTypes) {
       this.#type = 'multiple';
-      requestedEntryTypes = new Set(options.entryTypes);
-    } else {
+      NativePerformance.observe?.(this.#nativeObserverHandle, {
+        entryTypes: options.entryTypes.map(performanceEntryTypeToRaw),
+      });
+    } else if (options.type) {
       this.#type = 'single';
-      requestedEntryTypes = new Set([options.type]);
+      NativePerformance.observe?.(this.#nativeObserverHandle, {
+        type: performanceEntryTypeToRaw(options.type),
+        buffered: options.buffered,
+        durationThreshold: options.durationThreshold,
+      });
     }
+  }
 
-    // The same observer may receive multiple calls to "observe", so we need
-    // to check what is new on this call vs. previous ones.
-    const currentEntryTypes = registeredObservers.get(this)?.entryTypes;
-    const nextEntryTypes = currentEntryTypes
-      ? union(requestedEntryTypes, currentEntryTypes)
-      : requestedEntryTypes;
-
-    // This `observe` call is a no-op because there are no new things to observe.
-    if (currentEntryTypes && currentEntryTypes.size === nextEntryTypes.size) {
+  disconnect(): void {
+    if (!NativePerformance) {
+      warnNoNativePerformance();
       return;
     }
 
-    registeredObservers.set(this, {
-      callback: this.#callback,
-      durationThreshold:
-        options.type === 'event' ? options.durationThreshold : undefined,
-      entryTypes: nextEntryTypes,
-    });
-
-    if (!isOnPerformanceEntryCallbackSet) {
-      NativePerformanceObserver.setOnPerformanceEntryCallback(
-        onPerformanceEntry,
-      );
-      isOnPerformanceEntryCallbackSet = true;
+    if (this.#nativeObserverHandle == null || !NativePerformance.disconnect) {
+      return;
     }
 
-    // We only need to start listenening to new entry types being observed in
-    // this observer.
-    const newEntryTypes = currentEntryTypes
-      ? difference(
-          new Set(requestedEntryTypes.keys()),
-          new Set(currentEntryTypes.keys()),
-        )
-      : new Set(requestedEntryTypes.keys());
-    for (const type of newEntryTypes) {
-      if (!observerCountPerEntryType.has(type)) {
-        const rawType = performanceEntryTypeToRaw(type);
-        NativePerformanceObserver.startReporting(rawType);
-      }
-      observerCountPerEntryType.set(
-        type,
-        (observerCountPerEntryType.get(type) ?? 0) + 1,
-      );
-    }
-    applyDurationThresholds();
+    NativePerformance.disconnect(this.#nativeObserverHandle);
   }
 
-  disconnect(): void {
-    if (!NativePerformanceObserver) {
-      warnNoNativePerformanceObserver();
+  #createNativeObserver(): OpaqueNativeObserverHandle {
+    if (!NativePerformance || !NativePerformance.createObserver) {
+      warnNoNativePerformance();
       return;
     }
 
-    const observerConfig = registeredObservers.get(this);
-    if (!observerConfig) {
-      return;
-    }
+    this.#calledAtLeastOnce = false;
 
-    // Disconnect this observer
-    for (const type of observerConfig.entryTypes.keys()) {
-      const numberOfObserversForThisType =
-        observerCountPerEntryType.get(type) ?? 0;
-      if (numberOfObserversForThisType === 1) {
-        observerCountPerEntryType.delete(type);
-        NativePerformanceObserver.stopReporting(
-          performanceEntryTypeToRaw(type),
-        );
-      } else if (numberOfObserversForThisType !== 0) {
-        observerCountPerEntryType.set(type, numberOfObserversForThisType - 1);
+    return NativePerformance.createObserver(() => {
+      const rawEntries = NativePerformance.takeRecords?.(
+        this.#nativeObserverHandle,
+        true, // sort records
+      );
+      if (!rawEntries) {
+        return;
       }
-    }
 
-    // Disconnect all observers if this was the last one
-    registeredObservers.delete(this);
-    if (registeredObservers.size === 0) {
-      NativePerformanceObserver.setOnPerformanceEntryCallback(undefined);
-      isOnPerformanceEntryCallbackSet = false;
-    }
+      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;
+      }
 
-    applyDurationThresholds();
+      this.#callback(entryList, this, {droppedEntriesCount});
+    });
   }
 
   #validateObserveOptions(options: PerformanceObserverInit): void {
@@ -309,7 +218,7 @@ export class PerformanceObserver {
       );
     }
 
-    if (entryTypes && durationThreshold !== undefined) {
+    if (entryTypes && durationThreshold != null) {
       throw new TypeError(
         "Failed to execute 'observe' on 'PerformanceObserver': An observe() call must not include both entryTypes and durationThreshold arguments.",
       );
@@ -320,12 +229,4 @@ export class PerformanceObserver {
     getSupportedPerformanceEntryTypes();
 }
 
-function union<T>(a: $ReadOnlySet<T>, b: $ReadOnlySet<T>): Set<T> {
-  return new Set([...a, ...b]);
-}
-
-function difference<T>(a: $ReadOnlySet<T>, b: $ReadOnlySet<T>): Set<T> {
-  return new Set([...a].filter(x => !b.has(x)));
-}
-
 export {PerformanceEventTiming};

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

@@ -12,7 +12,7 @@ import type {PerformanceEntryType} from './PerformanceEntry';
 import type {
   RawPerformanceEntry,
   RawPerformanceEntryType,
-} from './specs/NativePerformanceObserver';
+} from './specs/NativePerformance';
 
 import {PerformanceEventTiming} from './EventTiming';
 import {PerformanceLongTaskTiming} from './LongTasks';

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

@@ -25,12 +25,12 @@ export type TimeStampOrName = DOMHighResTimeStamp | string;
 
 export type PerformanceMeasureInit = {
   detail?: DetailType,
-  startTime?: DOMHighResTimeStamp,
-  duration?: DOMHighResTimeStamp,
+  startTime: DOMHighResTimeStamp,
+  duration: DOMHighResTimeStamp,
 };
 
 export class PerformanceMark extends PerformanceEntry {
-  detail: DetailType;
+  #detail: DetailType;
 
   constructor(markName: string, markOptions?: PerformanceMarkOptions) {
     super({
@@ -41,20 +41,24 @@ export class PerformanceMark extends PerformanceEntry {
     });
 
     if (markOptions) {
-      this.detail = markOptions.detail;
+      this.#detail = markOptions.detail;
     }
   }
+
+  get detail(): DetailType {
+    return this.#detail;
+  }
 }
 
 export class PerformanceMeasure extends PerformanceEntry {
   #detail: DetailType;
 
-  constructor(measureName: string, measureOptions?: PerformanceMeasureInit) {
+  constructor(measureName: string, measureOptions: PerformanceMeasureInit) {
     super({
       name: measureName,
       entryType: 'measure',
-      startTime: measureOptions?.startTime ?? 0,
-      duration: measureOptions?.duration ?? 0,
+      startTime: measureOptions.startTime,
+      duration: measureOptions.duration,
     });
 
     if (measureOptions) {

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

@@ -0,0 +1,18 @@
+/**
+ * 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 warnOnce from '../../../../Libraries/Utilities/warnOnce';
+
+export function warnNoNativePerformance() {
+  warnOnce(
+    'missing-native-performance',
+    'Missing native implementation of Performance',
+  );
+}