@office-iss/react-native-win32 0.0.0-canary.272 → 0.0.0-canary.273

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

@@ -12,8 +12,8 @@
 
 import type {
   DOMHighResTimeStamp,
-  PerformanceEntryType,
   PerformanceEntryList,
+  PerformanceEntryType,
 } from './PerformanceEntry';
 import type {DetailType, PerformanceMarkOptions} from './UserTiming';
 
@@ -109,15 +109,24 @@ 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 {
@@ -143,6 +152,7 @@ export default class Performance {
 
     if (typeof startMarkOrOptions === 'string') {
       startMarkName = startMarkOrOptions;
+      options = {};
     } else if (startMarkOrOptions !== undefined) {
       options = startMarkOrOptions;
       if (endMark !== undefined) {
@@ -180,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,
@@ -201,6 +216,12 @@ export default class Performance {
       warnNoNativePerformance();
     }
 
+    const measure = new PerformanceMeasure(measureName, {
+      startTime: computedStartTime,
+      duration: computedDuration,
+      detail: options?.detail,
+    });
+
     return measure;
   }
 

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

@@ -10,9 +10,10 @@
 
 import type {
   DOMHighResTimeStamp,
-  PerformanceEntryType,
   PerformanceEntryList,
+  PerformanceEntryType,
 } from './PerformanceEntry';
+import type {OpaqueNativeObserverHandle} from './specs/NativePerformance';
 
 import {PerformanceEventTiming} from './EventTiming';
 import {
@@ -21,7 +22,6 @@ import {
   rawToPerformanceEntryType,
 } from './RawPerformanceEntry';
 import NativePerformance from './specs/NativePerformance';
-import type {OpaqueNativeObserverHandle} from './specs/NativePerformance';
 import {warnNoNativePerformance} from './Utilities';
 
 export {PerformanceEntry} from './PerformanceEntry';

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

@@ -33,6 +33,8 @@ export type RawPerformanceEntry = {
 export type OpaqueNativeObserverHandle = mixed;
 
 export type NativeBatchedObserverCallback = () => void;
+export type NativePerformanceMarkResult = number;
+export type NativePerformanceMeasureResult = $ReadOnlyArray<number>; // [startTime, duration]
 
 export type PerformanceObserverInit = {
   entryTypes?: $ReadOnlyArray<number>,
@@ -43,8 +45,10 @@ export type PerformanceObserverInit = {
 
 export interface Spec extends TurboModule {
   +now?: () => number;
-  +mark: (name: string, startTime: number) => void;
-  +measure: (
+  // TODO: remove when `markWithResult` is fully rolled out.
+  +mark?: (name: string, startTime: number) => void;
+  // TODO: remove when `measureWithResult` is fully rolled out.
+  +measure?: (
     name: string,
     startTime: number,
     endTime: number,
@@ -52,6 +56,18 @@ export interface Spec extends TurboModule {
     startMark?: string,
     endMark?: string,
   ) => void;
+  +markWithResult?: (
+    name: string,
+    startTime?: number,
+  ) => NativePerformanceMarkResult;
+  +measureWithResult?: (
+    name: string,
+    startTime: number,
+    endTime: number,
+    duration?: number,
+    startMark?: string,
+    endMark?: string,
+  ) => NativePerformanceMeasureResult;
   +clearMarks?: (entryName?: string) => void;
   +clearMeasures?: (entryName?: string) => void;
   +getEntries?: () => $ReadOnlyArray<RawPerformanceEntry>;

package/src/private/webapis/performance/specs/__mocks__/NativePerformanceMock.js

@@ -11,13 +11,14 @@
 import type {
   NativeBatchedObserverCallback,
   NativeMemoryInfo,
-  RawPerformanceEntry,
-  ReactNativeStartupTiming,
-  PerformanceObserverInit,
+  NativePerformanceMarkResult,
+  NativePerformanceMeasureResult,
   OpaqueNativeObserverHandle,
+  PerformanceObserverInit,
+  RawPerformanceEntry,
   RawPerformanceEntryType,
+  ReactNativeStartupTiming,
 } from '../NativePerformance';
-
 import typeof NativePerformance from '../NativePerformance';
 
 import {RawPerformanceEntryTypeValues} from '../../RawPerformanceEntry';
@@ -109,32 +110,51 @@ const NativePerformanceMock = {
 
   now: (): number => currentTime,
 
-  mark: (name: string, startTime: number): void => {
-    marks.set(name, startTime);
+  markWithResult: (
+    name: string,
+    startTime?: number,
+  ): NativePerformanceMarkResult => {
+    const computedStartTime = startTime ?? performance.now();
+
+    marks.set(name, computedStartTime);
     reportEntry({
       entryType: RawPerformanceEntryTypeValues.MARK,
       name,
-      startTime,
+      startTime: computedStartTime,
       duration: 0,
     });
+
+    return computedStartTime;
   },
 
-  measure: (
+  measureWithResult: (
     name: string,
     startTime: number,
     endTime: number,
     duration?: number,
     startMark?: string,
     endMark?: string,
-  ): void => {
-    const start = startMark != null ? marks.get(startMark) ?? 0 : startTime;
-    const end = endMark != null ? marks.get(endMark) ?? 0 : endTime;
+  ): NativePerformanceMeasureResult => {
+    const start = startMark != null ? marks.get(startMark) : startTime;
+    const end = endMark != null ? marks.get(endMark) : endTime;
+
+    if (start === undefined) {
+      throw new Error('startMark does not exist');
+    }
+
+    if (end === undefined) {
+      throw new Error('endMark does not exist');
+    }
+
+    const computedDuration = duration ?? end - start;
     reportEntry({
       entryType: RawPerformanceEntryTypeValues.MEASURE,
       name,
       startTime: start,
-      duration: duration ?? end - start,
+      duration: computedDuration,
     });
+
+    return [start, computedDuration];
   },
 
   getSimpleMemoryInfo: (): NativeMemoryInfo => {