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

package/Libraries/vendor/emitter/EventEmitter.d.ts

@@ -0,0 +1,164 @@
+/**
+ * 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
+ */
+
+/**
+ * EventSubscription represents a subscription to a particular event. It can
+ * remove its own subscription.
+ */
+interface EventSubscription {
+  eventType: string;
+  key: number;
+  subscriber: EventSubscriptionVendor;
+
+  /**
+   * @param subscriber the subscriber that controls
+   *   this subscription.
+   */
+  new (subscriber: EventSubscriptionVendor): EventSubscription;
+
+  /**
+   * Removes this subscription from the subscriber that controls it.
+   */
+  remove(): void;
+}
+
+/**
+ * EventSubscriptionVendor stores a set of EventSubscriptions that are
+ * subscribed to a particular event type.
+ */
+declare class EventSubscriptionVendor {
+  constructor();
+
+  /**
+   * Adds a subscription keyed by an event type.
+   *
+   */
+  addSubscription(
+    eventType: string,
+    subscription: EventSubscription,
+  ): EventSubscription;
+
+  /**
+   * Removes a bulk set of the subscriptions.
+   *
+   * @param eventType - Optional name of the event type whose
+   *   registered subscriptions to remove, if null remove all subscriptions.
+   */
+  removeAllSubscriptions(eventType?: string): void;
+
+  /**
+   * Removes a specific subscription. Instead of calling this function, call
+   * `subscription.remove()` directly.
+   *
+   */
+  removeSubscription(subscription: any): void;
+
+  /**
+   * Returns the array of subscriptions that are currently registered for the
+   * given event type.
+   *
+   * Note: This array can be potentially sparse as subscriptions are deleted
+   * from it when they are removed.
+   *
+   */
+  getSubscriptionsForType(eventType: string): EventSubscription[];
+}
+
+/**
+ * EmitterSubscription represents a subscription with listener and context data.
+ */
+interface EmitterSubscription extends EventSubscription {
+  emitter: EventEmitter;
+  listener: () => any;
+  context: any;
+
+  /**
+   * @param emitter - The event emitter that registered this
+   *   subscription
+   * @param subscriber - The subscriber that controls
+   *   this subscription
+   * @param listener - Function to invoke when the specified event is
+   *   emitted
+   * @param context - Optional context object to use when invoking the
+   *   listener
+   */
+  new (
+    emitter: EventEmitter,
+    subscriber: EventSubscriptionVendor,
+    listener: () => any,
+    context: any,
+  ): EmitterSubscription;
+
+  /**
+   * Removes this subscription from the emitter that registered it.
+   * 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(): void;
+}
+
+export default class EventEmitter {
+  /**
+   *
+   * @param subscriber - Optional subscriber instance
+   *   to use. If omitted, a new subscriber will be created for the emitter.
+   */
+  constructor(subscriber?: EventSubscriptionVendor | null);
+
+  /**
+   * 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;
+
+  /**
+   * Removes all of the registered listeners, including those registered as
+   * listener maps.
+   *
+   * @param eventType - Optional name of the event whose registered
+   *   listeners to remove
+   */
+  removeAllListeners(eventType?: string): void;
+
+  /**
+   * Returns the number of listeners that are currently registered for the given
+   * event.
+   *
+   * @param eventType - Name of the event to query
+   */
+  listenerCount(eventType: string): number;
+
+  /**
+   * Emits an event of the given type with the given data. All handlers of that
+   * particular type will be notified.
+   *
+   * @param eventType - Name of the event to emit
+   * @param Arbitrary arguments to be passed to each registered listener
+   *
+   * @example
+   *   emitter.addListener('someEvent', function(message) {
+   *     console.log(message);
+   *   });
+   *
+   *   emitter.emit('someEvent', 'abc'); // logs 'abc'
+   */
+  emit(eventType: string, ...params: any[]): void;
+}

package/Libraries/vendor/emitter/EventEmitter.js

@@ -1,228 +1,158 @@
 /**
- * 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
- * @noflow
- * @typecheck
  */
 
-'use strict';
-
-const EmitterSubscription = require('./EmitterSubscription');
-const EventSubscriptionVendor = require('./EventSubscriptionVendor');
+export interface EventSubscription {
+  remove(): void;
+}
 
