@office-iss/react-native-win32 0.74.3 → 0.75.0-preview.1

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

@@ -12,13 +12,15 @@
 
 import type {HighResTimeStamp, PerformanceEntryType} from './PerformanceEntry';
 import type {PerformanceEntryList} from './PerformanceObserver';
+import type {
+  PerformanceMarkOptions,
+  PerformanceMeasureOptions,
+} from './UserTiming';
 
 import warnOnce from '../../../../Libraries/Utilities/warnOnce';
 import EventCounts from './EventCounts';
 import MemoryInfo from './MemoryInfo';
-import NativePerformance from './NativePerformance';
-import NativePerformanceObserver from './NativePerformanceObserver';
-import {ALWAYS_LOGGED_ENTRY_TYPES, PerformanceEntry} from './PerformanceEntry';
+import {ALWAYS_LOGGED_ENTRY_TYPES} from './PerformanceEntry';
 import {warnNoNativePerformanceObserver} from './PerformanceObserver';
 import {
   performanceEntryTypeToRaw,
@@ -26,22 +28,17 @@ import {
 } from './RawPerformanceEntry';
 import {RawPerformanceEntryTypeValues} from './RawPerformanceEntry';
 import ReactNativeStartupTiming from './ReactNativeStartupTiming';
-
-type DetailType = mixed;
-
-export type PerformanceMarkOptions = {
-  detail?: DetailType,
-  startTime?: HighResTimeStamp,
-};
+import NativePerformance from './specs/NativePerformance';
+import NativePerformanceObserver from './specs/NativePerformanceObserver';
+import {PerformanceMark, PerformanceMeasure} from './UserTiming';
 
 declare var global: {
   // This value is defined directly via JSI, if available.
   +nativePerformanceNow?: ?() => number,
 };
 
-const getCurrentTimeStamp: () => HighResTimeStamp = global.nativePerformanceNow
-  ? global.nativePerformanceNow
-  : () => Date.now();
+const getCurrentTimeStamp: () => HighResTimeStamp =
+  NativePerformance?.now ?? 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
@@ -54,49 +51,6 @@ if (NativePerformanceObserver?.setIsBuffered) {
   );
 }
 
