react-native 0.82.0-rc.0 → 0.82.0-rc.1

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

@@ -9,8 +9,10 @@
  */
 
 // flowlint unsafe-getters-setters:off
-
-import type {PerformanceEntryJSON} from './PerformanceEntry';
+import type {
+  PerformanceEntryInit,
+  PerformanceEntryJSON,
+} from './PerformanceEntry';
 
 import {PerformanceEntry} from './PerformanceEntry';
 
@@ -22,10 +24,28 @@ export type PerformanceLongTaskTimingJSON = {
 
 export class TaskAttributionTiming extends PerformanceEntry {}
 
+export const TaskAttributionTiming_public: typeof TaskAttributionTiming =
+  /* eslint-disable no-shadow */
+  // $FlowExpectedError[incompatible-type]
+  function TaskAttributionTiming() {
+    throw new TypeError(
+      "Failed to construct 'TaskAttributionTiming': Illegal constructor",
+    );
+  };
+
+// $FlowExpectedError[prop-missing]
+TaskAttributionTiming_public.prototype = TaskAttributionTiming.prototype;
+
 const EMPTY_ATTRIBUTION: $ReadOnlyArray<TaskAttributionTiming> =
   Object.preventExtensions([]);
 
+export interface PerformanceLongTaskTimingInit extends PerformanceEntryInit {}
+
 export class PerformanceLongTaskTiming extends PerformanceEntry {
+  constructor(init: PerformanceEntryInit) {
+    super('longtask', init);
+  }
+
   get attribution(): $ReadOnlyArray<TaskAttributionTiming> {
     return EMPTY_ATTRIBUTION;
   }
@@ -37,3 +57,16 @@ export class PerformanceLongTaskTiming extends PerformanceEntry {
     };
   }
 }
+
+export const PerformanceLongTaskTiming_public: typeof PerformanceLongTaskTiming =
+  /* eslint-disable no-shadow */
+  // $FlowExpectedError[incompatible-type]
+  function PerformanceLongTaskTiming() {
+    throw new TypeError(
+      "Failed to construct 'PerformanceLongTaskTiming': Illegal constructor",
+    );
+  };
+
+// $FlowExpectedError[prop-missing]
+PerformanceLongTaskTiming_public.prototype =
+  PerformanceLongTaskTiming.prototype;

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

@@ -64,12 +64,13 @@ const cachedGetMarkTime = NativePerformance.getMarkTime;
 const cachedNativeClearMarks = NativePerformance.clearMarks;
 const cachedNativeClearMeasures = NativePerformance.clearMeasures;
 
