@office-iss/react-native-win32 0.0.0-canary.28 → 0.0.0-canary.281

package/Libraries/Interaction/FrameRateLogger.js

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) Facebook, Inc. and its affiliates.
+ * 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.
@@ -8,8 +8,6 @@
  * @flow strict-local
  */
 
-'use strict';
-
 import NativeFrameRateLogger from './NativeFrameRateLogger';
 
 const invariant = require('invariant');
@@ -32,36 +30,26 @@ const invariant = require('invariant');
  */
 const FrameRateLogger = {
   /**
-   * Enable `debug` to see local logs of what's going on. `reportStackTraces` will grab stack traces
-   * during UI thread stalls and upload them if the native module supports it.
+   * Enable `debug` to see local logs of what's going on.
    */
-  setGlobalOptions: function(options: {
-    debug?: boolean,
-    reportStackTraces?: boolean,
-    ...
-  }) {
+  setGlobalOptions: function (options: {debug?: boolean, ...}) {
     if (options.debug !== undefined) {
       invariant(
         NativeFrameRateLogger,
         'Trying to debug FrameRateLogger without the native module!',
       );
     }
-    if (NativeFrameRateLogger) {
-      // Needs to clone the object first to avoid modifying the argument.
-      const optionsClone = {
-        debug: !!options.debug,
-        reportStackTraces: !!options.reportStackTraces,
-      };
-      NativeFrameRateLogger.setGlobalOptions(optionsClone);
-    }
+    NativeFrameRateLogger?.setGlobalOptions({
+      debug: !!options.debug,
+    });
   },
 
   /**
    * Must call `setContext` before any events can be properly tracked, which is done automatically
    * in `AppRegistry`, but navigation is also a common place to hook in.
    */
-  setContext: function(context: string) {
-    NativeFrameRateLogger && NativeFrameRateLogger.setContext(context);
+  setContext: function (context: string) {
+    NativeFrameRateLogger?.setContext(context);
   },
 
   /**
@@ -69,7 +57,7 @@ const FrameRateLogger = {
    * automatically.
    */
   beginScroll() {
-    NativeFrameRateLogger && NativeFrameRateLogger.beginScroll();
+    NativeFrameRateLogger?.beginScroll();
   },
 
   /**
@@ -77,7 +65,7 @@ const FrameRateLogger = {
    * automatically.
    */
   endScroll() {
-    NativeFrameRateLogger && NativeFrameRateLogger.endScroll();
+    NativeFrameRateLogger?.endScroll();
   },
 };
 

package/Libraries/Interaction/InteractionManager.d.ts

@@ -0,0 +1,74 @@
+/**
+ * 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 {EmitterSubscription} from '../vendor/emitter/EventEmitter';
+
+export type Handle = number;
+
+export type SimpleTask = {
+  name: string;
+  gen: () => void;
+};
+export type PromiseTask = {
+  name: string;
+  gen: () => Promise<any>;
+};
+
+export interface InteractionManagerStatic {
+  Events: {
+    interactionStart: string;
+    interactionComplete: string;
+  };
+
+  /**
+   * Adds a listener to be invoked when events of the specified type are
+   * emitted. An optional calling context may be provided. The data arguments
+   * emitted will be passed to the listener function.
+   *
+   * @param eventType - Name of the event to listen to
+   * @param listener - Function to invoke when the specified event is
+   *   emitted
+   * @param context - Optional context object to use when invoking the
+   *   listener
+   */
+  addListener(
+    eventType: string,
+    listener: (...args: any[]) => any,
+    context?: any,
+  ): EmitterSubscription;
+
+  /**
+   * Schedule a function to run after all interactions have completed.
+   * Returns a cancellable
+   */
+  runAfterInteractions(task?: (() => any) | SimpleTask | PromiseTask): {
+    then: (onfulfilled?: () => any, onrejected?: () => any) => Promise<any>;
+    done: (...args: any[]) => any;
+    cancel: () => void;
+  };
+
+  /**
+   * Notify manager that an interaction has started.
+   */
+  createInteractionHandle(): Handle;
+
+  /**
+   * Notify manager that an interaction has completed.
+   */
+  clearInteractionHandle(handle: Handle): void;
+
+  /**
+   * 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).
+   */
+  setDeadline(deadline: number): void;
+}
+
+export const InteractionManager: InteractionManagerStatic;

package/Libraries/Interaction/InteractionManager.js

@@ -1,27 +1,29 @@
 /**
- * Copyright (c) Facebook, Inc. and its affiliates.
+ * 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
+ * @flow strict-local
  */
 
-'use strict';
+import type {Task} from './TaskQueue';
 
-const BatchedBridge = require('../BatchedBridge/BatchedBridge');
-const EventEmitter = require('../vendor/emitter/EventEmitter');
-const TaskQueue = require('./TaskQueue');
+import * as ReactNativeFeatureFlags from '../../src/private/featureflags/ReactNativeFeatureFlags';
+import EventEmitter from '../vendor/emitter/EventEmitter';
 
+const BatchedBridge = require('../BatchedBridge/BatchedBridge');
 const infoLog = require('../Utilities/infoLog');
+const TaskQueue = require('./TaskQueue');
 const invariant = require('invariant');
-const keyMirror = require('fbjs/lib/keyMirror');
 
 export type Handle = number;
-import type {Task} from './TaskQueue';
 
-const _emitter = new EventEmitter();
+const _emitter = new EventEmitter<{
+  interactionComplete: [],
+  interactionStart: [],
+}>();
 
 const DEBUG_DELAY: 0 = 0;
 const DEBUG: false = false;
@@ -76,25 +78,25 @@ const DEBUG: false = false;
  * from executing, making apps more responsive.
  */
 const InteractionManager = {
-  Events: keyMirror({
-    interactionStart: true,
-    interactionComplete: true,
-  }),
+  Events: {
+    interactionStart: 'interactionStart',
+    interactionComplete: 'interactionComplete',
+  },
 
   /**
    * Schedule a function to run after all interactions have completed. Returns a cancellable
    * "promise".
    */
-  runAfterInteractions(
-    task: ?Task,
-  ): {
-    then: Function,
-    done: Function,
-    cancel: Function,
+  runAfterInteractions(task: ?Task): {
+    then: <U>(
+      onFulfill?: ?(void) => ?(Promise<U> | U),
+      onReject?: ?(error: mixed) => ?(Promise<U> | U),
+    ) => Promise<U>,
+    cancel: () => void,
     ...
   } {
-    const tasks = [];
-    const promise = new Promise(resolve => {
+    const tasks: Array<Task> = [];
+    const promise = new Promise((resolve: () => void) => {
       _scheduleUpdate();
       if (task) {
         tasks.push(task);
@@ -106,17 +108,9 @@ const InteractionManager = {
       _taskQueue.enqueueTasks(tasks);
     });
     return {
+      // $FlowFixMe[method-unbinding] added when improving typing for this parameters
       then: promise.then.bind(promise),
-      done: (...args) => {
-        if (promise.done) {
-          return promise.done(...args);
-        } else {
-          console.warn(
-            'Tried to call done when not supported by current Promise implementation.',
-          );
-        }
-      },
-      cancel: function() {
+      cancel: function () {
         _taskQueue.cancelTasks(tasks);
       },
     };
@@ -144,6 +138,7 @@ const InteractionManager = {
     _deleteInteractionSet.add(handle);
   },
 
+  // $FlowFixMe[method-unbinding] added when improving typing for this parameters
   addListener: (_emitter.addListener.bind(_emitter): $FlowFixMe),
 
   /**
@@ -156,25 +151,20 @@ const InteractionManager = {
   },
 };
 
-const _interactionSet = new Set();
-const _addInteractionSet = new Set();
-const _deleteInteractionSet = new Set();
+const _interactionSet = new Set<number | Handle>();
+const _addInteractionSet = new Set<number | Handle>();
+const _deleteInteractionSet = new Set<Handle>();
 const _taskQueue = new TaskQueue({onMoreTasks: _scheduleUpdate});
-let _nextUpdateHandle = 0;
+let _nextUpdateHandle: $FlowFixMe | TimeoutID = 0;
 let _inc = 0;
 let _deadline = -1;
 
-declare function setImmediate(callback: any, ...args: Array<any>): number;
-
 /**
  * Schedule an asynchronous update to the interaction state.
  */
 function _scheduleUpdate() {
   if (!_nextUpdateHandle) {
     if (_deadline > 0) {
-      /* $FlowFixMe(>=0.63.0 site=react_native_fb) This comment suppresses an
-       * error found when Flow v0.63 was deployed. To see the error delete this
-       * comment and run Flow. */
       _nextUpdateHandle = setTimeout(_processUpdate, 0 + DEBUG_DELAY);
     } else {
       _nextUpdateHandle = setImmediate(_processUpdate);
@@ -219,4 +209,8 @@ function _processUpdate() {
   _deleteInteractionSet.clear();
 }
 
-module.exports = InteractionManager;
+module.exports = (
+  ReactNativeFeatureFlags.disableInteractionManager()
+    ? require('./InteractionManagerStub')
+    : InteractionManager
+) as typeof InteractionManager;

package/Libraries/Interaction/InteractionManagerStub.js

@@ -0,0 +1,176 @@
+/**
+ * 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);
+
+/**
+ * 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, reject) => {
+      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.
+  },
+};
+
+module.exports = InteractionManagerStub;

package/Libraries/Interaction/JSEventLoopWatchdog.js

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) Facebook, Inc. and its affiliates.
+ * 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.
@@ -11,15 +11,10 @@
 'use strict';
 
 const infoLog = require('../Utilities/infoLog');
-const performanceNow = require('fbjs/lib/performanceNow');
 
 type Handler = {
   onIterate?: () => void,
-  onStall: (params: {
-    lastInterval: number,
-    busyTime: number,
-    ...
-  }) => ?string,
+  onStall: (params: {lastInterval: number, busyTime: number, ...}) => ?string,
   ...
 };
 
@@ -28,7 +23,7 @@ type Handler = {
  * other events from being processed in a timely manner.
  *
  * The "stall" time is defined as the amount of time in access of the acceptable
- * threshold, which is typically around 100-200ms. So if the treshold is set to
+ * threshold, which is typically around 100-200ms. So if the threshold is set to
  * 100 and a timer fires 150 ms later than it was scheduled because the event
  * loop was tied up, that would be considered a 50ms stall.
  *
@@ -36,28 +31,28 @@ type Handler = {
  * queried with `getStats`.
  */
 const JSEventLoopWatchdog = {
-  getStats: function(): Object {
+  getStats: function (): Object {
     return {stallCount, totalStallTime, longestStall, acceptableBusyTime};
   },
-  reset: function() {
+  reset: function () {
     infoLog('JSEventLoopWatchdog: reset');
     totalStallTime = 0;
     stallCount = 0;
     longestStall = 0;
-    lastInterval = performanceNow();
+    lastInterval = global.performance.now();
   },
-  addHandler: function(handler: Handler) {
+  addHandler: function (handler: Handler) {
     handlers.push(handler);
   },
-  install: function({thresholdMS}: {thresholdMS: number, ...}) {
+  install: function ({thresholdMS}: {thresholdMS: number, ...}) {
     acceptableBusyTime = thresholdMS;
     if (installed) {
       return;
     }
     installed = true;
-    lastInterval = performanceNow();
+    lastInterval = global.performance.now();
     function iteration() {
-      const now = performanceNow();
+      const now = global.performance.now();
       const busyTime = now - lastInterval;
       if (busyTime >= thresholdMS) {
         const stallTime = busyTime - thresholdMS;

package/Libraries/Interaction/NativeFrameRateLogger.js

@@ -1,24 +1,13 @@
 /**
- * Copyright (c) Facebook, Inc. and its affiliates.
+ * 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
- * @flow strict-local
  */
 
-import type {TurboModule} from '../TurboModule/RCTExport';
-import * as TurboModuleRegistry from '../TurboModule/TurboModuleRegistry';
-
-export interface Spec extends TurboModule {
-  +setGlobalOptions: (options: {|
-    +debug?: ?boolean,
-    +reportStackTraces?: ?boolean,
-  |}) => void;
-  +setContext: (context: string) => void;
-  +beginScroll: () => void;
-  +endScroll: () => void;
-}
-
-export default (TurboModuleRegistry.get<Spec>('FrameRateLogger'): ?Spec);
+export * from '../../src/private/specs/modules/NativeFrameRateLogger';
+import NativeFrameRateLogger from '../../src/private/specs/modules/NativeFrameRateLogger';
+export default NativeFrameRateLogger;