-export class PerformanceMark extends PerformanceEntry {
-  detail: DetailType;
-
-  constructor(markName: string, markOptions?: PerformanceMarkOptions) {
-    super({
-      name: markName,
-      entryType: 'mark',
-      startTime: markOptions?.startTime ?? getCurrentTimeStamp(),
-      duration: 0,
-    });
-
-    if (markOptions) {
-      this.detail = markOptions.detail;
-    }
-  }
-}
-
-export type TimeStampOrName = HighResTimeStamp | string;
-
-export type PerformanceMeasureOptions = {
-  detail?: DetailType,
-  start?: TimeStampOrName,
-  end?: TimeStampOrName,
-  duration?: HighResTimeStamp,
-};
-
-export class PerformanceMeasure extends PerformanceEntry {
-  detail: DetailType;
-
-  constructor(measureName: string, measureOptions?: PerformanceMeasureOptions) {
-    super({
-      name: measureName,
-      entryType: 'measure',
-      startTime: 0,
-      duration: measureOptions?.duration ?? 0,
-    });
-
-    if (measureOptions) {
-      this.detail = measureOptions.detail;
-    }
-  }
-}
-
 function warnNoNativePerformance() {
   warnOnce(
     'missing-native-performance',

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

@@ -11,7 +11,6 @@
 import type {HighResTimeStamp, PerformanceEntryType} from './PerformanceEntry';
 
 import warnOnce from '../../../../Libraries/Utilities/warnOnce';
-import NativePerformanceObserver from './NativePerformanceObserver';
 import {PerformanceEntry} from './PerformanceEntry';
 import PerformanceEventTiming from './PerformanceEventTiming';
 import {
@@ -19,22 +18,25 @@ import {
   rawToPerformanceEntry,
   rawToPerformanceEntryType,
 } from './RawPerformanceEntry';
+import NativePerformanceObserver from './specs/NativePerformanceObserver';
 
 export type PerformanceEntryList = $ReadOnlyArray<PerformanceEntry>;
 
+export {PerformanceEntry} from './PerformanceEntry';
+
 export class PerformanceObserverEntryList {
-  _entries: PerformanceEntryList;
+  #entries: PerformanceEntryList;
 
   constructor(entries: PerformanceEntryList) {
-    this._entries = entries;
+    this.#entries = entries;
   }
 
   getEntries(): PerformanceEntryList {
-    return this._entries;
+    return this.#entries;
   }
 
   getEntriesByType(type: PerformanceEntryType): PerformanceEntryList {
-    return this._entries.filter(entry => entry.entryType === type);
+    return this.#entries.filter(entry => entry.entryType === type);
   }
 
   getEntriesByName(
@@ -42,9 +44,9 @@ export class PerformanceObserverEntryList {
     type?: PerformanceEntryType,
   ): PerformanceEntryList {
     if (type === undefined) {
-      return this._entries.filter(entry => entry.name === name);
+      return this.#entries.filter(entry => entry.name === name);
     } else {
-      return this._entries.filter(
+      return this.#entries.filter(
         entry => entry.name === name && entry.entryType === type,
       );
     }
@@ -98,11 +100,17 @@ const onPerformanceEntry = () => {
       const durationThreshold = observerConfig.entryTypes.get(entry.entryType);
       return entry.duration >= (durationThreshold ?? 0);
     });
-    observerConfig.callback(
-      new PerformanceObserverEntryList(entriesForObserver),
-      observer,
-      droppedEntriesCount,
-    );
+    if (entriesForObserver.length !== 0) {
+      try {
+        observerConfig.callback(
+          new PerformanceObserverEntryList(entriesForObserver),
+          observer,
+          droppedEntriesCount,
+        );
+      } catch (error) {
+        console.error(error);
+      }
+    }
   }
 };
 
@@ -167,11 +175,11 @@ function getSupportedPerformanceEntryTypes(): $ReadOnlyArray<PerformanceEntryTyp
  * observer.observe({ type: "event" });
  */
 export default class PerformanceObserver {
-  _callback: PerformanceObserverCallback;
-  _type: 'single' | 'multiple' | void;
+  #callback: PerformanceObserverCallback;
+  #type: 'single' | 'multiple' | void;
 
   constructor(callback: PerformanceObserverCallback) {
-    this._callback = callback;
+    this.#callback = callback;
   }
 
   observe(options: PerformanceObserverInit): void {
@@ -180,17 +188,17 @@ export default class PerformanceObserver {
       return;
     }
 
-    this._validateObserveOptions(options);
+    this.#validateObserveOptions(options);
 
     let requestedEntryTypes;
 
     if (options.entryTypes) {
-      this._type = 'multiple';
+      this.#type = 'multiple';
       requestedEntryTypes = new Map(
         options.entryTypes.map(t => [t, undefined]),
       );
     } else {
-      this._type = 'single';
+      this.#type = 'single';
       requestedEntryTypes = new Map([
         [options.type, options.durationThreshold],
       ]);
@@ -209,7 +217,7 @@ export default class PerformanceObserver {
     }
 
     registeredObservers.set(this, {
-      callback: this._callback,
+      callback: this.#callback,
       entryTypes: nextEntryTypes,
     });
 
@@ -276,7 +284,7 @@ export default class PerformanceObserver {
     applyDurationThresholds();
   }
 
-  _validateObserveOptions(options: PerformanceObserverInit): void {
+  #validateObserveOptions(options: PerformanceObserverInit): void {
     const {type, entryTypes, durationThreshold} = options;
 
     if (!type && !entryTypes) {
@@ -291,13 +299,13 @@ export default class PerformanceObserver {
       );
     }
 
-    if (this._type === 'multiple' && type) {
+    if (this.#type === 'multiple' && type) {
       throw new Error(
         "Failed to execute 'observe' on 'PerformanceObserver': This observer has performed observe({entryTypes:...}, therefore it cannot perform observe({type:...})",
       );
     }
 
-    if (this._type === 'single' && entryTypes) {
+    if (this.#type === 'single' && entryTypes) {
       throw new Error(
         "Failed to execute 'observe' on 'PerformanceObserver': This PerformanceObserver has performed observe({type:...}, therefore it cannot perform observe({entryTypes:...})",
       );

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

@@ -8,17 +8,16 @@
  * @flow strict
  */
 
+import type {PerformanceEntryType} from './PerformanceEntry';
 import type {
   RawPerformanceEntry,
   RawPerformanceEntryType,
-} from './NativePerformanceObserver';
-import type {PerformanceEntryType} from './PerformanceEntry';
+} from './specs/NativePerformanceObserver';
 
 import {PerformanceEntry} from './PerformanceEntry';
 import PerformanceEventTiming from './PerformanceEventTiming';
 
 export const RawPerformanceEntryTypeValues = {
-  UNDEFINED: 0,
   MARK: 1,
   MEASURE: 2,
   EVENT: 3,
@@ -56,10 +55,6 @@ export function rawToPerformanceEntryType(
       return 'measure';
     case RawPerformanceEntryTypeValues.EVENT:
       return 'event';
-    case RawPerformanceEntryTypeValues.UNDEFINED:
-      throw new TypeError(
-        "rawToPerformanceEntryType: UNDEFINED can't be cast to PerformanceEntryType",
-      );
     default:
       throw new TypeError(
         `rawToPerformanceEntryType: unexpected performance entry type received: ${type}`,

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

@@ -27,22 +27,22 @@ export default class ReactNativeStartupTiming {
   // We do NOT match web spect here for two reasons:
   // 1. The `ReactNativeStartupTiming` is non-standard API
   // 2. The timing information is relative to the time origin, which means `0` has valid meaning
-  _startTime: ?number;
-  _endTime: ?number;
-  _initializeRuntimeStart: ?number;
-  _initializeRuntimeEnd: ?number;
-  _executeJavaScriptBundleEntryPointStart: ?number;
-  _executeJavaScriptBundleEntryPointEnd: ?number;
+  #startTime: ?number;
+  #endTime: ?number;
+  #initializeRuntimeStart: ?number;
+  #initializeRuntimeEnd: ?number;
+  #executeJavaScriptBundleEntryPointStart: ?number;
+  #executeJavaScriptBundleEntryPointEnd: ?number;
 
   constructor(startUpTiming: ?ReactNativeStartupTimingLike) {
     if (startUpTiming != null) {
-      this._startTime = startUpTiming.startTime;
-      this._endTime = startUpTiming.endTime;
-      this._initializeRuntimeStart = startUpTiming.initializeRuntimeStart;
-      this._initializeRuntimeEnd = startUpTiming.initializeRuntimeEnd;
-      this._executeJavaScriptBundleEntryPointStart =
+      this.#startTime = startUpTiming.startTime;
+      this.#endTime = startUpTiming.endTime;
+      this.#initializeRuntimeStart = startUpTiming.initializeRuntimeStart;
+      this.#initializeRuntimeEnd = startUpTiming.initializeRuntimeEnd;
+      this.#executeJavaScriptBundleEntryPointStart =
         startUpTiming.executeJavaScriptBundleEntryPointStart;
-      this._executeJavaScriptBundleEntryPointEnd =
+      this.#executeJavaScriptBundleEntryPointEnd =
         startUpTiming.executeJavaScriptBundleEntryPointEnd;
     }
   }
@@ -51,41 +51,41 @@ export default class ReactNativeStartupTiming {
    * Start time of the RN app startup process. This is provided by the platform by implementing the `ReactMarker.setAppStartTime` API in the native platform code.
    */
   get startTime(): ?number {
-    return this._startTime;
+    return this.#startTime;
   }
 
   /**
    * End time of the RN app startup process. This is equal to `executeJavaScriptBundleEntryPointEnd`.
    */
   get endTime(): ?number {
-    return this._endTime;
+    return this.#endTime;
   }
 
   /**
    * Start time when RN runtime get initialized. This is when RN infra first kicks in app startup process.
    */
   get initializeRuntimeStart(): ?number {
-    return this._initializeRuntimeStart;
+    return this.#initializeRuntimeStart;
   }
 
   /**
    * End time when RN runtime get initialized. This is the last marker before ends of the app startup process.
    */
   get initializeRuntimeEnd(): ?number {
-    return this._initializeRuntimeEnd;
+    return this.#initializeRuntimeEnd;
   }
 
   /**
    * Start time of JS bundle being executed. This indicates the RN JS bundle is loaded and start to be evaluated.
    */
   get executeJavaScriptBundleEntryPointStart(): ?number {
-    return this._executeJavaScriptBundleEntryPointStart;
+    return this.#executeJavaScriptBundleEntryPointStart;
   }
 
   /**
    * End time of JS bundle being executed. This indicates all the synchronous entry point jobs are finished.
    */
   get executeJavaScriptBundleEntryPointEnd(): ?number {
-    return this._executeJavaScriptBundleEntryPointEnd;
+    return this.#executeJavaScriptBundleEntryPointEnd;
   }
 }

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

@@ -0,0 +1,63 @@
+/**
+ * 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.
+ *
+ * @format
+ * @flow strict
+ */
+
+import type {HighResTimeStamp} from './PerformanceEntry';
+
+import {PerformanceEntry} from './PerformanceEntry';
+
+type DetailType = mixed;
+
+export type PerformanceMarkOptions = {
+  detail?: DetailType,
+  startTime?: HighResTimeStamp,
+};
+
+export type TimeStampOrName = HighResTimeStamp | string;
+
+export type PerformanceMeasureOptions = {
+  detail?: DetailType,
+  start?: TimeStampOrName,
+  end?: TimeStampOrName,
+  duration?: HighResTimeStamp,
+};
+
+export class PerformanceMark extends PerformanceEntry {
+  detail: DetailType;
+
+  constructor(markName: string, markOptions?: PerformanceMarkOptions) {
+    super({
+      name: markName,
+      entryType: 'mark',
+      startTime: markOptions?.startTime ?? performance.now(),
+      duration: 0,
+    });
+
+    if (markOptions) {
+      this.detail = markOptions.detail;
+    }
+  }
+}
+
+export class PerformanceMeasure extends PerformanceEntry {
+  detail: DetailType;
+
+  constructor(measureName: string, measureOptions?: PerformanceMeasureOptions) {
+    super({
+      name: measureName,
+      entryType: 'measure',
+      startTime: 0,
+      duration: measureOptions?.duration ?? 0,
+    });
+
+    if (measureOptions) {
+      this.detail = measureOptions.detail;
+    }
+  }
+}

package/src/private/webapis/performance/{NativePerformance.js → specs/NativePerformance.js}

@@ -8,15 +8,16 @@
  * @format
  */
 
-import type {TurboModule} from '../../../../Libraries/TurboModule/RCTExport';
+import type {TurboModule} from '../../../../../Libraries/TurboModule/RCTExport';
 
-import * as TurboModuleRegistry from '../../../../Libraries/TurboModule/TurboModuleRegistry';
+import * as TurboModuleRegistry from '../../../../../Libraries/TurboModule/TurboModuleRegistry';
 
 export type NativeMemoryInfo = {[key: string]: ?number};
 
 export type ReactNativeStartupTiming = {[key: string]: ?number};
 
 export interface Spec extends TurboModule {
+  +now?: () => number;
   +mark: (name: string, startTime: number) => void;
   +measure: (
     name: string,

package/src/private/webapis/performance/{NativePerformanceObserver.js → specs/NativePerformanceObserver.js}

@@ -8,9 +8,9 @@
  * @format
  */
 
-import type {TurboModule} from '../../../../Libraries/TurboModule/RCTExport';
+import type {TurboModule} from '../../../../../Libraries/TurboModule/RCTExport';
 
-import * as TurboModuleRegistry from '../../../../Libraries/TurboModule/TurboModuleRegistry';
+import * as TurboModuleRegistry from '../../../../../Libraries/TurboModule/TurboModuleRegistry';
 
 export type RawPerformanceEntryType = number;
 

package/src/private/webapis/performance/{__mocks__ → specs/__mocks__}/NativePerformance.js

@@ -14,8 +14,8 @@ import type {
   Spec as NativePerformance,
 } from '../NativePerformance';
 
+import {RawPerformanceEntryTypeValues} from '../../RawPerformanceEntry';
 import NativePerformanceObserver from '../NativePerformanceObserver';
-import {RawPerformanceEntryTypeValues} from '../RawPerformanceEntry';
 
 const marks: Map<string, number> = new Map();
 

package/src/private/webapis/performance/{__mocks__ → specs/__mocks__}/NativePerformanceObserver.js

@@ -15,7 +15,7 @@ import type {
   Spec as NativePerformanceObserver,
 } from '../NativePerformanceObserver';
 
-import {RawPerformanceEntryTypeValues} from '../RawPerformanceEntry';
+import {RawPerformanceEntryTypeValues} from '../../RawPerformanceEntry';
 
 const reportingType: Set<RawPerformanceEntryType> = new Set();
 const isAlwaysLogged: Set<RawPerformanceEntryType> = new Set();
@@ -95,11 +95,10 @@ const NativePerformanceObserverMock: NativePerformanceObserver = {
     durationThresholds.set(entryType, durationThreshold);
   },
 
-  clearEntries: (entryType: RawPerformanceEntryType, entryName?: string) => {
+  clearEntries: (entryType?: RawPerformanceEntryType, entryName?: string) => {
     entries = entries.filter(
       e =>
-        (entryType !== RawPerformanceEntryTypeValues.UNDEFINED &&
-          e.entryType !== entryType) ||
+        (entryType != null && e.entryType !== entryType) ||
         (entryName != null && e.name !== entryName),
     );
   },

package/src-win/Libraries/Components/View/ViewPropTypes.d.ts

@@ -21,48 +21,6 @@ import {
 import {Touchable} from 'react-native/Libraries/Components/Touchable/Touchable';
 import {AccessibilityProps} from './ViewAccessibility';
 
-export type TVParallaxProperties = {
-  /**
-   * If true, parallax effects are enabled.  Defaults to true.
-   */
-  enabled?: boolean | undefined;
-
-  /**
-   * Defaults to 2.0.
-   */
-  shiftDistanceX?: number | undefined;
-
-  /**
-   * Defaults to 2.0.
-   */
-  shiftDistanceY?: number | undefined;
-
-  /**
-   * Defaults to 0.05.
-   */
-  tiltAngle?: number | undefined;
-
-  /**
-   * Defaults to 1.0
-   */
-  magnification?: number | undefined;
-
-  /**
-   * Defaults to 1.0
-   */
-  pressMagnification?: number | undefined;
-
-  /**
-   * Defaults to 0.3
-   */
-  pressDuration?: number | undefined;
-
-  /**
-   * Defaults to 0.3
-   */
-  pressDelay?: number | undefined;
-};
-
 export interface TVViewPropsIOS {
   /**
    * *(Apple TV only)* When set to true, this view will be focusable
@@ -79,13 +37,6 @@ export interface TVViewPropsIOS {
    */
   hasTVPreferredFocus?: boolean | undefined;
 
-  /**
-   * *(Apple TV only)* Object with properties to control Apple TV parallax effects.
-   *
-   * @platform ios
-   */
-  tvParallaxProperties?: TVParallaxProperties | undefined;
-
   /**
    * *(Apple TV only)* May be used to change the appearance of the Apple TV parallax effect when this view goes in or out of focus.  Defaults to 2.0.
    *
@@ -137,6 +88,13 @@ export interface ViewPropsAndroid {
    */
   collapsable?: boolean | undefined;
 
+  /**
+   * Setting to false prevents direct children of the view from being removed
+   * from the native view hierarchy, similar to the effect of setting
+   * `collapsable={false}` on each child.
+   */
+  collapsableChildren?: boolean | undefined;
+
   /**
    * Whether this view should render itself (and all of its children) into a single hardware texture on the GPU.
    *

package/types/modules/globals.d.ts

@@ -132,6 +132,10 @@ declare interface Headers {
   get(name: string): string | null;
   has(name: string): boolean;
   set(name: string, value: string): void;
+  entries(): IterableIterator<[string, string]>;
+  keys(): IterableIterator<string>;
+  values(): IterableIterator<string>;
+  [Symbol.iterator](): IterableIterator<[string, string]>;
 }
 
 declare var Headers: {