react-native-tvos 0.81.3-0 → 0.82.0-0rc1

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

@@ -15,38 +15,77 @@ import type {
   PerformanceEntryList,
   PerformanceEntryType,
 } from './PerformanceEntry';
-import type {DetailType, PerformanceMarkOptions} from './UserTiming';
+import type {
+  DetailType,
+  PerformanceMarkOptions,
+  PerformanceMeasureInit,
+} from './UserTiming';
 
 import DOMException from '../errors/DOMException';
+import structuredClone from '../structuredClone/structuredClone';
 import {setPlatformObject} from '../webidl/PlatformObjects';
 import {EventCounts} from './EventTiming';
 import {
   performanceEntryTypeToRaw,
   rawToPerformanceEntry,
 } from './internals/RawPerformanceEntry';
-import {warnNoNativePerformance} from './internals/Utilities';
+import {getCurrentTimeStamp} from './internals/Utilities';
 import MemoryInfo from './MemoryInfo';
 import ReactNativeStartupTiming from './ReactNativeStartupTiming';
-import NativePerformance from './specs/NativePerformance';
+import MaybeNativePerformance from './specs/NativePerformance';
 import {PerformanceMark, PerformanceMeasure} from './UserTiming';
+import nullthrows from 'nullthrows';
+
+export type PerformanceMeasureOptions =
+  | $ReadOnly<{
+      detail?: DetailType,
+      start?: DOMHighResTimeStamp | string,
+      duration?: DOMHighResTimeStamp,
+    }>
+  | $ReadOnly<{
+      detail?: DetailType,
+      start?: DOMHighResTimeStamp | string,
+      end?: DOMHighResTimeStamp | string,
+    }>
+  | $ReadOnly<{
+      detail?: DetailType,
+      duration?: DOMHighResTimeStamp | string,
+      end?: DOMHighResTimeStamp | string,
+    }>;
 
-declare var global: {
-  // This value is defined directly via JSI, if available.
-  +nativePerformanceNow?: ?() => number,
-};
+const ENTRY_TYPES_AVAILABLE_FROM_TIMELINE: $ReadOnlyArray<PerformanceEntryType> =
+  ['mark', 'measure'];
+
+const NativePerformance = nullthrows(MaybeNativePerformance);
 
-const getCurrentTimeStamp: () => DOMHighResTimeStamp =
-  NativePerformance?.now ?? global.nativePerformanceNow ?? (() => Date.now());
+const cachedReportMark = NativePerformance.reportMark;
+const cachedReportMeasure = NativePerformance.reportMeasure;
+const cachedGetMarkTime = NativePerformance.getMarkTime;
+const cachedNativeClearMarks = NativePerformance.clearMarks;
+const cachedNativeClearMeasures = NativePerformance.clearMeasures;
 
