@office-iss/react-native-win32 0.71.5 → 0.72.0-preview.1

package/Libraries/Utilities/createPerformanceLogger.js

@@ -8,53 +8,28 @@
  * @format
  */
 
-const Systrace = require('../Performance/Systrace');
-const infoLog = require('./infoLog');
+import type {
+  Extras,
+  ExtraValue,
+  IPerformanceLogger,
+  Timespan,
+} from './IPerformanceLogger';
 
-export type Timespan = {
-  startTime: number,
-  endTime?: number,
-  totalTime?: number,
-  startExtras?: Extras,
-  endExtras?: Extras,
-};
-
-// Extra values should be serializable primitives
-export type ExtraValue = number | string | boolean;
-
-export type Extras = {[key: string]: ExtraValue};
-
-export interface IPerformanceLogger {
-  addTimespan(
-    key: string,
-    startTime: number,
-    endTime: number,
-    startExtras?: Extras,
-    endExtras?: Extras,
-  ): void;
-  append(logger: IPerformanceLogger): void;
-  clear(): void;
-  clearCompleted(): void;
-  close(): void;
-  currentTimestamp(): number;
-  getExtras(): $ReadOnly<{[key: string]: ?ExtraValue, ...}>;
-  getPoints(): $ReadOnly<{[key: string]: ?number, ...}>;
-  getPointExtras(): $ReadOnly<{[key: string]: ?Extras, ...}>;
-  getTimespans(): $ReadOnly<{[key: string]: ?Timespan, ...}>;
-  hasTimespan(key: string): boolean;
-  isClosed(): boolean;
-  logEverything(): void;
-  markPoint(key: string, timestamp?: number, extras?: Extras): void;
-  removeExtra(key: string): ?ExtraValue;
-  setExtra(key: string, value: ExtraValue): void;
-  startTimespan(key: string, timestamp?: number, extras?: Extras): void;
-  stopTimespan(key: string, timestamp?: number, extras?: Extras): void;
-}
+import * as Systrace from '../Performance/Systrace';
+import Performance from '../WebPerformance/Performance';
+import infoLog from './infoLog';
 
 const _cookies: {[key: string]: number, ...} = {};
 
 const PRINT_TO_CONSOLE: false = false; // Type as false to prevent accidentally committing `true`;
 
+// This is the prefix for optional logging points/timespans as marks/measures via Performance API,
+// 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);
 
