@office-iss/react-native-win32 0.0.0-canary.270 → 0.0.0-canary.271

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

@@ -0,0 +1,247 @@
+/**
+ * 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,
+  RawPerformanceEntry,
+  ReactNativeStartupTiming,
+  PerformanceObserverInit,
+  OpaqueNativeObserverHandle,
+  RawPerformanceEntryType,
+} 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,
+
+  mark: (name: string, startTime: number): void => {
+    marks.set(name, startTime);
+    reportEntry({
+      entryType: RawPerformanceEntryTypeValues.MARK,
+      name,
+      startTime,
+      duration: 0,
+    });
+  },
+
+  measure: (
+    name: string,
+    startTime: number,
+    endTime: number,
+    duration?: number,
+    startMark?: string,
+    endMark?: string,
+  ): void => {
+    const start = startMark != null ? marks.get(startMark) ?? 0 : startTime;
+    const end = endMark != null ? marks.get(endMark) ?? 0 : endTime;
+    reportEntry({
+      entryType: RawPerformanceEntryTypeValues.MEASURE,
+      name,
+      startTime: start,
+      duration: duration ?? end - start,
+    });
+  },
+
+  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/src-win/Libraries/Components/AccessibilityInfo/AccessibilityInfo.d.ts

@@ -7,8 +7,7 @@
  * @format
  */
 
-import type * as React from 'react';
-import {HostComponent} from '../../../types/public/ReactNativeTypes';
+import {HostInstance} from '../../../types/public/ReactNativeTypes';
 import {EmitterSubscription} from '../../vendor/emitter/EventEmitter';
 
 type AccessibilityChangeEventName =
@@ -17,6 +16,8 @@ type AccessibilityChangeEventName =
   | 'grayscaleChanged' // iOS-only Event
   | 'invertColorsChanged' // iOS-only Event
   | 'reduceMotionChanged'
+  | 'highTextContrastChanged' // Android-only Event
+  | 'darkerSystemColorsChanged' // iOS-only Event
   | 'screenReaderChanged'
   | 'reduceTransparencyChanged'; // iOS-only Event
 
