react-native-windows 0.72.13 → 0.73.0-preview.1

package/Libraries/Utilities/Platform.flow.js

@@ -0,0 +1,84 @@
+/**
+ * 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.
+ *
+ * @flow strict
+ * @format
+ */
+
+export type PlatformSelectSpec<T> = {
+  default?: T,
+  native?: T,
+  ios?: T,
+  android?: T,
+  ...
+};
+
+type IOSPlatform = {
+  __constants: null,
+  OS: $TEMPORARY$string<'ios'>,
+  // $FlowFixMe[unsafe-getters-setters]
+  get Version(): string,
+  // $FlowFixMe[unsafe-getters-setters]
+  get constants(): {|
+    forceTouchAvailable: boolean,
+    interfaceIdiom: string,
+    isTesting: boolean,
+    isDisableAnimations?: boolean,
+    osVersion: string,
+    reactNativeVersion: {|
+      major: number,
+      minor: number,
+      patch: number,
+      prerelease: ?number,
+    |},
+    systemName: string,
+  |},
+  // $FlowFixMe[unsafe-getters-setters]
+  get isPad(): boolean,
+  // $FlowFixMe[unsafe-getters-setters]
+  get isTV(): boolean,
+  // $FlowFixMe[unsafe-getters-setters]
+  get isTesting(): boolean,
+  // $FlowFixMe[unsafe-getters-setters]
+  get isDisableAnimations(): boolean,
+  select: <T>(spec: PlatformSelectSpec<T>) => T,
+};
+
+type AndroidPlatform = {
+  __constants: null,
+  OS: $TEMPORARY$string<'android'>,
+  // $FlowFixMe[unsafe-getters-setters]
+  get Version(): number,
+  // $FlowFixMe[unsafe-getters-setters]
+  get constants(): {|
+    isTesting: boolean,
+    isDisableAnimations?: boolean,
+    reactNativeVersion: {|
+      major: number,
+      minor: number,
+      patch: number,
+      prerelease: ?number,
+    |},
+    Version: number,
+    Release: string,
+    Serial: string,
+    Fingerprint: string,
+    Model: string,
+    ServerHost?: string,
+    uiMode: string,
+    Brand: string,
+    Manufacturer: string,
+  |},
+  // $FlowFixMe[unsafe-getters-setters]
+  get isTV(): boolean,
+  // $FlowFixMe[unsafe-getters-setters]
+  get isTesting(): boolean,
+  // $FlowFixMe[unsafe-getters-setters]
+  get isDisableAnimations(): boolean,
+  select: <T>(spec: PlatformSelectSpec<T>) => T,
+};
+
+export type Platform = IOSPlatform | AndroidPlatform;

package/Libraries/Utilities/Platform.flow.windows.js

