react-native 0.71.6 → 0.72.0-rc.1

package/Libraries/Utilities/PixelRatio.js

@@ -10,7 +10,7 @@
 
 'use strict';
 
-const Dimensions = require('./Dimensions');
+const Dimensions = require('./Dimensions').default;
 
 /**
  * PixelRatio class gives access to the device pixel density.
@@ -124,4 +124,4 @@ class PixelRatio {
   static startDetecting() {}
 }
 
-module.exports = PixelRatio;
+export default PixelRatio;

package/Libraries/Utilities/ReactNativeTestTools.js

@@ -15,8 +15,8 @@ import type {ReactTestRenderer as ReactTestRendererType} from 'react-test-render
 const Switch = require('../Components/Switch/Switch').default;
 const TextInput = require('../Components/TextInput/TextInput');
 const View = require('../Components/View/View');
-const VirtualizedList = require('../Lists/VirtualizedList').default;
 const Text = require('../Text/Text');
+const {VirtualizedList} = require('@react-native/virtualized-lists');
 const React = require('react');
 const ShallowRenderer = require('react-shallow-renderer');
 const ReactTestRenderer = require('react-test-renderer');

package/Libraries/Utilities/__mocks__/PixelRatio.js

@@ -22,4 +22,4 @@ const PixelRatio = {
   startDetecting: jest.fn(),
 };
 
-module.exports = PixelRatio;
+export default PixelRatio;

package/Libraries/Utilities/codegenNativeCommands.js

@@ -18,7 +18,9 @@ function codegenNativeCommands<T: interface {}>(options: Options<$Keys<T>>): T {
   const commandObj: {[$Keys<T>]: (...$ReadOnlyArray<mixed>) => void} = {};
 
   options.supportedCommands.forEach(command => {
+    // $FlowFixMe[missing-local-annot]
     commandObj[command] = (ref, ...args) => {
+      // $FlowFixMe[incompatible-call]
       dispatchCommand(ref, command, args);
     };
   });

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/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/Vibration/React-RCTVibration.podspec

@@ -19,6 +19,19 @@ end
 folly_compiler_flags = '-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1 -Wno-comma -Wno-shorten-64-to-32'
 folly_version = '2021.07.22.00'
 
+header_search_paths = [
+  "\"$(PODS_ROOT)/RCT-Folly\"",
+  "\"${PODS_ROOT}/Headers/Public/React-Codegen/react/renderer/components\"",
+  "\"${PODS_CONFIGURATION_BUILD_DIR}/React-Codegen/React_Codegen.framework/Headers\""
+]
+
+if ENV["USE_FRAMEWORKS"]
+  header_search_paths = header_search_paths.concat([
+    "\"$(PODS_CONFIGURATION_BUILD_DIR)/ReactCommon/ReactCommon.framework/Headers/react/nativemodule/core\"",
+    "\"$(PODS_CONFIGURATION_BUILD_DIR)/React-NativeModulesApple/React_NativeModulesApple.framework/Headers\""
+  ])
+end
+
 Pod::Spec.new do |s|
   s.name                   = "React-RCTVibration"
   s.version                = version
@@ -26,7 +39,7 @@ Pod::Spec.new do |s|
   s.homepage               = "https://reactnative.dev/"
   s.documentation_url      = "https://reactnative.dev/docs/vibration"
   s.license                = package["license"]
-  s.author                 = "Facebook, Inc. and its affiliates"
+  s.author                 = "Meta Platforms, Inc. and its affiliates"
   s.platforms              = { :ios => "12.4" }
   s.compiler_flags         = folly_compiler_flags + ' -Wno-nullability-completeness'
   s.source                 = source
@@ -36,7 +49,7 @@ Pod::Spec.new do |s|
   s.pod_target_xcconfig    = {
                                "USE_HEADERMAP" => "YES",
                                "CLANG_CXX_LANGUAGE_STANDARD" => "c++17",
-                               "HEADER_SEARCH_PATHS" => "\"$(PODS_ROOT)/RCT-Folly\" \"${PODS_ROOT}/Headers/Public/React-Codegen/react/renderer/components\" \"${PODS_CONFIGURATION_BUILD_DIR}/React-Codegen/React_Codegen.framework/Headers\""
+                               "HEADER_SEARCH_PATHS" => header_search_paths.join(' ')
                              }
   s.frameworks             = "AudioToolbox"
 

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.cpp

@@ -0,0 +1,74 @@
+/*
+ * 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.
+ */
+
+#include <memory>
+
+#include <cxxreact/ReactMarker.h>
+#include <jsi/instrumentation.h>
+#include "NativePerformance.h"
+#include "PerformanceEntryReporter.h"
+
+#include "Plugins.h"
+
+std::shared_ptr<facebook::react::TurboModule> NativePerformanceModuleProvider(
+    std::shared_ptr<facebook::react::CallInvoker> jsInvoker) {
+  return std::make_shared<facebook::react::NativePerformance>(
+      std::move(jsInvoker));
+}
+
+namespace facebook::react {
+
+NativePerformance::NativePerformance(std::shared_ptr<CallInvoker> jsInvoker)
+    : NativePerformanceCxxSpec(std::move(jsInvoker)) {}
+
+void NativePerformance::mark(
+    jsi::Runtime &rt,
+    std::string name,
+    double startTime,
+    double duration) {
+  PerformanceEntryReporter::getInstance().mark(name, startTime, duration);
+}
+
+void NativePerformance::measure(
+    jsi::Runtime &rt,
+    std::string name,
+    double startTime,
+    double endTime,
+    std::optional<double> duration,
+    std::optional<std::string> startMark,
+    std::optional<std::string> endMark) {
+  PerformanceEntryReporter::getInstance().measure(
+      name, startTime, endTime, duration, startMark, endMark);
+}
+
+std::unordered_map<std::string, double> NativePerformance::getSimpleMemoryInfo(
+    jsi::Runtime &rt) {
+  auto heapInfo = rt.instrumentation().getHeapInfo(false);
+  std::unordered_map<std::string, double> heapInfoToJs;
+  for (auto &entry : heapInfo) {
+    heapInfoToJs[entry.first] = static_cast<double>(entry.second);
+  }
+  return heapInfoToJs;
+}
+
+ReactNativeStartupTiming NativePerformance::getReactNativeStartupTiming(
+    jsi::Runtime &rt) {
+  ReactNativeStartupTiming result = {0, 0, 0, 0};
+
+  ReactMarker::StartupLogger &startupLogger =
+      ReactMarker::StartupLogger::getInstance();
+  result.startTime = startupLogger.getAppStartTime();
+  result.executeJavaScriptBundleEntryPointStart =
+      startupLogger.getRunJSBundleStartTime();
+  result.executeJavaScriptBundleEntryPointEnd =
+      startupLogger.getRunJSBundleEndTime();
+  result.endTime = startupLogger.getRunJSBundleEndTime();
+
+  return result;
+}
+
+} // namespace facebook::react

