react-native-tvos 0.64.2-2 → 0.66.3-0

package/Libraries/Vibration/NativeVibration.js

@@ -8,8 +8,6 @@
  * @format
  */
 
-'use strict';
-
 import type {TurboModule} from '../TurboModule/RCTExport';
 import * as TurboModuleRegistry from '../TurboModule/TurboModuleRegistry';
 import Platform from '../Utilities/Platform';

package/Libraries/Vibration/RCTVibrationPlugins.mm

@@ -17,12 +17,13 @@
 #import <unordered_map>
 
 Class RCTVibrationClassProvider(const char *name) {
-  static std::unordered_map<std::string, Class (*)(void)> sCoreModuleClassMap = {
+  // Intentionally leak to avoid crashing after static destructors are run.
+  static const auto sCoreModuleClassMap = new const std::unordered_map<std::string, Class (*)(void)>{
     {"Vibration", RCTVibrationCls},
   };
 
-  auto p = sCoreModuleClassMap.find(name);
-  if (p != sCoreModuleClassMap.end()) {
+  auto p = sCoreModuleClassMap->find(name);
+  if (p != sCoreModuleClassMap->end()) {
     auto classFunc = p->second;
     return classFunc();
   }

package/Libraries/Vibration/React-RCTVibration.podspec

@@ -11,13 +11,13 @@ version = package['version']
 source = { :git => 'https://github.com/facebook/react-native.git' }
 if version == '1000.0.0'
   # This is an unpublished version, use the latest commit hash of the react-native repo, which we’re presumably in.
-  source[:commit] = `git rev-parse HEAD`.strip
+  source[:commit] = `git rev-parse HEAD`.strip if system("git rev-parse --git-dir > /dev/null 2>&1")
 else
   source[:tag] = "v#{version}"
 end
 
 folly_compiler_flags = '-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1 -Wno-comma -Wno-shorten-64-to-32'
-folly_version = '2020.01.13.00'
+folly_version = '2021.06.28.00-v2'
 
 Pod::Spec.new do |s|
   s.name                   = "React-RCTVibration"
@@ -27,7 +27,7 @@ Pod::Spec.new do |s|
   s.documentation_url      = "https://reactnative.dev/docs/vibration"
   s.license                = package["license"]
   s.author                 = "Facebook, Inc. and its affiliates"
-  s.platforms              = { :ios => "10.0", :tvos => "10.0" }
+  s.platforms              = { :ios => "11.0", :tvos => "11.0" }
   s.compiler_flags         = folly_compiler_flags + ' -Wno-nullability-completeness'
   s.source                 = source
   s.source_files           = "*.{m,mm}"

package/Libraries/Vibration/Vibration.js

@@ -9,8 +9,6 @@
  * @jsdoc
  */
 
-'use strict';
-
 import NativeVibration from './NativeVibration';
 const Platform = require('../Utilities/Platform');
 

package/Libraries/WebSocket/NativeWebSocketModule.js

@@ -8,8 +8,6 @@
  * @format
  */
 
-'use strict';
-
 import type {TurboModule} from '../TurboModule/RCTExport';
 import * as TurboModuleRegistry from '../TurboModule/TurboModuleRegistry';
 

package/Libraries/WebSocket/WebSocket.js

@@ -8,13 +8,13 @@
  * @flow
  */
 
-'use strict';
-
 import Blob from '../Blob/Blob';
+import type {BlobData} from '../Blob/BlobTypes';
 import BlobManager from '../Blob/BlobManager';
 import NativeEventEmitter from '../EventEmitter/NativeEventEmitter';
 import binaryToBase64 from '../Utilities/binaryToBase64';
-import {type EventSubscription} from '../vendor/emitter/EventEmitter';
+import Platform from '../Utilities/Platform';
+import type {EventSubscription} from '../vendor/emitter/EventEmitter';
 import NativeWebSocketModule from './NativeWebSocketModule';
 import WebSocketEvent from './WebSocketEvent';
 import base64 from 'base64-js';
@@ -46,6 +46,17 @@ const WEBSOCKET_EVENTS = ['close', 'error', 'message', 'open'];
 
 let nextWebSocketId = 0;
 
+type WebSocketEventDefinitions = {
+  websocketOpen: [{id: number, protocol: string}],
+  websocketClosed: [{id: number, code: number, reason: string}],
+  websocketMessage: [
+    | {type: 'binary', id: number, data: string}
+    | {type: 'text', id: number, data: string}
+    | {type: 'blob', id: number, data: BlobData},
+  ],
+  websocketFailed: [{id: number, message: string}],
+};
+
 /**
  * Browser-compatible WebSockets implementation.
  *
@@ -64,7 +75,7 @@ class WebSocket extends (EventTarget(...WEBSOCKET_EVENTS): any) {
   CLOSED: number = CLOSED;
 
   _socketId: number;
-  _eventEmitter: NativeEventEmitter;
+  _eventEmitter: NativeEventEmitter<WebSocketEventDefinitions>;
   _subscriptions: Array<EventSubscription>;
   _binaryType: ?BinaryType;
 
@@ -85,6 +96,7 @@ class WebSocket extends (EventTarget(...WEBSOCKET_EVENTS): any) {
     options: ?{headers?: {origin?: string, ...}, ...},
   ) {
     super();
+    this.url = url;
     if (typeof protocols === 'string') {
       protocols = [protocols];
     }
@@ -92,20 +104,17 @@ class WebSocket extends (EventTarget(...WEBSOCKET_EVENTS): any) {
     const {headers = {}, ...unrecognized} = options || {};
 
     // Preserve deprecated backwards compatibility for the 'origin' option
-    /* $FlowFixMe(>=0.68.0 site=react_native_fb) This comment suppresses an
-     * error found when Flow v0.68 was deployed. To see the error delete this
-     * comment and run Flow. */
     if (unrecognized && typeof unrecognized.origin === 'string') {
       console.warn(
         'Specifying `origin` as a WebSocket connection option is deprecated. Include it under `headers` instead.',
       );
-      /* $FlowFixMe(>=0.54.0 site=react_native_fb,react_native_oss) This
-       * comment suppresses an error found when Flow v0.54 was deployed. To see
-       * the error delete this comment and run Flow. */
+      /* $FlowFixMe[prop-missing] (>=0.54.0 site=react_native_fb,react_native_
+       * oss) This comment suppresses an error found when Flow v0.54 was
+       * deployed. To see the error delete this comment and run Flow. */
       headers.origin = unrecognized.origin;
-      /* $FlowFixMe(>=0.54.0 site=react_native_fb,react_native_oss) This
-       * comment suppresses an error found when Flow v0.54 was deployed. To see
-       * the error delete this comment and run Flow. */
+      /* $FlowFixMe[prop-missing] (>=0.54.0 site=react_native_fb,react_native_
+       * oss) This comment suppresses an error found when Flow v0.54 was
+       * deployed. To see the error delete this comment and run Flow. */
       delete unrecognized.origin;
     }
 
@@ -123,7 +132,11 @@ class WebSocket extends (EventTarget(...WEBSOCKET_EVENTS): any) {
       protocols = null;
     }
 
-    this._eventEmitter = new NativeEventEmitter(NativeWebSocketModule);
+    this._eventEmitter = new NativeEventEmitter(
+      // T88715063: NativeEventEmitter only used this parameter on iOS. Now it uses it on all platforms, so this code was modified automatically to preserve its behavior
+      // If you want to use the native module on other platforms, please remove this condition and test its behavior
+      Platform.OS !== 'ios' ? null : NativeWebSocketModule,
+    );
     this._socketId = nextWebSocketId++;
     this._registerEvents();
     NativeWebSocketModule.connect(url, protocols, {headers}, this._socketId);

package/Libraries/WebSocket/WebSocketInterceptor.js

@@ -7,10 +7,9 @@
  * @format
  */
 
-'use strict';
-
 import NativeEventEmitter from '../EventEmitter/NativeEventEmitter';
 import NativeWebSocketModule from './NativeWebSocketModule';
+import Platform from '../Utilities/Platform';
 import base64 from 'base64-js';
 
 const originalRCTWebSocketConnect = NativeWebSocketModule.connect;
@@ -133,7 +132,11 @@ const WebSocketInterceptor = {
     if (isInterceptorEnabled) {
       return;
     }
-    eventEmitter = new NativeEventEmitter(NativeWebSocketModule);
+    eventEmitter = new NativeEventEmitter(
+      // T88715063: NativeEventEmitter only used this parameter on iOS. Now it uses it on all platforms, so this code was modified automatically to preserve its behavior
+      // If you want to use the native module on other platforms, please remove this condition and test its behavior
+      Platform.OS !== 'ios' ? null : NativeWebSocketModule,
+    );
     WebSocketInterceptor._registerEvents();
 
     // Override `connect` method for all RCTWebSocketModule requests

package/Libraries/YellowBox/YellowBoxDeprecated.js

@@ -67,6 +67,7 @@ if (__DEV__) {
   };
 }
 
+// $FlowFixMe[method-unbinding]
 module.exports = (YellowBox: Class<React.Component<Props>> & {
   ignoreWarnings($ReadOnlyArray<IgnorePattern>): void,
   install(): void,

package/Libraries/__flowtests__/ReactNativeTypes-flowtest.js

@@ -8,8 +8,6 @@
  * @format
  */
 
-'use strict';
-
 import * as React from 'react';
 import type {HostComponent} from '../Renderer/shims/ReactNativeTypes';
 

package/Libraries/promiseRejectionTrackingOptions.js

@@ -8,8 +8,6 @@
  * @flow strict
  */
 
-'use strict';
-
 import typeof {enable} from 'promise/setimmediate/rejection-tracking';
 
 type ExtractOptionsType = <P>((options?: ?P) => void) => P;
@@ -20,8 +18,10 @@ let rejectionTrackingOptions: $Call<ExtractOptionsType, enable> = {
     let message: string;
     let stack: ?string;
 
+    // $FlowFixMe[method-unbinding] added when improving typing for this parameters
     const stringValue = Object.prototype.toString.call(rejection);
     if (stringValue === '[object Error]') {
+      // $FlowFixMe[method-unbinding] added when improving typing for this parameters
       message = Error.prototype.toString.call(rejection);
       const error: Error = (rejection: $FlowFixMe);
       stack = error.stack;

package/Libraries/vendor/emitter/EventEmitter.js

@@ -4,17 +4,50 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @flow strict-local
+ * @flow strict
  * @format
  */
 
 'use strict';
 
-// $FlowFixMe - EventEmitter Type Safety
 const EventEmitter = require('./_EventEmitter');
 
+import type {EventSubscription} from './EventSubscription';
+
 export default EventEmitter;
 
-export interface EventSubscription {
-  remove(): void;
+export type {EventSubscription};
+
+/**
+ * Essential interface for an EventEmitter.
+ */
+export interface IEventEmitter<TEventToArgsMap: {...}> {
+  /**
+   * Registers a listener that is called when the supplied event is emitted.
+   * Returns a subscription that has a `remove` method to undo registration.
+   */
+  addListener<TEvent: $Keys<TEventToArgsMap>>(
+    eventType: TEvent,
+    listener: (...args: $ElementType<TEventToArgsMap, TEvent>) => mixed,
+    context?: mixed,
+  ): EventSubscription;
+
+  /**
+   * Emits the supplied event. Additional arguments supplied to `emit` will be
+   * passed through to each of the registered listeners.
+   */
+  emit<TEvent: $Keys<TEventToArgsMap>>(
+    eventType: TEvent,
+    ...args: $ElementType<TEventToArgsMap, TEvent>
+  ): void;
+
+  /**
+   * Removes all registered listeners.
+   */
+  removeAllListeners<TEvent: $Keys<TEventToArgsMap>>(eventType?: ?TEvent): void;
+
+  /**
+   * Returns the number of registered listeners for the supplied event.
+   */
+  listenerCount<TEvent: $Keys<TEventToArgsMap>>(eventType: TEvent): number;
 }

package/Libraries/vendor/emitter/EventSubscription.js

@@ -0,0 +1,19 @@
+/**
+ * Copyright (c) Facebook, Inc. and its 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';
+
+// This exists as a separate file only to avoid circular dependencies from
+// using this in `_EmitterSubscription`. Combine this back into `EventEmitter`
+// after migration and cleanup is done.
+
+export interface EventSubscription {
+  remove(): void;
+}

package/Libraries/vendor/emitter/_EmitterSubscription.js

@@ -5,23 +5,25 @@
  * LICENSE file in the root directory of this source tree.
  *
  * @format
- * @flow
+ * @flow strict
  */
 
 'use strict';
 
 import type EventEmitter from './EventEmitter';
-import EventSubscription from './_EventSubscription';
+import _EventSubscription from './_EventSubscription';
 import type EventSubscriptionVendor from './_EventSubscriptionVendor';
+import {type EventSubscription} from './EventSubscription';
 
 /**
  * EmitterSubscription represents a subscription with listener and context data.
  */
-class EmitterSubscription extends EventSubscription {
-  // $FlowFixMe[value-as-type]
-  emitter: EventEmitter;
-  listener: Function;
-  context: ?Object;
+class EmitterSubscription<EventDefinitions: {...}, K: $Keys<EventDefinitions>>
+  extends _EventSubscription<EventDefinitions, K>
+  implements EventSubscription {
+  emitter: EventEmitter<EventDefinitions>;
+  listener: ?(...$ElementType<EventDefinitions, K>) => mixed;
+  context: ?$FlowFixMe;
 
   /**
    * @param {EventEmitter} emitter - The event emitter that registered this
@@ -34,11 +36,10 @@ class EmitterSubscription extends EventSubscription {
    *   listener
    */
   constructor(
-    // $FlowFixMe[value-as-type]
-    emitter: EventEmitter,
-    subscriber: EventSubscriptionVendor,
-    listener: Function,
-    context: ?Object,
+    emitter: EventEmitter<EventDefinitions>,
+    subscriber: EventSubscriptionVendor<EventDefinitions>,
+    listener: (...$ElementType<EventDefinitions, K>) => mixed,
+    context: ?$FlowFixMe,
   ) {
     super(subscriber);
     this.emitter = emitter;
@@ -48,12 +49,12 @@ class EmitterSubscription extends EventSubscription {
 
   /**
    * Removes this subscription from the emitter that registered it.
-   * Note: we're overriding the `remove()` method of EventSubscription here
+   * Note: we're overriding the `remove()` method of _EventSubscription here
    * but deliberately not calling `super.remove()` as the responsibility
    * for removing the subscription lies with the EventEmitter.
    */
-  remove() {
-    this.emitter.removeSubscription(this);
+  remove(): void {
+    this.emitter.__removeSubscription(this);
   }
 }
 

package/Libraries/vendor/emitter/_EventEmitter.js

@@ -5,15 +5,14 @@
  * LICENSE file in the root directory of this source tree.
  *
  * @format
- * @noflow
+ * @flow strict
  * @typecheck
  */
 
-'use strict';
-
 const invariant = require('invariant');
 
 import EmitterSubscription from './_EmitterSubscription';
+import {type EventSubscription} from './EventSubscription';
 import EventSubscriptionVendor from './_EventSubscriptionVendor';
 
 const sparseFilterPredicate = () => true;
@@ -31,17 +30,17 @@ const sparseFilterPredicate = () => true;
  * mechanism on top of which extra functionality can be composed. For example, a
  * more advanced emitter may use an EventHolder and EventFactory.
  */
-class EventEmitter {
-  _subscriber: EventSubscriptionVendor;
+class EventEmitter<EventDefinitions: {...}> {
+  _subscriber: EventSubscriptionVendor<EventDefinitions> = new EventSubscriptionVendor<EventDefinitions>();
 
   /**
    * @constructor
-   *
-   * @param {EventSubscriptionVendor} subscriber - Optional subscriber instance
-   *   to use. If omitted, a new subscriber will be created for the emitter.
    */
-  constructor(subscriber: ?EventSubscriptionVendor) {
-    this._subscriber = subscriber || new EventSubscriptionVendor();
+  constructor(subscriber: ?EventSubscriptionVendor<EventDefinitions>) {
+    if (subscriber != null) {
+      console.warn('EventEmitter(...): Constructor argument is deprecated.');
+      this._subscriber = subscriber;
+    }
   }
 
   /**
@@ -49,24 +48,22 @@ class EventEmitter {
    * emitted. An optional calling context may be provided. The data arguments
    * emitted will be passed to the listener function.
    *
-   * TODO: Annotate the listener arg's type. This is tricky because listeners
-   *       can be invoked with varargs.
-   *
    * @param {string} eventType - Name of the event to listen to
    * @param {function} 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: Function,
-    context: ?Object,
-  ): EmitterSubscription {
+  addListener<K: $Keys<EventDefinitions>>(
+    eventType: K,
+    // FIXME: listeners should return void instead of mixed to prevent issues
+    listener: (...$ElementType<EventDefinitions, K>) => mixed,
+    context: $FlowFixMe,
+  ): EventSubscription {
     return (this._subscriber.addSubscription(
       eventType,
       new EmitterSubscription(this, this._subscriber, listener, context),
-    ): any);
+    ): $FlowFixMe);
   }
 
   /**
@@ -76,15 +73,29 @@ class EventEmitter {
    * @param {?string} eventType - Optional name of the event whose registered
    *   listeners to remove
    */
-  removeAllListeners(eventType: ?string) {
+  removeAllListeners<K: $Keys<EventDefinitions>>(eventType: ?K): void {
     this._subscriber.removeAllSubscriptions(eventType);
   }
 
   /**
-   * Removes a specific subscription. Called by the `remove()` method of the
-   * subscription itself to ensure any necessary cleanup is performed.
+   * @deprecated Use `remove` on the EventSubscription from `addListener`.
+   */
+  removeSubscription<K: $Keys<EventDefinitions>>(
+    subscription: EmitterSubscription<EventDefinitions, K>,
+  ): void {
+    console.warn(
+      'EventEmitter.removeSubscription(...): Method has been deprecated. ' +
+        'Please instead use `remove()` on the subscription itself.',
+    );
+    this.__removeSubscription(subscription);
+  }
+
+  /**
+   * Called by `EmitterSubscription` to bypass the above deprecation warning.
    */
-  removeSubscription(subscription: EmitterSubscription) {
+  __removeSubscription<K: $Keys<EventDefinitions>>(
+    subscription: EmitterSubscription<EventDefinitions, K>,
+  ): void {
     invariant(
       subscription.emitter === this,
       'Subscription does not belong to this emitter.',
@@ -99,7 +110,7 @@ class EventEmitter {
    * @param {string} eventType - Name of the event to query
    * @returns {number}
    */
-  listenerCount(eventType: string): number {
+  listenerCount<K: $Keys<EventDefinitions>>(eventType: K): number {
     const subscriptions = this._subscriber.getSubscriptionsForType(eventType);
     return subscriptions
       ? // We filter out missing entries because the array is sparse.
@@ -124,7 +135,10 @@ class EventEmitter {
    *
    *   emitter.emit('someEvent', 'abc'); // logs 'abc'
    */
-  emit(eventType: string) {
+  emit<K: $Keys<EventDefinitions>>(
+    eventType: K,
+    ...args: $ElementType<EventDefinitions, K>
+  ): void {
     const subscriptions = this._subscriber.getSubscriptionsForType(eventType);
     if (subscriptions) {
       for (let i = 0, l = subscriptions.length; i < l; i++) {
@@ -132,29 +146,25 @@ class EventEmitter {
 
         // The subscription may have been removed during this event loop.
         if (subscription && subscription.listener) {
-          subscription.listener.apply(
-            subscription.context,
-            Array.prototype.slice.call(arguments, 1),
-          );
+          subscription.listener.apply(subscription.context, args);
         }
       }
     }
   }
 
   /**
-   * Removes the given listener for event of specific type.
-   *
-   * @param {string} eventType - Name of the event to emit
-   * @param {function} listener - Function to invoke when the specified event is
-   *   emitted
-   *
-   * @example
-   *   emitter.removeListener('someEvent', function(message) {
-   *     console.log(message);
-   *   }); // removes the listener if already registered
-   *
+   * @deprecated Use `remove` on the EventSubscription from `addListener`.
    */
-  removeListener(eventType: String, listener) {
+  removeListener<K: $Keys<EventDefinitions>>(
+    eventType: K,
+    // FIXME: listeners should return void instead of mixed to prevent issues
+    listener: (...$ElementType<EventDefinitions, K>) => mixed,
+  ): void {
+    console.warn(
+      `EventEmitter.removeListener('${eventType}', ...): Method has been ` +
+        'deprecated. Please instead use `remove()` on the subscription ' +
+        'returned by `EventEmitter.addListener`.',
+    );
     const subscriptions = this._subscriber.getSubscriptionsForType(eventType);
     if (subscriptions) {
       for (let i = 0, l = subscriptions.length; i < l; i++) {

package/Libraries/vendor/emitter/_EventSubscription.js

@@ -5,36 +5,40 @@
  * LICENSE file in the root directory of this source tree.
  *
  * @format
- * @flow strict-local
+ * @flow strict
  */
 
 'use strict';
 
+import {type EventSubscription} from './EventSubscription';
 import type EventSubscriptionVendor from './_EventSubscriptionVendor';
 
 /**
  * EventSubscription represents a subscription to a particular event. It can
  * remove its own subscription.
  */
-class EventSubscription {
-  eventType: string;
+class _EventSubscription<EventDefinitions: {...}, K: $Keys<EventDefinitions>>
+  implements EventSubscription {
+  eventType: K;
   key: number;
-  subscriber: EventSubscriptionVendor;
+  subscriber: EventSubscriptionVendor<EventDefinitions>;
+  listener: ?(...$ElementType<EventDefinitions, K>) => mixed;
+  context: ?$FlowFixMe;
 
   /**
    * @param {EventSubscriptionVendor} subscriber the subscriber that controls
    *   this subscription.
    */
-  constructor(subscriber: EventSubscriptionVendor) {
+  constructor(subscriber: EventSubscriptionVendor<EventDefinitions>) {
     this.subscriber = subscriber;
   }
 
   /**
    * Removes this subscription from the subscriber that controls it.
    */
-  remove() {
+  remove(): void {
     this.subscriber.removeSubscription(this);
   }
 }
 
-module.exports = EventSubscription;
+module.exports = _EventSubscription;

package/Libraries/vendor/emitter/_EventSubscriptionVendor.js

@@ -5,7 +5,7 @@
  * LICENSE file in the root directory of this source tree.
  *
  * @format
- * @flow
+ * @flow strict
  */
 
 'use strict';
@@ -18,13 +18,16 @@ import type EventSubscription from './_EventSubscription';
  * EventSubscriptionVendor stores a set of EventSubscriptions that are
  * subscribed to a particular event type.
  */
-class EventSubscriptionVendor {
-  _subscriptionsForType: Object;
-  _currentSubscription: ?EventSubscription;
+class EventSubscriptionVendor<EventDefinitions: {...}> {
+  _subscriptionsForType: {
+    [type: $Keys<EventDefinitions>]: Array<
+      EventSubscription<EventDefinitions, $FlowFixMe>,
+    >,
+    ...,
+  };
 
   constructor() {
     this._subscriptionsForType = {};
-    this._currentSubscription = null;
   }
 
   /**
@@ -33,10 +36,10 @@ class EventSubscriptionVendor {
    * @param {string} eventType
    * @param {EventSubscription} subscription
    */
-  addSubscription(
-    eventType: string,
-    subscription: EventSubscription,
-  ): EventSubscription {
+  addSubscription<K: $Keys<EventDefinitions>>(
+    eventType: K,
+    subscription: EventSubscription<EventDefinitions, K>,
+  ): EventSubscription<EventDefinitions, K> {
     invariant(
       subscription.subscriber === this,
       'The subscriber of the subscription is incorrectly set.',
@@ -55,10 +58,10 @@ class EventSubscriptionVendor {
    * Removes a bulk set of the subscriptions.
    *
    * @param {?string} eventType - Optional name of the event type whose
-   *   registered supscriptions to remove, if null remove all subscriptions.
+   *   registered subscriptions to remove, if null remove all subscriptions.
    */
-  removeAllSubscriptions(eventType: ?string) {
-    if (eventType === undefined) {
+  removeAllSubscriptions<K: $Keys<EventDefinitions>>(eventType: ?K): void {
+    if (eventType == null) {
       this._subscriptionsForType = {};
     } else {
       delete this._subscriptionsForType[eventType];
@@ -71,7 +74,9 @@ class EventSubscriptionVendor {
    *
    * @param {object} subscription
    */
-  removeSubscription(subscription: Object) {
+  removeSubscription<K: $Keys<EventDefinitions>>(
+    subscription: EventSubscription<EventDefinitions, K>,
+  ): void {
     const eventType = subscription.eventType;
     const key = subscription.key;
 
@@ -93,7 +98,9 @@ class EventSubscriptionVendor {
    * @param {string} eventType
    * @returns {?array}
    */
-  getSubscriptionsForType(eventType: string): ?[EventSubscription] {
+  getSubscriptionsForType<K: $Keys<EventDefinitions>>(
+    eventType: K,
+  ): ?Array<EventSubscription<EventDefinitions, K>> {
     return this._subscriptionsForType[eventType];
   }
 }