@office-iss/react-native-win32 0.0.0-canary.297 → 0.0.0-canary.299

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

@@ -0,0 +1,108 @@
+/**
+ * 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
+ */
+
+// flowlint unsafe-getters-setters:off
+
+import type {
+  DOMHighResTimeStamp,
+  PerformanceEntryJSON,
+} from './PerformanceEntry';
+
+import {PerformanceEntry} from './PerformanceEntry';
+
+export type PerformanceResourceTimingJSON = {
+  ...PerformanceEntryJSON,
+  fetchStart: DOMHighResTimeStamp,
+  requestStart: DOMHighResTimeStamp,
+  connectStart: DOMHighResTimeStamp,
+  connectEnd: DOMHighResTimeStamp,
+  responseStart: DOMHighResTimeStamp,
+  responseEnd: DOMHighResTimeStamp,
+  responseStatus: ?number,
+  ...
+};
+
+export class PerformanceResourceTiming extends PerformanceEntry {
+  #fetchStart: DOMHighResTimeStamp;
+  #requestStart: DOMHighResTimeStamp;
+  #connectStart: DOMHighResTimeStamp;
+  #connectEnd: DOMHighResTimeStamp;
+  #responseStart: DOMHighResTimeStamp;
+  #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,
+    });
+    this.#fetchStart = init.fetchStart;
+    this.#requestStart = init.requestStart;
+    this.#connectStart = init.connectStart;
+    this.#connectEnd = init.connectEnd;
+    this.#responseStart = init.responseStart;
+    this.#responseEnd = init.responseEnd;
+    this.#responseStatus = init.responseStatus;
+  }
+
+  get fetchStart(): DOMHighResTimeStamp {
+    return this.#fetchStart;
+  }
+
+  get requestStart(): DOMHighResTimeStamp {
+    return this.#requestStart;
+  }
+
+  get connectStart(): DOMHighResTimeStamp {
+    return this.#connectStart;
+  }
+
+  get connectEnd(): DOMHighResTimeStamp {
+    return this.#connectEnd;
+  }
+
+  get responseStart(): DOMHighResTimeStamp {
+    return this.#responseStart;
+  }
+
+  get responseEnd(): DOMHighResTimeStamp {
+    return this.#responseEnd;
+  }
+
+  get responseStatus(): ?number {
+    return this.#responseStatus;
+  }
+
+  toJSON(): PerformanceResourceTimingJSON {
+    return {
+      ...super.toJSON(),
+      fetchStart: this.#fetchStart,
+      requestStart: this.#requestStart,
+      connectStart: this.#connectStart,
+      connectEnd: this.#connectEnd,
+      responseStart: this.#responseStart,
+      responseEnd: this.#responseEnd,
+      responseStatus: this.#responseStatus,
+    };
+  }
+}

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

@@ -4,8 +4,8 @@
  * 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
+ * @format
  */
 
 // flowlint unsafe-getters-setters:off
@@ -29,9 +29,12 @@ export type PerformanceMeasureInit = {
   duration: DOMHighResTimeStamp,
 };
 
