react-native 0.69.1 → 0.70.0-rc.0

package/Libraries/Settings/React-RCTSettings.podspec

@@ -17,7 +17,7 @@ else
 end
 
 folly_compiler_flags = '-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1 -Wno-comma -Wno-shorten-64-to-32'
-folly_version = '2021.06.28.00-v2'
+folly_version = '2021.07.22.00'
 
 Pod::Spec.new do |s|
   s.name                   = "React-RCTSettings"

package/Libraries/Storage/AsyncStorage.js

@@ -198,6 +198,8 @@ const AsyncStorage = {
    *
    * See https://reactnative.dev/docs/asyncstorage#flushgetrequests
    * */
+  /* $FlowFixMe[missing-this-annot] The 'this' type annotation(s) required by
+   * Flow's LTI update could not be added via codemod */
   flushGetRequests: function (): void {
     const getRequests = this._getRequests;
     const getKeys = this._getKeys;
@@ -213,7 +215,7 @@ const AsyncStorage = {
       //
       // Is there a way to avoid using the map but fix the bug in this breaking test?
       // https://github.com/facebook/react-native/commit/8dd8ad76579d7feef34c014d387bf02065692264
-      const map = {};
+      const map: {[string]: string} = {};
       result &&
         result.forEach(([key, value]) => {
           map[key] = value;
@@ -237,6 +239,8 @@ const AsyncStorage = {
    *
    * See https://reactnative.dev/docs/asyncstorage#multiget
    */
+  /* $FlowFixMe[missing-this-annot] The 'this' type annotation(s) required by
+   * Flow's LTI update could not be added via codemod */
   multiGet: function (
     keys: Array<string>,
     callback?: ?(errors: ?Array<Error>, result: ?Array<Array<string>>) => void,
@@ -366,6 +370,8 @@ function convertErrors(
 
 declare function convertError(void | null): null;
 declare function convertError({message: string, key?: string}): Error;
+/* $FlowFixMe[missing-local-annot] The type annotation(s) required by Flow's
+ * LTI update could not be added via codemod */
 function convertError(error) {
   if (!error) {
     return null;

package/Libraries/StyleSheet/PlatformColorValueTypes.ios.js

@@ -58,9 +58,13 @@ export const normalizeColorObject = (
     const dynamic = color.dynamic;
     const dynamicColor: NativeColorValue = {
       dynamic: {
+        // $FlowFixMe[incompatible-use]
         light: normalizeColor(dynamic.light),
+        // $FlowFixMe[incompatible-use]
         dark: normalizeColor(dynamic.dark),
+        // $FlowFixMe[incompatible-use]
         highContrastLight: normalizeColor(dynamic.highContrastLight),
+        // $FlowFixMe[incompatible-use]
         highContrastDark: normalizeColor(dynamic.highContrastDark),
       },
     };
@@ -78,9 +82,13 @@ export const processColorObject = (
     const dynamic = color.dynamic;
     const dynamicColor: NativeColorValue = {
       dynamic: {
+        // $FlowFixMe[incompatible-use]
         light: processColor(dynamic.light),
+        // $FlowFixMe[incompatible-use]
         dark: processColor(dynamic.dark),
+        // $FlowFixMe[incompatible-use]
         highContrastLight: processColor(dynamic.highContrastLight),
+        // $FlowFixMe[incompatible-use]
         highContrastDark: processColor(dynamic.highContrastDark),
       },
     };

package/Libraries/StyleSheet/flattenStyle.js

@@ -24,7 +24,7 @@ function flattenStyle<+TStyleProp: DangerouslyImpreciseStyleProp>(
     return style;
   }
 
-  const result = {};
+  const result: {[string]: $FlowFixMe} = {};
   for (let i = 0, styleLength = style.length; i < styleLength; ++i) {
     const computedStyle = flattenStyle(style[i]);
     if (computedStyle) {

package/Libraries/StyleSheet/processTransform.js

@@ -116,6 +116,8 @@ function processTransform(
 /**
  * Performs a destructive operation on a transform matrix.
  */
+/* $FlowFixMe[missing-this-annot] The 'this' type annotation(s) required by
+ * Flow's LTI update could not be added via codemod */
 function _multiplyTransform(
   result: Array<number>,
   matrixMathFunction: Function,

package/Libraries/StyleSheet/splitLayoutProps.js

@@ -50,10 +50,12 @@ export default function splitLayoutProps(props: ?____ViewStyle_Internal): {
         case 'top':
         case 'transform':
           // $FlowFixMe[cannot-write]
+          // $FlowFixMe[incompatible-use]
           outer[prop] = props[prop];
           break;
         default:
           // $FlowFixMe[cannot-write]
+          // $FlowFixMe[incompatible-use]
           inner[prop] = props[prop];
           break;
       }

package/Libraries/Text/Text.js

@@ -8,6 +8,9 @@
  * @format
  */
 
+import type {PressEvent} from '../Types/CoreEventTypes';
+
+import Platform from '../Utilities/Platform';
 import * as PressabilityDebug from '../Pressability/PressabilityDebug';
 import usePressability from '../Pressability/usePressability';
 import StyleSheet from '../StyleSheet/StyleSheet';
@@ -72,11 +75,11 @@ const Text: React.AbstractComponent<
             pressRectOffset: pressRetentionOffset,
             onLongPress,
             onPress,
-            onPressIn(event) {
+            onPressIn(event: PressEvent) {
               setHighlighted(!suppressHighlighting);
               onPressIn?.(event);
             },
-            onPressOut(event) {
+            onPressOut(event: PressEvent) {
               setHighlighted(false);
               onPressOut?.(event);
             },
@@ -105,25 +108,25 @@ const Text: React.AbstractComponent<
       eventHandlers == null
         ? null
         : {
-            onResponderGrant(event) {
+            onResponderGrant(event: PressEvent) {
               eventHandlers.onResponderGrant(event);
               if (onResponderGrant != null) {
                 onResponderGrant(event);
               }
             },
-            onResponderMove(event) {
+            onResponderMove(event: PressEvent) {
               eventHandlers.onResponderMove(event);
               if (onResponderMove != null) {
                 onResponderMove(event);
               }
             },
-            onResponderRelease(event) {
+            onResponderRelease(event: PressEvent) {
               eventHandlers.onResponderRelease(event);
               if (onResponderRelease != null) {
                 onResponderRelease(event);
               }
             },
-            onResponderTerminate(event) {
+            onResponderTerminate(event: PressEvent) {
               eventHandlers.onResponderTerminate(event);
               if (onResponderTerminate != null) {
                 onResponderTerminate(event);
@@ -168,6 +171,11 @@ const Text: React.AbstractComponent<
 
   const hasTextAncestor = useContext(TextAncestor);
 
+  const _accessible = Platform.select({
+    ios: accessible !== false,
+    default: accessible,
+  });
+
   return hasTextAncestor ? (
     <NativeVirtualText
       {...restProps}
@@ -185,7 +193,7 @@ const Text: React.AbstractComponent<
         {...restProps}
         {...eventHandlersForText}
         disabled={_disabled}
-        accessible={accessible !== false}
+        accessible={_accessible}
         accessibilityState={_accessibilityState}
         allowFontScaling={allowFontScaling !== false}
         ellipsizeMode={ellipsizeMode ?? 'tail'}

package/Libraries/Types/CoreEventTypes.js

@@ -83,17 +83,143 @@ export type TextLayoutEvent = SyntheticEvent<
   |}>,
 >;
 
-export type PointerEvent = ResponderSyntheticEvent<
-  $ReadOnly<{|
-    pointerId: number,
-    pressure: number,
-    pointerType: string,
-    clientX: number,
-    clientY: number,
-    target: ?number,
-    timestamp: number,
-  |}>,
->;
+/**
+ * https://developer.mozilla.org/en-US/docs/Web/API/UIEvent
+ */
+export interface NativeUIEvent {
+  /**
+   * Returns a long with details about the event, depending on the event type.
+   */
+  +detail: number;
+}
+
+/**
+ * https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent
+ */
+export interface NativeMouseEvent extends NativeUIEvent {
+  /**
+   * The X coordinate of the mouse pointer in global (screen) coordinates.
+   */
+  +screenX: number;
+  /**
+   * The Y coordinate of the mouse pointer in global (screen) coordinates.
+   */
+  +screenY: number;
+  /**
+   * The X coordinate of the mouse pointer relative to the whole document.
+   */
+  +pageX: number;
+  /**
+   * The Y coordinate of the mouse pointer relative to the whole document.
+   */
+  +pageY: number;
+  /**
+   * The X coordinate of the mouse pointer in local (DOM content) coordinates.
+   */
+  +clientX: number;
+  /**
+   * The Y coordinate of the mouse pointer in local (DOM content) coordinates.
+   */
+  +clientY: number;
+  /**
+   * Alias for NativeMouseEvent.clientX
+   */
+  +x: number;
+  /**
+   * Alias for NativeMouseEvent.clientY
+   */
+  +y: number;
+  /**
+   * Returns true if the control key was down when the mouse event was fired.
+   */
+  +ctrlKey: boolean;
+  /**
+   * Returns true if the shift key was down when the mouse event was fired.
+   */
+  +shiftKey: boolean;
+  /**
+   * Returns true if the alt key was down when the mouse event was fired.
+   */
+  +altKey: boolean;
+  /**
+   * Returns true if the meta key was down when the mouse event was fired.
+   */
+  +metaKey: boolean;
+  /**
+   * The button number that was pressed (if applicable) when the mouse event was fired.
+   */
+  +button: number;
+  /**
+   * The buttons being depressed (if any) when the mouse event was fired.
+   */
+  +buttons: number;
+  /**
+   * The secondary target for the event, if there is one.
+   */
+  +relatedTarget: null | number | React.ElementRef<HostComponent<mixed>>;
+  // offset is proposed: https://drafts.csswg.org/cssom-view/#extensions-to-the-mouseevent-interface
+  /**
+   * The X coordinate of the mouse pointer between that event and the padding edge of the target node
+   */
+  +offsetX: number;
+  /**
+   * The Y coordinate of the mouse pointer between that event and the padding edge of the target node
+   */
+  +offsetY: number;
+}
+
+/**
+ * https://developer.mozilla.org/en-US/docs/Web/API/PointerEvent
+ */
+export interface NativePointerEvent extends NativeMouseEvent {
+  /**
+   * A unique identifier for the pointer causing the event.
+   */
+  +pointerId: number;
+  /**
+   * The width (magnitude on the X axis), in CSS pixels, of the contact geometry of the pointer
+   */
+  +width: number;
+  /**
+   * The height (magnitude on the Y axis), in CSS pixels, of the contact geometry of the pointer.
+   */
+  +height: number;
+  /**
+   * The normalized pressure of the pointer input in the range 0 to 1, where 0 and 1 represent
+   * the minimum and maximum pressure the hardware is capable of detecting, respectively.
+   */
+  +pressure: number;
+  /**
+   * The normalized tangential pressure of the pointer input (also known as barrel pressure or
+   * cylinder stress) in the range -1 to 1, where 0 is the neutral position of the control.
+   */
+  +tangentialPressure: number;
+  /**
+   * The plane angle (in degrees, in the range of -90 to 90) between the Y–Z plane and the plane
+   * containing both the pointer (e.g. pen stylus) axis and the Y axis.
+   */
+  +tiltX: number;
+  /**
+   * The plane angle (in degrees, in the range of -90 to 90) between the X–Z plane and the plane
+   * containing both the pointer (e.g. pen stylus) axis and the X axis.
+   */
+  +tiltY: number;
+  /**
+   * The clockwise rotation of the pointer (e.g. pen stylus) around its major axis in degrees,
+   * with a value in the range 0 to 359.
+   */
+  +twist: number;
+  /**
+   * Indicates the device type that caused the event (mouse, pen, touch, etc.)
+   */
+  +pointerType: string;
+  /**
+   * Indicates if the pointer represents the primary pointer of this pointer type.
+   */
+  +isPrimary: boolean;
+}
+
+export type PointerEvent = SyntheticEvent<NativePointerEvent>;
 
 export type PressEvent = ResponderSyntheticEvent<
   $ReadOnly<{|

package/Libraries/Utilities/Dimensions.js

@@ -108,19 +108,6 @@ class Dimensions {
     );
     return eventEmitter.addListener(type, handler);
   }
-
-  /**
-   * @deprecated Use `remove` on the EventSubscription from `addEventListener`.
-   */
-  static removeEventListener(type: 'change', handler: Function) {
-    invariant(
-      type === 'change',
-      'Trying to remove listener for unknown event: "%s"',
-      type,
-    );
-    // NOTE: This will report a deprecation notice via `console.error`.
-    eventEmitter.removeListener(type, handler);
-  }
 }
 
 let initialDims: ?$ReadOnly<DimensionsPayload> =

package/Libraries/Utilities/HMRClient.js

@@ -256,7 +256,7 @@ Error: ${e.message}`;
   },
 };
 
-function setHMRUnavailableReason(reason) {
+function setHMRUnavailableReason(reason: string) {
   invariant(hmrClient, 'Expected HMRClient.setup() call at startup.');
   if (hmrUnavailableReason !== null) {
     // Don't show more than one warning.
@@ -273,7 +273,7 @@ function setHMRUnavailableReason(reason) {
   }
 }
 
-function registerBundleEntryPoints(client) {
+function registerBundleEntryPoints(client: MetroHMRClient) {
   if (hmrUnavailableReason != null) {
     DevSettings.reload('Bundle Splitting – Metro disconnected');
     return;
@@ -290,7 +290,7 @@ function registerBundleEntryPoints(client) {
   }
 }
 
-function flushEarlyLogs(client) {
+function flushEarlyLogs(client: MetroHMRClient) {
   try {
     pendingLogs.forEach(([level, data]) => {
       HMRClient.log(level, data);

package/Libraries/Utilities/Platform.ios.js

@@ -47,13 +47,6 @@ const Platform = {
   get isPad(): boolean {
     return this.constants.interfaceIdiom === 'pad';
   },
-  /**
-   * Deprecated, use `isTV` instead.
-   */
-  // $FlowFixMe[unsafe-getters-setters]
-  get isTVOS(): boolean {
-    return Platform.isTV;
-  },
   // $FlowFixMe[unsafe-getters-setters]
   get isTV(): boolean {
     return this.constants.interfaceIdiom === 'tv';

package/Libraries/Utilities/ReactNativeTestTools.js

@@ -180,7 +180,9 @@ function renderAndEnforceStrictMode(element: React.Node): any {
 }
 
 function renderWithStrictMode(element: React.Node): ReactTestRendererType {
-  const WorkAroundBugWithStrictModeInTestRenderer = prps => prps.children;
+  const WorkAroundBugWithStrictModeInTestRenderer = (prps: {
+    children: React.Node,
+  }) => prps.children;
   const StrictMode = (React: $FlowFixMe).StrictMode;
   return ReactTestRenderer.create(
     <WorkAroundBugWithStrictModeInTestRenderer>

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/React-RCTVibration.podspec

@@ -17,7 +17,7 @@ else
 end
 
 folly_compiler_flags = '-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1 -Wno-comma -Wno-shorten-64-to-32'
-folly_version = '2021.06.28.00-v2'
+folly_version = '2021.07.22.00'
 
 Pod::Spec.new do |s|
   s.name                   = "React-RCTVibration"

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;
 }