package/Libraries/WebPerformance/NativePerformance.h

@@ -0,0 +1,76 @@
+/*
+ * 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.
+ */
+
+#pragma once
+
+#include <FBReactNativeSpec/FBReactNativeSpecJSI.h>
+#include <memory>
+#include <string>
+
+#include "NativePerformanceObserver.h"
+
+namespace facebook::react {
+class PerformanceEntryReporter;
+
+#pragma mark - Structs
+
+using ReactNativeStartupTiming =
+    NativePerformanceCxxBaseReactNativeStartupTiming<
+        int32_t, // Start time of the RN app startup process
+        int32_t, // End time of the RN app startup process
+        int32_t, // Start time that RN app execute the JS bundle
+        int32_t // End time that RN app execute the JS bundle
+        >;
+
+template <>
+struct Bridging<ReactNativeStartupTiming>
+    : NativePerformanceCxxBaseReactNativeStartupTimingBridging<
+          int32_t,
+          int32_t,
+          int32_t,
+          int32_t> {};
+
+#pragma mark - implementation
+
+class NativePerformance : public NativePerformanceCxxSpec<NativePerformance>,
+                          std::enable_shared_from_this<NativePerformance> {
+ public:
+  NativePerformance(std::shared_ptr<CallInvoker> jsInvoker);
+
+  void
+  mark(jsi::Runtime &rt, std::string name, double startTime, double duration);
+
+  void measure(
+      jsi::Runtime &rt,
+      std::string name,
+      double startTime,
+      double endTime,
+      std::optional<double> duration,
+      std::optional<std::string> startMark,
+      std::optional<std::string> endMark);
+
+  // To align with web API, we will make sure to return three properties
+  // (jsHeapSizeLimit, totalJSHeapSize, usedJSHeapSize) + anything needed from
+  // the VM side.
+  // `jsHeapSizeLimit`: The maximum size of the heap, in bytes, that
+  // is available to the context.
+  // `totalJSHeapSize`: The total allocated heap size, in bytes.
+  // `usedJSHeapSize`: The currently active segment of JS heap, in
+  // bytes.
+  //
+  // Note that we use int64_t here and it's ok to lose precision in JS doubles
+  // for heap size information, as double's 2^53 sig bytes is large enough.
+  std::unordered_map<std::string, double> getSimpleMemoryInfo(jsi::Runtime &rt);
+
+  // Collect and return the RN app startup timing information for performance
+  // tracking.
+  ReactNativeStartupTiming getReactNativeStartupTiming(jsi::Runtime &rt);
+
+ private:
+};
+
+} // namespace facebook::react

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);