-export class PerformanceMark extends PerformanceEntry {
-  #detail: DetailType;
+class PerformanceMarkTemplate extends PerformanceEntry {
+  // We don't use private fields because they're significantly slower to
+  // initialize on construction and to access.
+  _detail: DetailType;
 
+  // This constructor isn't really used. See `PerformanceMark` below.
   constructor(markName: string, markOptions?: PerformanceMarkOptions) {
     super({
       name: markName,
@@ -41,18 +44,46 @@ export class PerformanceMark extends PerformanceEntry {
     });
 
     if (markOptions) {
-      this.#detail = markOptions.detail;
+      this._detail = markOptions.detail;
     }
   }
 
   get detail(): DetailType {
-    return this.#detail;
+    return this._detail;
   }
 }
 
-export class PerformanceMeasure extends PerformanceEntry {
-  #detail: DetailType;
+// This is the real value we're exporting where we define the class a function
+// so we don't need to call `super()` and we can avoid the performance penalty
+// of the current code transpiled with Babel.
+// We should remove this when we have built-in support for classes in the
+// runtime.
+export const PerformanceMark: typeof PerformanceMarkTemplate =
+  // $FlowExpectedError[incompatible-type]
+  function PerformanceMark(
+    this: PerformanceMarkTemplate,
+    markName: string,
+    markOptions?: PerformanceMarkOptions,
+  ) {
+    this.__name = markName;
+    this.__entryType = 'mark';
+    this.__startTime = markOptions?.startTime ?? performance.now();
+    this.__duration = 0;
+
+    if (markOptions) {
+      this._detail = markOptions.detail;
+    }
+  };
+
+// $FlowExpectedError[prop-missing]
+PerformanceMark.prototype = PerformanceMarkTemplate.prototype;
 
+class PerformanceMeasureTemplate extends PerformanceEntry {
+  // We don't use private fields because they're significantly slower to
+  // initialize on construction and to access.
+  _detail: DetailType;
+
+  // This constructor isn't really used. See `PerformanceMeasure` below.
   constructor(measureName: string, measureOptions: PerformanceMeasureInit) {
     super({
       name: measureName,
@@ -62,11 +93,32 @@ export class PerformanceMeasure extends PerformanceEntry {
     });
 
     if (measureOptions) {
-      this.#detail = measureOptions.detail;
+      this._detail = measureOptions.detail;
     }
   }
 
   get detail(): DetailType {
-    return this.#detail;
+    return this._detail;
   }
 }
+
+// We do the same here as we do for `PerformanceMark` for performance reasons.
+export const PerformanceMeasure: typeof PerformanceMeasureTemplate =
+  // $FlowExpectedError[incompatible-type]
+  function PerformanceMeasure(
+    this: PerformanceMeasureTemplate,
+    measureName: string,
+    measureOptions: PerformanceMeasureInit,
+  ) {
+    this.__name = measureName;
+    this.__entryType = 'measure';
+    this.__startTime = measureOptions.startTime;
+    this.__duration = measureOptions.duration;
+
+    if (measureOptions) {
+      this._detail = measureOptions.detail;
+    }
+  };
+
+// $FlowExpectedError[prop-missing]
+PerformanceMeasure.prototype = PerformanceMeasureTemplate.prototype;

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

@@ -4,8 +4,8 @@
  * 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
+ * @format
  */
 
 import type {PerformanceEntryType} from '../PerformanceEntry';
@@ -17,6 +17,7 @@ import type {
 import {PerformanceEventTiming} from '../EventTiming';
 import {PerformanceLongTaskTiming} from '../LongTasks';
 import {PerformanceEntry} from '../PerformanceEntry';
+import {PerformanceResourceTiming} from '../ResourceTiming';
 import {PerformanceMark, PerformanceMeasure} from '../UserTiming';
 
 export const RawPerformanceEntryTypeValues = {
@@ -30,38 +31,52 @@ export const RawPerformanceEntryTypeValues = {
 export function rawToPerformanceEntry(
   entry: RawPerformanceEntry,
 ): PerformanceEntry {
-  if (entry.entryType === RawPerformanceEntryTypeValues.EVENT) {
-    return new PerformanceEventTiming({
-      name: entry.name,
-      startTime: entry.startTime,
-      duration: entry.duration,
-      processingStart: entry.processingStart,
-      processingEnd: entry.processingEnd,
-      interactionId: entry.interactionId,
-    });
-  } else if (entry.entryType === RawPerformanceEntryTypeValues.LONGTASK) {
-    return new PerformanceLongTaskTiming({
-      name: entry.name,
-      entryType: rawToPerformanceEntryType(entry.entryType),
-      startTime: entry.startTime,
-      duration: entry.duration,
-    });
-  } else if (entry.entryType === RawPerformanceEntryTypeValues.MARK) {
-    return new PerformanceMark(entry.name, {
-      startTime: entry.startTime,
-    });
-  } else if (entry.entryType === RawPerformanceEntryTypeValues.MEASURE) {
-    return new PerformanceMeasure(entry.name, {
-      startTime: entry.startTime,
-      duration: entry.duration,
-    });
-  } else {
-    return new PerformanceEntry({
-      name: entry.name,
-      entryType: rawToPerformanceEntryType(entry.entryType),
-      startTime: entry.startTime,
-      duration: entry.duration,
-    });
+  switch (entry.entryType) {
+    case RawPerformanceEntryTypeValues.EVENT:
+      return new PerformanceEventTiming({
+        name: entry.name,
+        startTime: entry.startTime,
+        duration: entry.duration,
+        processingStart: entry.processingStart,
+        processingEnd: entry.processingEnd,
+        interactionId: entry.interactionId,
+      });
+    case RawPerformanceEntryTypeValues.LONGTASK:
+      return new PerformanceLongTaskTiming({
+        name: entry.name,
+        entryType: rawToPerformanceEntryType(entry.entryType),
+        startTime: entry.startTime,
+        duration: entry.duration,
+      });
+    case RawPerformanceEntryTypeValues.MARK:
+      return new PerformanceMark(entry.name, {
+        startTime: entry.startTime,
+      });
+    case RawPerformanceEntryTypeValues.MEASURE:
+      return new PerformanceMeasure(entry.name, {
+        startTime: entry.startTime,
+        duration: entry.duration,
+      });
+    case RawPerformanceEntryTypeValues.RESOURCE:
+      return new PerformanceResourceTiming({
+        name: entry.name,
+        startTime: entry.startTime,
+        duration: entry.duration,
+        fetchStart: entry.fetchStart ?? 0,
+        requestStart: entry.requestStart ?? 0,
+        connectStart: entry.connectStart ?? 0,
+        connectEnd: entry.connectEnd ?? 0,
+        responseStart: entry.responseStart ?? 0,
+        responseEnd: entry.responseEnd ?? 0,
+        responseStatus: entry.responseStatus,
+      });
+    default:
+      return new PerformanceEntry({
+        name: entry.name,
+        entryType: rawToPerformanceEntryType(entry.entryType),
+        startTime: entry.startTime,
+        duration: entry.duration,
+      });
   }
 }
 

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

@@ -4,8 +4,8 @@
  * 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
+ * @format
  */
 
 import warnOnce from '../../../../../Libraries/Utilities/warnOnce';

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

@@ -39,7 +39,7 @@ export type RawPerformanceEntry = {
   responseStatus?: number,
 };
 
-export type OpaqueNativeObserverHandle = mixed;
+export opaque type OpaqueNativeObserverHandle = mixed;
 
 export type NativeBatchedObserverCallback = () => void;
 export type NativePerformanceMarkResult = number;
@@ -58,6 +58,15 @@ export interface Spec extends TurboModule {
     name: string,
     startTime?: number,
   ) => NativePerformanceMarkResult;
+  +measure?: (
+    name: string,
+    startTime?: number,
+    endTime?: number,
+    duration?: number,
+    startMark?: string,
+    endMark?: string,
+  ) => NativePerformanceMeasureResult;
+  // DEPRECATED: Use measure instead.
   +measureWithResult?: (
     name: string,
     startTime: number,
@@ -96,6 +105,9 @@ export interface Spec extends TurboModule {
   ) => $ReadOnlyArray<RawPerformanceEntry>;
 
   +getSupportedPerformanceEntryTypes?: () => $ReadOnlyArray<RawPerformanceEntryType>;
+
+  +setCurrentTimeStampForTesting?: (timeStamp: number) => void;
+  +clearEventCountsForTesting?: () => void;
 }
 
 export default (TurboModuleRegistry.get<Spec>('NativePerformanceCxx'): ?Spec);

package/src/private/webapis/utils/ArrayLikeUtils.js

@@ -4,8 +4,8 @@
  * 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
+ * @format
  */
 
 /**

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

@@ -13,14 +13,19 @@ import {GestureResponderHandlers} from 'react-native/types/public/ReactNativeRen
 import {StyleProp} from 'react-native/Libraries/StyleSheet/StyleSheet';
 import {ViewStyle} from 'react-native/Libraries/StyleSheet/StyleSheetTypes';
 import {
+  BlurEvent,
+  FocusEvent,
   LayoutChangeEvent,
+  PointerEvents,
   MouseEvent, // Win32
   NativeSyntheticEvent, // Win32
-  PointerEvents,
-} from 'react-native/Libraries/Types/CoreEventTypes';
+} from '../../Types/CoreEventTypes';
 import {Touchable} from 'react-native/Libraries/Components/Touchable/Touchable';
 import {AccessibilityProps} from './ViewAccessibility';
 
+/**
+ * @deprecated These properties are not implemented natively.
+ */
 export interface TVViewPropsIOS {
   /**
    * *(Apple TV only)* When set to true, this view will be focusable
@@ -34,6 +39,7 @@ export interface TVViewPropsIOS {
    * *(Apple TV only)* May be set to true to force the Apple TV focus engine to move focus to this view.
    *
    * @platform ios
+   * @deprecated Use `focusable` instead
    */
   hasTVPreferredFocus?: boolean | undefined;
 
@@ -81,6 +87,20 @@ export interface ViewPropsIOS extends TVViewPropsIOS {
 }
 
 export interface ViewPropsAndroid {
+  /**
+   * Callback that is called when the view is blurred.
+   *
+   * Note: This will only be called if the view is focusable.
+   */
+  onBlur?: ((e: BlurEvent) => void) | null | undefined;
+
+  /**
+   * Callback that is called when the view is focused.
+   *
+   * Note: This will only be called if the view is focusable.
+   */
+  onFocus?: ((e: FocusEvent) => void) | null | undefined;
+
   /**
    * Whether this view should render itself (and all of its children) into a single hardware texture on the GPU.
    *

package/types/modules/Devtools.d.ts

@@ -9,24 +9,38 @@
 
 declare module 'react-native/Libraries/Core/Devtools/parseErrorStack' {
   export type StackFrame = {
-    file: string;
+    column: number | null | undefined;
+    file: string | null | undefined;
+    lineNumber: number | null | undefined;
     methodName: string;
-    lineNumber: number;
-    column: number | null;
   };
 
-  export interface ExtendedError extends Error {
-    framesToPop?: number | undefined;
-  }
-
-  export default function parseErrorStack(error: ExtendedError): StackFrame[];
+  export default function parseErrorStack(errorStack?: string): StackFrame[];
 }
 
 declare module 'react-native/Libraries/Core/Devtools/symbolicateStackTrace' {
   import {StackFrame} from 'react-native/Libraries/Core/Devtools/parseErrorStack';
 
+  export type CodeFrame = Readonly<{
+    content: string;
+    location:
+      | {
+          row: number;
+          column: number;
+          [key: string]: any;
+        }
+      | null
+      | undefined;
+    fileName: string;
+  }>;
+
+  export type SymbolicatedStackTrace = Readonly<{
+    stack: ReadonlyArray<StackFrame>;
+    codeFrame: CodeFrame | null | undefined;
+  }>;
+
   export default function symbolicateStackTrace(
     stack: ReadonlyArray<StackFrame>,
     extraData?: any,
-  ): Promise<StackFrame[]>;
+  ): Promise<SymbolicatedStackTrace>;
 }

package/Libraries/BugReporting/BugReporting.js

@@ -1,140 +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.
- *
- * @format
- * @flow strict-local
- */
-
-import RCTDeviceEventEmitter from '../EventEmitter/RCTDeviceEventEmitter';
-import NativeRedBox from '../NativeModules/specs/NativeRedBox';
-import {type EventSubscription} from '../vendor/emitter/EventEmitter';
-import NativeBugReporting from './NativeBugReporting';
-
-type ExtraData = {[key: string]: string, ...};
-type SourceCallback = () => string;
-type DebugData = {
-  extras: ExtraData,
-  files: ExtraData,
-  ...
-};
-
-function defaultExtras() {
-  BugReporting.addFileSource('react_hierarchy.txt', () =>
-    require('./dumpReactTree').default(),
-  );
-}
-
-/**
- * A simple class for collecting bug report data. Components can add sources that will be queried when a bug report
- * is created via `collectExtraData`. For example, a list component might add a source that provides the list of rows
- * that are currently visible on screen. Components should also remember to call `remove()` on the object that is
- * returned by `addSource` when they are unmounted.
- */
-class BugReporting {
-  static _extraSources: Map<string, SourceCallback> = new Map();
-  static _fileSources: Map<string, SourceCallback> = new Map();
-  static _subscription: ?EventSubscription = null;
-  static _redboxSubscription: ?EventSubscription = null;
-
-  static _maybeInit() {
-    if (!BugReporting._subscription) {
-      BugReporting._subscription = RCTDeviceEventEmitter.addListener(
-        'collectBugExtraData',
-        // $FlowFixMe[method-unbinding]
-        BugReporting.collectExtraData,
-        null,
-      );
-      defaultExtras();
-    }
-
-    if (!BugReporting._redboxSubscription) {
-      BugReporting._redboxSubscription = RCTDeviceEventEmitter.addListener(
-        'collectRedBoxExtraData',
-        // $FlowFixMe[method-unbinding]
-        BugReporting.collectExtraData,
-        null,
-      );
-    }
-  }
-
-  /**
-   * Maps a string key to a simple callback that should return a string payload to be attached
-   * to a bug report. Source callbacks are called when `collectExtraData` is called.
-   *
-   * Returns an object to remove the source when the component unmounts.
-   *
-   * Conflicts trample with a warning.
-   */
-  static addSource(
-    key: string,
-    callback: SourceCallback,
-  ): {remove: () => void, ...} {
-    return this._addSource(key, callback, BugReporting._extraSources);
-  }
-
-  /**
-   * Maps a string key to a simple callback that should return a string payload to be attached
-   * to a bug report. Source callbacks are called when `collectExtraData` is called.
-   *
-   * Returns an object to remove the source when the component unmounts.
-   *
-   * Conflicts trample with a warning.
-   */
-  static addFileSource(
-    key: string,
-    callback: SourceCallback,
-  ): {remove: () => void, ...} {
-    return this._addSource(key, callback, BugReporting._fileSources);
-  }
-
-  static _addSource(
-    key: string,
-    callback: SourceCallback,
-    source: Map<string, SourceCallback>,
-  ): {remove: () => void, ...} {
-    BugReporting._maybeInit();
-    if (source.has(key)) {
-      console.warn(
-        `BugReporting.add* called multiple times for same key '${key}'`,
-      );
-    }
-    source.set(key, callback);
-    return {
-      remove: () => {
-        source.delete(key);
-      },
-    };
-  }
-
-  /**
-   * This can be called from a native bug reporting flow, or from JS code.
-   *
-   * If available, this will call `NativeModules.BugReporting.setExtraData(extraData)`
-   * after collecting `extraData`.
-   */
-  static collectExtraData(): DebugData {
-    const extraData: ExtraData = {};
-    for (const [key, callback] of BugReporting._extraSources) {
-      extraData[key] = callback();
-    }
-    const fileData: ExtraData = {};
-    for (const [key, callback] of BugReporting._fileSources) {
-      fileData[key] = callback();
-    }
-
-    if (NativeBugReporting != null && NativeBugReporting.setExtraData != null) {
-      NativeBugReporting.setExtraData(extraData, fileData);
-    }
-
-    if (NativeRedBox != null && NativeRedBox.setExtraData != null) {
-      NativeRedBox.setExtraData(extraData, 'From BugReporting.js');
-    }
-
-    return {extras: extraData, files: fileData};
-  }
-}
-
-export default BugReporting;

package/Libraries/BugReporting/NativeBugReporting.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-local
- * @format
- */
-
-export * from '../../src/private/specs_DEPRECATED/modules/NativeBugReporting';
-import NativeBugReporting from '../../src/private/specs_DEPRECATED/modules/NativeBugReporting';
-export default NativeBugReporting;