react-native-windows 0.76.2 → 0.77.0-preview.1

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

@@ -25,12 +25,12 @@ export type TimeStampOrName = DOMHighResTimeStamp | string;
 
 export type PerformanceMeasureInit = {
   detail?: DetailType,
-  startTime?: DOMHighResTimeStamp,
-  duration?: DOMHighResTimeStamp,
+  startTime: DOMHighResTimeStamp,
+  duration: DOMHighResTimeStamp,
 };
 
 export class PerformanceMark extends PerformanceEntry {
-  detail: DetailType;
+  #detail: DetailType;
 
   constructor(markName: string, markOptions?: PerformanceMarkOptions) {
     super({
@@ -41,20 +41,24 @@ export class PerformanceMark extends PerformanceEntry {
     });
 
     if (markOptions) {
-      this.detail = markOptions.detail;
+      this.#detail = markOptions.detail;
     }
   }
+
+  get detail(): DetailType {
+    return this.#detail;
+  }
 }
 
 export class PerformanceMeasure extends PerformanceEntry {
   #detail: DetailType;
 
-  constructor(measureName: string, measureOptions?: PerformanceMeasureInit) {
+  constructor(measureName: string, measureOptions: PerformanceMeasureInit) {
     super({
       name: measureName,
       entryType: 'measure',
-      startTime: measureOptions?.startTime ?? 0,
-      duration: measureOptions?.duration ?? 0,
+      startTime: measureOptions.startTime,
+      duration: measureOptions.duration,
     });
 
     if (measureOptions) {

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

@@ -0,0 +1,18 @@
+/**
+ * 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',
+  );
+}

package/src/private/webapis/performance/specs/NativePerformance.js

@@ -16,10 +16,39 @@ export type NativeMemoryInfo = {[key: string]: ?number};
 
 export type ReactNativeStartupTiming = {[key: string]: ?number};
 
+export type RawPerformanceEntryType = number;
+
+export type RawPerformanceEntry = {
+  name: string,
+  entryType: RawPerformanceEntryType,
+  startTime: number,
+  duration: number,
+
+  // For "event" entries only:
+  processingStart?: number,
+  processingEnd?: number,
+  interactionId?: number,
+};
+
+export type OpaqueNativeObserverHandle = mixed;
+
+export type NativeBatchedObserverCallback = () => void;
+export type NativePerformanceMarkResult = number;
+export type NativePerformanceMeasureResult = $ReadOnlyArray<number>; // [startTime, duration]
+
+export type PerformanceObserverInit = {
+  entryTypes?: $ReadOnlyArray<number>,
+  type?: number,
+  buffered?: boolean,
+  durationThreshold?: number,
+};
+
 export interface Spec extends TurboModule {
   +now?: () => number;
-  +mark: (name: string, startTime: number) => void;
-  +measure: (
+  // TODO: remove when `markWithResult` is fully rolled out.
+  +mark?: (name: string, startTime: number) => void;
+  // TODO: remove when `measureWithResult` is fully rolled out.
+  +measure?: (
     name: string,
     startTime: number,
     endTime: number,
@@ -27,8 +56,48 @@ export interface Spec extends TurboModule {
     startMark?: string,
     endMark?: string,
   ) => void;
+  +markWithResult?: (
+    name: string,
+    startTime?: number,
+  ) => NativePerformanceMarkResult;
+  +measureWithResult?: (
+    name: string,
+    startTime: number,
+    endTime: number,
+    duration?: number,
+    startMark?: string,
+    endMark?: string,
+  ) => NativePerformanceMeasureResult;
+  +clearMarks?: (entryName?: string) => void;
+  +clearMeasures?: (entryName?: string) => void;
+  +getEntries?: () => $ReadOnlyArray<RawPerformanceEntry>;
+  +getEntriesByName?: (
+    entryName: string,
+    entryType?: ?RawPerformanceEntryType,
+  ) => $ReadOnlyArray<RawPerformanceEntry>;
+  +getEntriesByType?: (
+    entryType: RawPerformanceEntryType,
+  ) => $ReadOnlyArray<RawPerformanceEntry>;
+  +getEventCounts?: () => $ReadOnlyArray<[string, number]>;
   +getSimpleMemoryInfo: () => NativeMemoryInfo;
   +getReactNativeStartupTiming: () => ReactNativeStartupTiming;
+
+  +createObserver?: (
+    callback: NativeBatchedObserverCallback,
+  ) => OpaqueNativeObserverHandle;
+  +getDroppedEntriesCount?: (observer: OpaqueNativeObserverHandle) => number;
+
+  +observe?: (
+    observer: OpaqueNativeObserverHandle,
+    options: PerformanceObserverInit,
+  ) => void;
+  +disconnect?: (observer: OpaqueNativeObserverHandle) => void;
+  +takeRecords?: (
+    observer: OpaqueNativeObserverHandle,
+    sort: boolean,
+  ) => $ReadOnlyArray<RawPerformanceEntry>;
+
+  +getSupportedPerformanceEntryTypes?: () => $ReadOnlyArray<RawPerformanceEntryType>;
 }
 
 export default (TurboModuleRegistry.get<Spec>('NativePerformanceCxx'): ?Spec);

package/src/private/webapis/performance/specs/__mocks__/NativePerformanceMock.js

@@ -0,0 +1,267 @@
+/**
+ * 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 {
+  NativeBatchedObserverCallback,
+  NativeMemoryInfo,
+  NativePerformanceMarkResult,
+  NativePerformanceMeasureResult,
+  OpaqueNativeObserverHandle,
+  PerformanceObserverInit,
+  RawPerformanceEntry,
+  RawPerformanceEntryType,
+  ReactNativeStartupTiming,
+} from '../NativePerformance';
+import typeof NativePerformance from '../NativePerformance';
+
+import {RawPerformanceEntryTypeValues} from '../../RawPerformanceEntry';
+
+type MockObserver = {
+  handleEntry: (entry: RawPerformanceEntry) => void,
+  callback: NativeBatchedObserverCallback,
+  didScheduleFlushBuffer: boolean,
+  entries: Array<RawPerformanceEntry>,
+  options: PerformanceObserverInit,
+  droppedEntriesCount: number,
+};
+
+const eventCounts: Map<string, number> = new Map();
+const observers: Set<MockObserver> = new Set();
+const marks: Map<string, number> = new Map();
+let entries: Array<RawPerformanceEntry> = [];
+
+function getMockObserver(
+  opaqueNativeObserverHandle: OpaqueNativeObserverHandle,
+): MockObserver {
+  return opaqueNativeObserverHandle as $FlowFixMe as MockObserver;
+}
+
+function createMockObserver(callback: NativeBatchedObserverCallback) {
+  const observer: MockObserver = {
+    callback,
+    didScheduleFlushBuffer: false,
+    entries: [],
+    options: {},
+    droppedEntriesCount: 0,
+    handleEntry: (entry: RawPerformanceEntry) => {
+      if (
+        observer.options.type !== entry.entryType &&
+        !observer.options.entryTypes?.includes(entry.entryType)
+      ) {
+        return;
+      }
+
+      if (
+        entry.entryType === RawPerformanceEntryTypeValues.EVENT &&
+        entry.duration < (observer.options?.durationThreshold ?? 0)
+      ) {
+        return;
+      }
+
+      observer.entries.push(entry);
+
+      if (!observer.didScheduleFlushBuffer) {
+        observer.didScheduleFlushBuffer = true;
+        // $FlowFixMe[incompatible-call]
+        global.queueMicrotask(() => {
+          observer.didScheduleFlushBuffer = false;
+          // We want to emulate the way it's done in native (i.e. async/batched)
+          observer.callback();
+        });
+      }
+    },
+  };
+
+  return observer;
+}
+
+export function reportEntry(entry: RawPerformanceEntry) {
+  entries.push(entry);
+
+  switch (entry.entryType) {
+    case RawPerformanceEntryTypeValues.MARK:
+      marks.set(entry.name, entry.startTime);
+      break;
+    case RawPerformanceEntryTypeValues.MEASURE:
+      break;
+    case RawPerformanceEntryTypeValues.EVENT:
+      eventCounts.set(entry.name, (eventCounts.get(entry.name) ?? 0) + 1);
+      break;
+  }
+
+  for (const observer of observers) {
+    observer.handleEntry(entry);
+  }
+}
+
+let currentTime: number = 12;
+
+const NativePerformanceMock = {
+  setCurrentTime: (time: number): void => {
+    currentTime = time;
+  },
+
+  now: (): number => currentTime,
+
+  markWithResult: (
+    name: string,
+    startTime?: number,
+  ): NativePerformanceMarkResult => {
+    const computedStartTime = startTime ?? performance.now();
+
+    marks.set(name, computedStartTime);
+    reportEntry({
+      entryType: RawPerformanceEntryTypeValues.MARK,
+      name,
+      startTime: computedStartTime,
+      duration: 0,
+    });
+
+    return computedStartTime;
+  },
+
+  measureWithResult: (
+    name: string,
+    startTime: number,
+    endTime: number,
+    duration?: number,
+    startMark?: string,
+    endMark?: string,
+  ): NativePerformanceMeasureResult => {
+    const start = startMark != null ? marks.get(startMark) : startTime;
+    const end = endMark != null ? marks.get(endMark) : endTime;
+
+    if (start === undefined) {
+      throw new Error('startMark does not exist');
+    }
+
+    if (end === undefined) {
+      throw new Error('endMark does not exist');
+    }
+
+    const computedDuration = duration ?? end - start;
+    reportEntry({
+      entryType: RawPerformanceEntryTypeValues.MEASURE,
+      name,
+      startTime: start,
+      duration: computedDuration,
+    });
+
+    return [start, computedDuration];
+  },
+
+  getSimpleMemoryInfo: (): NativeMemoryInfo => {
+    return {};
+  },
+
+  getReactNativeStartupTiming: (): ReactNativeStartupTiming => {
+    return {
+      startTime: 0,
+      endTime: 0,
+      executeJavaScriptBundleEntryPointStart: 0,
+      executeJavaScriptBundleEntryPointEnd: 0,
+      initializeRuntimeStart: 0,
+      initializeRuntimeEnd: 0,
+    };
+  },
+
+  getEventCounts: (): $ReadOnlyArray<[string, number]> => {
+    return Array.from(eventCounts.entries());
+  },
+
+  createObserver: (
+    callback: NativeBatchedObserverCallback,
+  ): OpaqueNativeObserverHandle => {
+    return createMockObserver(callback);
+  },
+
+  getDroppedEntriesCount: (observer: OpaqueNativeObserverHandle): number => {
+    return getMockObserver(observer).droppedEntriesCount;
+  },
+
+  observe: (
+    observer: OpaqueNativeObserverHandle,
+    options: PerformanceObserverInit,
+  ): void => {
+    const mockObserver = getMockObserver(observer);
+    mockObserver.options = options;
+    observers.add(mockObserver);
+  },
+
+  disconnect: (observer: OpaqueNativeObserverHandle): void => {
+    const mockObserver = getMockObserver(observer);
+    observers.delete(mockObserver);
+  },
+
+  takeRecords: (
+    observer: OpaqueNativeObserverHandle,
+  ): $ReadOnlyArray<RawPerformanceEntry> => {
+    const mockObserver = getMockObserver(observer);
+    const observerEntries = mockObserver.entries;
+    mockObserver.entries = [];
+    return observerEntries.sort((a, b) => a.startTime - b.startTime);
+  },
+
+  clearMarks: (entryName?: string) => {
+    if (entryName != null) {
+      marks.delete(entryName);
+    } else {
+      marks.clear();
+    }
+
+    entries = entries.filter(
+      entry =>
+        entry.entryType !== RawPerformanceEntryTypeValues.MARK ||
+        (entryName != null && entry.name !== entryName),
+    );
+  },
+
+  clearMeasures: (entryName?: string) => {
+    entries = entries.filter(
+      entry =>
+        entry.entryType !== RawPerformanceEntryTypeValues.MEASURE ||
+        (entryName != null && entry.name !== entryName),
+    );
+  },
+
+  getEntries: (): $ReadOnlyArray<RawPerformanceEntry> => {
+    return [...entries].sort((a, b) => a.startTime - b.startTime);
+  },
+
+  getEntriesByName: (
+    entryName: string,
+    entryType?: ?RawPerformanceEntryType,
+  ): $ReadOnlyArray<RawPerformanceEntry> => {
+    return NativePerformanceMock.getEntries().filter(
+      entry =>
+        (entryType == null || entry.entryType === entryType) &&
+        entry.name === entryName,
+    );
+  },
+
+  getEntriesByType: (
+    entryType: RawPerformanceEntryType,
+  ): $ReadOnlyArray<RawPerformanceEntry> => {
+    return entries.filter(entry => entry.entryType === entryType);
+  },
+
+  getSupportedPerformanceEntryTypes:
+    (): $ReadOnlyArray<RawPerformanceEntryType> => {
+      return [
+        RawPerformanceEntryTypeValues.MARK,
+        RawPerformanceEntryTypeValues.MEASURE,
+        RawPerformanceEntryTypeValues.EVENT,
+      ];
+    },
+};
+
+(NativePerformanceMock: NativePerformance);
+
+export default NativePerformanceMock;

package/templates/cpp-lib/template.config.js

@@ -199,15 +199,21 @@ async function postInstall(config = {}, options = {}) {
   const namespaceCpp = namespace.replace(/\./g, '::');
 
   // Update package.json codegen
-  await templateUtils.updateProjectPackageJson(libConfig, libOptions, {
-    codegenConfig: {
-      windows: {
-        namespace: namespaceCpp + 'Codegen',
-        outputDirectory: `windows/${projectName}/codegen`,
-        separateDataTypes: true,
+  await templateUtils.updateProjectPackageJson(
+    libConfig,
+    libOptions,
+    {
+      codegenConfig: {
+        windows: {
+          namespace: namespaceCpp + 'Codegen',
+          outputDirectory: `windows/${projectName}/codegen`,
+          separateDataTypes: true,
+        },
       },
     },
-  });
+    true, // save options from command
+    true, // if a "files" property exists, make sure "windows" is included
+  );
 
   if (exExists) {
     const {rnwVersion} = templateUtils.getRnwInfo(exConfig, exOptions);

package/templates/templateUtils.js

@@ -115,6 +115,7 @@ async function updateProjectPackageJson(
   options = {},
   props = {},
   saveOptions = true,
+  ensureWindowsInFiles = false,
 ) {
   const projectRoot = config?.root ?? process.cwd();
   const projectPackage =
@@ -139,6 +140,15 @@ async function updateProjectPackageJson(
   if (options?.logging) {
     console.log(`Modifying ${path.join(projectRoot, 'package.json')}...`);
   }
+
+  // add "windows" to files if property exists
+  if (ensureWindowsInFiles && projectPackage.json.files !== undefined) {
+    props.files = projectPackage.json.files;
+    if (!props.files.includes('windows')) {
+      props.files.push('windows');
+    }
+  }
+
   await projectPackage.mergeProps(props);
 }
 

package/types/index.d.ts

@@ -104,7 +104,6 @@ export * from '../Libraries/Components/View/ViewAccessibility';
 export * from '../Libraries/Components/View/ViewPropTypes';
 export * from '../Libraries/Components/Button';
 export * from '../Libraries/Core/registerCallableModule';
-export * from '../Libraries/DevToolsSettings/DevToolsSettingsManager';
 export * from '../Libraries/EventEmitter/NativeEventEmitter';
 export * from '../Libraries/EventEmitter/RCTDeviceEventEmitter';
 export * from '../Libraries/EventEmitter/RCTNativeAppEventEmitter';
@@ -142,6 +141,7 @@ export * as TurboModuleRegistry from '../Libraries/TurboModule/TurboModuleRegist
 export * from '../Libraries/Types/CoreEventTypes';
 export * from '../Libraries/Utilities/Appearance';
 export * from '../Libraries/Utilities/BackHandler';
+export * from '../src/private/devmenu/DevMenu';
 export * from '../Libraries/Utilities/DevSettings';
 export * from '../Libraries/Utilities/Dimensions';
 export * from '../Libraries/Utilities/PixelRatio';

package/types/public/ReactNativeTypes.d.ts

@@ -86,9 +86,7 @@ export interface NativeMethods {
    * _Can also be called with a relativeNativeNodeHandle but is deprecated._
    */
   measureLayout(
-    relativeToNativeComponentRef:
-      | React.ElementRef<HostComponent<unknown>>
-      | number,
+    relativeToNativeComponentRef: HostInstance | number,
     onSuccess: MeasureLayoutOnSuccessCallback,
     onFail?: () => void,
   ): void;
@@ -111,10 +109,6 @@ export interface NativeMethods {
    * Removes focus from an input or view. This is the opposite of `focus()`.
    */
   blur(): void;
-
-  refs: {
-    [key: string]: React.Component<any, any>;
-  };
 }
 
 /**
@@ -126,6 +120,8 @@ export type NativeMethodsMixin = NativeMethods;
  */
 export type NativeMethodsMixinType = NativeMethods;
 
+export type HostInstance = NativeMethods;
+
 /**
  * Represents a native component, such as those returned from `requireNativeComponent`.
  *
@@ -139,5 +135,5 @@ export interface HostComponent<P>
     React.ComponentClass<P>,
     Exclude<keyof React.ComponentClass<P>, 'new'>
   > {
-  new (props: P, context?: any): React.Component<P> & Readonly<NativeMethods>;
+  new (props: P, context?: any): React.Component<P> & HostInstance;
 }

package/Libraries/DevToolsSettings/DevToolsSettingsManager.android.js

@@ -1,35 +0,0 @@
-/**
- * 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 DevSettings from '../Utilities/DevSettings';
-import NativeDevToolsSettingsManager from './NativeDevToolsSettingsManager';
-
-module.exports = {
-  setConsolePatchSettings(newSettings: string) {
-    NativeDevToolsSettingsManager?.setConsolePatchSettings(newSettings);
-  },
-  getConsolePatchSettings(): ?string {
-    return NativeDevToolsSettingsManager?.getConsolePatchSettings();
-  },
-  setProfilingSettings(newSettings: string) {
-    if (NativeDevToolsSettingsManager?.setProfilingSettings != null) {
-      NativeDevToolsSettingsManager.setProfilingSettings(newSettings);
-    }
-  },
-  getProfilingSettings(): ?string {
-    if (NativeDevToolsSettingsManager?.getProfilingSettings != null) {
-      return NativeDevToolsSettingsManager.getProfilingSettings();
-    }
-    return null;
-  },
-  reload(): void {
-    DevSettings?.reload();
-  },
-};

package/Libraries/DevToolsSettings/DevToolsSettingsManager.d.ts

@@ -1,20 +0,0 @@
-/**
- * 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
- */
-
-export interface DevToolsSettingsManagerStatic {
-  reload(): void;
-  setConsolePatchSettings(newSettings: string): void;
-  getConsolePatchSettings(): string | null;
-  setProfilingSettings(newSettings: string): void;
-  getProfilingSettings(): string | null;
-}
-
-export const DevToolsSettingsManager: DevToolsSettingsManagerStatic;
-export type DevToolsSettingsManager = DevToolsSettingsManagerStatic;

package/Libraries/DevToolsSettings/DevToolsSettingsManager.ios.js

@@ -1,49 +0,0 @@
-/**
- * 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 '../Settings/Settings';
-import DevSettings from '../Utilities/DevSettings';
-
-const CONSOLE_PATCH_SETTINGS_KEY = 'ReactDevTools::ConsolePatchSettings';
-const PROFILING_SETTINGS_KEY = 'ReactDevTools::ProfilingSettings';
-
-const DevToolsSettingsManager = {
-  setConsolePatchSettings(newConsolePatchSettings: string): void {
-    Settings.set({
-      [CONSOLE_PATCH_SETTINGS_KEY]: newConsolePatchSettings,
-    });
-  },
-  getConsolePatchSettings(): ?string {
-    const value = Settings.get(CONSOLE_PATCH_SETTINGS_KEY);
-    if (typeof value === 'string') {
-      return value;
-    }
-    return null;
-  },
-
-  setProfilingSettings(newProfilingSettings: string): void {
-    Settings.set({
-      [PROFILING_SETTINGS_KEY]: newProfilingSettings,
-    });
-  },
-  getProfilingSettings(): ?string {
-    const value = Settings.get(PROFILING_SETTINGS_KEY);
-    if (typeof value === 'string') {
-      return value;
-    }
-    return null;
-  },
-
-  reload(): void {
-    DevSettings?.reload();
-  },
-};
-
-module.exports = DevToolsSettingsManager;

package/Libraries/DevToolsSettings/DevToolsSettingsManager.windows.js

@@ -1,35 +0,0 @@
-/**
- * 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 DevSettings from '../Utilities/DevSettings';
-import NativeDevToolsSettingsManager from './NativeDevToolsSettingsManager';
-
-module.exports = {
-  setConsolePatchSettings(newSettings: string) {
-    NativeDevToolsSettingsManager?.setConsolePatchSettings(newSettings);
-  },
-  getConsolePatchSettings(): ?string {
-    return NativeDevToolsSettingsManager?.getConsolePatchSettings();
-  },
-  setProfilingSettings(newSettings: string) {
-    if (NativeDevToolsSettingsManager?.setProfilingSettings != null) {
-      NativeDevToolsSettingsManager.setProfilingSettings(newSettings);
-    }
-  },
-  getProfilingSettings(): ?string {
-    if (NativeDevToolsSettingsManager?.getProfilingSettings != null) {
-      return NativeDevToolsSettingsManager.getProfilingSettings();
-    }
-    return null;
-  },
-  reload(): void {
-    DevSettings?.reload();
-  },
-};

package/Libraries/DevToolsSettings/NativeDevToolsSettingsManager.js

@@ -1,13 +0,0 @@
-/**
- * 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
- */
-
-export * from '../../src/private/specs/modules/NativeDevToolsSettingsManager';
-import NativeDevToolsSettingsManager from '../../src/private/specs/modules/NativeDevToolsSettingsManager';
-export default NativeDevToolsSettingsManager;