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

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

@@ -21,12 +21,13 @@ import {
   rawToPerformanceEntry,
   rawToPerformanceEntryType,
 } from './internals/RawPerformanceEntry';
-import {warnNoNativePerformance} from './internals/Utilities';
-import NativePerformance from './specs/NativePerformance';
+import MaybeNativePerformance from './specs/NativePerformance';
 import nullthrows from 'nullthrows';
 
 export {PerformanceEntry} from './PerformanceEntry';
 
+const NativePerformance = nullthrows(MaybeNativePerformance);
+
 export class PerformanceObserverEntryList {
   #entries: PerformanceEntryList;
 
@@ -75,13 +76,6 @@ export interface PerformanceObserverInit {
 }
 
 function getSupportedPerformanceEntryTypes(): $ReadOnlyArray<PerformanceEntryType> {
-  if (!NativePerformance) {
-    return Object.freeze([]);
-  }
-  if (!NativePerformance.getSupportedPerformanceEntryTypes) {
-    // fallback if getSupportedPerformanceEntryTypes is not defined on native side
-    return Object.freeze(['mark', 'measure', 'event']);
-  }
   return Object.freeze(
     NativePerformance.getSupportedPerformanceEntryTypes().map(
       rawToPerformanceEntryType,
@@ -120,11 +114,6 @@ export class PerformanceObserver {
   }
 
   observe(options: PerformanceObserverInit): void {
-    if (!NativePerformance || NativePerformance.observe == null) {
-      warnNoNativePerformance();
-      return;
-    }
-
     this.#validateObserveOptions(options);
 
     if (this.#nativeObserverHandle == null) {
@@ -135,12 +124,12 @@ export class PerformanceObserver {
 
     if (options.entryTypes) {
       this.#type = 'multiple';
-      NativePerformance.observe?.(observerHandle, {
+      NativePerformance.observe(observerHandle, {
         entryTypes: options.entryTypes.map(performanceEntryTypeToRaw),
       });
     } else if (options.type) {
       this.#type = 'single';
-      NativePerformance.observe?.(observerHandle, {
+      NativePerformance.observe(observerHandle, {
         type: performanceEntryTypeToRaw(options.type),
         buffered: options.buffered,
         durationThreshold: options.durationThreshold,
@@ -149,12 +138,7 @@ export class PerformanceObserver {
   }
 
   disconnect(): void {
-    if (!NativePerformance) {
-      warnNoNativePerformance();
-      return;
-    }
-
-    if (this.#nativeObserverHandle == null || !NativePerformance.disconnect) {
+    if (this.#nativeObserverHandle == null) {
       return;
     }
 
@@ -162,16 +146,11 @@ export class PerformanceObserver {
   }
 
   #createNativeObserver(): OpaqueNativeObserverHandle | null {
-    if (!NativePerformance || !NativePerformance.createObserver) {
-      warnNoNativePerformance();
-      return null;
-    }
-
     this.#calledAtLeastOnce = false;
 
     const observerHandle: OpaqueNativeObserverHandle =
       NativePerformance.createObserver(() => {
-        const rawEntries = NativePerformance.takeRecords?.(
+        const rawEntries = NativePerformance.takeRecords(
           observerHandle,
           true, // sort records
         );
@@ -185,7 +164,7 @@ export class PerformanceObserver {
         let droppedEntriesCount = 0;
         if (!this.#calledAtLeastOnce) {
           droppedEntriesCount =
-            NativePerformance.getDroppedEntriesCount?.(observerHandle) ?? 0;
+            NativePerformance.getDroppedEntriesCount(observerHandle);
           this.#calledAtLeastOnce = true;
         }
 

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

@@ -11,45 +11,52 @@
 // flowlint unsafe-getters-setters:off
 
 import type {DOMHighResTimeStamp} from './PerformanceEntry';
+import type {
+  ExtensionMarkerPayload,
+  ExtensionTrackEntryPayload,
+} from './UserTimingExtensibility';
 
+import {getCurrentTimeStamp} from './internals/Utilities';
 import {PerformanceEntry} from './PerformanceEntry';
 
-export type DetailType = mixed;
+export type DetailType =
+  | mixed
+  // This will effectively ignored by Flow (mixed | anything = mixed)
+  // but we'll use it as documentation for how to use the extensibility API.
+  | {devtools?: ExtensionMarkerPayload | ExtensionTrackEntryPayload, ...};
 
-export type PerformanceMarkOptions = {
+export type PerformanceMarkOptions = $ReadOnly<{
   detail?: DetailType,
   startTime?: DOMHighResTimeStamp,
-};
+}>;
 
 export type TimeStampOrName = DOMHighResTimeStamp | string;
 
-export type PerformanceMeasureInit = {
+export type PerformanceMeasureInit = $ReadOnly<{
   detail?: DetailType,
   startTime: DOMHighResTimeStamp,
   duration: DOMHighResTimeStamp,
-};
+}>;
 
 class PerformanceMarkTemplate extends PerformanceEntry {
   // We don't use private fields because they're significantly slower to
   // initialize on construction and to access.
-  _detail: DetailType;
+  __detail: DetailType;
 
   // This constructor isn't really used. See `PerformanceMark` below.
   constructor(markName: string, markOptions?: PerformanceMarkOptions) {
     super({
       name: markName,
       entryType: 'mark',
-      startTime: markOptions?.startTime ?? performance.now(),
+      startTime: markOptions?.startTime ?? getCurrentTimeStamp(),
       duration: 0,
     });
 
-    if (markOptions) {
-      this._detail = markOptions.detail;
-    }
+    this.__detail = markOptions?.detail ?? null;
   }
 
   get detail(): DetailType {
-    return this._detail;
+    return this.__detail;
   }
 }
 
@@ -67,12 +74,10 @@ export const PerformanceMark: typeof PerformanceMarkTemplate =
   ) {
     this.__name = markName;
     this.__entryType = 'mark';
-    this.__startTime = markOptions?.startTime ?? performance.now();
+    this.__startTime = markOptions?.startTime ?? getCurrentTimeStamp();
     this.__duration = 0;
 
-    if (markOptions) {
-      this._detail = markOptions.detail;
-    }
+    this.__detail = markOptions?.detail ?? null;
   };
 
 // $FlowExpectedError[prop-missing]
@@ -81,7 +86,7 @@ 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;
+  __detail: DetailType;
 
   // This constructor isn't really used. See `PerformanceMeasure` below.
   constructor(measureName: string, measureOptions: PerformanceMeasureInit) {
@@ -92,13 +97,11 @@ class PerformanceMeasureTemplate extends PerformanceEntry {
       duration: measureOptions.duration,
     });
 
-    if (measureOptions) {
-      this._detail = measureOptions.detail;
-    }
+    this.__detail = measureOptions?.detail ?? null;
   }
 
   get detail(): DetailType {
-    return this._detail;
+    return this.__detail;
   }
 }
 
@@ -115,9 +118,7 @@ export const PerformanceMeasure: typeof PerformanceMeasureTemplate =
     this.__startTime = measureOptions.startTime;
     this.__duration = measureOptions.duration;
 
-    if (measureOptions) {
-      this._detail = measureOptions.detail;
-    }
+    this.__detail = measureOptions.detail ?? null;
   };
 
 // $FlowExpectedError[prop-missing]

package/src/private/webapis/performance/UserTimingExtensibility.js.flow

@@ -0,0 +1,38 @@
+/**
+ * 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 type DevToolsColor =
+  | 'primary'
+  | 'primary-light'
+  | 'primary-dark'
+  | 'secondary'
+  | 'secondary-light'
+  | 'secondary-dark'
+  | 'tertiary'
+  | 'tertiary-light'
+  | 'tertiary-dark'
+  | 'warning'
+  | 'error';
+
+export interface ExtensionTrackEntryPayload {
+  dataType?: 'track-entry'; // Defaults to "track-entry"
+  color?: DevToolsColor; // Defaults to "primary"
+  track: string; // Required: Name of the custom track
+  trackGroup?: string; // Optional: Group for organizing tracks
+  properties?: Array<[string, string]>; // Key-value pairs for detailed view
+  tooltipText?: string; // Short description for tooltip
+}
+
+export interface ExtensionMarkerPayload {
+  dataType: 'marker'; // Required: Identifies as a marker
+  color?: DevToolsColor; // Defaults to "primary"
+  properties?: Array<[string, string]>; // Key-value pairs for detailed view
+  tooltipText?: string; // Short description for tooltip
+}

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

@@ -9,6 +9,7 @@
  */
 
 import warnOnce from '../../../../../Libraries/Utilities/warnOnce';
+import NativePerformance from '../specs/NativePerformance';
 
 export function warnNoNativePerformance() {
   warnOnce(
@@ -16,3 +17,11 @@ export function warnNoNativePerformance() {
     'Missing native implementation of Performance',
   );
 }
+
+declare var global: {
+  // This value is defined directly via JSI, if available.
+  +nativePerformanceNow?: ?() => number,
+};
+
+export const getCurrentTimeStamp: () => DOMHighResTimeStamp =
+  NativePerformance?.now ?? global.nativePerformanceNow ?? (() => Date.now());

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

@@ -53,60 +53,46 @@ export type PerformanceObserverInit = {
 };
 
 export interface Spec extends TurboModule {
-  +now?: () => number;
-  +markWithResult?: (
-    name: string,
-    startTime?: number,
-  ) => NativePerformanceMarkResult;
-  +measure?: (
-    name: string,
-    startTime?: number,
-    endTime?: number,
-    duration?: number,
-    startMark?: string,
-    endMark?: string,
-  ) => NativePerformanceMeasureResult;
-  // DEPRECATED: Use measure instead.
-  +measureWithResult?: (
+  +now: () => number;
+  +reportMark?: (name: string, startTime: number, entry: mixed) => void;
+  +reportMeasure?: (
     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?: (
+    duration: number,
+    entry: mixed,
+  ) => void;
+  +getMarkTime?: (name: string) => ?number;
+  +clearMarks: (entryName?: string) => void;
+  +clearMeasures: (entryName?: string) => void;
+  +getEntries: () => $ReadOnlyArray<RawPerformanceEntry>;
+  +getEntriesByName: (
     entryName: string,
     entryType?: ?RawPerformanceEntryType,
   ) => $ReadOnlyArray<RawPerformanceEntry>;
-  +getEntriesByType?: (
+  +getEntriesByType: (
     entryType: RawPerformanceEntryType,
   ) => $ReadOnlyArray<RawPerformanceEntry>;
-  +getEventCounts?: () => $ReadOnlyArray<[string, number]>;
+  +getEventCounts: () => $ReadOnlyArray<[string, number]>;
   +getSimpleMemoryInfo: () => NativeMemoryInfo;
   +getReactNativeStartupTiming: () => ReactNativeStartupTiming;
 
-  +createObserver?: (
+  +createObserver: (
     callback: NativeBatchedObserverCallback,
   ) => OpaqueNativeObserverHandle;
-  +getDroppedEntriesCount?: (observer: OpaqueNativeObserverHandle) => number;
+  +getDroppedEntriesCount: (observer: OpaqueNativeObserverHandle) => number;
 
-  +observe?: (
+  +observe: (
     observer: OpaqueNativeObserverHandle,
     options: PerformanceObserverInit,
   ) => void;
-  +disconnect?: (observer: OpaqueNativeObserverHandle) => void;
-  +takeRecords?: (
+  +disconnect: (observer: OpaqueNativeObserverHandle) => void;
+  +takeRecords: (
     observer: OpaqueNativeObserverHandle,
     sort: boolean,
   ) => $ReadOnlyArray<RawPerformanceEntry>;
 
-  +getSupportedPerformanceEntryTypes?: () => $ReadOnlyArray<RawPerformanceEntryType>;
+  +getSupportedPerformanceEntryTypes: () => $ReadOnlyArray<RawPerformanceEntryType>;
 
-  +setCurrentTimeStampForTesting?: (timeStamp: number) => void;
   +clearEventCountsForTesting?: () => void;
 }
 

package/src/private/webapis/structuredClone/structuredClone.js

@@ -79,7 +79,7 @@ function structuredCloneInternal<T>(value: T): T {
   }
 
   // Simple object fast path
-  // $FlowIssue[prop-missing] Why doesn't Flow know about Object.prototype?
+  // $FlowFixMe[prop-missing] Why doesn't Flow know about Object.prototype?
   if (Object.getPrototypeOf(value) === ObjectPrototype) {
     const result = {};
     memory.set(value, result);

package/Libraries/Interaction/InteractionManagerStub.js

@@ -1,184 +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
- */
-
-import type {EventSubscription} from '../vendor/emitter/EventEmitter';
-
-const invariant = require('invariant');
-
-export type Handle = number;
-
-type Task =
-  | {
-      name: string,
-      run: () => void,
-    }
-  | {
-      name: string,
-      gen: () => Promise<void>,
-    }
-  | (() => void);
-
-// NOTE: The original implementation of `InteractionManager` never rejected
-// the returned promise. This preserves that behavior in the stub.
-function reject(error: Error): void {
-  setTimeout(() => {
-    throw error;
-  }, 0);
-}
-
-/**
- * InteractionManager allows long-running work to be scheduled after any
- * interactions/animations have completed. In particular, this allows JavaScript
- * animations to run smoothly.
- *
- * Applications can schedule tasks to run after interactions with the following:
- *
- * ```
- * InteractionManager.runAfterInteractions(() => {
- *   // ...long-running synchronous task...
- * });
- * ```
- *
- * Compare this to other scheduling alternatives:
- *
- * - requestAnimationFrame(): for code that animates a view over time.
- * - setImmediate/setTimeout(): run code later, note this may delay animations.
- * - runAfterInteractions(): run code later, without delaying active animations.
- *
- * The touch handling system considers one or more active touches to be an
- * 'interaction' and will delay `runAfterInteractions()` callbacks until all
- * touches have ended or been cancelled.
- *
- * InteractionManager also allows applications to register animations by
- * creating an interaction 'handle' on animation start, and clearing it upon
- * completion:
- *
- * ```
- * var handle = InteractionManager.createInteractionHandle();
- * // run animation... (`runAfterInteractions` tasks are queued)
- * // later, on animation completion:
- * InteractionManager.clearInteractionHandle(handle);
- * // queued tasks run if all handles were cleared
- * ```
- *
- * `runAfterInteractions` takes either a plain callback function, or a
- * `PromiseTask` object with a `gen` method that returns a `Promise`.  If a
- * `PromiseTask` is supplied, then it is fully resolved (including asynchronous
- * dependencies that also schedule more tasks via `runAfterInteractions`) before
- * starting on the next task that might have been queued up synchronously
- * earlier.
- *
- * By default, queued tasks are executed together in a loop in one
- * `setImmediate` batch. If `setDeadline` is called with a positive number, then
- * tasks will only be executed until the deadline (in terms of js event loop run
- * time) approaches, at which point execution will yield via setTimeout,
- * allowing events such as touches to start interactions and block queued tasks
- * from executing, making apps more responsive.
- *
- * @deprecated
- */
-const InteractionManagerStub = {
-  Events: {
-    interactionStart: 'interactionStart',
-    interactionComplete: 'interactionComplete',
-  },
-
-  /**
-   * Schedule a function to run after all interactions have completed. Returns a cancellable
-   * "promise".
-   *
-   * @deprecated
-   */
-  runAfterInteractions(task: ?Task): {
-    then: <U>(
-      onFulfill?: ?(void) => ?(Promise<U> | U),
-      onReject?: ?(error: mixed) => ?(Promise<U> | U),
-    ) => Promise<U>,
-    cancel: () => void,
-    ...
-  } {
-    let immediateID: ?$FlowIssue;
-    const promise = new Promise(resolve => {
-      immediateID = setImmediate(() => {
-        if (typeof task === 'object' && task !== null) {
-          if (typeof task.gen === 'function') {
-            task.gen().then(resolve, reject);
-          } else if (typeof task.run === 'function') {
-            try {
-              task.run();
-              resolve();
-            } catch (error) {
-              reject(error);
-            }
-          } else {
-            reject(new TypeError(`Task "${task.name}" missing gen or run.`));
-          }
-        } else if (typeof task === 'function') {
-          try {
-            task();
-            resolve();
-          } catch (error) {
-            reject(error);
-          }
-        } else {
-          reject(new TypeError('Invalid task of type: ' + typeof task));
-        }
-      });
-    });
-
-    return {
-      // $FlowFixMe[method-unbinding] added when improving typing for this parameters
-      then: promise.then.bind(promise),
-      cancel() {
-        clearImmediate(immediateID);
-      },
-    };
-  },
-
-  /**
-   * Notify manager that an interaction has started.
-   *
-   * @deprecated
-   */
-  createInteractionHandle(): Handle {
-    return -1;
-  },
-
-  /**
-   * Notify manager that an interaction has completed.
-   *
-   * @deprecated
-   */
-  clearInteractionHandle(handle: Handle) {
-    invariant(!!handle, 'InteractionManager: Must provide a handle to clear.');
-  },
-
-  /**
-   * @deprecated
-   */
-  addListener(): EventSubscription {
-    return {
-      remove() {},
-    };
-  },
-
-  /**
-   * A positive number will use setTimeout to schedule any tasks after the
-   * eventLoopRunningTime hits the deadline value, otherwise all tasks will be
-   * executed in one setImmediate batch (default).
-   *
-   * @deprecated
-   */
-  setDeadline(deadline: number) {
-    // Do nothing.
-  },
-};
-
-export default InteractionManagerStub;