@@ -0,0 +1,111 @@
+/**
+ * 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.
+ *
+ * @flow strict
+ * @format
+ */
+
+export type PlatformSelectSpec<T> = {
+  default?: T,
+  native?: T,
+  ios?: T,
+  android?: T,
+  windows?: T,
+  ...
+};
+
+type IOSPlatform = {
+  __constants: null,
+  OS: $TEMPORARY$string<'ios'>,
+  // $FlowFixMe[unsafe-getters-setters]
+  get Version(): string,
+  // $FlowFixMe[unsafe-getters-setters]
+  get constants(): {|
+    forceTouchAvailable: boolean,
+    interfaceIdiom: string,
+    isTesting: boolean,
+    isDisableAnimations?: boolean,
+    osVersion: string,
+    reactNativeVersion: {|
+      major: number,
+      minor: number,
+      patch: number,
+      prerelease: ?number,
+    |},
+    systemName: string,
+  |},
+  // $FlowFixMe[unsafe-getters-setters]
+  get isPad(): boolean,
+  // $FlowFixMe[unsafe-getters-setters]
+  get isTV(): boolean,
+  // $FlowFixMe[unsafe-getters-setters]
+  get isTesting(): boolean,
+  // $FlowFixMe[unsafe-getters-setters]
+  get isDisableAnimations(): boolean,
+  select: <T>(spec: PlatformSelectSpec<T>) => T,
+};
+
+type AndroidPlatform = {
+  __constants: null,
+  OS: $TEMPORARY$string<'android'>,
+  // $FlowFixMe[unsafe-getters-setters]
+  get Version(): number,
+  // $FlowFixMe[unsafe-getters-setters]
+  get constants(): {|
+    isTesting: boolean,
+    isDisableAnimations?: boolean,
+    reactNativeVersion: {|
+      major: number,
+      minor: number,
+      patch: number,
+      prerelease: ?number,
+    |},
+    Version: number,
+    Release: string,
+    Serial: string,
+    Fingerprint: string,
+    Model: string,
+    ServerHost?: string,
+    uiMode: string,
+    Brand: string,
+    Manufacturer: string,
+  |},
+  // $FlowFixMe[unsafe-getters-setters]
+  get isTV(): boolean,
+  // $FlowFixMe[unsafe-getters-setters]
+  get isTesting(): boolean,
+  // $FlowFixMe[unsafe-getters-setters]
+  get isDisableAnimations(): boolean,
+  select: <T>(spec: PlatformSelectSpec<T>) => T,
+};
+
+type WindowsPlatform = {
+  __constants: null,
+  OS: $TEMPORARY$string<'windows'>,
+  // $FlowFixMe[unsafe-getters-setters]
+  get Version(): number,
+  // $FlowFixMe[unsafe-getters-setters]
+  get constants(): {|
+    isTesting: boolean,
+    isDisableAnimations?: boolean,
+    reactNativeVersion: {|
+      major: number,
+      minor: number,
+      patch: number,
+      prerelease: ?string,
+    |},
+    osVersion: number,
+  |},
+  // $FlowFixMe[unsafe-getters-setters]
+  get isTV(): boolean,
+  // $FlowFixMe[unsafe-getters-setters]
+  get isTesting(): boolean,
+  // $FlowFixMe[unsafe-getters-setters]
+  get isDisableAnimations(): boolean,
+  select: <T>(spec: PlatformSelectSpec<T>) => T,
+};
+
+export type Platform = IOSPlatform | AndroidPlatform | WindowsPlatform;

package/Libraries/Utilities/Platform.ios.js

@@ -8,16 +8,14 @@
  * @flow strict
  */
 
-import NativePlatformConstantsIOS from './NativePlatformConstantsIOS';
+import type {
+  Platform as PlatformType,
+  PlatformSelectSpec,
+} from './Platform.flow';
 
-export type PlatformSelectSpec<T> = {
-  default?: T,
-  native?: T,
-  ios?: T,
-  ...
-};
+import NativePlatformConstantsIOS from './NativePlatformConstantsIOS';
 