-const invariant = require('invariant');
+export interface IEventEmitter<TEventToArgsMap: {...}> {
+  addListener<TEvent: $Keys<TEventToArgsMap>>(
+    eventType: TEvent,
+    listener: (...args: TEventToArgsMap[TEvent]) => mixed,
+    context?: mixed,
+  ): EventSubscription;
 
-const sparseFilterPredicate = () => true;
+  emit<TEvent: $Keys<TEventToArgsMap>>(
+    eventType: TEvent,
+    ...args: TEventToArgsMap[TEvent]
+  ): void;
 
-/**
- * @class EventEmitter
- * @description
- * An EventEmitter is responsible for managing a set of listeners and publishing
- * events to them when it is told that such events happened. In addition to the
- * data for the given event it also sends a event control object which allows
- * the listeners/handlers to prevent the default behavior of the given event.
- *
- * The emitter is designed to be generic enough to support all the different
- * contexts in which one might want to emit events. It is a simple multicast
- * 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;
-  _currentSubscription: ?EmitterSubscription;
-
-  /**
-   * @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();
-  }
+  removeAllListeners<TEvent: $Keys<TEventToArgsMap>>(eventType?: ?TEvent): void;
 
-  /**
-   * 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.
-   *
-   * 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 {
-    return (this._subscriber.addSubscription(
-      eventType,
-      new EmitterSubscription(this, this._subscriber, listener, context),
-    ): any);
-  }
+  listenerCount<TEvent: $Keys<TEventToArgsMap>>(eventType: TEvent): number;
+}
 
-  /**
-   * Similar to addListener, except that the listener is removed after it is
-   * invoked once.
-   *
-   * @param {string} eventType - Name of the event to listen to
-   * @param {function} listener - Function to invoke only once when the
-   *   specified event is emitted
-   * @param {*} context - Optional context object to use when invoking the
-   *   listener
-   */
-  once(
-    eventType: string,
-    listener: Function,
-    context: ?Object,
-  ): EmitterSubscription {
-    return this.addListener(eventType, (...args) => {
-      this.removeCurrentListener();
-      listener.apply(context, args);
-    });
-  }
+interface Registration<TArgs> {
+  +context: mixed;
+  +listener: (...args: TArgs) => mixed;
+  +remove: () => void;
+}
 
-  /**
-   * Removes all of the registered listeners, including those registered as
-   * listener maps.
-   *
-   * @param {?string} eventType - Optional name of the event whose registered
-   *   listeners to remove
-   */
-  removeAllListeners(eventType: ?string) {
-    this._subscriber.removeAllSubscriptions(eventType);
-  }
+type Registry<TEventToArgsMap: {...}> = {
+  [K in keyof TEventToArgsMap]: Set<Registration<TEventToArgsMap[K]>>,
+};
 
-  /**
-   * Provides an API that can be called during an eventing cycle to remove the
-   * last listener that was invoked. This allows a developer to provide an event
-   * object that can remove the listener (or listener map) during the
-   * invocation.
-   *
-   * If it is called when not inside of an emitting cycle it will throw.
-   *
-   * @throws {Error} When called not during an eventing cycle
-   *
-   * @example
-   *   var subscription = emitter.addListenerMap({
-   *     someEvent: function(data, event) {
-   *       console.log(data);
-   *       emitter.removeCurrentListener();
-   *     }
-   *   });
-   *
-   *   emitter.emit('someEvent', 'abc'); // logs 'abc'
-   *   emitter.emit('someEvent', 'def'); // does not log anything
-   */
-  removeCurrentListener() {
-    invariant(
-      !!this._currentSubscription,
-      'Not in an emitting cycle; there is no current subscription',
-    );
-    this.removeSubscription(this._currentSubscription);
-  }
+/**
+ * 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 default class EventEmitter<TEventToArgsMap: {...}>
+  implements IEventEmitter<TEventToArgsMap>
+{
+  // $FlowFixMe[incompatible-type]
+  #registry: Registry<TEventToArgsMap> = {};
 
   /**
-   * Removes a specific subscription. Called by the `remove()` method of the
-   * subscription itself to ensure any necessary cleanup is performed.
+   * Registers a listener that is called when the supplied event is emitted.
+   * Returns a subscription that has a `remove` method to undo registration.
    */
-  removeSubscription(subscription: EmitterSubscription) {
-    invariant(
-      subscription.emitter === this,
-      'Subscription does not belong to this emitter.',
-    );
-    this._subscriber.removeSubscription(subscription);
+  addListener<TEvent: $Keys<TEventToArgsMap>>(
+    eventType: TEvent,
+    listener: (...args: TEventToArgsMap[TEvent]) => mixed,
+    context: mixed,
+  ): EventSubscription {
+    if (typeof listener !== 'function') {
+      throw new TypeError(
+        'EventEmitter.addListener(...): 2nd argument must be a function.',
+      );
+    }
+    const registrations = allocate<
+      TEventToArgsMap,
+      TEvent,
+      TEventToArgsMap[TEvent],
+    >(this.#registry, eventType);
+    const registration: Registration<TEventToArgsMap[TEvent]> = {
+      context,
+      listener,
+      remove(): void {
+        registrations.delete(registration);
+      },
+    };
+    registrations.add(registration);
+    return registration;
   }
 
   /**
-   * Returns an array of listeners that are currently registered for the given
-   * event.
+   * Emits the supplied event. Additional arguments supplied to `emit` will be
+   * passed through to each of the registered listeners.
    *
-   * @param {string} eventType - Name of the event to query
-   * @returns {array}
+   * If a listener modifies the listeners registered for the same event, those
+   * changes will not be reflected in the current invocation of `emit`.
    */
-  listeners(eventType: string): [EmitterSubscription] {
-    const subscriptions = this._subscriber.getSubscriptionsForType(eventType);
-    return subscriptions
-      ? subscriptions
-          // We filter out missing entries because the array is sparse.
-          // "callbackfn is called only for elements of the array which actually
-          // exist; it is not called for missing elements of the array."
-          // https://www.ecma-international.org/ecma-262/9.0/index.html#sec-array.prototype.filter
-          .filter(sparseFilterPredicate)
-          .map(subscription => subscription.listener)
-      : [];
+  emit<TEvent: $Keys<TEventToArgsMap>>(
+    eventType: TEvent,
+    ...args: TEventToArgsMap[TEvent]
+  ): void {
+    const registrations: ?Set<Registration<TEventToArgsMap[TEvent]>> =
+      this.#registry[eventType];
+    if (registrations != null) {
+      // Copy `registrations` to take a snapshot when we invoke `emit`, in case
+      // registrations are added or removed when listeners are invoked.
+      for (const registration of Array.from(registrations)) {
+        // $FlowFixMe[incompatible-call]
+        registration.listener.apply(registration.context, args);
+      }
+    }
   }
 
   /**
-   * Emits an event of the given type with the given data. All handlers of that
-   * particular type will be notified.
-   *
-   * @param {string} eventType - Name of the event to emit
-   * @param {...*} Arbitrary arguments to be passed to each registered listener
-   *
-   * @example
-   *   emitter.addListener('someEvent', function(message) {
-   *     console.log(message);
-   *   });
-   *
-   *   emitter.emit('someEvent', 'abc'); // logs 'abc'
+   * Removes all registered listeners.
    */
-  emit(eventType: string) {
-    const subscriptions = this._subscriber.getSubscriptionsForType(eventType);
-    if (subscriptions) {
-      for (let i = 0, l = subscriptions.length; i < l; i++) {
-        const subscription = subscriptions[i];
-
-        // The subscription may have been removed during this event loop.
-        if (subscription && subscription.listener) {
-          this._currentSubscription = subscription;
-          subscription.listener.apply(
-            subscription.context,
-            Array.prototype.slice.call(arguments, 1),
-          );
-        }
-      }
-      this._currentSubscription = null;
+  removeAllListeners<TEvent: $Keys<TEventToArgsMap>>(
+    eventType?: ?TEvent,
+  ): void {
+    if (eventType == null) {
+      // $FlowFixMe[incompatible-type]
+      this.#registry = {};
+    } else {
+      delete this.#registry[eventType];
     }
   }
 
   /**
-   * 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
-   *
+   * Returns the number of registered listeners for the supplied event.
    */
-  removeListener(eventType: String, listener) {
-    const subscriptions = this._subscriber.getSubscriptionsForType(eventType);
-    if (subscriptions) {
-      for (let i = 0, l = subscriptions.length; i < l; i++) {
-        const subscription = subscriptions[i];
-
-        // The subscription may have been removed during this event loop.
-        // its listener matches the listener in method parameters
-        if (subscription && subscription.listener === listener) {
-          subscription.remove();
-        }
-      }
-    }
+  listenerCount<TEvent: $Keys<TEventToArgsMap>>(eventType: TEvent): number {
+    const registrations: ?Set<Registration<mixed>> = this.#registry[eventType];
+    return registrations == null ? 0 : registrations.size;
   }
 }
 
-module.exports = EventEmitter;
+function allocate<
+  TEventToArgsMap: {...},
+  TEvent: $Keys<TEventToArgsMap>,
+  TEventArgs: 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

@@ -0,0 +1,81 @@
+/**
+ * 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 EventEmitter from '../EventEmitter';
+
+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/babel.config.js

@@ -0,0 +1,3 @@
+module.exports = {
+  presets: ["module:@rnw-scripts/babel-react-native-config"],
+};