-export type PerformanceMeasureOptions = {
-  detail?: DetailType,
-  start?: DOMHighResTimeStamp,
-  duration?: DOMHighResTimeStamp,
-  end?: DOMHighResTimeStamp,
+const MARK_OPTIONS_REUSABLE_OBJECT: PerformanceMarkOptions = {
+  startTime: 0,
+  detail: undefined,
 };
 
-const ENTRY_TYPES_AVAILABLE_FROM_TIMELINE: $ReadOnlyArray<PerformanceEntryType> =
-  ['mark', 'measure'];
+const MEASURE_OPTIONS_REUSABLE_OBJECT: PerformanceMeasureInit = {
+  name: '',
+  startTime: 0,
+  duration: 0,
+  detail: undefined,
+};
+
+const getMarkTimeForMeasure = (markName: string): number => {
+  const markTime = cachedGetMarkTime(markName);
+  if (markTime == null) {
+    throw new DOMException(
+      `Failed to execute 'measure' on 'Performance': The mark '${markName}' does not exist.`,
+      'SyntaxError',
+    );
+  }
+  return markTime;
+};
 
 /**
  * Partial implementation of the Performance interface for RN,
@@ -58,177 +97,302 @@ export default class Performance {
 
   // Get the current JS memory information.
   get memory(): MemoryInfo {
-    if (NativePerformance?.getSimpleMemoryInfo) {
-      // JSI API implementations may have different variants of names for the JS
-      // heap information we need here. We will parse the result based on our
-      // guess of the implementation for now.
-      const memoryInfo = NativePerformance.getSimpleMemoryInfo();
-      if (memoryInfo.hasOwnProperty('hermes_heapSize')) {
-        // We got memory information from Hermes
-        const {
-          hermes_heapSize: totalJSHeapSize,
-          hermes_allocatedBytes: usedJSHeapSize,
-        } = memoryInfo;
-
-        return new MemoryInfo({
-          jsHeapSizeLimit: null, // We don't know the heap size limit from Hermes.
-          totalJSHeapSize,
-          usedJSHeapSize,
-        });
-      } else {
-        // JSC and V8 has no native implementations for memory information in JSI::Instrumentation
-        return new MemoryInfo();
-      }
+    // JSI API implementations may have different variants of names for the JS
+    // heap information we need here. We will parse the result based on our
+    // guess of the implementation for now.
+    const memoryInfo = NativePerformance.getSimpleMemoryInfo();
+    if (memoryInfo.hasOwnProperty('hermes_heapSize')) {
+      // We got memory information from Hermes
+      const {
+        hermes_heapSize: totalJSHeapSize,
+        hermes_allocatedBytes: usedJSHeapSize,
+      } = memoryInfo;
+
+      return new MemoryInfo({
+        jsHeapSizeLimit: null, // We don't know the heap size limit from Hermes.
+        totalJSHeapSize,
+        usedJSHeapSize,
+      });
+    } else {
+      // JSC and V8 has no native implementations for memory information in JSI::Instrumentation
+      return new MemoryInfo();
     }
-
-    return new MemoryInfo();
   }
 
   // Startup metrics is not used in web, but only in React Native.
   get rnStartupTiming(): ReactNativeStartupTiming {
-    if (NativePerformance?.getReactNativeStartupTiming) {
-      const {
-        startTime,
-        endTime,
-        initializeRuntimeStart,
-        initializeRuntimeEnd,
-        executeJavaScriptBundleEntryPointStart,
-        executeJavaScriptBundleEntryPointEnd,
-      } = NativePerformance.getReactNativeStartupTiming();
-      return new ReactNativeStartupTiming({
-        startTime,
-        endTime,
-        initializeRuntimeStart,
-        initializeRuntimeEnd,
-        executeJavaScriptBundleEntryPointStart,
-        executeJavaScriptBundleEntryPointEnd,
-      });
-    }
-    return new ReactNativeStartupTiming();
+    const {
+      startTime,
+      endTime,
+      initializeRuntimeStart,
+      initializeRuntimeEnd,
+      executeJavaScriptBundleEntryPointStart,
+      executeJavaScriptBundleEntryPointEnd,
+    } = NativePerformance.getReactNativeStartupTiming();
+    return new ReactNativeStartupTiming({
+      startTime,
+      endTime,
+      initializeRuntimeStart,
+      initializeRuntimeEnd,
+      executeJavaScriptBundleEntryPointStart,
+      executeJavaScriptBundleEntryPointEnd,
+    });
   }
 
   mark(
     markName: string,
     markOptions?: PerformanceMarkOptions,
   ): PerformanceMark {
-    let computedStartTime;
-    if (NativePerformance?.markWithResult) {
-      computedStartTime = NativePerformance.markWithResult(
-        markName,
-        markOptions?.startTime,
+    // IMPORTANT: this method has been micro-optimized.
+    // Please run the benchmarks in `Performance-benchmarks-itest` to ensure
+    // changes do not regress performance.
+
+    if (markName === undefined) {
+      throw new TypeError(
+        `Failed to execute 'mark' on 'Performance': 1 argument required, but only 0 present.`,
       );
-    } else {
-      warnNoNativePerformance();
-      computedStartTime = performance.now();
     }
 
-    return new PerformanceMark(markName, {
-      startTime: computedStartTime,
-      detail: markOptions?.detail,
-    });
-  }
+    const resolvedMarkName =
+      typeof markName === 'string' ? markName : String(markName);
 
-  clearMarks(markName?: string): void {
-    if (!NativePerformance?.clearMarks) {
-      warnNoNativePerformance();
-      return;
-    }
+    let resolvedStartTime;
+    let resolvedDetail;
 
-    NativePerformance.clearMarks(markName);
-  }
+    let startTime;
+    let detail;
+    if (markOptions != null) {
+      ({startTime, detail} = markOptions);
+    }
 
-  measure(
-    measureName: string,
-    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) {
+    if (startTime !== undefined) {
+      resolvedStartTime =
+        typeof startTime === 'number' ? startTime : Number(startTime);
+      if (resolvedStartTime < 0) {
         throw new TypeError(
-          "Performance.measure: Can't have both options and endMark",
+          `Failed to execute 'mark' on 'Performance': '${resolvedMarkName}' cannot have a negative start time.`,
         );
-      }
-      if (options.start === undefined && options.end === undefined) {
-        throw new TypeError(
-          'Performance.measure: Must have at least one of start/end specified in options',
-        );
-      }
-      if (
-        options.start !== undefined &&
-        options.end !== undefined &&
-        options.duration !== undefined
+      } else if (
+        // This is faster than calling Number.isFinite()
+        // eslint-disable-next-line no-self-compare
+        resolvedStartTime !== resolvedStartTime ||
+        resolvedStartTime === Infinity
       ) {
         throw new TypeError(
-          "Performance.measure: Can't have both start/end and duration explicitly in options",
+          `Failed to execute 'mark' on 'Performance': Failed to read the 'startTime' property from 'PerformanceMarkOptions': The provided double value is non-finite.`,
         );
       }
+    } else {
+      resolvedStartTime = getCurrentTimeStamp();
+    }
 
-      if (typeof options.start === 'number') {
-        startTime = options.start;
-      } else {
-        startMarkName = options.start;
-      }
+    if (detail !== undefined) {
+      resolvedDetail = structuredClone(detail);
+    }
 
-      if (typeof options.end === 'number') {
-        endTime = options.end;
-      } else {
-        endMarkName = options.end;
-      }
+    // $FlowExpectedError[cannot-write]
+    MARK_OPTIONS_REUSABLE_OBJECT.startTime = resolvedStartTime;
+    // $FlowExpectedError[cannot-write]
+    MARK_OPTIONS_REUSABLE_OBJECT.detail = resolvedDetail;
+
+    const entry = new PerformanceMark(
+      resolvedMarkName,
+      MARK_OPTIONS_REUSABLE_OBJECT,
+    );
 
-      duration = options.duration ?? duration;
+    cachedReportMark(resolvedMarkName, resolvedStartTime, entry);
+
+    return entry;
+  }
+
+  clearMarks(markName?: string): void {
+    cachedNativeClearMarks(markName);
+  }
+
+  measure(
+    measureName: string,
+    startMarkOrOptions?: string | PerformanceMeasureOptions,
+    endMark?: string,
+  ): PerformanceMeasure {
+    // IMPORTANT: this method has been micro-optimized.
+    // Please run the benchmarks in `Performance-benchmarks-itest` to ensure
+    // changes do not regress performance.
+
+    let resolvedMeasureName: string;
+    let resolvedStartTime: number;
+    let resolvedDuration: number;
+    let resolvedDetail: mixed;
+
+    if (measureName === undefined) {
+      throw new TypeError(
+        `Failed to execute 'measure' on 'Performance': 1 argument required, but only 0 present.`,
+      );
     }
 
-    let computedStartTime = startTime;
-    let computedDuration = duration;
-
-    if (NativePerformance?.measureWithResult) {
-      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',
-        );
+    resolvedMeasureName =
+      typeof measureName === 'string' ? measureName : String(measureName);
+
+    if (startMarkOrOptions != null) {
+      switch (typeof startMarkOrOptions) {
+        case 'object': {
+          if (endMark !== undefined) {
+            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, end, duration, detail} = startMarkOrOptions;
+
+          let resolvedEndTime;
+
+          if (
+            start !== undefined &&
+            end !== undefined &&
+            duration !== undefined
+          ) {
+            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`,
+            );
+          }
+
+          switch (typeof start) {
+            case 'undefined': {
+              // This will be handled after all options have been processed.
+              break;
+            }
+            case 'number': {
+              resolvedStartTime = start;
+              break;
+            }
+            case 'string': {
+              resolvedStartTime = getMarkTimeForMeasure(start);
+              break;
+            }
+            default: {
+              resolvedStartTime = getMarkTimeForMeasure(String(start));
+            }
+          }
+
+          switch (typeof end) {
+            case 'undefined': {
+              // This will be handled after all options have been processed.
+              break;
+            }
+            case 'number': {
+              resolvedEndTime = end;
+              break;
+            }
+            case 'string': {
+              resolvedEndTime = getMarkTimeForMeasure(end);
+              break;
+            }
+            default: {
+              resolvedEndTime = getMarkTimeForMeasure(String(end));
+            }
+          }
+
+          switch (typeof duration) {
+            case 'undefined': {
+              // This will be handled after all options have been processed.
+              break;
+            }
+            case 'number': {
+              resolvedDuration = duration;
+              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 (resolvedStartTime === undefined) {
+            if (
+              resolvedEndTime !== undefined &&
+              resolvedDuration !== undefined
+            ) {
+              resolvedStartTime = resolvedEndTime - resolvedDuration;
+            } else {
+              resolvedStartTime = 0;
+            }
+          }
+
+          if (resolvedDuration === undefined) {
+            if (
+              resolvedStartTime !== undefined &&
+              resolvedEndTime !== undefined
+            ) {
+              resolvedDuration = resolvedEndTime - resolvedStartTime;
+            } else {
+              resolvedDuration = getCurrentTimeStamp() - resolvedStartTime;
+            }
+          }
+
+          if (detail !== undefined) {
+            resolvedDetail = structuredClone(detail);
+          }
+
+          break;
+        }
+        case 'string': {
+          resolvedStartTime = getMarkTimeForMeasure(startMarkOrOptions);
+
+          if (endMark !== undefined) {
+            resolvedDuration =
+              getMarkTimeForMeasure(endMark) - resolvedStartTime;
+          } else {
+            resolvedDuration = getCurrentTimeStamp() - resolvedStartTime;
+          }
+          break;
+        }
+        default: {
+          resolvedStartTime = getMarkTimeForMeasure(String(startMarkOrOptions));
+
+          if (endMark !== undefined) {
+            resolvedDuration =
+              getMarkTimeForMeasure(endMark) - resolvedStartTime;
+          } else {
+            resolvedDuration = getCurrentTimeStamp() - resolvedStartTime;
+          }
+        }
       }
     } else {
-      warnNoNativePerformance();
-    }
+      resolvedStartTime = 0;
 
-    const measure = new PerformanceMeasure(measureName, {
-      startTime: computedStartTime,
-      duration: computedDuration ?? 0,
-      detail: options?.detail,
-    });
+      if (endMark !== undefined) {
+        resolvedDuration = getMarkTimeForMeasure(endMark) - resolvedStartTime;
+      } else {
+        resolvedDuration = getCurrentTimeStamp() - resolvedStartTime;
+      }
+    }
 
-    return measure;
+    // $FlowExpectedError[cannot-write]
+    MEASURE_OPTIONS_REUSABLE_OBJECT.name = resolvedMeasureName;
+    // $FlowExpectedError[cannot-write]
+    MEASURE_OPTIONS_REUSABLE_OBJECT.startTime = resolvedStartTime;
+    // $FlowExpectedError[cannot-write]
+    MEASURE_OPTIONS_REUSABLE_OBJECT.duration = resolvedDuration;
+    // $FlowExpectedError[cannot-write]
+    MEASURE_OPTIONS_REUSABLE_OBJECT.detail = resolvedDetail;
+
+    const entry = new PerformanceMeasure(MEASURE_OPTIONS_REUSABLE_OBJECT);
+
+    cachedReportMeasure(
+      resolvedMeasureName,
+      resolvedStartTime,
+      resolvedDuration,
+      entry,
+    );
+
+    return entry;
   }
 
   clearMeasures(measureName?: string): void {
-    if (!NativePerformance?.clearMeasures) {
-      warnNoNativePerformance();
-      return;
-    }
-
-    NativePerformance?.clearMeasures(measureName);
+    cachedNativeClearMeasures(measureName);
   }
 
   /**
@@ -243,10 +407,6 @@ export default class Performance {
    * https://www.w3.org/TR/performance-timeline/#extensions-to-the-performance-interface
    */
   getEntries(): PerformanceEntryList {
-    if (!NativePerformance?.getEntries) {
-      warnNoNativePerformance();
-      return [];
-    }
     return NativePerformance.getEntries().map(rawToPerformanceEntry);
   }
 
@@ -259,11 +419,6 @@ export default class Performance {
       return [];
     }
 
-    if (!NativePerformance?.getEntriesByType) {
-      warnNoNativePerformance();
-      return [];
-    }
-
     return NativePerformance.getEntriesByType(
       performanceEntryTypeToRaw(entryType),
     ).map(rawToPerformanceEntry);
@@ -281,11 +436,6 @@ export default class Performance {
       return [];
     }
 
-    if (!NativePerformance?.getEntriesByName) {
-      warnNoNativePerformance();
-      return [];
-    }
-
     return NativePerformance.getEntriesByName(
       entryName,
       entryType != null ? performanceEntryTypeToRaw(entryType) : undefined,
@@ -293,4 +443,16 @@ export default class Performance {
   }
 }
 
+export const Performance_public: typeof Performance =
+  /* eslint-disable no-shadow */
+  // $FlowExpectedError[incompatible-type]
+  function Performance() {
+    throw new TypeError(
+      "Failed to construct 'Performance': Illegal constructor",
+    );
+  };
+
+// $FlowExpectedError[prop-missing]
+Performance_public.prototype = Performance.prototype;
+
 setPlatformObject(Performance);

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

@@ -28,50 +28,67 @@ export type PerformanceEntryJSON = {
   ...
 };
 
+export interface PerformanceEntryInit {
+  +name: string;
+  +startTime: DOMHighResTimeStamp;
+  +duration: DOMHighResTimeStamp;
+}
+
 export class PerformanceEntry {
-  #name: string;
-  #entryType: PerformanceEntryType;
-  #startTime: DOMHighResTimeStamp;
-  #duration: DOMHighResTimeStamp;
-
-  constructor(init: {
-    name: string,
-    entryType: PerformanceEntryType,
-    startTime: DOMHighResTimeStamp,
-    duration: DOMHighResTimeStamp,
-  }) {
-    this.#name = init.name;
-    this.#entryType = init.entryType;
-    this.#startTime = init.startTime;
-    this.#duration = init.duration;
+  // 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.
+  __entryType: PerformanceEntryType;
+  __name: string;
+  __startTime: DOMHighResTimeStamp;
+  __duration: DOMHighResTimeStamp;
+
+  constructor(entryType: PerformanceEntryType, init: PerformanceEntryInit) {
+    this.__entryType = entryType;
+    this.__name = init.name;
+    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,
     };
   }
 }
 
+export const PerformanceEntry_public: typeof PerformanceEntry =
+  /* eslint-disable no-shadow */
+  // $FlowExpectedError[incompatible-type]
+  function PerformanceEntry() {
+    throw new TypeError(
+      "Failed to construct 'PerformanceEntry': Illegal constructor",
+    );
+  };
+
+// $FlowExpectedError[prop-missing]
+PerformanceEntry_public.prototype = PerformanceEntry.prototype;
+
 setPlatformObject(PerformanceEntry);
 
 export type PerformanceEntryList = $ReadOnlyArray<PerformanceEntry>;