-const Platform = {
+const Platform: PlatformType = {
   __constants: null,
   OS: 'ios',
   // $FlowFixMe[unsafe-getters-setters]
@@ -30,6 +28,7 @@ const Platform = {
     forceTouchAvailable: boolean,
     interfaceIdiom: string,
     isTesting: boolean,
+    isDisableAnimations?: boolean,
     osVersion: string,
     reactNativeVersion: {|
       major: number,
@@ -65,6 +64,11 @@ const Platform = {
     }
     return false;
   },
+  // $FlowFixMe[unsafe-getters-setters]
+  get isDisableAnimations(): boolean {
+    // $FlowFixMe[object-this-reference]
+    return this.constants.isDisableAnimations ?? this.isTesting;
+  },
   select: <T>(spec: PlatformSelectSpec<T>): T =>
     // $FlowFixMe[incompatible-return]
     'ios' in spec ? spec.ios : 'native' in spec ? spec.native : spec.default,

package/Libraries/Utilities/Platform.windows.js

@@ -6,16 +6,14 @@
  * @flow strict
  */
 
-import NativePlatformConstantsWin from './NativePlatformConstantsWin';
+import type {
+  Platform as PlatformType,
+  PlatformSelectSpec,
+} from './Platform.flow';
 
-export type PlatformSelectSpec<T> = {
-  windows?: T,
-  native?: T,
-  default?: T,
-  ...
-};
+import NativePlatformConstantsWin from './NativePlatformConstantsWin';
 
-const Platform = {
+const Platform: PlatformType = {
   __constants: null,
   OS: 'windows',
   // $FlowFixMe[unsafe-getters-setters]
@@ -26,6 +24,7 @@ const Platform = {
   // $FlowFixMe[unsafe-getters-setters]
   get constants(): {|
     isTesting: boolean,
+    isDisableAnimations?: boolean,
     reactNativeVersion: {|
       major: number,
       minor: number,
@@ -51,6 +50,11 @@ const Platform = {
     return false;
   },
   // $FlowFixMe[unsafe-getters-setters]
+  get isDisableAnimations(): boolean {
+    // $FlowFixMe[object-this-reference]
+    return this.constants.isDisableAnimations ?? this.isTesting;
+  },
+  // $FlowFixMe[unsafe-getters-setters]
   get isTV(): boolean {
     // $FlowFixMe[object-this-reference]
     return false;

package/Libraries/Utilities/PolyfillFunctions.js

@@ -32,7 +32,7 @@ function polyfillObjectProperty<T>(
 ): void {
   const descriptor = Object.getOwnPropertyDescriptor<$FlowFixMe>(object, name);
   if (__DEV__ && descriptor) {
-    const backupName = `original${name[0].toUpperCase()}${name.substr(1)}`;
+    const backupName = `original${name[0].toUpperCase()}${name.slice(1)}`;
     Object.defineProperty(object, backupName, descriptor);
   }
 

package/Libraries/Utilities/ReactNativeTestTools.js

@@ -28,7 +28,6 @@ const ReactTestRenderer = require('react-test-renderer');
 const shallowRenderer = new ShallowRenderer();
 export type ReactTestInstance = $PropertyType<ReactTestRendererType, 'root'>;
 export type Predicate = (node: ReactTestInstance) => boolean;
-type $ReturnType<Fn> = $Call<<Ret, A>((...A) => Ret) => Ret, Fn>;
 /* $FlowFixMe[value-as-type] (>=0.125.1 site=react_native_fb) This comment
  * suppresses an error found when Flow v0.125.1 was deployed. To see the error,
  * delete this comment and run Flow. */
@@ -36,7 +35,7 @@ export type ReactTestRendererJSON =
   /* $FlowFixMe[prop-missing] (>=0.125.1 site=react_native_fb) This comment
    * suppresses an error found when Flow v0.125.1 was deployed. To see the error,
    * delete this comment and run Flow. */
-  $ReturnType<ReactTestRenderer.create.toJSON>;
+  ReturnType<ReactTestRenderer.create.toJSON>;
 
 function byClickable(): Predicate {
   return withMessage(

package/Libraries/Utilities/SceneTracker.js

@@ -10,7 +10,7 @@
 
 'use strict';
 
-export type Scene = {name: string, ...};
+export type Scene = {name: string, [string]: mixed, ...};
 
 let _listeners: Array<(scene: Scene) => void> = [];
 

package/Libraries/Utilities/createPerformanceLogger.js

@@ -16,7 +16,8 @@ import type {
 } from './IPerformanceLogger';
 
 import * as Systrace from '../Performance/Systrace';
-import Performance from '../WebPerformance/Performance';
+import ReactNativeFeatureFlags from '../ReactNative/ReactNativeFeatureFlags';
+import NativePerformance from '../WebPerformance/NativePerformance';
 import infoLog from './infoLog';
 
 const _cookies: {[key: string]: number, ...} = {};
@@ -27,11 +28,8 @@ const PRINT_TO_CONSOLE: false = false; // Type as false to prevent accidentally
 // used to separate these internally from other marks/measures
 const WEB_PERFORMANCE_PREFIX = 'global_perf_';
 
-// TODO: Remove once T143070419 is done
-const performance = new Performance();
-
 export const getCurrentTimestamp: () => number =
-  global.nativeQPLTimestamp ?? global.performance.now.bind(global.performance);
+  global.nativeQPLTimestamp ?? (() => global.performance.now());
 
 class PerformanceLogger implements IPerformanceLogger {
   _timespans: {[key: string]: ?Timespan} = {};
@@ -39,10 +37,50 @@ class PerformanceLogger implements IPerformanceLogger {
   _points: {[key: string]: ?number} = {};
   _pointExtras: {[key: string]: ?Extras, ...} = {};
   _closed: boolean = false;
-  _isLoggingForWebPerformance: boolean = false;
+  _isGlobalLogger: boolean = false;
+  _isGlobalWebPerformanceLoggerEnabled: ?boolean;
 
-  constructor(isLoggingForWebPerformance?: boolean) {
-    this._isLoggingForWebPerformance = isLoggingForWebPerformance === true;
+  constructor(isGlobalLogger?: boolean) {
+    this._isGlobalLogger = isGlobalLogger === true;
+  }
+
+  _isLoggingForWebPerformance(): boolean {
+    if (!this._isGlobalLogger || NativePerformance == null) {
+      return false;
+    }
+    if (this._isGlobalWebPerformanceLoggerEnabled == null) {
+      this._isGlobalWebPerformanceLoggerEnabled =
+        ReactNativeFeatureFlags.isGlobalWebPerformanceLoggerEnabled();
+    }
+    return this._isGlobalWebPerformanceLoggerEnabled === true;
+  }
+
+  // NOTE: The Performance.mark/measure calls are wrapped here to ensure that
+  // we are safe from the cases when the global 'peformance' object is still not yet defined.
+  // It is only necessary in this file because of potential race conditions in the initialization
+  // order between 'createPerformanceLogger' and 'setUpPerformance'.
+  //
+  // In most of the other cases this kind of check for `performance` being defined
+  // wouldn't be necessary.
+  _performanceMark(key: string, startTime: number) {
+    if (this._isLoggingForWebPerformance()) {
+      global.performance?.mark?.(key, {
+        startTime,
+      });
+    }
+  }
+
+  _performanceMeasure(
+    key: string,
+    start: number | string,
+    end: number | string,
+  ) {
+    if (this._isLoggingForWebPerformance()) {
+      global.performance?.measure?.(key, {
+        start,
+        end,
+      });
+    }
   }
 
   addTimespan(
@@ -76,12 +114,11 @@ class PerformanceLogger implements IPerformanceLogger {
       endExtras,
     };
 
-    if (this._isLoggingForWebPerformance) {
-      performance.measure(`${WEB_PERFORMANCE_PREFIX}_${key}`, {
-        start: startTime,
-        end: endTime,
-      });
-    }
+    this._performanceMeasure(
+      `${WEB_PERFORMANCE_PREFIX}_${key}`,
+      startTime,
+      endTime,
+    );
   }
 
   append(performanceLogger: IPerformanceLogger) {
@@ -197,11 +234,7 @@ class PerformanceLogger implements IPerformanceLogger {
       this._pointExtras[key] = extras;
     }
 
-    if (this._isLoggingForWebPerformance) {
-      performance.mark(`${WEB_PERFORMANCE_PREFIX}_${key}`, {
-        startTime: timestamp,
-      });
-    }
+    this._performanceMark(`${WEB_PERFORMANCE_PREFIX}_${key}`, timestamp);
   }
 
   removeExtra(key: string): ?ExtraValue {
@@ -264,11 +297,10 @@ class PerformanceLogger implements IPerformanceLogger {
       infoLog('PerformanceLogger.js', 'start: ' + key);
     }
 
-    if (this._isLoggingForWebPerformance) {
-      performance.mark(`${WEB_PERFORMANCE_PREFIX}_timespan_start_${key}`, {
-        startTime: timestamp,
-      });
-    }
+    this._performanceMark(
+      `${WEB_PERFORMANCE_PREFIX}_timespan_start_${key}`,
+      timestamp,
+    );
   }
 
   stopTimespan(
@@ -315,12 +347,11 @@ class PerformanceLogger implements IPerformanceLogger {
       delete _cookies[key];
     }
 
-    if (this._isLoggingForWebPerformance) {
-      performance.measure(`${WEB_PERFORMANCE_PREFIX}_${key}`, {
-        start: `${WEB_PERFORMANCE_PREFIX}_timespan_start_${key}`,
-        end: timestamp,
-      });
-    }
+    this._performanceMeasure(
+      `${WEB_PERFORMANCE_PREFIX}_${key}`,
+      `${WEB_PERFORMANCE_PREFIX}_timespan_start_${key}`,
+      timestamp,
+    );
   }
 }
 
@@ -334,7 +365,7 @@ export type {Extras, ExtraValue, IPerformanceLogger, Timespan};
  * The loggers need to have minimal overhead since they're used in production.
  */
 export default function createPerformanceLogger(
-  isLoggingForWebPerformance?: boolean,
+  isGlobalLogger?: boolean,
 ): IPerformanceLogger {
-  return new PerformanceLogger(isLoggingForWebPerformance);
+  return new PerformanceLogger(isGlobalLogger);
 }

package/Libraries/Utilities/useColorScheme.js

@@ -13,14 +13,13 @@
 import type {ColorSchemeName} from './NativeAppearance';
 
 import Appearance from './Appearance';
-import {useSyncExternalStore} from 'use-sync-external-store/shim';
+import {useSyncExternalStore} from 'react';
+
+const subscribe = (onStoreChange: () => void) => {
+  const appearanceSubscription = Appearance.addChangeListener(onStoreChange);
+  return () => appearanceSubscription.remove();
+};
 
 export default function useColorScheme(): ?ColorSchemeName {
-  return useSyncExternalStore(
-    callback => {
-      const appearanceSubscription = Appearance.addChangeListener(callback);
-      return () => appearanceSubscription.remove();
-    },
-    () => Appearance.getColorScheme(),
-  );
+  return useSyncExternalStore(subscribe, Appearance.getColorScheme);
 }

package/Libraries/WebPerformance/MemoryInfo.js

@@ -11,7 +11,7 @@
 
 // flowlint unsafe-getters-setters:off
 
-export type MemoryInfoLike = {
+type MemoryInfoLike = {
   jsHeapSizeLimit: ?number,
   totalJSHeapSize: ?number,
   usedJSHeapSize: ?number,

package/Libraries/WebPerformance/NativePerformance.js

@@ -12,17 +12,12 @@ import type {TurboModule} from '../TurboModule/RCTExport';
 
 import * as TurboModuleRegistry from '../TurboModule/TurboModuleRegistry';
 
-export type NativeMemoryInfo = {[key: string]: number};
+export type NativeMemoryInfo = {[key: string]: ?number};
 
-export type ReactNativeStartupTiming = {|
-  startTime: number,
-  endTime: number,
-  executeJavaScriptBundleEntryPointStart: number,
-  executeJavaScriptBundleEntryPointEnd: number,
-|};
+export type ReactNativeStartupTiming = {[key: string]: ?number};
 
 export interface Spec extends TurboModule {
-  +mark: (name: string, startTime: number, duration: number) => void;
+  +mark: (name: string, startTime: number) => void;
   +measure: (
     name: string,
     startTime: number,

package/Libraries/WebPerformance/NativePerformanceObserver.js

@@ -33,6 +33,10 @@ export type GetPendingEntriesResult = {|
 export interface Spec extends TurboModule {
   +startReporting: (entryType: RawPerformanceEntryType) => void;
   +stopReporting: (entryType: RawPerformanceEntryType) => void;
+  +setIsBuffered: (
+    entryTypes: $ReadOnlyArray<RawPerformanceEntryType>,
+    isBuffered: boolean,
+  ) => void;
   +popPendingEntries: () => GetPendingEntriesResult;
   +setOnPerformanceEntryCallback: (callback?: () => void) => void;
   +logRawEntry: (entry: RawPerformanceEntry) => void;

package/Libraries/WebPerformance/Performance.js

@@ -18,7 +18,7 @@ import EventCounts from './EventCounts';
 import MemoryInfo from './MemoryInfo';
 import NativePerformance from './NativePerformance';
 import NativePerformanceObserver from './NativePerformanceObserver';
-import {PerformanceEntry} from './PerformanceEntry';
+import {ALWAYS_LOGGED_ENTRY_TYPES, PerformanceEntry} from './PerformanceEntry';
 import {warnNoNativePerformanceObserver} from './PerformanceObserver';
 import {
   performanceEntryTypeToRaw,
@@ -43,6 +43,17 @@ const getCurrentTimeStamp: () => HighResTimeStamp = global.nativePerformanceNow
   ? 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,
+  );
+}
+
 export class PerformanceMark extends PerformanceEntry {
   detail: DetailType;
 
@@ -132,9 +143,22 @@ export default class Performance {
   // Startup metrics is not used in web, but only in React Native.
   get reactNativeStartupTiming(): ReactNativeStartupTiming {
     if (NativePerformance?.getReactNativeStartupTiming) {
-      return new ReactNativeStartupTiming(
-        NativePerformance.getReactNativeStartupTiming(),
-      );
+      const {
+        startTime,
+        endTime,
+        initializeRuntimeStart,
+        initializeRuntimeEnd,
+        executeJavaScriptBundleEntryPointStart,
+        executeJavaScriptBundleEntryPointEnd,
+      } = NativePerformance.getReactNativeStartupTiming();
+      return new ReactNativeStartupTiming({
+        startTime,
+        endTime,
+        initializeRuntimeStart,
+        initializeRuntimeEnd,
+        executeJavaScriptBundleEntryPointStart,
+        executeJavaScriptBundleEntryPointEnd,
+      });
     }
     return new ReactNativeStartupTiming();
   }
@@ -146,7 +170,7 @@ export default class Performance {
     const mark = new PerformanceMark(markName, markOptions);
 
     if (NativePerformance?.mark) {
-      NativePerformance.mark(markName, mark.startTime, mark.duration);
+      NativePerformance.mark(markName, mark.startTime);
     } else {
       warnNoNativePerformance();
     }
@@ -261,7 +285,7 @@ export default class Performance {
    * https://www.w3.org/TR/performance-timeline/#extensions-to-the-performance-interface
    */
   getEntries(): PerformanceEntryList {
-    if (!NativePerformanceObserver?.clearEntries) {
+    if (!NativePerformanceObserver?.getEntries) {
       warnNoNativePerformanceObserver();
       return [];
     }
@@ -269,14 +293,16 @@ export default class Performance {
   }
 
   getEntriesByType(entryType: PerformanceEntryType): PerformanceEntryList {
-    if (entryType !== 'mark' && entryType !== 'measure') {
-      console.log(
-        `Performance.getEntriesByType: Only valid for 'mark' and 'measure' entry types, got ${entryType}`,
+    if (!ALWAYS_LOGGED_ENTRY_TYPES.includes(entryType)) {
+      console.warn(
+        `Performance.getEntriesByType: Only valid for ${JSON.stringify(
+          ALWAYS_LOGGED_ENTRY_TYPES,
+        )} entry types, got ${entryType}`,
       );
       return [];
     }
 
-    if (!NativePerformanceObserver?.clearEntries) {
+    if (!NativePerformanceObserver?.getEntries) {
       warnNoNativePerformanceObserver();
       return [];
     }
@@ -291,16 +317,17 @@ export default class Performance {
   ): PerformanceEntryList {
     if (
       entryType !== undefined &&
-      entryType !== 'mark' &&
-      entryType !== 'measure'
+      !ALWAYS_LOGGED_ENTRY_TYPES.includes(entryType)
     ) {
-      console.log(
-        `Performance.getEntriesByName: Only valid for 'mark' and 'measure' entry types, got ${entryType}`,
+      console.warn(
+        `Performance.getEntriesByName: Only valid for ${JSON.stringify(
+          ALWAYS_LOGGED_ENTRY_TYPES,
+        )} entry types, got ${entryType}`,
       );
       return [];
     }
 
-    if (!NativePerformanceObserver?.clearEntries) {
+    if (!NativePerformanceObserver?.getEntries) {
       warnNoNativePerformanceObserver();
       return [];
     }

package/Libraries/WebPerformance/PerformanceEntry.js

@@ -11,6 +11,19 @@
 export type HighResTimeStamp = number;
 export type PerformanceEntryType = 'mark' | 'measure' | 'event';
 
+export type PerformanceEntryJSON = {
+  name: string,
+  entryType: PerformanceEntryType,
+  startTime: HighResTimeStamp,
+  duration: HighResTimeStamp,
+  ...
+};
+
+export const ALWAYS_LOGGED_ENTRY_TYPES: $ReadOnlyArray<PerformanceEntryType> = [
+  'mark',
+  'measure',
+];
+
 export class PerformanceEntry {
   name: string;
   entryType: PerformanceEntryType;
@@ -29,12 +42,7 @@ export class PerformanceEntry {
     this.duration = init.duration;
   }
 
-  toJSON(): {
-    name: string,
-    entryType: PerformanceEntryType,
-    startTime: HighResTimeStamp,
-    duration: HighResTimeStamp,
-  } {
+  toJSON(): PerformanceEntryJSON {
     return {
       name: this.name,
       entryType: this.entryType,