react-native-windows 0.69.5 → 0.70.0-preview.2

package/Libraries/Utilities/codegenNativeCommands.js

@@ -8,14 +8,23 @@
  * @flow
  */
 
-import {dispatchCommand} from '../../Libraries/Renderer/shims/ReactNative';
+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;
+}
 
 type Options<T = string> = $ReadOnly<{|
   supportedCommands: $ReadOnlyArray<T>,
 |}>;
 
 function codegenNativeCommands<T: interface {}>(options: Options<$Keys<T>>): T {
-  const commandObj = {};
+  const commandObj: {[$Keys<T>]: (...$ReadOnlyArray<mixed>) => void} = {};
 
   options.supportedCommands.forEach(command => {
     commandObj[command] = (ref, ...args) => {

package/Libraries/Utilities/deepFreezeAndThrowOnMutationInDev.js

@@ -70,6 +70,8 @@ function deepFreezeAndThrowOnMutationInDev<T: {...} | Array<mixed>>(
   return object;
 }
 
+/* $FlowFixMe[missing-local-annot] The type annotation(s) required by Flow's
+ * LTI update could not be added via codemod */
 function throwOnImmutableMutation(key: empty, value) {
   throw Error(
     'You attempted to set the key `' +

package/Libraries/Utilities/stringifySafe.js

@@ -27,6 +27,8 @@ export function createStringifySafeWithLimits(limits: {|
     maxObjectKeysLimit = Number.POSITIVE_INFINITY,
   } = limits;
   const stack = [];
+  /* $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 {
     while (stack.length && this !== stack[0]) {
       stack.shift();
@@ -65,7 +67,7 @@ export function createStringifySafeWithLimits(limits: {|
         retval = `{ ... object with ${keys.length} keys ... }`;
       } else if (keys.length > maxObjectKeysLimit) {
         // Return a sample of the keys.
-        retval = {};
+        retval = ({}: {[string]: mixed});
         for (let k of keys.slice(0, maxObjectKeysLimit)) {
           retval[k] = value[k];
         }

package/Libraries/Utilities/truncate.js

@@ -29,7 +29,7 @@ const truncate = function (
   maxChars: number,
   options?: truncateOptions,
 ): ?string {
-  options = Object.assign({}, defaultOptions, options);
+  options = {...defaultOptions, ...options};
   if (
     str &&
     str.length &&

package/Libraries/Utilities/verifyComponentAttributeEquivalence.js

@@ -63,7 +63,7 @@ export default function verifyComponentAttributeEquivalence(
 // Return the different key-value pairs of the right object, by iterating through the keys in the left object
 // Note it won't return a difference where a key is missing in the left but exists the right.
 function lefthandObjectDiff(leftObj: Object, rightObj: Object): Object {
-  const differentKeys = {};
+  const differentKeys: {[string]: any | {...}} = {};
 
   function compare(leftItem: any, rightItem: any, key: string) {
     if (typeof leftItem !== typeof rightItem && leftItem != null) {
@@ -110,7 +110,7 @@ export function getConfigWithoutViewProps(
 
   return Object.keys(viewConfig[propName])
     .filter(prop => !PlatformBaseViewConfig[propName][prop])
-    .reduce((obj, prop) => {
+    .reduce<{[string]: any}>((obj, prop) => {
       obj[prop] = viewConfig[propName][prop];
       return obj;
     }, {});

package/Libraries/Vibration/Vibration.js

@@ -40,7 +40,7 @@ function vibrateByPattern(pattern: Array<number>, repeat: boolean = false) {
 }
 
 function vibrateScheduler(
-  id,
+  id: number,
   pattern: Array<number>,
   repeat: boolean,
   nextIndex: number,

package/Libraries/WebSocket/WebSocket.js

@@ -104,6 +104,7 @@ class WebSocket extends (EventTarget(...WEBSOCKET_EVENTS): any) {
     const {headers = {}, ...unrecognized} = options || {};
 
     // Preserve deprecated backwards compatibility for the 'origin' option
+    // $FlowFixMe[prop-missing]
     if (unrecognized && typeof unrecognized.origin === 'string') {
       console.warn(
         'Specifying `origin` as a WebSocket connection option is deprecated. Include it under `headers` instead.',

package/Libraries/vendor/emitter/EventEmitter.js

@@ -8,20 +8,63 @@
  * @format
  */
 
-'use strict';
+export interface EventSubscription {
+  remove(): void;
+}
+
+export interface IEventEmitter<TEventToArgsMap: {...}> {
+  addListener<TEvent: $Keys<TEventToArgsMap>>(
+    eventType: TEvent,
+    listener: (...args: $ElementType<TEventToArgsMap, TEvent>) => mixed,
+    context?: mixed,
+  ): EventSubscription;
 
-const EventEmitter = require('./_EventEmitter');
+  emit<TEvent: $Keys<TEventToArgsMap>>(
+    eventType: TEvent,
+    ...args: $ElementType<TEventToArgsMap, TEvent>
+  ): void;
 
-import type {EventSubscription} from './EventSubscription';
+  removeAllListeners<TEvent: $Keys<TEventToArgsMap>>(eventType?: ?TEvent): void;
+
+  listenerCount<TEvent: $Keys<TEventToArgsMap>>(eventType: TEvent): number;
+}
 
-export default EventEmitter;
+interface Registration<TArgs> {
+  +context: mixed;
+  +listener: (...args: TArgs) => mixed;
+  +remove: () => void;
+}
 
-export type {EventSubscription};
+type Registry<TEventToArgsMap: {...}> = $ObjMap<
+  TEventToArgsMap,
+  <TArgs>(TArgs) => Set<Registration<TArgs>>,
+>;
 
 /**
- * Essential interface for an EventEmitter.
+ * EventEmitter manages listeners and publishes events to them.
+ *
+ * EventEmitter accepts a single type parameter that defines the valid events
+ * and associated listener argument(s).
+ *
+ * @example
+ *
+ *   const emitter = new EventEmitter<{
+ *     success: [number, string],
+ *     error: [Error],
+ *   }>();
+ *
+ *   emitter.on('success', (statusCode, responseText) => {...});
+ *   emitter.emit('success', 200, '...');
+ *
+ *   emitter.on('error', error => {...});
+ *   emitter.emit('error', new Error('Resource not found'));
+ *
  */
-export interface IEventEmitter<TEventToArgsMap: {...}> {
+export default class EventEmitter<TEventToArgsMap: {...}>
+  implements IEventEmitter<TEventToArgsMap>
+{
+  _registry: Registry<TEventToArgsMap> = {};
+
   /**
    * Registers a listener that is called when the supplied event is emitted.
    * Returns a subscription that has a `remove` method to undo registration.
@@ -29,25 +72,75 @@ export interface IEventEmitter<TEventToArgsMap: {...}> {
   addListener<TEvent: $Keys<TEventToArgsMap>>(
     eventType: TEvent,
     listener: (...args: $ElementType<TEventToArgsMap, TEvent>) => mixed,
-    context?: mixed,
-  ): EventSubscription;
+    context: mixed,
+  ): EventSubscription {
+    const registrations = allocate(this._registry, eventType);
+    const registration: Registration<$ElementType<TEventToArgsMap, TEvent>> = {
+      context,
+      listener,
+      remove(): void {
+        registrations.delete(registration);
+      },
+    };
+    registrations.add(registration);
+    return registration;
+  }
 
   /**
    * Emits the supplied event. Additional arguments supplied to `emit` will be
    * passed through to each of the registered listeners.
+   *
+   * If a listener modifies the listeners registered for the same event, those
+   * changes will not be reflected in the current invocation of `emit`.
    */
   emit<TEvent: $Keys<TEventToArgsMap>>(
     eventType: TEvent,
     ...args: $ElementType<TEventToArgsMap, TEvent>
-  ): void;
+  ): void {
+    const registrations: ?Set<
+      Registration<$ElementType<TEventToArgsMap, TEvent>>,
+    > = this._registry[eventType];
+    if (registrations != null) {
+      for (const registration of [...registrations]) {
+        registration.listener.apply(registration.context, args);
+      }
+    }
+  }
 
   /**
    * Removes all registered listeners.
    */
-  removeAllListeners<TEvent: $Keys<TEventToArgsMap>>(eventType?: ?TEvent): void;
+  removeAllListeners<TEvent: $Keys<TEventToArgsMap>>(
+    eventType?: ?TEvent,
+  ): void {
+    if (eventType == null) {
+      this._registry = {};
+    } else {
+      delete this._registry[eventType];
+    }
+  }
 
   /**
    * Returns the number of registered listeners for the supplied event.
    */
-  listenerCount<TEvent: $Keys<TEventToArgsMap>>(eventType: TEvent): number;
+  listenerCount<TEvent: $Keys<TEventToArgsMap>>(eventType: TEvent): number {
+    const registrations: ?Set<Registration<mixed>> = this._registry[eventType];
+    return registrations == null ? 0 : registrations.size;
+  }
+}
+
+function allocate<
+  TEventToArgsMap: {...},
+  TEvent: $Keys<TEventToArgsMap>,
+  TEventArgs: $ElementType<TEventToArgsMap, TEvent>,
+>(
+  registry: Registry<TEventToArgsMap>,
+  eventType: TEvent,
+): Set<Registration<TEventArgs>> {
+  let registrations: ?Set<Registration<TEventArgs>> = registry[eventType];
+  if (registrations == null) {
+    registrations = new Set();
+    registry[eventType] = registrations;
+  }
+  return registrations;
 }

package/Libraries/vendor/emitter/__flowtests__/EventEmitter-flowtest.js

@@ -1,5 +1,8 @@
 /**
- * (c) Meta Platforms, Inc. and affiliates. Confidential and proprietary.
+ * 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
@@ -7,119 +10,72 @@
 
 import EventEmitter from '../EventEmitter';
 
-type MyEvents = {
-  noArgsEvent: [],
-  stringEvent: [string],
-  numberEvent: [number],
-  anotherNumberEvent: [number],
-  objectAndBooleanEvent: [{prop: string}, boolean],
-};
-
-export function testBaseEventEmitterInstance() {
-  const emitter = new EventEmitter<MyEvents>();
-
-  emitter.addListener('noArgsEvent', expectedUndefined => {
-    (expectedUndefined: void);
-  });
-
-  emitter.addListener('stringEvent', expectedString => {
-    (expectedString: string);
-  });
-
-  emitter.addListener('numberEvent', expectedNumber => {
-    (expectedNumber: number);
-  });
-
-  emitter.addListener('anotherNumberEvent', expectedNumber => {
-    (expectedNumber: number);
-  });
-
-  emitter.addListener(
-    'objectAndBooleanEvent',
-    (expectedObject, expectedBoolean, unexpectedArg) => {
-      (expectedObject: {prop: string});
-      (expectedBoolean: boolean);
-      (unexpectedArg: void);
-    },
-  );
-
-  // $FlowExpectedError[prop-missing]
-  emitter.addListener('unexpectedEvent', () => {});
-
-  // $FlowExpectedError[incompatible-call]
-  emitter.addListener('noArgsEvent', (value: number) => {});
-
-  // $FlowExpectedError[incompatible-call]
-  emitter.addListener('numberEvent', (value: string) => {});
-
-  emitter.emit('noArgsEvent');
-  emitter.emit('stringEvent', 'value');
-  emitter.emit('numberEvent', 4);
-  emitter.emit('anotherNumberEvent', 4);
-  emitter.emit('objectAndBooleanEvent', {prop: 'value'}, true);
-}
-
-export function testSubclass() {
-  // $FlowExpectedError[incompatible-type-arg]
-  class EmitterWithUndefinedDefinition extends EventEmitter<void> {}
-
-  // $FlowExpectedError[incompatible-type-arg]
-  class EmitterWithNumberDefinition extends EventEmitter<number> {}
-
-  class EmitterWithInvalidDefinitions extends EventEmitter<{
-    foo: number,
-  }> {}
-
-  const emitter = new EmitterWithInvalidDefinitions();
-  // $FlowExpectedError[not-an-array]
-  // $FlowExpectedError[incompatible-call]
-  emitter.emit('foo');
-
-  class EmitterWithValidDefinitions extends EventEmitter<MyEvents> {}
-}
-
-export function testSubclassInstance() {
-  class MyEmitter extends EventEmitter<MyEvents> {}
-
-  const emitter = new MyEmitter();
-
-  emitter.addListener('noArgsEvent', expectedUndefined => {
-    (expectedUndefined: void);
-  });
-
-  emitter.addListener('stringEvent', expectedString => {
-    (expectedString: string);
-  });
-
-  emitter.addListener('numberEvent', expectedNumber => {
-    (expectedNumber: number);
-  });
-
-  emitter.addListener('anotherNumberEvent', expectedNumber => {
-    (expectedNumber: number);
-  });
-
-  emitter.addListener(
-    'objectAndBooleanEvent',
-    (expectedObject, expectedBoolean, unexpectedArg) => {
-      (expectedObject: {prop: string});
-      (expectedBoolean: boolean);
-      (unexpectedArg: void);
-    },
-  );
-
-  // $FlowExpectedError[prop-missing]
-  emitter.addListener('unexpectedEvent', () => {});
-
-  // $FlowExpectedError[incompatible-call]
-  emitter.addListener('noArgsEvent', (value: number) => {});
-
-  // $FlowExpectedError[incompatible-call]
-  emitter.addListener('numberEvent', (value: string) => {});
-
-  emitter.emit('noArgsEvent');
-  emitter.emit('stringEvent', 'value');
-  emitter.emit('numberEvent', 4);
-  emitter.emit('anotherNumberEvent', 4);
-  emitter.emit('objectAndBooleanEvent', {prop: 'value'}, true);
-}
+const emitter = new EventEmitter<{
+  void: [],
+  string: [string],
+  strings: [string, string],
+  error: [Error],
+}>();
+
+const subscription = emitter.addListener('void', unknown => {
+  (unknown: void);
+});
+subscription.remove();
+
+emitter.addListener('string', foo => {
+  (foo: string);
+});
+emitter.addListener('strings', (foo, bar) => {
+  (foo: string);
+  (bar: string);
+});
+emitter.addListener('error', error => {
+  (error: Error);
+});
+
+emitter.emit('void');
+emitter.emit('string', 'foo');
+emitter.emit('strings', 'foo', 'bar');
+emitter.emit('error', new Error());
+
+emitter.removeAllListeners('void');
+emitter.removeAllListeners('string');
+emitter.removeAllListeners('strings');
+emitter.removeAllListeners('error');
+emitter.removeAllListeners();
+
+emitter.listenerCount('void');
+emitter.listenerCount('string');
+emitter.listenerCount('strings');
+emitter.listenerCount('error');
+
+// $FlowExpectedError[prop-missing]
+emitter.addListener('does-not-exist', () => {
+  // ...
+});
+
+// $FlowExpectedError[prop-missing]
+subscription.context;
+// $FlowExpectedError[prop-missing]
+subscription.listener;
+// $FlowExpectedError[prop-missing]
+subscription.once;
+
+// $FlowExpectedError[invalid-tuple-arity]
+emitter.emit('void', undefined);
+// $FlowExpectedError[incompatible-call]
+emitter.emit('string', 123);
+// $FlowExpectedError[invalid-tuple-arity]
+emitter.emit('strings', 'foo');
+// $FlowExpectedError[invalid-tuple-arity]
+emitter.emit('strings', 'foo', 'bar', 'baz');
+// $FlowExpectedError[invalid-tuple-arity]
+emitter.emit('error');
+// $FlowExpectedError[prop-missing]
+emitter.emit('does-not-exist');
+
+// $FlowExpectedError[prop-missing]
+emitter.removeAllListeners('does-not-exist');
+
+// $FlowExpectedError[prop-missing]
+emitter.listenerCount('does-not-exist');

package/Microsoft.ReactNative/Base/CoreNativeModules.cpp

@@ -5,6 +5,7 @@
 #include "CoreNativeModules.h"
 
 // Modules
+#include <AppModelHelpers.h>
 #include <AsyncStorageModule.h>
 #include <Modules/Animated/NativeAnimatedModule.h>
 #include <Modules/AppearanceModule.h>
@@ -19,20 +20,17 @@
 
 namespace Microsoft::ReactNative {
 
+using winrt::Microsoft::ReactNative::ReactPropertyBag;
+
 namespace {
 
-bool HasPackageIdentity() noexcept {
-  static const bool hasPackageIdentity = []() noexcept {
-    auto packageStatics = winrt::get_activation_factory<winrt::Windows::ApplicationModel::IPackageStatics>(
-        winrt::name_of<winrt::Windows::ApplicationModel::Package>());
-    auto abiPackageStatics = static_cast<winrt::impl::abi_t<winrt::Windows::ApplicationModel::IPackageStatics> *>(
-        winrt::get_abi(packageStatics));
-    winrt::com_ptr<winrt::impl::abi_t<winrt::Windows::ApplicationModel::IPackage>> dummy;
-    return abiPackageStatics->get_Current(winrt::put_abi(dummy)) !=
-        winrt::impl::hresult_from_win32(APPMODEL_ERROR_NO_PACKAGE);
-  }();
-
-  return hasPackageIdentity;
+using winrt::Microsoft::ReactNative::ReactPropertyId;
+
+ReactPropertyId<bool> HttpUseMonolithicModuleProperty() noexcept {
+  static ReactPropertyId<bool> propId{
+      L"ReactNative.Http"
+      L"UseMonolithicModule"};
+  return propId;
 }
 
 } // namespace
@@ -50,11 +48,25 @@ std::vector<facebook::react::NativeModuleDescription> GetCoreModules(
       [props = context->Properties()]() { return Microsoft::React::CreateHttpModule(props); },
       jsMessageQueue);
 
+  if (!ReactPropertyBag(context->Properties()).Get(HttpUseMonolithicModuleProperty())) {
+    modules.emplace_back(
+        Microsoft::React::GetBlobModuleName(),
+        [props = context->Properties()]() { return Microsoft::React::CreateBlobModule(props); },
+        batchingUIMessageQueue);
+
+    modules.emplace_back(
+        Microsoft::React::GetFileReaderModuleName(),
+        [props = context->Properties()]() { return Microsoft::React::CreateFileReaderModule(props); },
+        batchingUIMessageQueue);
+  }
+
   modules.emplace_back(
       "Timing",
       [batchingUIMessageQueue]() { return facebook::react::CreateTimingModule(batchingUIMessageQueue); },
       batchingUIMessageQueue);
 
+  // Note: `context` is moved to remove the reference from the current scope.
+  // This should either be the last usage of `context`, or the std::move call should happen later in this method.
   modules.emplace_back(
       NativeAnimatedModule::name,
       [context = std::move(context)]() mutable { return std::make_unique<NativeAnimatedModule>(std::move(context)); },