@office-iss/react-native-win32 0.81.2 → 0.82.0-preview.2

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

@@ -61,7 +61,7 @@ function structuredCloneInternal<T>(value: T): T {
 
   // Handles circular references.
   if (memory.has(value)) {
-    // $FlowExpectedError[incompatible-return] we know memory.get(value) is T
+    // $FlowExpectedError[incompatible-type] we know memory.get(value) is T
     return memory.get(value);
   }
 
@@ -74,12 +74,12 @@ function structuredCloneInternal<T>(value: T): T {
       result[key] = structuredCloneInternal(value[key]);
     }
 
-    // $FlowExpectedError[incompatible-return] we know result is T
+    // $FlowExpectedError[incompatible-type] we know result is T
     return result;
   }
 
   // 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);
@@ -89,7 +89,7 @@ function structuredCloneInternal<T>(value: T): T {
       result[key] = structuredCloneInternal(value[key]);
     }
 
-    // $FlowExpectedError[incompatible-return] we know result is T
+    // $FlowExpectedError[incompatible-type] we know result is T
     return result;
   }
 
@@ -99,7 +99,7 @@ function structuredCloneInternal<T>(value: T): T {
     if (value instanceof Cls) {
       const result = new Cls(value);
       memory.set(value, result);
-      // $FlowExpectedError[incompatible-return] we know result is T
+      // $FlowExpectedError[incompatible-type] we know result is T
       return result;
     }
   }
@@ -115,7 +115,7 @@ function structuredCloneInternal<T>(value: T): T {
       );
     }
 
-    // $FlowExpectedError[incompatible-return] we know result is T
+    // $FlowExpectedError[incompatible-type] we know result is T
     return result;
   }
 
@@ -127,7 +127,7 @@ function structuredCloneInternal<T>(value: T): T {
       result.add(structuredCloneInternal(innerValue));
     }
 
-    // $FlowExpectedError[incompatible-return] we know result is T
+    // $FlowExpectedError[incompatible-type] we know result is T
     return result;
   }
 
@@ -135,7 +135,7 @@ function structuredCloneInternal<T>(value: T): T {
     const result = new RegExp(value.source, value.flags);
     memory.set(value, result);
 
-    // $FlowExpectedError[incompatible-return] we know result is T
+    // $FlowExpectedError[incompatible-type] we know result is T
     return result;
   }
 
@@ -162,7 +162,7 @@ function structuredCloneInternal<T>(value: T): T {
 
     result.stack = value.stack;
 
-    // $FlowExpectedError[incompatible-return] we know result is T
+    // $FlowExpectedError[incompatible-type] we know result is T
     return result;
   }
 
@@ -185,7 +185,7 @@ function structuredCloneInternal<T>(value: T): T {
     result[key] = structuredCloneInternal(value[key]);
   }
 
-  // $FlowExpectedError[incompatible-return] we know result is T
+  // $FlowExpectedError[incompatible-type] we know result is T
   return result;
 }
 

package/src-win/Libraries/Components/Touchable/TouchableWin32.tsx

@@ -30,7 +30,7 @@ import { IKeyboardEvent } from '../View/ViewPropTypes';
 const BoundingDimensions = require('./BoundingDimensions');
 const Position = require('./Position');
 