-const MARK_OPTIONS_REUSABLE_OBJECT: {...PerformanceMarkOptions} = {
+const MARK_OPTIONS_REUSABLE_OBJECT: PerformanceMarkOptions = {
   startTime: 0,
   detail: undefined,
 };
 
-const MEASURE_OPTIONS_REUSABLE_OBJECT: {...PerformanceMeasureInit} = {
+const MEASURE_OPTIONS_REUSABLE_OBJECT: PerformanceMeasureInit = {
+  name: '',
   startTime: 0,
   duration: 0,
   detail: undefined,
@@ -189,7 +190,9 @@ export default class Performance {
       resolvedDetail = structuredClone(detail);
     }
 
+    // $FlowExpectedError[cannot-write]
     MARK_OPTIONS_REUSABLE_OBJECT.startTime = resolvedStartTime;
+    // $FlowExpectedError[cannot-write]
     MARK_OPTIONS_REUSABLE_OBJECT.detail = resolvedDetail;
 
     const entry = new PerformanceMark(
@@ -367,14 +370,16 @@ export default class Performance {
       }
     }
 
+    // $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(
-      resolvedMeasureName,
-      MEASURE_OPTIONS_REUSABLE_OBJECT,
-    );
+    const entry = new PerformanceMeasure(MEASURE_OPTIONS_REUSABLE_OBJECT);
 
     cachedReportMeasure(
       resolvedMeasureName,
@@ -438,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,24 +28,25 @@ export type PerformanceEntryJSON = {
   ...
 };
 
+export interface PerformanceEntryInit {
+  +name: string;
+  +startTime: DOMHighResTimeStamp;
+  +duration: DOMHighResTimeStamp;
+}
+
 export class PerformanceEntry {
   // 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.
-  __name: string;
   __entryType: PerformanceEntryType;
+  __name: string;
   __startTime: DOMHighResTimeStamp;
   __duration: DOMHighResTimeStamp;
 
-  constructor(init: {
-    name: string,
-    entryType: PerformanceEntryType,
-    startTime: DOMHighResTimeStamp,
-    duration: DOMHighResTimeStamp,
-  }) {
+  constructor(entryType: PerformanceEntryType, init: PerformanceEntryInit) {
+    this.__entryType = entryType;
     this.__name = init.name;
-    this.__entryType = init.entryType;
     this.__startTime = init.startTime;
     this.__duration = init.duration;
   }
@@ -76,6 +77,18 @@ export class PerformanceEntry {
   }
 }
 
+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>;

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

@@ -57,6 +57,19 @@ export class PerformanceObserverEntryList {
   }
 }
 
+export const PerformanceObserverEntryList_public: typeof PerformanceObserverEntryList =
+  /* eslint-disable no-shadow */
+  // $FlowExpectedError[incompatible-type]
+  function PerformanceObserverEntryList() {
+    throw new TypeError(
+      "Failed to construct 'PerformanceObserverEntryList': Illegal constructor",
+    );
+  };
+
+// $FlowExpectedError[prop-missing]
+PerformanceObserverEntryList_public.prototype =
+  PerformanceObserverEntryList.prototype;
+
 export type PerformanceObserverCallbackOptions = {
   droppedEntriesCount: number,
 };
@@ -145,6 +158,22 @@ export class PerformanceObserver {
     NativePerformance.disconnect(this.#nativeObserverHandle);
   }
 
+  takeRecords(): PerformanceEntryList {
+    let entries: PerformanceEntryList = [];
+
+    if (this.#nativeObserverHandle != null) {
+      const rawEntries = NativePerformance.takeRecords(
+        this.#nativeObserverHandle,
+        true,
+      );
+      if (rawEntries && rawEntries.length > 0) {
+        entries = rawEntries.map(rawToPerformanceEntry);
+      }
+    }
+
+    return entries;
+  }
+
   #createNativeObserver(): OpaqueNativeObserverHandle | null {
     this.#calledAtLeastOnce = false;
 
@@ -154,7 +183,7 @@ export class PerformanceObserver {
           observerHandle,
           true, // sort records
         );
-        if (!rawEntries) {
+        if (!rawEntries || rawEntries.length === 0) {
           return;
         }
 

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

@@ -29,6 +29,19 @@ export type PerformanceResourceTimingJSON = {
   ...
 };
 
+export interface PerformanceResourceTimingInit {
+  +name: string;
+  +startTime: DOMHighResTimeStamp;
+  +duration: DOMHighResTimeStamp;
+  +fetchStart: DOMHighResTimeStamp;
+  +requestStart: DOMHighResTimeStamp;
+  +connectStart: DOMHighResTimeStamp;
+  +connectEnd: DOMHighResTimeStamp;
+  +responseStart: DOMHighResTimeStamp;
+  +responseEnd: DOMHighResTimeStamp;
+  +responseStatus?: number;
+}
+
 export class PerformanceResourceTiming extends PerformanceEntry {
   #fetchStart: DOMHighResTimeStamp;
   #requestStart: DOMHighResTimeStamp;
@@ -38,24 +51,9 @@ export class PerformanceResourceTiming extends PerformanceEntry {
   #responseEnd: DOMHighResTimeStamp;
   #responseStatus: ?number;
 
-  constructor(init: {
-    name: string,
-    startTime: DOMHighResTimeStamp,
-    duration: DOMHighResTimeStamp,
-    fetchStart: DOMHighResTimeStamp,
-    requestStart: DOMHighResTimeStamp,
-    connectStart: DOMHighResTimeStamp,
-    connectEnd: DOMHighResTimeStamp,
-    responseStart: DOMHighResTimeStamp,
-    responseEnd: DOMHighResTimeStamp,
-    responseStatus?: number,
-  }) {
-    super({
-      name: init.name,
-      entryType: 'resource',
-      startTime: init.startTime,
-      duration: init.duration,
-    });
+  constructor(init: PerformanceResourceTimingInit) {
+    super('resource', init);
+
     this.#fetchStart = init.fetchStart;
     this.#requestStart = init.requestStart;
     this.#connectStart = init.connectStart;
@@ -106,3 +104,16 @@ export class PerformanceResourceTiming extends PerformanceEntry {
     };
   }
 }
+
+export const PerformanceResourceTiming_public: typeof PerformanceResourceTiming =
+  /* eslint-disable no-shadow */
+  // $FlowExpectedError[incompatible-type]
+  function PerformanceResourceTiming() {
+    throw new TypeError(
+      "Failed to construct 'PerformanceResourceTiming': Illegal constructor",
+    );
+  };
+
+// $FlowExpectedError[prop-missing]
+PerformanceResourceTiming_public.prototype =
+  PerformanceResourceTiming.prototype;

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

@@ -9,8 +9,10 @@
  */
 
 // flowlint unsafe-getters-setters:off
-
-import type {DOMHighResTimeStamp} from './PerformanceEntry';
+import type {
+  DOMHighResTimeStamp,
+  PerformanceEntryInit,
+} from './PerformanceEntry';
 import type {
   ExtensionMarkerPayload,
   ExtensionTrackEntryPayload,
@@ -25,18 +27,16 @@ export type DetailType =
   // but we'll use it as documentation for how to use the extensibility API.
   | {devtools?: ExtensionMarkerPayload | ExtensionTrackEntryPayload, ...};
 
-export type PerformanceMarkOptions = $ReadOnly<{
-  detail?: DetailType,
-  startTime?: DOMHighResTimeStamp,
-}>;
+export interface PerformanceMarkOptions {
+  +detail?: DetailType;
+  +startTime?: DOMHighResTimeStamp;
+}
 
 export type TimeStampOrName = DOMHighResTimeStamp | string;
 
-export type PerformanceMeasureInit = $ReadOnly<{
-  detail?: DetailType,
-  startTime: DOMHighResTimeStamp,
-  duration: DOMHighResTimeStamp,
-}>;
+export interface PerformanceMeasureInit extends PerformanceEntryInit {
+  +detail?: DetailType;
+}
 
 class PerformanceMarkTemplate extends PerformanceEntry {
   // We don't use private fields because they're significantly slower to
@@ -45,9 +45,8 @@ class PerformanceMarkTemplate extends PerformanceEntry {
 
   // This constructor isn't really used. See `PerformanceMark` below.
   constructor(markName: string, markOptions?: PerformanceMarkOptions) {
-    super({
+    super('mark', {
       name: markName,
-      entryType: 'mark',
       startTime: markOptions?.startTime ?? getCurrentTimeStamp(),
       duration: 0,
     });
@@ -72,8 +71,8 @@ export const PerformanceMark: typeof PerformanceMarkTemplate =
     markName: string,
     markOptions?: PerformanceMarkOptions,
   ) {
-    this.__name = markName;
     this.__entryType = 'mark';
+    this.__name = markName;
     this.__startTime = markOptions?.startTime ?? getCurrentTimeStamp();
     this.__duration = 0;
 
@@ -89,15 +88,10 @@ class PerformanceMeasureTemplate extends PerformanceEntry {
   __detail: DetailType;
 
   // This constructor isn't really used. See `PerformanceMeasure` below.
-  constructor(measureName: string, measureOptions: PerformanceMeasureInit) {
-    super({
-      name: measureName,
-      entryType: 'measure',
-      startTime: measureOptions.startTime,
-      duration: measureOptions.duration,
-    });
+  constructor(init: PerformanceMeasureInit) {
+    super('measure', init);
 
-    this.__detail = measureOptions?.detail ?? null;
+    this.__detail = init?.detail ?? null;
   }
 
   get detail(): DetailType {
@@ -110,16 +104,27 @@ export const PerformanceMeasure: typeof PerformanceMeasureTemplate =
   // $FlowExpectedError[incompatible-type]
   function PerformanceMeasure(
     this: PerformanceMeasureTemplate,
-    measureName: string,
-    measureOptions: PerformanceMeasureInit,
+    init: PerformanceMeasureInit,
   ) {
-    this.__name = measureName;
     this.__entryType = 'measure';
-    this.__startTime = measureOptions.startTime;
-    this.__duration = measureOptions.duration;
+    this.__name = init.name;
+    this.__startTime = init.startTime;
+    this.__duration = init.duration;
 
-    this.__detail = measureOptions.detail ?? null;
+    this.__detail = init.detail ?? null;
   };
 
 // $FlowExpectedError[prop-missing]
 PerformanceMeasure.prototype = PerformanceMeasureTemplate.prototype;
+
+export const PerformanceMeasure_public: typeof PerformanceMeasure =
+  /* eslint-disable no-shadow */
+  // $FlowExpectedError[incompatible-type]
+  function PerformanceMeasure() {
+    throw new TypeError(
+      "Failed to construct 'PerformanceMeasure': Illegal constructor",
+    );
+  };
+
+// $FlowExpectedError[prop-missing]
+PerformanceMeasure_public.prototype = PerformanceMeasure.prototype;

package/src/private/webapis/performance/internals/RawPerformanceEntry.js

@@ -44,7 +44,6 @@ export function rawToPerformanceEntry(
     case RawPerformanceEntryTypeValues.LONGTASK:
       return new PerformanceLongTaskTiming({
         name: entry.name,
-        entryType: rawToPerformanceEntryType(entry.entryType),
         startTime: entry.startTime,
         duration: entry.duration,
       });
@@ -53,7 +52,8 @@ export function rawToPerformanceEntry(
         startTime: entry.startTime,
       });
     case RawPerformanceEntryTypeValues.MEASURE:
-      return new PerformanceMeasure(entry.name, {
+      return new PerformanceMeasure({
+        name: entry.name,
         startTime: entry.startTime,
         duration: entry.duration,
       });
@@ -71,9 +71,8 @@ export function rawToPerformanceEntry(
         responseStatus: entry.responseStatus,
       });
     default:
-      return new PerformanceEntry({
+      return new PerformanceEntry(rawToPerformanceEntryType(entry.entryType), {
         name: entry.name,
-        entryType: rawToPerformanceEntryType(entry.entryType),
         startTime: entry.startTime,
         duration: entry.duration,
       });

package/third-party-podspecs/replace_dependencies_version.js

@@ -10,7 +10,7 @@
 
 'use strict';
 
-const {execSync} = require('child_process');
+const {spawnSync} = require('child_process');
 const fs = require('fs');
 const yargs = require('yargs');
 
@@ -66,7 +66,9 @@ function replaceRNDepsConfiguration(
   fs.mkdirSync(finalLocation, {recursive: true});
 
   console.log('Extracting the tarball', tarballURLPath);
-  execSync(`tar -xf ${tarballURLPath} -C ${finalLocation}`);
+  spawnSync('tar', ['-xf', tarballURLPath, '-C', finalLocation], {
+    stdio: 'inherit',
+  });
 
   // Now we need to remove the extra third-party folder as we do in the podspec's prepare-script
   // We need to take the ReactNativeDependencies.xcframework folder and move it up one level