react-native-windows 0.70.9 → 0.71.0-preview.2

package/Libraries/Utilities/Platform.windows.js

@@ -8,10 +8,10 @@
 
 import NativePlatformConstantsWin from './NativePlatformConstantsWin';
 
-export type PlatformSelectSpec<A, N, D> = {
-  windows?: A,
-  native?: N,
-  default?: D,
+export type PlatformSelectSpec<T> = {
+  windows?: T,
+  native?: T,
+  default?: T,
   ...
 };
 
@@ -20,6 +20,7 @@ const Platform = {
   OS: 'windows',
   // $FlowFixMe[unsafe-getters-setters]
   get Version(): number {
+    // $FlowFixMe[object-this-reference]
     return this.constants.osVersion;
   },
   // $FlowFixMe[unsafe-getters-setters]
@@ -33,23 +34,28 @@ const Platform = {
     |},
     osVersion: number,
   |} {
+    // $FlowFixMe[object-this-reference]
     if (this.__constants == null) {
+      // $FlowFixMe[object-this-reference]
       this.__constants = NativePlatformConstantsWin.getConstants();
     }
+    // $FlowFixMe[object-this-reference]
     return this.__constants;
   },
   // $FlowFixMe[unsafe-getters-setters]
   get isTesting(): boolean {
     if (__DEV__) {
+      // $FlowFixMe[object-this-reference]
       return this.constants.isTesting;
     }
     return false;
   },
   // $FlowFixMe[unsafe-getters-setters]
   get isTV(): boolean {
+    // $FlowFixMe[object-this-reference]
     return false;
   },
-  select: <A, N, D>(spec: PlatformSelectSpec<A, N, D>): A | N | D =>
+  select: <T>(spec: PlatformSelectSpec<T>): T =>
     'windows' in spec
       ? // $FlowFixMe[incompatible-return]
         spec.windows

package/Libraries/Utilities/PolyfillFunctions.js

@@ -30,7 +30,7 @@ function polyfillObjectProperty<T>(
   name: string,
   getValue: () => T,
 ): void {
-  const descriptor = Object.getOwnPropertyDescriptor(object, name);
+  const descriptor = Object.getOwnPropertyDescriptor<$FlowFixMe>(object, name);
   if (__DEV__ && descriptor) {
     const backupName = `original${name[0].toUpperCase()}${name.substr(1)}`;
     Object.defineProperty(object, backupName, descriptor);

package/Libraries/Utilities/ReactNativeTestTools.js

@@ -10,22 +10,24 @@
 
 /* eslint-env jest */
 
-const React = require('react');
+import type {ReactTestRenderer as ReactTestRendererType} from 'react-test-renderer';
 
-const ReactTestRenderer = require('react-test-renderer');
+const Switch = require('../Components/Switch/Switch').default;
+const TextInput = require('../Components/TextInput/TextInput');
+const View = require('../Components/View/View');
+const VirtualizedList = require('../Lists/VirtualizedList').default;
+const Text = require('../Text/Text');
+const React = require('react');
 const ShallowRenderer = require('react-shallow-renderer');
+const ReactTestRenderer = require('react-test-renderer');
+
 /* $FlowFixMe[not-a-function] (>=0.125.1 site=react_native_fb) This comment
  * suppresses an error found when Flow v0.125.1 was deployed. To see the error,
  * delete this comment and run Flow. */
 // $FlowFixMe[invalid-constructor]
 const shallowRenderer = new ShallowRenderer();
-
-import type {ReactTestRenderer as ReactTestRendererType} from 'react-test-renderer';
-
 export type ReactTestInstance = $PropertyType<ReactTestRendererType, 'root'>;
-
 export type Predicate = (node: ReactTestInstance) => boolean;
-
 type $ReturnType<Fn> = $Call<<Ret, A>((...A) => Ret) => Ret, Fn>;
 /* $FlowFixMe[value-as-type] (>=0.125.1 site=react_native_fb) This comment
  * suppresses an error found when Flow v0.125.1 was deployed. To see the error,
@@ -36,14 +38,6 @@ export type ReactTestRendererJSON =
    * delete this comment and run Flow. */
   $ReturnType<ReactTestRenderer.create.toJSON>;
 
-const {
-  Switch,
-  Text,
-  TextInput,
-  View,
-  VirtualizedList,
-} = require('react-native');
-
 function byClickable(): Predicate {
   return withMessage(
     node =>

package/Libraries/Utilities/codegenNativeCommands.js

@@ -8,16 +8,7 @@
  * @flow
  */
 
-let dispatchCommand;
-if (global.RN$Bridgeless) {
-  // Note: this function has the same implementation in the legacy and new renderer.
-  // However, evaluating the old renderer comes with some side effects.
-  dispatchCommand =
-    require('../../Libraries/Renderer/shims/ReactFabric').dispatchCommand;
-} else {
-  dispatchCommand =
-    require('../../Libraries/Renderer/shims/ReactNative').dispatchCommand;
-}
+const {dispatchCommand} = require('../ReactNative/RendererProxy');
 
 type Options<T = string> = $ReadOnly<{|
   supportedCommands: $ReadOnlyArray<T>,

package/Libraries/Utilities/codegenNativeComponent.js

@@ -10,8 +10,9 @@
 
 // TODO: move this file to shims/ReactNative (requires React update and sync)
 
-import requireNativeComponent from '../../Libraries/ReactNative/requireNativeComponent';
 import type {HostComponent} from '../../Libraries/Renderer/shims/ReactNativeTypes';
+
+import requireNativeComponent from '../../Libraries/ReactNative/requireNativeComponent';
 import UIManager from '../ReactNative/UIManager';
 
 // TODO: import from CodegenSchema once workspaces are enabled
@@ -54,6 +55,7 @@ function codegenNativeComponent<Props>(
       options.paperComponentNameDeprecated != null &&
       UIManager.hasViewManagerConfig(options.paperComponentNameDeprecated)
     ) {
+      // $FlowFixMe[incompatible-type]
       componentNameInUse = options.paperComponentNameDeprecated;
     } else {
       throw new Error(
@@ -65,6 +67,7 @@ function codegenNativeComponent<Props>(
   }
 
   return (requireNativeComponent<Props>(
+    // $FlowFixMe[incompatible-call]
     componentNameInUse,
   ): HostComponent<Props>);
 }

package/Libraries/Utilities/createPerformanceLogger.js

@@ -9,7 +9,6 @@
  */
 
 const Systrace = require('../Performance/Systrace');
-
 const infoLog = require('./infoLog');
 
 export type Timespan = {
@@ -137,31 +136,31 @@ class PerformanceLogger implements IPerformanceLogger {
     this._closed = true;
   }
 
-  currentTimestamp() {
+  currentTimestamp(): number {
     return getCurrentTimestamp();
   }
 
-  getExtras() {
+  getExtras(): {[key: string]: ?ExtraValue} {
     return this._extras;
   }
 
-  getPoints() {
+  getPoints(): {[key: string]: ?number} {
     return this._points;
   }
 
-  getPointExtras() {
+  getPointExtras(): {[key: string]: ?Extras} {
     return this._pointExtras;
   }
 
-  getTimespans() {
+  getTimespans(): {[key: string]: ?Timespan} {
     return this._timespans;
   }
 
-  hasTimespan(key: string) {
+  hasTimespan(key: string): boolean {
     return !!this._timespans[key];
   }
 
-  isClosed() {
+  isClosed(): boolean {
     return this._closed;
   }
 

package/Libraries/Utilities/differ/deepDiffer.js

@@ -97,5 +97,5 @@ const deepDiffer = function (
   return false;
 };
 
+deepDiffer.unstable_setLogListeners = unstable_setLogListeners;
 module.exports = deepDiffer;
-module.exports.unstable_setLogListeners = unstable_setLogListeners;

package/Libraries/Utilities/groupByEveryN.js

@@ -28,7 +28,7 @@
 
 function groupByEveryN<T>(array: Array<T>, n: number): Array<Array<?T>> {
   const result = [];
-  let temp = [];
+  let temp: Array<?T> = [];
 
   for (let i = 0; i < array.length; ++i) {
     if (i > 0 && i % n === 0) {

package/Libraries/Utilities/stringifySafe.js

@@ -26,7 +26,9 @@ export function createStringifySafeWithLimits(limits: {|
     maxArrayLimit = Number.POSITIVE_INFINITY,
     maxObjectKeysLimit = Number.POSITIVE_INFINITY,
   } = limits;
-  const stack = [];
+  const stack: Array<
+    string | {+[string]: mixed} | {'...(truncated keys)...': number},
+  > = [];
   /* $FlowFixMe[missing-this-annot] The 'this' type annotation(s) required by
    * Flow's LTI update could not be added via codemod */
   function replacer(key: string, value: mixed): mixed {

package/Libraries/Utilities/useColorScheme.js

@@ -10,10 +10,11 @@
 
 'use strict';
 
-import {useSyncExternalStore} from 'use-sync-external-store/shim';
-import Appearance from './Appearance';
 import type {ColorSchemeName} from './NativeAppearance';
 
+import Appearance from './Appearance';
+import {useSyncExternalStore} from 'use-sync-external-store/shim';
+
 export default function useColorScheme(): ?ColorSchemeName {
   return useSyncExternalStore(
     callback => {

package/Libraries/Utilities/useRefEffect.js

@@ -31,7 +31,7 @@ export default function useRefEffect<TInstance>(
 ): CallbackRef<TInstance | null> {
   const cleanupRef = useRef<(() => void) | void>(undefined);
   return useCallback(
-    instance => {
+    (instance: null | TInstance) => {
       if (cleanupRef.current) {
         cleanupRef.current();
         cleanupRef.current = undefined;

package/Libraries/Vibration/NativeVibration.js

@@ -9,6 +9,7 @@
  */
 
 import type {TurboModule} from '../TurboModule/RCTExport';
+
 import * as TurboModuleRegistry from '../TurboModule/TurboModuleRegistry';
 
 export interface Spec extends TurboModule {

package/Libraries/Vibration/Vibration.d.ts

@@ -0,0 +1,43 @@
+/**
+ * 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
+ */
+
+/**
+ * The Vibration API is exposed at `Vibration.vibrate()`.
+ * The vibration is asynchronous so this method will return immediately.
+ *
+ * There will be no effect on devices that do not support Vibration, eg. the simulator.
+ *
+ * **Note for android**
+ * add `<uses-permission android:name="android.permission.VIBRATE"/>` to `AndroidManifest.xml`
+ *
+ * **Android Usage:**
+ *
+ * [0, 500, 200, 500]
+ * V(0.5s) --wait(0.2s)--> V(0.5s)
+ *
+ * [300, 500, 200, 500]
+ * --wait(0.3s)--> V(0.5s) --wait(0.2s)--> V(0.5s)
+ *
+ * **iOS Usage:**
+ * if first argument is 0, it will not be included in pattern array.
+ *
+ * [0, 1000, 2000, 3000]
+ * V(fixed) --wait(1s)--> V(fixed) --wait(2s)--> V(fixed) --wait(3s)--> V(fixed)
+ */
+export interface VibrationStatic {
+  vibrate(pattern?: number | number[] | null, repeat?: boolean | null): void;
+
+  /**
+   * Stop vibration
+   */
+  cancel(): void;
+}
+
+export const Vibration: VibrationStatic;
+export type Vibration = VibrationStatic;

package/Libraries/Vibration/Vibration.js

@@ -10,6 +10,7 @@
  */
 
 import NativeVibration from './NativeVibration';
+
 const Platform = require('../Utilities/Platform');
 
 /**

package/Libraries/WebPerformance/NativePerformanceObserver.js

@@ -0,0 +1,41 @@
+/**
+ * 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 '../TurboModule/RCTExport';
+
+import * as TurboModuleRegistry from '../TurboModule/TurboModuleRegistry';
+
+export const RawPerformanceEntryTypeValues = {
+  UNDEFINED: 0,
+};
+
+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 interface Spec extends TurboModule {
+  +startReporting: (entryType: string) => void;
+  +stopReporting: (entryType: string) => void;
+  +getPendingEntries: () => $ReadOnlyArray<RawPerformanceEntry>;
+  +setOnPerformanceEntryCallback: (callback?: () => void) => void;
+}
+
+export default (TurboModuleRegistry.get<Spec>(
+  'NativePerformanceObserverCxx',
+): ?Spec);

package/Libraries/WebPerformance/PerformanceObserver.js

@@ -0,0 +1,223 @@
+/**
+ * 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 type {
+  RawPerformanceEntry,
+  RawPerformanceEntryType,
+} from './NativePerformanceObserver';
+
+import warnOnce from '../Utilities/warnOnce';
+import NativePerformanceObserver from './NativePerformanceObserver';
+
+export type HighResTimeStamp = number;
+// TODO: Extend once new types (such as event) are supported.
+// TODO: Get rid of the "undefined" once there is at least one type supported.
+export type PerformanceEntryType = 'undefined';
+
+export class PerformanceEntry {
+  name: string;
+  entryType: PerformanceEntryType;
+  startTime: HighResTimeStamp;
+  duration: number;
+
+  constructor(init: {
+    name: string,
+    entryType: PerformanceEntryType,
+    startTime: HighResTimeStamp,
+    duration: number,
+  }) {
+    this.name = init.name;
+    this.entryType = init.entryType;
+    this.startTime = init.startTime;
+    this.duration = init.duration;
+  }
+
+  // $FlowIgnore: Flow(unclear-type)
+  toJSON(): Object {
+    return {
+      name: this.name,
+      entryType: this.entryType,
+      startTime: this.startTime,
+      duration: this.duration,
+    };
+  }
+}
+
+function rawToPerformanceEntryType(
+  type: RawPerformanceEntryType,
+): PerformanceEntryType {
+  return 'undefined';
+}
+
+function rawToPerformanceEntry(entry: RawPerformanceEntry): PerformanceEntry {
+  return new PerformanceEntry({
+    name: entry.name,
+    entryType: rawToPerformanceEntryType(entry.entryType),
+    startTime: entry.startTime,
+    duration: entry.duration,
+  });
+}
+
+export type PerformanceEntryList = $ReadOnlyArray<PerformanceEntry>;
+
+export class PerformanceObserverEntryList {
+  _entries: PerformanceEntryList;
+
+  constructor(entries: PerformanceEntryList) {
+    this._entries = entries;
+  }
+
+  getEntries(): PerformanceEntryList {
+    return this._entries;
+  }
+
+  getEntriesByType(type: PerformanceEntryType): PerformanceEntryList {
+    return this._entries.filter(entry => entry.entryType === type);
+  }
+
+  getEntriesByName(
+    name: string,
+    type?: PerformanceEntryType,
+  ): PerformanceEntryList {
+    if (type === undefined) {
+      return this._entries.filter(entry => entry.name === name);
+    } else {
+      return this._entries.filter(
+        entry => entry.name === name && entry.entryType === type,
+      );
+    }
+  }
+}
+
+export type PerformanceObserverCallback = (
+  list: PerformanceObserverEntryList,
+  observer: PerformanceObserver,
+) => void;
+
+export type PerformanceObserverInit =
+  | {
+      entryTypes: Array<PerformanceEntryType>,
+    }
+  | {
+      type: PerformanceEntryType,
+    };
+
+let _observedEntryTypeRefCount: Map<PerformanceEntryType, number> = new Map();
+
+let _observers: Set<PerformanceObserver> = new Set();
+
+let _onPerformanceEntryCallbackIsSet: boolean = false;
+
+function warnNoNativePerformanceObserver() {
+  warnOnce(
+    'missing-native-performance-observer',
+    'Missing native implementation of PerformanceObserver',
+  );
+}
+
+/**
+ * Implementation of the PerformanceObserver interface for RN,
+ * corresponding to the standard in https://www.w3.org/TR/performance-timeline/
+ *
+ * @example
+ * const observer = new PerformanceObserver((list, _observer) => {
+ *   const entries = list.getEntries();
+ *   entries.forEach(entry => {
+ *     reportEvent({
+ *       eventName: entry.name,
+ *       startTime: entry.startTime,
+ *       endTime: entry.startTime + entry.duration,
+ *       processingStart: entry.processingStart,
+ *       processingEnd: entry.processingEnd,
+ *       interactionId: entry.interactionId,
+ *     });
+ *   });
+ * });
+ * observer.observe({ type: "event" });
+ */
+export default class PerformanceObserver {
+  _callback: PerformanceObserverCallback;
+  _entryTypes: $ReadOnlySet<PerformanceEntryType>;
+
+  constructor(callback: PerformanceObserverCallback) {
+    this._callback = callback;
+  }
+
+  observe(options: PerformanceObserverInit) {
+    if (!NativePerformanceObserver) {
+      warnNoNativePerformanceObserver();
+      return;
+    }
+    if (!_onPerformanceEntryCallbackIsSet) {
+      NativePerformanceObserver.setOnPerformanceEntryCallback(
+        onPerformanceEntry,
+      );
+      _onPerformanceEntryCallbackIsSet = true;
+    }
+    if (options.entryTypes) {
+      this._entryTypes = new Set(options.entryTypes);
+    } else {
+      this._entryTypes = new Set([options.type]);
+    }
+    this._entryTypes.forEach(type => {
+      if (!_observedEntryTypeRefCount.has(type)) {
+        NativePerformanceObserver.startReporting(type);
+      }
+      _observedEntryTypeRefCount.set(
+        type,
+        (_observedEntryTypeRefCount.get(type) ?? 0) + 1,
+      );
+    });
+    _observers.add(this);
+  }
+
+  disconnect(): void {
+    if (!NativePerformanceObserver) {
+      warnNoNativePerformanceObserver();
+      return;
+    }
+    this._entryTypes.forEach(type => {
+      const entryTypeRefCount = _observedEntryTypeRefCount.get(type) ?? 0;
+      if (entryTypeRefCount === 1) {
+        _observedEntryTypeRefCount.delete(type);
+        NativePerformanceObserver.stopReporting(type);
+      } else if (entryTypeRefCount !== 0) {
+        _observedEntryTypeRefCount.set(type, entryTypeRefCount - 1);
+      }
+    });
+    _observers.delete(this);
+    if (_observers.size === 0) {
+      NativePerformanceObserver.setOnPerformanceEntryCallback(undefined);
+      _onPerformanceEntryCallbackIsSet = false;
+    }
+  }
+
+  static supportedEntryTypes: $ReadOnlyArray<PerformanceEntryType> =
+    // TODO: add types once they are fully supported
+    Object.freeze([]);
+}
+
+// This is a callback that gets scheduled and periodically called from the native side
+function onPerformanceEntry() {
+  if (!NativePerformanceObserver) {
+    return;
+  }
+  const rawEntries = NativePerformanceObserver.getPendingEntries();
+  const entries = rawEntries.map(rawToPerformanceEntry);
+  _observers.forEach(observer => {
+    const entriesForObserver: PerformanceEntryList = entries.filter(entry =>
+      observer._entryTypes.has(entry.entryType),
+    );
+    observer._callback(
+      new PerformanceObserverEntryList(entriesForObserver),
+      observer,
+    );
+  });
+}

package/Libraries/WebSocket/NativeWebSocketModule.js

@@ -9,6 +9,7 @@
  */
 
 import type {TurboModule} from '../TurboModule/RCTExport';
+
 import * as TurboModuleRegistry from '../TurboModule/TurboModuleRegistry';
 
 export interface Spec extends TurboModule {

package/Libraries/WebSocket/WebSocket.js

@@ -8,13 +8,14 @@
  * @flow
  */
 
-import Blob from '../Blob/Blob';
 import type {BlobData} from '../Blob/BlobTypes';
+import type {EventSubscription} from '../vendor/emitter/EventEmitter';
+
+import Blob from '../Blob/Blob';
 import BlobManager from '../Blob/BlobManager';
 import NativeEventEmitter from '../EventEmitter/NativeEventEmitter';
 import binaryToBase64 from '../Utilities/binaryToBase64';
 import Platform from '../Utilities/Platform';
-import type {EventSubscription} from '../vendor/emitter/EventEmitter';
 import NativeWebSocketModule from './NativeWebSocketModule';
 import WebSocketEvent from './WebSocketEvent';
 import base64 from 'base64-js';
@@ -42,6 +43,10 @@ const CLOSED = 3;
 
 const CLOSE_NORMAL = 1000;
 
+// Abnormal closure where no code is provided in a control frame
+// https://www.rfc-editor.org/rfc/rfc6455.html#section-7.1.5
+const CLOSE_ABNORMAL = 1006;
+
 const WEBSOCKET_EVENTS = ['close', 'error', 'message', 'open'];
 
 let nextWebSocketId = 0;
@@ -259,6 +264,7 @@ class WebSocket extends (EventTarget(...WEBSOCKET_EVENTS): any) {
           new WebSocketEvent('close', {
             code: ev.code,
             reason: ev.reason,
+            // TODO: missing `wasClean` (exposed on iOS as `clean` but missing on Android)
           }),
         );
         this._unregisterEvents();
@@ -276,7 +282,9 @@ class WebSocket extends (EventTarget(...WEBSOCKET_EVENTS): any) {
         );
         this.dispatchEvent(
           new WebSocketEvent('close', {
-            message: ev.message,
+            code: CLOSE_ABNORMAL,
+            reason: ev.message,
+            // TODO: Expose `wasClean`
           }),
         );
         this._unregisterEvents();

package/Libraries/WebSocket/WebSocketInterceptor.js

@@ -8,8 +8,8 @@
  */
 
 import NativeEventEmitter from '../EventEmitter/NativeEventEmitter';
-import NativeWebSocketModule from './NativeWebSocketModule';
 import Platform from '../Utilities/Platform';
+import NativeWebSocketModule from './NativeWebSocketModule';
 import base64 from 'base64-js';
 
 const originalRCTWebSocketConnect = NativeWebSocketModule.connect;

package/Libraries/YellowBox/YellowBoxDeprecated.d.ts

@@ -0,0 +1,19 @@
+/**
+ * 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
+ */
+
+import type * as React from 'react';
+
+/**
+ * YellowBox has been replaced with LogBox.
+ * @see LogBox
+ * @deprecated
+ */
+export const YellowBox: React.ComponentClass<any, any> & {
+  ignoreWarnings: (warnings: string[]) => void;
+};

package/Libraries/YellowBox/YellowBoxDeprecated.js

@@ -10,11 +10,10 @@
 
 'use strict';
 
-const React = require('react');
+import type {IgnorePattern} from '../LogBox/Data/LogBoxData';
 
 const LogBox = require('../LogBox/LogBox');
-
-import type {IgnorePattern} from '../LogBox/Data/LogBoxData';
+const React = require('react');
 
 type Props = $ReadOnly<{||}>;