@@ -64,6 +39,11 @@ class PerformanceLogger implements IPerformanceLogger {
   _points: {[key: string]: ?number} = {};
   _pointExtras: {[key: string]: ?Extras, ...} = {};
   _closed: boolean = false;
+  _isLoggingForWebPerformance: boolean = false;
+
+  constructor(isLoggingForWebPerformance?: boolean) {
+    this._isLoggingForWebPerformance = isLoggingForWebPerformance === true;
+  }
 
   addTimespan(
     key: string,
@@ -95,6 +75,13 @@ class PerformanceLogger implements IPerformanceLogger {
       startExtras,
       endExtras,
     };
+
+    if (this._isLoggingForWebPerformance) {
+      performance.measure(`${WEB_PERFORMANCE_PREFIX}_${key}`, {
+        start: startTime,
+        end: endTime,
+      });
+    }
   }
 
   append(performanceLogger: IPerformanceLogger) {
@@ -209,6 +196,12 @@ class PerformanceLogger implements IPerformanceLogger {
     if (extras) {
       this._pointExtras[key] = extras;
     }
+
+    if (this._isLoggingForWebPerformance) {
+      performance.mark(`${WEB_PERFORMANCE_PREFIX}_${key}`, {
+        startTime: timestamp,
+      });
+    }
   }
 
   removeExtra(key: string): ?ExtraValue {
@@ -270,6 +263,12 @@ class PerformanceLogger implements IPerformanceLogger {
     if (PRINT_TO_CONSOLE) {
       infoLog('PerformanceLogger.js', 'start: ' + key);
     }
+
+    if (this._isLoggingForWebPerformance) {
+      performance.mark(`${WEB_PERFORMANCE_PREFIX}_timespan_start_${key}`, {
+        startTime: timestamp,
+      });
+    }
   }
 
   stopTimespan(
@@ -315,14 +314,27 @@ class PerformanceLogger implements IPerformanceLogger {
       Systrace.endAsyncEvent(key, _cookies[key]);
       delete _cookies[key];
     }
+
+    if (this._isLoggingForWebPerformance) {
+      performance.measure(`${WEB_PERFORMANCE_PREFIX}_${key}`, {
+        start: `${WEB_PERFORMANCE_PREFIX}_timespan_start_${key}`,
+        end: timestamp,
+      });
+    }
   }
 }
 
+// Re-exporting for backwards compatibility with all the clients that
+// may still import it from this module.
+export type {Extras, ExtraValue, IPerformanceLogger, Timespan};
+
 /**
  * This function creates performance loggers that can be used to collect and log
  * various performance data such as timespans, points and extras.
  * The loggers need to have minimal overhead since they're used in production.
  */
-export default function createPerformanceLogger(): IPerformanceLogger {
-  return new PerformanceLogger();
+export default function createPerformanceLogger(
+  isLoggingForWebPerformance?: boolean,
+): IPerformanceLogger {
+  return new PerformanceLogger(isLoggingForWebPerformance);
 }

package/Libraries/Utilities/stringifySafe.js

@@ -26,9 +26,7 @@ export function createStringifySafeWithLimits(limits: {|
     maxArrayLimit = Number.POSITIVE_INFINITY,
     maxObjectKeysLimit = Number.POSITIVE_INFINITY,
   } = limits;
-  const stack: Array<
-    string | {+[string]: mixed} | {'...(truncated keys)...': number},
-  > = [];
+  const stack: Array<mixed> = [];
   /* $FlowFixMe[missing-this-annot] The 'this' type annotation(s) required by
    * Flow's LTI update could not be added via codemod */
   function replacer(key: string, value: mixed): mixed {
@@ -47,10 +45,7 @@ export function createStringifySafeWithLimits(limits: {|
       return value;
     }
 
-    let retval:
-      | string
-      | {+[string]: mixed}
-      | $TEMPORARY$object<{'...(truncated keys)...': number}> = value;
+    let retval: mixed = value;
     if (Array.isArray(value)) {
       if (stack.length >= maxDepth) {
         retval = `[ ... array with ${value.length} values ... ]`;

package/Libraries/Utilities/useColorScheme.js

@@ -13,7 +13,7 @@
 import type {ColorSchemeName} from './NativeAppearance';
 
 import Appearance from './Appearance';
-import {useSyncExternalStore} from 'use-sync-external-store/shim';
+import {useSyncExternalStore} from 'react';
 
 export default function useColorScheme(): ?ColorSchemeName {
   return useSyncExternalStore(

package/Libraries/Utilities/useWindowDimensions.js

@@ -22,9 +22,9 @@ export default function useWindowDimensions():
   useEffect(() => {
     function handleChange({
       window,
-    }:
-      | $FlowFixMe
-      | $TEMPORARY$object<{window: DisplayMetrics | DisplayMetricsAndroid}>) {
+    }: {
+      window: DisplayMetrics | DisplayMetricsAndroid,
+    }) {
       if (
         dimensions.width !== window.width ||
         dimensions.height !== window.height ||

package/Libraries/WebPerformance/EventCounts.js

@@ -0,0 +1,78 @@
+/**
+ * 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
+ */
+
+import NativePerformanceObserver from './NativePerformanceObserver';
+import {warnNoNativePerformanceObserver} from './PerformanceObserver';
+
+type EventCountsForEachCallbackType =
+  | (() => void)
+  | ((value: number) => void)
+  | ((value: number, key: string) => void)
+  | ((value: number, key: string, map: Map<string, number>) => void);
+
+let cachedEventCounts: ?Map<string, number>;
+
+function getCachedEventCounts(): Map<string, number> {
+  if (cachedEventCounts) {
+    return cachedEventCounts;
+  }
+  if (!NativePerformanceObserver) {
+    warnNoNativePerformanceObserver();
+    return new Map();
+  }
+
+  cachedEventCounts = new Map<string, number>(
+    NativePerformanceObserver.getEventCounts(),
+  );
+  // $FlowFixMe[incompatible-call]
+  global.queueMicrotask(() => {
+    // To be consistent with the calls to the API from the same task,
+    // but also not to refetch the data from native too often,
+    // schedule to invalidate the cache later,
+    // after the current task is guaranteed to have finished.
+    cachedEventCounts = null;
+  });
+  return cachedEventCounts ?? new Map();
+}
+/**
+ * Implementation of the EventCounts Web Performance API
+ * corresponding to the standard in
+ * https://www.w3.org/TR/event-timing/#eventcounts
+ */
+export default class EventCounts {
+  // flowlint unsafe-getters-setters:off
+  get size(): number {
+    return getCachedEventCounts().size;
+  }
+
+  entries(): Iterator<[string, number]> {
+    return getCachedEventCounts().entries();
+  }
+
+  forEach(callback: EventCountsForEachCallbackType): void {
+    return getCachedEventCounts().forEach(callback);
+  }
+
+  get(key: string): ?number {
+    return getCachedEventCounts().get(key);
+  }
+
+  has(key: string): boolean {
+    return getCachedEventCounts().has(key);
+  }
+
+  keys(): Iterator<string> {
+    return getCachedEventCounts().keys();
+  }
+
+  values(): Iterator<number> {
+    return getCachedEventCounts().values();
+  }
+}

package/Libraries/WebPerformance/MemoryInfo.js

@@ -0,0 +1,54 @@
+/**
+ * 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
+ * @oncall react_native
+ */
+
+// flowlint unsafe-getters-setters:off
+
+export type MemoryInfoLike = {
+  jsHeapSizeLimit: ?number,
+  totalJSHeapSize: ?number,
+  usedJSHeapSize: ?number,
+};
+
+// Read-only object with JS memory information. This is returned by the performance.memory API.
+export default class MemoryInfo {
+  _jsHeapSizeLimit: ?number;
+  _totalJSHeapSize: ?number;
+  _usedJSHeapSize: ?number;
+
+  constructor(memoryInfo: ?MemoryInfoLike) {
+    if (memoryInfo != null) {
+      this._jsHeapSizeLimit = memoryInfo.jsHeapSizeLimit;
+      this._totalJSHeapSize = memoryInfo.totalJSHeapSize;
+      this._usedJSHeapSize = memoryInfo.usedJSHeapSize;
+    }
+  }
+
+  /**
+   * The maximum size of the heap, in bytes, that is available to the context
+   */
+  get jsHeapSizeLimit(): ?number {
+    return this._jsHeapSizeLimit;
+  }
+
+  /**
+   * The total allocated heap size, in bytes
+   */
+  get totalJSHeapSize(): ?number {
+    return this._totalJSHeapSize;
+  }
+
+  /**
+   * The currently active segment of JS heap, in bytes.
+   */
+  get usedJSHeapSize(): ?number {
+    return this._usedJSHeapSize;
+  }
+}

package/Libraries/WebPerformance/NativePerformance.js

@@ -0,0 +1,38 @@
+/**
+ * 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
+ */
+
+import type {TurboModule} from '../TurboModule/RCTExport';
+
+import * as TurboModuleRegistry from '../TurboModule/TurboModuleRegistry';
+
+export type NativeMemoryInfo = {[key: string]: number};
+
+export type ReactNativeStartupTiming = {|
+  startTime: number,
+  endTime: number,
+  executeJavaScriptBundleEntryPointStart: number,
+  executeJavaScriptBundleEntryPointEnd: number,
+|};
+
+export interface Spec extends TurboModule {
+  +mark: (name: string, startTime: number, duration: number) => void;
+  +measure: (
+    name: string,
+    startTime: number,
+    endTime: number,
+    duration?: number,
+    startMark?: string,
+    endMark?: string,
+  ) => void;
+  +getSimpleMemoryInfo: () => NativeMemoryInfo;
+  +getReactNativeStartupTiming: () => ReactNativeStartupTiming;
+}
+
+export default (TurboModuleRegistry.get<Spec>('NativePerformanceCxx'): ?Spec);

package/Libraries/WebPerformance/NativePerformanceObserver.js

@@ -12,10 +12,6 @@ import type {TurboModule} from '../TurboModule/RCTExport';
 
 import * as TurboModuleRegistry from '../TurboModule/TurboModuleRegistry';
 
-export const RawPerformanceEntryTypeValues = {
-  UNDEFINED: 0,
-};
-
 export type RawPerformanceEntryType = number;
 
 export type RawPerformanceEntry = {|
@@ -29,11 +25,30 @@ export type RawPerformanceEntry = {|
   interactionId?: number,
 |};
 
+export type GetPendingEntriesResult = {|
+  entries: $ReadOnlyArray<RawPerformanceEntry>,
+  droppedEntriesCount: number,
+|};
+
 export interface Spec extends TurboModule {
-  +startReporting: (entryType: string) => void;
-  +stopReporting: (entryType: string) => void;
-  +getPendingEntries: () => $ReadOnlyArray<RawPerformanceEntry>;
+  +startReporting: (entryType: RawPerformanceEntryType) => void;
+  +stopReporting: (entryType: RawPerformanceEntryType) => void;
+  +popPendingEntries: () => GetPendingEntriesResult;
   +setOnPerformanceEntryCallback: (callback?: () => void) => void;
+  +logRawEntry: (entry: RawPerformanceEntry) => void;
+  +getEventCounts: () => $ReadOnlyArray<[string, number]>;
+  +setDurationThreshold: (
+    entryType: RawPerformanceEntryType,
+    durationThreshold: number,
+  ) => void;
+  +clearEntries: (
+    entryType: RawPerformanceEntryType,
+    entryName?: string,
+  ) => void;
+  +getEntries: (
+    entryType?: RawPerformanceEntryType,
+    entryName?: string,
+  ) => $ReadOnlyArray<RawPerformanceEntry>;
 }
 
 export default (TurboModuleRegistry.get<Spec>(