@office-iss/react-native-win32 0.70.2 → 0.71.0-preview.1

package/Libraries/Performance/QuickPerformanceLogger.js

@@ -13,11 +13,18 @@
 const AUTO_SET_TIMESTAMP = -1;
 const DUMMY_INSTANCE_KEY = 0;
 
-// Defines map of annotations for markEvent
+// Defines map of annotations
 // Use as following:
 // {string: {key1: value1, key2: value2}}
 export type AnnotationsMap = $Shape<{
   string: ?{[string]: string, ...},
+  int: ?{[string]: number, ...},
+  double: ?{[string]: number, ...},
+  bool: ?{[string]: boolean, ...},
+  string_array: ?{[string]: $ReadOnlyArray<string>, ...},
+  int_array: ?{[string]: $ReadOnlyArray<number>, ...},
+  double_array: ?{[string]: $ReadOnlyArray<number>, ...},
+  bool_array: ?{[string]: $ReadOnlyArray<boolean>, ...},
 }>;
 
 const QuickPerformanceLogger = {
@@ -54,17 +61,34 @@ const QuickPerformanceLogger = {
 
   markerAnnotate(
     markerId: number,
-    annotationKey: string,
-    annotationValue: string,
+    annotations: AnnotationsMap,
     instanceKey: number = DUMMY_INSTANCE_KEY,
   ): void {
-    if (global.nativeQPLMarkerAnnotate) {
-      global.nativeQPLMarkerAnnotate(
-        markerId,
-        instanceKey,
-        annotationKey,
-        annotationValue,
-      );
+    if (global.nativeQPLMarkerAnnotateWithMap) {
+      global.nativeQPLMarkerAnnotateWithMap(markerId, annotations, instanceKey);
+    } else if (global.nativeQPLMarkerAnnotate) {
+      for (const type of [
+        'string',
+        'int',
+        'double',
+        'bool',
+        'string_array',
+        'int_array',
+        'double_array',
+        'bool_array',
+      ]) {
+        const keyValsOfType = annotations[type];
+        if (keyValsOfType != null) {
+          for (const annotationKey of Object.keys(keyValsOfType)) {
+            global.nativeQPLMarkerAnnotate(
+              markerId,
+              instanceKey,
+              annotationKey,
+              keyValsOfType[annotationKey].toString(),
+            );
+          }
+        }
+      }
     }
   },
 

package/Libraries/Performance/Systrace.d.ts

@@ -0,0 +1,66 @@
+/**
+ * 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
+ */
+
+type EventName = string | (() => string);
+type EventArgs = {[key: string]: string} | void | null;
+
+/**
+ * Indicates if the application is currently being traced.
+ *
+ * Calling methods on this module when the application isn't being traced is
+ * cheap, but this method can be used to avoid computing expensive values for
+ * those functions.
+ *
+ * @example
+ * if (Systrace.isEnabled()) {
+ *   const expensiveArgs = computeExpensiveArgs();
+ *   Systrace.beginEvent('myEvent', expensiveArgs);
+ * }
+ */
+export function isEnabled(): boolean;
+
+/**
+ * @deprecated This function is now a no-op but it's left for backwards
+ * compatibility. `isEnabled` will now synchronously check if we're actively
+ * profiling or not. This is necessary because we don't have callbacks to know
+ * when profiling has started/stopped on Android APIs.
+ */
+export function setEnabled(_doEnable: boolean): void;
+
+/**
+ * Marks the start of a synchronous event that should end in the same stack
+ * frame. The end of this event should be marked using the `endEvent` function.
+ */
+export function beginEvent(eventName: EventName, args?: EventArgs): void;
+
+/**
+ * Marks the end of a synchronous event started in the same stack frame.
+ */
+export function endEvent(args?: EventArgs): void;
+
+/**
+ * Marks the start of a potentially asynchronous event. The end of this event
+ * should be marked calling the `endAsyncEvent` function with the cookie
+ * returned by this function.
+ */
+export function beginAsyncEvent(eventName: EventName, args?: EventArgs): number;
+
+/**
+ * Registers a new value for a counter event.
+ */
+export function endAsyncEvent(
+  eventName: EventName,
+  cookie: number,
+  args?: EventArgs,
+): void;
+
+/**
+ * counterEvent registers the value to the eventName on the systrace timeline
+ **/
+export function counterEvent(eventName: EventName, value: number): void;

package/Libraries/Performance/Systrace.js

@@ -8,217 +8,132 @@
  * @format
  */
 
-'use strict';
-
-const invariant = require('invariant');
+import typeof * as SystraceModule from './Systrace';
 
 const TRACE_TAG_REACT_APPS = 1 << 17; // eslint-disable-line no-bitwise
-const TRACE_TAG_JS_VM_CALLS = 1 << 27; // eslint-disable-line no-bitwise
 
-let _enabled = false;
 let _asyncCookie = 0;
-const _markStack = [];
-let _markStackIndex = -1;
-let _canInstallReactHook = false;
-
-// Implements a subset of User Timing API necessary for React measurements.
-// https://developer.mozilla.org/en-US/docs/Web/API/User_Timing_API
-const REACT_MARKER = '\u269B';
-const userTimingPolyfill = __DEV__
-  ? {
-      mark(markName: string) {
-        if (_enabled) {
-          _markStackIndex++;
-          _markStack[_markStackIndex] = markName;
-          let systraceLabel = markName;
-          // Since perf measurements are a shared namespace in User Timing API,
-          // we prefix all React results with a React emoji.
-          if (markName[0] === REACT_MARKER) {
-            // This is coming from React.
-            // Removing component IDs keeps trace colors stable.
-            const indexOfId = markName.lastIndexOf(' (#');
-            const cutoffIndex = indexOfId !== -1 ? indexOfId : markName.length;
-            // Also cut off the emoji because it breaks Systrace
-            systraceLabel = markName.slice(2, cutoffIndex);
-          }
-          Systrace.beginEvent(systraceLabel);
-        }
-      },
-      measure(measureName: string, startMark: ?string, endMark: ?string) {
-        if (_enabled) {
-          invariant(
-            typeof measureName === 'string' &&
-              typeof startMark === 'string' &&
-              typeof endMark === 'undefined',
-            'Only performance.measure(string, string) overload is supported.',
-          );
-          const topMark = _markStack[_markStackIndex];
-          invariant(
-            startMark === topMark,
-            'There was a mismatching performance.measure() call. ' +
-              'Expected "%s" but got "%s."',
-            topMark,
-            startMark,
-          );
-          _markStackIndex--;
-          // We can't use more descriptive measureName because Systrace doesn't
-          // let us edit labels post factum.
-          Systrace.endEvent();
-        }
-      },
-      clearMarks(markName: string) {
-        if (_enabled) {
-          if (_markStackIndex === -1) {
-            return;
-          }
-          if (markName === _markStack[_markStackIndex]) {
-            // React uses this for "cancelling" started measurements.
-            // Systrace doesn't support deleting measurements, so we just stop them.
-            if (userTimingPolyfill != null) {
-              userTimingPolyfill.measure(markName, markName);
-            }
-          }
-        }
-      },
-      clearMeasures() {
-        // React calls this to avoid memory leaks in browsers, but we don't keep
-        // measurements anyway.
-      },
-    }
-  : null;
 
-function installPerformanceHooks(
-  polyfill: null | $TEMPORARY$object<{
-    clearMarks(markName: string): void,
-    clearMeasures(): void,
-    mark(markName: string): void,
-    measure(measureName: string, startMark: ?string, endMark: ?string): void,
-  }>,
-) {
-  if (polyfill) {
-    if (global.performance === undefined) {
-      global.performance = {};
-    }
+type EventName = string | (() => string);
+type EventArgs = ?{[string]: string};
 
-    Object.keys(polyfill).forEach(methodName => {
-      if (typeof global.performance[methodName] !== 'function') {
-        global.performance[methodName] = polyfill[methodName];
-      }
-    });
-  }
+/**
+ * Indicates if the application is currently being traced.
+ *
+ * Calling methods on this module when the application isn't being traced is
+ * cheap, but this method can be used to avoid computing expensive values for
+ * those functions.
+ *
+ * @example
+ * if (Systrace.isEnabled()) {
+ *   const expensiveArgs = computeExpensiveArgs();
+ *   Systrace.beginEvent('myEvent', expensiveArgs);
+ * }
+ */
+export function isEnabled(): boolean {
+  return global.nativeTraceIsTracing
+    ? global.nativeTraceIsTracing(TRACE_TAG_REACT_APPS)
+    : Boolean(global.__RCTProfileIsProfiling);
 }
 
-const Systrace = {
-  installReactHook() {
-    if (_enabled) {
-      if (__DEV__) {
-        installPerformanceHooks(userTimingPolyfill);
-      }
-    }
-    _canInstallReactHook = true;
-  },
-
-  setEnabled(enabled: boolean) {
-    if (_enabled !== enabled) {
-      if (__DEV__) {
-        if (enabled) {
-          global.nativeTraceBeginLegacy &&
-            global.nativeTraceBeginLegacy(TRACE_TAG_JS_VM_CALLS);
-        } else {
-          global.nativeTraceEndLegacy &&
-            global.nativeTraceEndLegacy(TRACE_TAG_JS_VM_CALLS);
-        }
-        if (_canInstallReactHook) {
-          if (enabled) {
-            installPerformanceHooks(userTimingPolyfill);
-          }
-        }
-      }
-      _enabled = enabled;
-    }
-  },
-
-  isEnabled(): boolean {
-    return _enabled;
-  },
+/**
+ * @deprecated This function is now a no-op but it's left for backwards
+ * compatibility. `isEnabled` will now synchronously check if we're actively
+ * profiling or not. This is necessary because we don't have callbacks to know
+ * when profiling has started/stopped on Android APIs.
+ */
+export function setEnabled(_doEnable: boolean): void {}
 
-  /**
-   * beginEvent/endEvent for starting and then ending a profile within the same call stack frame
-   **/
-  beginEvent(
-    profileName?: string | (() => string),
-    args?: {[string]: string, ...},
-  ) {
-    if (_enabled) {
-      const profileNameString =
-        typeof profileName === 'function' ? profileName() : profileName;
-      global.nativeTraceBeginSection(
-        TRACE_TAG_REACT_APPS,
-        profileNameString,
-        args,
-      );
-    }
-  },
+/**
+ * Marks the start of a synchronous event that should end in the same stack
+ * frame. The end of this event should be marked using the `endEvent` function.
+ */
+export function beginEvent(eventName: EventName, args?: EventArgs): void {
+  if (isEnabled()) {
+    const eventNameString =
+      typeof eventName === 'function' ? eventName() : eventName;
+    global.nativeTraceBeginSection(TRACE_TAG_REACT_APPS, eventNameString, args);
+  }
+}
 
-  endEvent() {
-    if (_enabled) {
-      global.nativeTraceEndSection(TRACE_TAG_REACT_APPS);
-    }
-  },
+/**
+ * Marks the end of a synchronous event started in the same stack frame.
+ */
+export function endEvent(args?: EventArgs): void {
+  if (isEnabled()) {
+    global.nativeTraceEndSection(TRACE_TAG_REACT_APPS, args);
+  }
+}
 
-  /**
-   * beginAsyncEvent/endAsyncEvent for starting and then ending a profile where the end can either
-   * occur on another thread or out of the current stack frame, eg await
-   * the returned cookie variable should be used as input into the endAsyncEvent call to end the profile
-   **/
-  beginAsyncEvent(profileName?: string | (() => string)): number {
-    const cookie = _asyncCookie;
-    if (_enabled) {
-      _asyncCookie++;
-      const profileNameString =
-        typeof profileName === 'function' ? profileName() : profileName;
-      global.nativeTraceBeginAsyncSection(
-        TRACE_TAG_REACT_APPS,
-        profileNameString,
-        cookie,
-      );
-    }
-    return cookie;
-  },
+/**
+ * Marks the start of a potentially asynchronous event. The end of this event
+ * should be marked calling the `endAsyncEvent` function with the cookie
+ * returned by this function.
+ */
+export function beginAsyncEvent(
+  eventName: EventName,
+  args?: EventArgs,
+): number {
+  const cookie = _asyncCookie;
+  if (isEnabled()) {
+    _asyncCookie++;
+    const eventNameString =
+      typeof eventName === 'function' ? eventName() : eventName;
+    global.nativeTraceBeginAsyncSection(
+      TRACE_TAG_REACT_APPS,
+      eventNameString,
+      cookie,
+      args,
+    );
+  }
+  return cookie;
+}
 
-  endAsyncEvent(profileName?: string | (() => string), cookie?: number) {
-    if (_enabled) {
-      const profileNameString =
-        typeof profileName === 'function' ? profileName() : profileName;
-      global.nativeTraceEndAsyncSection(
-        TRACE_TAG_REACT_APPS,
-        profileNameString,
-        cookie,
-      );
-    }
-  },
+/**
+ * Marks the end of a potentially asynchronous event, which was started with
+ * the given cookie.
+ */
+export function endAsyncEvent(
+  eventName: EventName,
+  cookie: number,
+  args?: EventArgs,
+): void {
+  if (isEnabled()) {
+    const eventNameString =
+      typeof eventName === 'function' ? eventName() : eventName;
+    global.nativeTraceEndAsyncSection(
+      TRACE_TAG_REACT_APPS,
+      eventNameString,
+      cookie,
+      args,
+    );
+  }
+}
 
-  /**
-   * counterEvent registers the value to the profileName on the systrace timeline
-   **/
-  counterEvent(profileName?: string | (() => string), value?: number) {
-    if (_enabled) {
-      const profileNameString =
-        typeof profileName === 'function' ? profileName() : profileName;
-      global.nativeTraceCounter &&
-        global.nativeTraceCounter(
-          TRACE_TAG_REACT_APPS,
-          profileNameString,
-          value,
-        );
-    }
-  },
-};
+/**
+ * Registers a new value for a counter event.
+ */
+export function counterEvent(eventName: EventName, value: number): void {
+  if (isEnabled()) {
+    const eventNameString =
+      typeof eventName === 'function' ? eventName() : eventName;
+    global.nativeTraceCounter &&
+      global.nativeTraceCounter(TRACE_TAG_REACT_APPS, eventNameString, value);
+  }
+}
 
 if (__DEV__) {
+  const Systrace: SystraceModule = {
+    isEnabled,
+    setEnabled,
+    beginEvent,
+    endEvent,
+    beginAsyncEvent,
+    endAsyncEvent,
+    counterEvent,
+  };
+
   // The metro require polyfill can not have dependencies (true for all polyfills).
   // Ensure that `Systrace` is available in polyfill by exposing it globally.
   global[(global.__METRO_GLOBAL_PREFIX__ || '') + '__SYSTRACE'] = Systrace;
 }
-
-module.exports = Systrace;

package/Libraries/PermissionsAndroid/NativePermissionsAndroid.js

@@ -9,6 +9,7 @@
  */
 
 import type {TurboModule} from '../TurboModule/RCTExport';
+
 import * as TurboModuleRegistry from '../TurboModule/TurboModuleRegistry';
 
 // TODO: Use proper enum types.

package/Libraries/PermissionsAndroid/PermissionsAndroid.d.ts

@@ -0,0 +1,115 @@
+/**
+ * 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
+ */
+
+export interface Rationale {
+  title: string;
+  message: string;
+  buttonPositive: string;
+  buttonNegative?: string | undefined;
+  buttonNeutral?: string | undefined;
+}
+
+export type Permission =
+  | 'android.permission.READ_CALENDAR'
+  | 'android.permission.WRITE_CALENDAR'
+  | 'android.permission.CAMERA'
+  | 'android.permission.READ_CONTACTS'
+  | 'android.permission.WRITE_CONTACTS'
+  | 'android.permission.GET_ACCOUNTS'
+  | 'android.permission.ACCESS_BACKGROUND_LOCATION'
+  | 'android.permission.ACCESS_FINE_LOCATION'
+  | 'android.permission.ACCESS_COARSE_LOCATION'
+  | 'android.permission.RECORD_AUDIO'
+  | 'android.permission.READ_PHONE_STATE'
+  | 'android.permission.CALL_PHONE'
+  | 'android.permission.READ_CALL_LOG'
+  | 'android.permission.WRITE_CALL_LOG'
+  | 'com.android.voicemail.permission.ADD_VOICEMAIL'
+  | 'com.android.voicemail.permission.READ_VOICEMAIL'
+  | 'com.android.voicemail.permission.WRITE_VOICEMAIL'
+  | 'android.permission.USE_SIP'
+  | 'android.permission.PROCESS_OUTGOING_CALLS'
+  | 'android.permission.BODY_SENSORS'
+  | 'android.permission.BODY_SENSORS_BACKGROUND'
+  | 'android.permission.SEND_SMS'
+  | 'android.permission.RECEIVE_SMS'
+  | 'android.permission.READ_SMS'
+  | 'android.permission.RECEIVE_WAP_PUSH'
+  | 'android.permission.RECEIVE_MMS'
+  | 'android.permission.READ_EXTERNAL_STORAGE'
+  | 'android.permission.READ_MEDIA_IMAGES'
+  | 'android.permission.READ_MEDIA_VIDEO'
+  | 'android.permission.READ_MEDIA_AUDIO'
+  | 'android.permission.WRITE_EXTERNAL_STORAGE'
+  | 'android.permission.BLUETOOTH_CONNECT'
+  | 'android.permission.BLUETOOTH_SCAN'
+  | 'android.permission.BLUETOOTH_ADVERTISE'
+  | 'android.permission.ACCESS_MEDIA_LOCATION'
+  | 'android.permission.ACCEPT_HANDOVER'
+  | 'android.permission.ACTIVITY_RECOGNITION'
+  | 'android.permission.ANSWER_PHONE_CALLS'
+  | 'android.permission.READ_PHONE_NUMBERS'
+  | 'android.permission.UWB_RANGING'
+  | 'android.permission.POST_NOTIFICATIONS'
+  | 'android.permission.NEARBY_WIFI_DEVICES';
+
+export type PermissionStatus = 'granted' | 'denied' | 'never_ask_again';
+
+export interface PermissionsAndroidStatic {
+  /**
+   * A list of permission results that are returned
+   */
+  RESULTS: {[key: string]: PermissionStatus};
+  /**
+   * A list of specified "dangerous" permissions that require prompting the user
+   */
+  PERMISSIONS: {[key: string]: Permission};
+  new (): PermissionsAndroidStatic;
+  /**
+   * @deprecated Use check instead
+   */
+  checkPermission(permission: Permission): Promise<boolean>;
+  /**
+   * Returns a promise resolving to a boolean value as to whether the specified
+   * permissions has been granted
+   */
+  check(permission: Permission): Promise<boolean>;
+  /**
+   * @deprecated Use request instead
+   */
+  requestPermission(
+    permission: Permission,
+    rationale?: Rationale,
+  ): Promise<boolean>;
+  /**
+   * Prompts the user to enable a permission and returns a promise resolving to a
+   * string value indicating whether the user allowed or denied the request
+   *
+   * If the optional rationale argument is included (which is an object with a
+   * title and message), this function checks with the OS whether it is necessary
+   * to show a dialog explaining why the permission is needed
+   * (https://developer.android.com/training/permissions/requesting.html#explain)
+   * and then shows the system permission dialog
+   */
+  request(
+    permission: Permission,
+    rationale?: Rationale,
+  ): Promise<PermissionStatus>;
+  /**
+   * Prompts the user to enable multiple permissions in the same dialog and
+   * returns an object with the permissions as keys and strings as values
+   * indicating whether the user allowed or denied the request
+   */
+  requestMultiple(
+    permissions: Array<Permission>,
+  ): Promise<{[key in Permission]: PermissionStatus}>;
+}
+
+export const PermissionsAndroid: PermissionsAndroidStatic;
+export type PermissionsAndroid = PermissionsAndroidStatic;

package/Libraries/PermissionsAndroid/PermissionsAndroid.js

@@ -8,16 +8,17 @@
  * @flow strict
  */
 
-const Platform = require('../Utilities/Platform');
-
-import NativeDialogManagerAndroid from '../NativeModules/specs/NativeDialogManagerAndroid';
-import NativePermissionsAndroid from './NativePermissionsAndroid';
 import type {
   PermissionStatus,
   PermissionType,
 } from './NativePermissionsAndroid';
+
+import NativeDialogManagerAndroid from '../NativeModules/specs/NativeDialogManagerAndroid';
+import NativePermissionsAndroid from './NativePermissionsAndroid';
 import invariant from 'invariant';
 
+const Platform = require('../Utilities/Platform');
+
 export type Rationale = {
   title: string,
   message: string,

package/Libraries/Pressability/Pressability.js

@@ -8,24 +8,25 @@
  * @format
  */
 
-import {isHoverEnabled} from './HoverState';
-import invariant from 'invariant';
-import SoundManager from '../Components/Sound/SoundManager';
-import {normalizeRect, type RectOrSize} from '../StyleSheet/Rect';
+import type {HostComponent} from '../Renderer/shims/ReactNativeTypes';
 import type {
   BlurEvent,
   FocusEvent,
-  PressEvent,
   MouseEvent,
+  PressEvent,
 } from '../Types/CoreEventTypes';
+
+import SoundManager from '../Components/Sound/SoundManager';
+import ReactNativeFeatureFlags from '../ReactNative/ReactNativeFeatureFlags';
+import UIManager from '../ReactNative/UIManager';
+import {type RectOrSize, normalizeRect} from '../StyleSheet/Rect';
+import {type PointerEvent} from '../Types/CoreEventTypes';
+import Platform from '../Utilities/Platform';
+import {isHoverEnabled} from './HoverState';
 import PressabilityPerformanceEventEmitter from './PressabilityPerformanceEventEmitter.js';
 import {type PressabilityTouchSignal as TouchSignal} from './PressabilityTypes.js';
-import Platform from '../Utilities/Platform';
-import UIManager from '../ReactNative/UIManager';
-import type {HostComponent} from '../Renderer/shims/ReactNativeTypes';
+import invariant from 'invariant';
 import * as React from 'react';
-import ReactNativeFeatureFlags from '../ReactNative/ReactNativeFeatureFlags';
-import {type PointerEvent} from '../Types/CoreEventTypes';
 
 export type PressabilityConfig = $ReadOnly<{|
   /**
@@ -549,6 +550,7 @@ export default class Pressability {
 
     if (process.env.NODE_ENV === 'test') {
       // We are setting this in order to find this node in ReactNativeTestTools
+      // $FlowFixMe[prop-missing]
       responderEventHandlers.onStartShouldSetResponder.testOnly_pressabilityConfig =
         () => this._config;
     }