@office-iss/react-native-win32 0.0.0-canary.266 → 0.0.0-canary.267

package/src/private/featureflags/ReactNativeFeatureFlags.js

@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @generated SignedSource<<79bdedd5a09ba284cdaa2e4f40ffd2fd>>
+ * @generated SignedSource<<e161b67cb919ad7e2e67ddcb3c501adb>>
  * @flow strict
  */
 
@@ -36,6 +36,7 @@ export type ReactNativeFeatureFlagsJsOnly = {
   enableAnimatedPropsMemo: Getter<boolean>,
   enableOptimisedVirtualizedCells: Getter<boolean>,
   isLayoutAnimationEnabled: Getter<boolean>,
+  shouldSkipStateUpdatesForLoopingAnimations: Getter<boolean>,
   shouldUseAnimatedObjectForTransform: Getter<boolean>,
   shouldUseRemoveClippedSubviewsAsDefaultOnIOS: Getter<boolean>,
   shouldUseSetNativePropsInFabric: Getter<boolean>,
@@ -55,13 +56,14 @@ export type ReactNativeFeatureFlags = {
   destroyFabricSurfacesInReactInstanceManager: Getter<boolean>,
   enableAlignItemsBaselineOnFabricIOS: Getter<boolean>,
   enableAndroidLineHeightCentering: Getter<boolean>,
-  enableAndroidMixBlendModeProp: Getter<boolean>,
   enableBackgroundStyleApplicator: Getter<boolean>,
+  enableBridgelessArchitecture: Getter<boolean>,
   enableCleanTextInputYogaNode: Getter<boolean>,
   enableDeletionOfUnmountedViews: Getter<boolean>,
   enableEagerRootViewAttachment: Getter<boolean>,
   enableEventEmitterRetentionDuringGesturesOnAndroid: Getter<boolean>,
   enableFabricLogs: Getter<boolean>,
+  enableFabricRenderer: Getter<boolean>,
   enableFabricRendererExclusively: Getter<boolean>,
   enableGranularShadowTreeStateReconciliation: Getter<boolean>,
   enableIOSViewClipToPaddingBox: Getter<boolean>,
@@ -97,8 +99,8 @@ export type ReactNativeFeatureFlags = {
   useOptimizedEventBatchingOnAndroid: Getter<boolean>,
   useRuntimeShadowNodeReferenceUpdate: Getter<boolean>,
   useRuntimeShadowNodeReferenceUpdateOnLayout: Getter<boolean>,
-  useStateAlignmentMechanism: Getter<boolean>,
   useTurboModuleInterop: Getter<boolean>,
+  useTurboModules: Getter<boolean>,
 }
 
 /**
@@ -146,6 +148,11 @@ export const enableOptimisedVirtualizedCells: Getter<boolean> = createJavaScript
  */
 export const isLayoutAnimationEnabled: Getter<boolean> = createJavaScriptFlagGetter('isLayoutAnimationEnabled', true);
 
+/**
+ * If the animation is within Animated.loop, we do not send state updates to React.
+ */
+export const shouldSkipStateUpdatesForLoopingAnimations: Getter<boolean> = createJavaScriptFlagGetter('shouldSkipStateUpdatesForLoopingAnimations', false);
+
 /**
  * Enables use of AnimatedObject for animating transform values.
  */
@@ -204,14 +211,14 @@ export const enableAlignItemsBaselineOnFabricIOS: Getter<boolean> = createNative
  * When enabled, custom line height calculation will be centered from top to bottom.
  */
 export const enableAndroidLineHeightCentering: Getter<boolean> = createNativeFlagGetter('enableAndroidLineHeightCentering', false);
-/**
- * Enables mix-blend-mode prop on Android.
- */
-export const enableAndroidMixBlendModeProp: Getter<boolean> = createNativeFlagGetter('enableAndroidMixBlendModeProp', false);
 /**
  * Use BackgroundStyleApplicator in place of other background/border drawing code
  */
 export const enableBackgroundStyleApplicator: Getter<boolean> = createNativeFlagGetter('enableBackgroundStyleApplicator', true);
+/**
+ * Feature flag to enable the new bridgeless architecture. Note: Enabling this will force enable the following flags: `useTurboModules` & `enableFabricRenderer.
+ */
+export const enableBridgelessArchitecture: Getter<boolean> = createNativeFlagGetter('enableBridgelessArchitecture', false);
 /**
  * Clean yoga node when <TextInput /> does not change.
  */
@@ -232,6 +239,10 @@ export const enableEventEmitterRetentionDuringGesturesOnAndroid: Getter<boolean>
  * This feature flag enables logs for Fabric.
  */
 export const enableFabricLogs: Getter<boolean> = createNativeFlagGetter('enableFabricLogs', false);
+/**
+ * Enables the use of the Fabric renderer in the whole app.
+ */
+export const enableFabricRenderer: Getter<boolean> = createNativeFlagGetter('enableFabricRenderer', false);
 /**
  * When the app is completely migrated to Fabric, set this flag to true to disable parts of Paper infrastructure that are not needed anymore but consume memory and CPU. Specifically, UIViewOperationQueue and EventDispatcherImpl will no longer work as they will not subscribe to ReactChoreographer for updates.
  */
@@ -372,14 +383,14 @@ export const useRuntimeShadowNodeReferenceUpdate: Getter<boolean> = createNative
  * When enabled, cloning shadow nodes during layout will update the reference held by the current JS fiber tree.
  */
 export const useRuntimeShadowNodeReferenceUpdateOnLayout: Getter<boolean> = createNativeFlagGetter('useRuntimeShadowNodeReferenceUpdateOnLayout', false);
-/**
- * When enabled, it uses optimised state reconciliation algorithm.
- */
-export const useStateAlignmentMechanism: Getter<boolean> = createNativeFlagGetter('useStateAlignmentMechanism', false);
 /**
  * In Bridgeless mode, should legacy NativeModules use the TurboModule system?
  */
 export const useTurboModuleInterop: Getter<boolean> = createNativeFlagGetter('useTurboModuleInterop', false);
+/**
+ * When enabled, NativeModules will be executed by using the TurboModule system
+ */
+export const useTurboModules: Getter<boolean> = createNativeFlagGetter('useTurboModules', false);
 
 /**
  * Overrides the feature flags with the provided methods.

package/src/private/featureflags/specs/NativeReactNativeFeatureFlags.js

@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @generated SignedSource<<ee3f60941427d4efa2f5b03bf0b78514>>
+ * @generated SignedSource<<cd4a2a047e3a6fdb4205efb518906462>>
  * @flow strict
  */
 
@@ -30,13 +30,14 @@ export interface Spec extends TurboModule {
   +destroyFabricSurfacesInReactInstanceManager?: () => boolean;
   +enableAlignItemsBaselineOnFabricIOS?: () => boolean;
   +enableAndroidLineHeightCentering?: () => boolean;
-  +enableAndroidMixBlendModeProp?: () => boolean;
   +enableBackgroundStyleApplicator?: () => boolean;
+  +enableBridgelessArchitecture?: () => boolean;
   +enableCleanTextInputYogaNode?: () => boolean;
   +enableDeletionOfUnmountedViews?: () => boolean;
   +enableEagerRootViewAttachment?: () => boolean;
   +enableEventEmitterRetentionDuringGesturesOnAndroid?: () => boolean;
   +enableFabricLogs?: () => boolean;
+  +enableFabricRenderer?: () => boolean;
   +enableFabricRendererExclusively?: () => boolean;
   +enableGranularShadowTreeStateReconciliation?: () => boolean;
   +enableIOSViewClipToPaddingBox?: () => boolean;
@@ -72,8 +73,8 @@ export interface Spec extends TurboModule {
   +useOptimizedEventBatchingOnAndroid?: () => boolean;
   +useRuntimeShadowNodeReferenceUpdate?: () => boolean;
   +useRuntimeShadowNodeReferenceUpdateOnLayout?: () => boolean;
-  +useStateAlignmentMechanism?: () => boolean;
   +useTurboModuleInterop?: () => boolean;
+  +useTurboModules?: () => boolean;
 }
 
 const NativeReactNativeFeatureFlags: ?Spec = TurboModuleRegistry.get<Spec>(

package/src/private/reactdevtools/ReactDevToolsSettingsManager.android.js

@@ -0,0 +1,20 @@
+/**
+ * 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-local
+ * @format
+ */
+
+import NativeReactDevToolsSettingsManager from '../specs/modules/NativeReactDevToolsSettingsManager';
+
+module.exports = {
+  setGlobalHookSettings(settings: string) {
+    NativeReactDevToolsSettingsManager?.setGlobalHookSettings(settings);
+  },
+  getGlobalHookSettings(): ?string {
+    return NativeReactDevToolsSettingsManager?.getGlobalHookSettings();
+  },
+};

package/src/private/reactdevtools/ReactDevToolsSettingsManager.ios.js

@@ -0,0 +1,30 @@
+/**
+ * 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-local
+ * @format
+ */
+
+import Settings from '../../../Libraries/Settings/Settings';
+
+const GLOBAL_HOOK_SETTINGS = 'ReactDevTools::HookSettings';
+
+const ReactDevToolsSettingsManager = {
+  setGlobalHookSettings(settings: string): void {
+    Settings.set({
+      [GLOBAL_HOOK_SETTINGS]: settings,
+    });
+  },
+  getGlobalHookSettings(): ?string {
+    const value = Settings.get(GLOBAL_HOOK_SETTINGS);
+    if (typeof value === 'string') {
+      return value;
+    }
+    return null;
+  },
+};
+
+module.exports = ReactDevToolsSettingsManager;

package/src/private/reactdevtools/ReactDevToolsSettingsManager.win32.js

@@ -0,0 +1,20 @@
+/**
+ * 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-local
+ * @format
+ */
+
+import NativeReactDevToolsSettingsManager from '../specs/modules/NativeReactDevToolsSettingsManager';
+
+module.exports = {
+  setGlobalHookSettings(settings: string) {
+    NativeReactDevToolsSettingsManager?.setGlobalHookSettings(settings);
+  },
+  getGlobalHookSettings(): ?string {
+    return NativeReactDevToolsSettingsManager?.getGlobalHookSettings();
+  },
+};

package/src/private/specs/components/AndroidHorizontalScrollContentViewNativeComponent.js

@@ -23,4 +23,5 @@ type NativeType = HostComponent<NativeProps>;
 
 export default (codegenNativeComponent<NativeProps>(
   'AndroidHorizontalScrollContentView',
+  {interfaceOnly: true},
 ): NativeType);

package/src/private/specs/modules/{NativeDevToolsSettingsManager.js → NativeReactDevToolsSettingsManager.js}

@@ -13,12 +13,10 @@ import type {TurboModule} from '../../../../Libraries/TurboModule/RCTExport';
 import * as TurboModuleRegistry from '../../../../Libraries/TurboModule/TurboModuleRegistry';
 
 export interface Spec extends TurboModule {
-  +setConsolePatchSettings: (newConsolePatchSettings: string) => void;
-  +getConsolePatchSettings: () => ?string;
-  +setProfilingSettings?: (newProfilingSettings: string) => void;
-  +getProfilingSettings?: () => ?string;
+  +setGlobalHookSettings: (settings: string) => void;
+  +getGlobalHookSettings: () => ?string;
 }
 
 export default (TurboModuleRegistry.get<Spec>(
-  'DevToolsSettingsManager',
+  'ReactDevToolsSettingsManager',
 ): ?Spec);

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

@@ -16,7 +16,7 @@ import type {
 } from './PerformanceEntry';
 
 import {PerformanceEntry} from './PerformanceEntry';
-import {warnNoNativePerformanceObserver} from './PerformanceObserver';
+import {warnNoNativePerformanceObserver} from './Utilities';
 import NativePerformanceObserver from './specs/NativePerformanceObserver';
 
 export type PerformanceEventTimingJSON = {

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

@@ -17,11 +17,10 @@ import type {
 import type {PerformanceEntryList} from './PerformanceObserver';
 import type {DetailType, PerformanceMarkOptions} from './UserTiming';
 
-import warnOnce from '../../../../Libraries/Utilities/warnOnce';
 import {EventCounts} from './EventTiming';
 import MemoryInfo from './MemoryInfo';
 import {ALWAYS_LOGGED_ENTRY_TYPES} from './PerformanceEntry';
-import {warnNoNativePerformanceObserver} from './PerformanceObserver';
+import {warnNoNativePerformanceObserver} from './Utilities';
 import {
   performanceEntryTypeToRaw,
   rawToPerformanceEntry,
@@ -31,6 +30,7 @@ import ReactNativeStartupTiming from './ReactNativeStartupTiming';
 import NativePerformance from './specs/NativePerformance';
 import NativePerformanceObserver from './specs/NativePerformanceObserver';
 import {PerformanceMark, PerformanceMeasure} from './UserTiming';
+import {warnNoNativePerformance} from './Utilities';
 
 declare var global: {
   // This value is defined directly via JSI, if available.
@@ -40,24 +40,6 @@ declare var global: {
 const getCurrentTimeStamp: () => DOMHighResTimeStamp =
   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
-// 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,
-  );
-}
-
-function warnNoNativePerformance() {
-  warnOnce(
-    'missing-native-performance',
-    'Missing native implementation of Performance',
-  );
-}
-
 export type PerformanceMeasureOptions = {
   detail?: DetailType,
   start?: DOMHighResTimeStamp,
@@ -145,7 +127,7 @@ export default class Performance {
       return;
     }
 
-    NativePerformanceObserver?.clearEntries(
+    NativePerformanceObserver.clearEntries(
       RawPerformanceEntryTypeValues.MARK,
       markName,
     );

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

@@ -13,7 +13,6 @@ import type {
   PerformanceEntryType,
 } from './PerformanceEntry';
 
-import warnOnce from '../../../../Libraries/Utilities/warnOnce';
 import {PerformanceEventTiming} from './EventTiming';
 import {PerformanceEntry} from './PerformanceEntry';
 import {
@@ -22,6 +21,8 @@ import {
   rawToPerformanceEntryType,
 } from './RawPerformanceEntry';
 import NativePerformanceObserver from './specs/NativePerformanceObserver';
+import type {OpaqueNativeObserverHandle} from './specs/NativePerformanceObserver';
+import {warnNoNativePerformanceObserver} from './Utilities';
 
 export type PerformanceEntryList = $ReadOnlyArray<PerformanceEntry>;
 
@@ -56,89 +57,24 @@ export class PerformanceObserverEntryList {
   }
 }
 
+export type PerformanceObserverCallbackOptions = {
+  droppedEntriesCount: number,
+};
+
 export type PerformanceObserverCallback = (
   list: PerformanceObserverEntryList,
   observer: PerformanceObserver,
   // The number of buffered entries which got dropped from the buffer due to the buffer being full:
-  droppedEntryCount?: number,
+  options?: PerformanceObserverCallbackOptions,
 ) => void;
 
-export type PerformanceObserverInit =
-  | {
-      entryTypes: Array<PerformanceEntryType>,
-    }
-  | {
-      type: PerformanceEntryType,
-      durationThreshold?: DOMHighResTimeStamp,
-    };
-
-type PerformanceObserverConfig = {|
-  callback: PerformanceObserverCallback,
-  entryTypes: $ReadOnlySet<PerformanceEntryType>,
-  durationThreshold: ?number,
-|};
-
-const observerCountPerEntryType: Map<PerformanceEntryType, number> = new Map();
-const registeredObservers: Map<PerformanceObserver, PerformanceObserverConfig> =
-  new Map();
-let isOnPerformanceEntryCallbackSet: boolean = false;
-
-// This is a callback that gets scheduled and periodically called from the native side
-const onPerformanceEntry = () => {
-  if (!NativePerformanceObserver) {
-    return;
-  }
-  const entryResult = NativePerformanceObserver.popPendingEntries();
-  const rawEntries = entryResult?.entries ?? [];
-  const droppedEntriesCount = entryResult?.droppedEntriesCount;
-  if (rawEntries.length === 0) {
-    return;
-  }
-  const entries = rawEntries.map(rawToPerformanceEntry);
-  for (const [observer, observerConfig] of registeredObservers.entries()) {
-    const entriesForObserver: PerformanceEntryList = entries.filter(entry => {
-      if (!observerConfig.entryTypes.has(entry.entryType)) {
-        return false;
-      }
-
-      if (
-        entry.entryType === 'event' &&
-        observerConfig.durationThreshold != null
-      ) {
-        return entry.duration >= observerConfig.durationThreshold;
-      }
-
-      return true;
-    });
-    if (entriesForObserver.length !== 0) {
-      try {
-        observerConfig.callback(
-          new PerformanceObserverEntryList(entriesForObserver),
-          observer,
-          droppedEntriesCount,
-        );
-      } catch (error) {
-        console.error(error);
-      }
-    }
-  }
+export type PerformanceObserverInit = {
+  entryTypes?: Array<PerformanceEntryType>,
+  type?: PerformanceEntryType,
+  buffered?: boolean,
+  durationThreshold?: DOMHighResTimeStamp,
 };
 
-export function warnNoNativePerformanceObserver() {
-  warnOnce(
-    'missing-native-performance-observer',
-    'Missing native implementation of PerformanceObserver',
-  );
-}
-
-function applyDurationThresholds() {
-  const durationThresholds = Array.from(registeredObservers.values())
-    .map(observerConfig => observerConfig.durationThreshold)
-    .filter(Boolean);
-
-  return Math.min(...durationThresholds);
-}
-
 function getSupportedPerformanceEntryTypes(): $ReadOnlyArray<PerformanceEntryType> {
   if (!NativePerformanceObserver) {
     return Object.freeze([]);
@@ -175,111 +111,96 @@ function getSupportedPerformanceEntryTypes(): $ReadOnlyArray<PerformanceEntryTyp
  * observer.observe({ type: "event" });
  */
 export class PerformanceObserver {
+  #nativeObserverHandle: OpaqueNativeObserverHandle | null = null;
   #callback: PerformanceObserverCallback;
   #type: 'single' | 'multiple' | void;
+  #calledAtLeastOnce = false;
 
   constructor(callback: PerformanceObserverCallback) {
     this.#callback = callback;
   }
 
   observe(options: PerformanceObserverInit): void {
-    if (!NativePerformanceObserver) {
+    if (
+      !NativePerformanceObserver ||
+      NativePerformanceObserver.observe == null
+    ) {
       warnNoNativePerformanceObserver();
       return;
     }
 
     this.#validateObserveOptions(options);
 
-    let requestedEntryTypes;
+    if (this.#nativeObserverHandle == null) {
+      this.#nativeObserverHandle = this.#createNativeObserver();
+    }
 
     if (options.entryTypes) {
       this.#type = 'multiple';
-      requestedEntryTypes = new Set(options.entryTypes);
-    } else {
+      NativePerformanceObserver.observe?.(this.#nativeObserverHandle, {
+        entryTypes: options.entryTypes.map(performanceEntryTypeToRaw),
+      });
+    } else if (options.type) {
       this.#type = 'single';
-      requestedEntryTypes = new Set([options.type]);
+      NativePerformanceObserver.observe?.(this.#nativeObserverHandle, {
+        type: performanceEntryTypeToRaw(options.type),
+        buffered: options.buffered,
+        durationThreshold: options.durationThreshold,
+      });
     }
+  }
 
-    // The same observer may receive multiple calls to "observe", so we need
-    // to check what is new on this call vs. previous ones.
-    const currentEntryTypes = registeredObservers.get(this)?.entryTypes;
-    const nextEntryTypes = currentEntryTypes
-      ? union(requestedEntryTypes, currentEntryTypes)
-      : requestedEntryTypes;
-
-    // This `observe` call is a no-op because there are no new things to observe.
-    if (currentEntryTypes && currentEntryTypes.size === nextEntryTypes.size) {
+  disconnect(): void {
+    if (!NativePerformanceObserver) {
+      warnNoNativePerformanceObserver();
       return;
     }
 
-    registeredObservers.set(this, {
-      callback: this.#callback,
-      durationThreshold:
-        options.type === 'event' ? options.durationThreshold : undefined,
-      entryTypes: nextEntryTypes,
-    });
-
-    if (!isOnPerformanceEntryCallbackSet) {
-      NativePerformanceObserver.setOnPerformanceEntryCallback(
-        onPerformanceEntry,
-      );
-      isOnPerformanceEntryCallbackSet = true;
+    if (
+      this.#nativeObserverHandle == null ||
+      !NativePerformanceObserver.disconnect
+    ) {
+      return;
     }
 
-    // We only need to start listenening to new entry types being observed in
-    // this observer.
-    const newEntryTypes = currentEntryTypes
-      ? difference(
-          new Set(requestedEntryTypes.keys()),
-          new Set(currentEntryTypes.keys()),
-        )
-      : new Set(requestedEntryTypes.keys());
-    for (const type of newEntryTypes) {
-      if (!observerCountPerEntryType.has(type)) {
-        const rawType = performanceEntryTypeToRaw(type);
-        NativePerformanceObserver.startReporting(rawType);
-      }
-      observerCountPerEntryType.set(
-        type,
-        (observerCountPerEntryType.get(type) ?? 0) + 1,
-      );
-    }
-    applyDurationThresholds();
+    NativePerformanceObserver.disconnect(this.#nativeObserverHandle);
   }
 
-  disconnect(): void {
-    if (!NativePerformanceObserver) {
+  #createNativeObserver(): OpaqueNativeObserverHandle {
+    if (
+      !NativePerformanceObserver ||
+      !NativePerformanceObserver.createObserver
+    ) {
       warnNoNativePerformanceObserver();
       return;
     }
 
-    const observerConfig = registeredObservers.get(this);
-    if (!observerConfig) {
-      return;
-    }
+    this.#calledAtLeastOnce = false;
 
-    // Disconnect this observer
-    for (const type of observerConfig.entryTypes.keys()) {
-      const numberOfObserversForThisType =
-        observerCountPerEntryType.get(type) ?? 0;
-      if (numberOfObserversForThisType === 1) {
-        observerCountPerEntryType.delete(type);
-        NativePerformanceObserver.stopReporting(
-          performanceEntryTypeToRaw(type),
-        );
-      } else if (numberOfObserversForThisType !== 0) {
-        observerCountPerEntryType.set(type, numberOfObserversForThisType - 1);
+    return NativePerformanceObserver.createObserver(() => {
+      // $FlowNotNull
+      const rawEntries = NativePerformanceObserver.takeRecords?.(
+        this.#nativeObserverHandle,
+        true, // sort records
+      );
+      if (!rawEntries) {
+        return;
       }
-    }
 
-    // Disconnect all observers if this was the last one
-    registeredObservers.delete(this);
-    if (registeredObservers.size === 0) {
-      NativePerformanceObserver.setOnPerformanceEntryCallback(undefined);
-      isOnPerformanceEntryCallbackSet = false;
-    }
+      const entries = rawEntries.map(rawToPerformanceEntry);
+      const entryList = new PerformanceObserverEntryList(entries);
+
+      let droppedEntriesCount = 0;
+      if (!this.#calledAtLeastOnce) {
+        droppedEntriesCount =
+          NativePerformanceObserver.getDroppedEntriesCount?.(
+            this.#nativeObserverHandle,
+          ) ?? 0;
+        this.#calledAtLeastOnce = true;
+      }
 
-    applyDurationThresholds();
+      this.#callback(entryList, this, {droppedEntriesCount});
+    });
   }
 
   #validateObserveOptions(options: PerformanceObserverInit): void {
@@ -309,7 +230,7 @@ export class PerformanceObserver {
       );
     }
 
-    if (entryTypes && durationThreshold !== undefined) {
+    if (entryTypes && durationThreshold != null) {
       throw new TypeError(
         "Failed to execute 'observe' on 'PerformanceObserver': An observe() call must not include both entryTypes and durationThreshold arguments.",
       );
@@ -320,12 +241,4 @@ export class PerformanceObserver {
     getSupportedPerformanceEntryTypes();
 }
 
-function union<T>(a: $ReadOnlySet<T>, b: $ReadOnlySet<T>): Set<T> {
-  return new Set([...a, ...b]);
-}
-
-function difference<T>(a: $ReadOnlySet<T>, b: $ReadOnlySet<T>): Set<T> {
-  return new Set([...a].filter(x => !b.has(x)));
-}
-
 export {PerformanceEventTiming};

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

@@ -0,0 +1,25 @@
+/**
+ * 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 warnOnce from '../../../../Libraries/Utilities/warnOnce';
+
+export function warnNoNativePerformance() {
+  warnOnce(
+    'missing-native-performance',
+    'Missing native implementation of Performance',
+  );
+}
+
+export function warnNoNativePerformanceObserver() {
+  warnOnce(
+    'missing-native-performance-observer',
+    'Missing native implementation of PerformanceObserver',
+  );
+}