@@ -69,6 +70,21 @@ export interface AccessibilityInfoStatic {
    */
   isReduceMotionEnabled: () => Promise<boolean>;
 
+  /**
+   *
+   * Query whether high text contrast is currently enabled.
+   *
+   * @platform android
+   */
+  isHighTextContrastEnabled: () => Promise<boolean>;
+
+  /**
+   * Query whether darker system colors is currently enabled.
+   *
+   * @platform ios
+   */
+  isDarkerSystemColorsEnabled: () => Promise<boolean>;
+
   /**
    * Query whether reduce motion and prefer cross-fade transitions settings are currently enabled.
    *
@@ -152,7 +168,7 @@ export interface AccessibilityInfoStatic {
    */
   getRecommendedTimeoutMillis: (originalTimeout: number) => Promise<number>;
   sendAccessibilityEvent: (
-    handle: React.ElementRef<HostComponent<unknown>>,
+    handle: HostInstance,
     eventType: AccessibilityEventTypes,
   ) => void;
 }

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;
@@ -122,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`.
  *
@@ -135,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/src/private/webapis/performance/specs/NativePerformanceObserver.js

@@ -1,69 +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 {TurboModule} from '../../../../../Libraries/TurboModule/RCTExport';
-
-import * as TurboModuleRegistry from '../../../../../Libraries/TurboModule/TurboModuleRegistry';
-
-export type RawPerformanceEntryType = number;
-
-export type OpaqueNativeObserverHandle = mixed;
-
-export type NativeBatchedObserverCallback = () => void;
-
-export type RawPerformanceEntry = {|
-  name: string,
-  entryType: RawPerformanceEntryType,
-  startTime: number,
-  duration: number,
-  // For "event" entries only:
-  processingStart?: number,
-  processingEnd?: number,
-  interactionId?: number,
-|};
-
-export type PerformanceObserverInit = {
-  entryTypes?: $ReadOnlyArray<number>,
-  type?: number,
-  buffered?: boolean,
-  durationThreshold?: number,
-};
-
-export interface Spec extends TurboModule {
-  +getEventCounts: () => $ReadOnlyArray<[string, number]>;
-  +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>;
-
-  +clearEntries: (
-    entryType?: RawPerformanceEntryType,
-    entryName?: string,
-  ) => void;
-  +getEntries: (
-    entryType?: RawPerformanceEntryType,
-    entryName?: string,
-  ) => $ReadOnlyArray<RawPerformanceEntry>;
-  +getSupportedPerformanceEntryTypes: () => $ReadOnlyArray<RawPerformanceEntryType>;
-}
-
-export default (TurboModuleRegistry.get<Spec>(
-  'NativePerformanceObserverCxx',
-): ?Spec);

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

@@ -1,69 +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 {
-  NativeMemoryInfo,
-  ReactNativeStartupTiming,
-} from '../NativePerformance';
-
-import {RawPerformanceEntryTypeValues} from '../../RawPerformanceEntry';
-import NativePerformance from '../NativePerformance';
-import {logMockEntry} from './NativePerformanceObserver';
-
-const marks: Map<string, number> = new Map();
-
-const NativePerformanceMock: typeof NativePerformance = {
-  mark: (name: string, startTime: number): void => {
-    NativePerformance?.mark(name, startTime);
-    marks.set(name, startTime);
-    logMockEntry({
-      entryType: RawPerformanceEntryTypeValues.MARK,
-      name,
-      startTime,
-      duration: 0,
-    });
-  },
-
-  measure: (
-    name: string,
-    startTime: number,
-    endTime: number,
-    duration?: number,
-    startMark?: string,
-    endMark?: string,
-  ): void => {
-    const start = startMark != null ? marks.get(startMark) ?? 0 : startTime;
-    const end = endMark != null ? marks.get(endMark) ?? 0 : endTime;
-    NativePerformance?.measure(name, start, end);
-    logMockEntry({
-      entryType: RawPerformanceEntryTypeValues.MEASURE,
-      name,
-      startTime: start,
-      duration: duration ?? end - start,
-    });
-  },
-
-  getSimpleMemoryInfo: (): NativeMemoryInfo => {
-    return {};
-  },
-
-  getReactNativeStartupTiming: (): ReactNativeStartupTiming => {
-    return {
-      startTime: 0,
-      endTime: 0,
-      executeJavaScriptBundleEntryPointStart: 0,
-      executeJavaScriptBundleEntryPointEnd: 0,
-      initializeRuntimeStart: 0,
-      initializeRuntimeEnd: 0,
-    };
-  },
-};
-
-export default NativePerformanceMock;

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

@@ -1,154 +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 {
-  NativeBatchedObserverCallback,
-  RawPerformanceEntry,
-  RawPerformanceEntryType,
-  OpaqueNativeObserverHandle,
-  PerformanceObserverInit,
-  Spec as NativePerformanceObserver,
-} from '../NativePerformanceObserver';
-
-import {RawPerformanceEntryTypeValues} from '../../RawPerformanceEntry';
-
-jest.mock(
-  '../NativePerformance',
-  () => require('../__mocks__/NativePerformance').default,
-);
-
-jest.mock(
-  '../NativePerformanceObserver',
-  () => require('../__mocks__/NativePerformanceObserver').default,
-);
-
-const eventCounts: Map<string, number> = new Map();
-let observers: MockObserver[] = [];
-let entries: Array<RawPerformanceEntry> = [];
-
-export function logMockEntry(entry: RawPerformanceEntry) {
-  entries.push(entry);
-
-  if (entry.entryType === RawPerformanceEntryTypeValues.EVENT) {
-    eventCounts.set(entry.name, (eventCounts.get(entry.name) ?? 0) + 1);
-  }
-
-  for (const observer of observers) {
-    if (
-      observer.options.type !== entry.entryType &&
-      !observer.options.entryTypes?.includes(entry.entryType)
-    ) {
-      continue;
-    }
-
-    if (entry.entryType === RawPerformanceEntryTypeValues.EVENT) {
-      const {durationThreshold = 0} = observer.options;
-      if (durationThreshold > 0 && entry.duration < durationThreshold) {
-        continue;
-      }
-    }
-
-    observer.entries.push(entry);
-
-    // $FlowFixMe[incompatible-call]
-    global.queueMicrotask(() => {
-      // We want to emulate the way it's done in native (i.e. async/batched)
-      observer.callback();
-    });
-  }
-}
-
-type MockObserver = {
-  callback: NativeBatchedObserverCallback,
-  entries: Array<RawPerformanceEntry>,
-  options: PerformanceObserverInit,
-  droppedEntriesCount: number,
-};
-
-const NativePerformanceObserverMock: NativePerformanceObserver = {
-  getEventCounts: (): $ReadOnlyArray<[string, number]> => {
-    return Array.from(eventCounts.entries());
-  },
-
-  createObserver: (
-    callback: NativeBatchedObserverCallback,
-  ): OpaqueNativeObserverHandle => {
-    const observer: MockObserver = {
-      callback,
-      entries: [],
-      options: {},
-      droppedEntriesCount: 0,
-    };
-
-    return observer;
-  },
-
-  getDroppedEntriesCount: (observer: OpaqueNativeObserverHandle): number => {
-    // $FlowFixMe
-    const mockObserver = (observer: any) as MockObserver;
-    return mockObserver.droppedEntriesCount;
-  },
-
-  observe: (
-    observer: OpaqueNativeObserverHandle,
-    options: PerformanceObserverInit,
-  ): void => {
-    // $FlowFixMe
-    const mockObserver = (observer: any) as MockObserver;
-    mockObserver.options = options;
-    observers.push(mockObserver);
-  },
-
-  disconnect: (observer: OpaqueNativeObserverHandle): void => {
-    // $FlowFixMe
-    const mockObserver = (observer: any) as MockObserver;
-    observers = observers.filter(e => e !== mockObserver);
-  },
-
-  takeRecords: (
-    observer: OpaqueNativeObserverHandle,
-  ): $ReadOnlyArray<RawPerformanceEntry> => {
-    // $FlowFixMe
-    const mockObserver = (observer: any) as MockObserver;
-    const observerEntries = mockObserver.entries;
-    mockObserver.entries = [];
-    return observerEntries;
-  },
-
-  clearEntries: (entryType?: RawPerformanceEntryType, entryName?: string) => {
-    entries = entries.filter(
-      e =>
-        (entryType != null && e.entryType !== entryType) ||
-        (entryName != null && e.name !== entryName),
-    );
-  },
-
-  getEntries: (
-    entryType?: RawPerformanceEntryType,
-    entryName?: string,
-  ): $ReadOnlyArray<RawPerformanceEntry> => {
-    return entries.filter(
-      e =>
-        (entryType == null || e.entryType === entryType) &&
-        (entryName == null || e.name === entryName),
-    );
-  },
-
-  getSupportedPerformanceEntryTypes:
-    (): $ReadOnlyArray<RawPerformanceEntryType> => {
-      return [
-        RawPerformanceEntryTypeValues.MARK,
-        RawPerformanceEntryTypeValues.MEASURE,
-        RawPerformanceEntryTypeValues.EVENT,
-      ];
-    },
-};
-
-export default NativePerformanceObserverMock;