-const {findNodeHandle} = require('../../ReactNative/RendererProxy');
+const {findNodeHandle} = require('../../Renderer/shims/ReactNative');
 
 /**
  * Extracts a single touch, generally this is the active touch or touch that

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;

package/Libraries/Interaction/TaskQueue.js

@@ -1,183 +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
- */
-
-'use strict';
-
-const invariant = require('invariant');
-
-export type SimpleTask = {
-  name: string,
-  run: () => void,
-};
-export type PromiseTask = {
-  name: string,
-  gen: () => Promise<void>,
-};
-export type Task = SimpleTask | PromiseTask | (() => void);
-
-const DEBUG: false = false;
-
-/**
- * TaskQueue - A system for queueing and executing a mix of simple callbacks and
- * trees of dependent tasks based on Promises. No tasks are executed unless
- * `processNext` is called.
- *
- * `enqueue` takes a Task object with either a simple `run` callback, or a
- * `gen` function that returns a `Promise` and puts it in the queue.  If a gen
- * function is supplied, then the promise it returns will block execution of
- * tasks already in the queue until it resolves. This can be used to make sure
- * the first task is fully resolved (including asynchronous dependencies that
- * also schedule more tasks via `enqueue`) before starting on the next task.
- * The `onMoreTasks` constructor argument is used to inform the owner that an
- * async task has resolved and that the queue should be processed again.
- *
- * Note: Tasks are only actually executed with explicit calls to `processNext`.
- */
-class TaskQueue {
-  /**
-   * TaskQueue instances are self contained and independent, so multiple tasks
-   * of varying semantics and priority can operate together.
-   *
-   * `onMoreTasks` is invoked when `PromiseTask`s resolve if there are more
-   * tasks to process.
-   */
-  constructor({onMoreTasks}: {onMoreTasks: () => void, ...}) {
-    this._onMoreTasks = onMoreTasks;
-    this._queueStack = [{tasks: [], popable: false}];
-  }
-
-  /**
-   * Add a task to the queue.  It is recommended to name your tasks for easier
-   * async debugging. Tasks will not be executed until `processNext` is called
-   * explicitly.
-   */
-  enqueue(task: Task): void {
-    this._getCurrentQueue().push(task);
-  }
-
-  enqueueTasks(tasks: Array<Task>): void {
-    tasks.forEach(task => this.enqueue(task));
-  }
-
-  cancelTasks(tasksToCancel: Array<Task>): void {
-    // search through all tasks and remove them.
-    this._queueStack = this._queueStack
-      .map(queue => ({
-        ...queue,
-        tasks: queue.tasks.filter(task => tasksToCancel.indexOf(task) === -1),
-      }))
-      .filter((queue, idx) => queue.tasks.length > 0 || idx === 0);
-  }
-
-  /**
-   * Check to see if `processNext` should be called.
-   *
-   * @returns {boolean} Returns true if there are tasks that are ready to be
-   * processed with `processNext`, or returns false if there are no more tasks
-   * to be processed right now, although there may be tasks in the queue that
-   * are blocked by earlier `PromiseTask`s that haven't resolved yet.
-   * `onMoreTasks` will be called after each `PromiseTask` resolves if there are
-   * tasks ready to run at that point.
-   */
-  hasTasksToProcess(): boolean {
-    return this._getCurrentQueue().length > 0;
-  }
-
-  /**
-   * Executes the next task in the queue.
-   */
-  processNext(): void {
-    const queue = this._getCurrentQueue();
-    if (queue.length) {
-      const task = queue.shift();
-      try {
-        if (typeof task === 'object' && task.gen) {
-          DEBUG && console.log('TaskQueue: genPromise for task ' + task.name);
-          this._genPromise(task);
-        } else if (typeof task === 'object' && task.run) {
-          DEBUG && console.log('TaskQueue: run task ' + task.name);
-          task.run();
-        } else {
-          invariant(
-            typeof task === 'function',
-            'Expected Function, SimpleTask, or PromiseTask, but got:\n' +
-              JSON.stringify(task, null, 2),
-          );
-          DEBUG && console.log('TaskQueue: run anonymous task');
-          task();
-        }
-      } catch (e) {
-        e.message =
-          // $FlowFixMe[incompatible-type]
-          // $FlowFixMe[incompatible-use]
-          'TaskQueue: Error with task ' + (task.name || '') + ': ' + e.message;
-        throw e;
-      }
-    }
-  }
-
-  _queueStack: Array<{
-    tasks: Array<Task>,
-    popable: boolean,
-    ...
-  }>;
-  _onMoreTasks: () => void;
-
-  _getCurrentQueue(): Array<Task> {
-    const stackIdx = this._queueStack.length - 1;
-    const queue = this._queueStack[stackIdx];
-    if (
-      queue.popable &&
-      queue.tasks.length === 0 &&
-      this._queueStack.length > 1
-    ) {
-      this._queueStack.pop();
-      DEBUG &&
-        console.log('TaskQueue: popped queue: ', {
-          stackIdx,
-          queueStackSize: this._queueStack.length,
-        });
-      return this._getCurrentQueue();
-    } else {
-      return queue.tasks;
-    }
-  }
-
-  _genPromise(task: PromiseTask) {
-    // Each async task pushes it's own queue onto the queue stack. This
-    // effectively defers execution of previously queued tasks until the promise
-    // resolves, at which point we allow the new queue to be popped, which
-    // happens once it is fully processed.
-    this._queueStack.push({tasks: [], popable: false});
-    const stackIdx = this._queueStack.length - 1;
-    const stackItem = this._queueStack[stackIdx];
-    DEBUG && console.log('TaskQueue: push new queue: ', {stackIdx});
-    DEBUG && console.log('TaskQueue: exec gen task ' + task.name);
-    task
-      .gen()
-      .then(() => {
-        DEBUG &&
-          console.log('TaskQueue: onThen for gen task ' + task.name, {
-            stackIdx,
-            queueStackSize: this._queueStack.length,
-          });
-        stackItem.popable = true;
-        this.hasTasksToProcess() && this._onMoreTasks();
-      })
-      .catch(ex => {
-        setTimeout(() => {
-          ex.message = `TaskQueue: Error resolving Promise in task ${task.name}: ${ex.message}`;
-          throw ex;
-        }, 0);
-      });
-  }
-}
-
-export default TaskQueue;

package/Libraries/ReactNative/ReactNativeFeatureFlags.js

@@ -1,31 +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
- */
-
-export type FeatureFlags = {
-  /**
-   * Function used to enable / disable W3C pointer event emitting in React Native.
-   * If enabled you must also flip the equivalent native flags on each platform:
-   * iOS -> RCTSetDispatchW3CPointerEvents
-   * Android -> ReactFeatureFlags.dispatchPointerEvents
-   */
-  shouldEmitW3CPointerEvents: () => boolean,
-  /**
-   * Function used to enable / disable Pressibility from using W3C Pointer Events
-   * for its hover callbacks
-   */
-  shouldPressibilityUseW3CPointerEventsForHover: () => boolean,
-};
-
-const ReactNativeFeatureFlags: FeatureFlags = {
-  shouldEmitW3CPointerEvents: () => false,
-  shouldPressibilityUseW3CPointerEventsForHover: () => false,
-};
-
-export default ReactNativeFeatureFlags;