Unify events and output single TypeScript declaration (#2407)

* fix(events): unify events to a single EventManager type, add support for single typescript declaration

* fix(lint): fix lint

* fix(events): fix incorrect instatiation

* fix(events): clean up redundant methods

* fix(events): keep EventEmitter name, alias NodeEventEmitter

* fix(events): fix loose reference

* fix(EventEmitter): remove on/off alias as redundant

* fix(RTCUtils): bring event handlers under class to use same event emitter

* fix(RTCUtils): fix lint

.gitignore

 stats.json
 .vscode
 dist
+index.d.ts
 types/auto
 types/types-comparer/auto.json
 types/types-comparer/hand-crafted.json

JitsiConference.js

 import { getLogger } from '@jitsi/logger';
-import EventEmitter from 'events';
 import $ from 'jquery';
 import isEqual from 'lodash.isequal';
 import { Strophe } from 'strophe.js';
 import LocalStatsCollector from './modules/statistics/LocalStatsCollector';
 import SpeakerStatsCollector from './modules/statistics/SpeakerStatsCollector';
 import Statistics from './modules/statistics/statistics';
+import EventEmitter from './modules/util/EventEmitter';
 import { safeSubtract } from './modules/util/MathUtil';
 import RandomUtil from './modules/util/RandomUtil';
 import ComponentsVersions from './modules/version/ComponentsVersions';

JitsiMediaDevices.js

-import EventEmitter from 'events';
-
 import * as JitsiMediaDevicesEvents from './JitsiMediaDevicesEvents';
 import RTC from './modules/RTC/RTC';
 import browser from './modules/browser';
+import Listenable from './modules/util/Listenable';
 import { MediaType } from './service/RTC/MediaType';
 import RTCEvents from './service/RTC/RTCEvents';
 
 /**
  * Media devices utilities for Jitsi.
  */
-class JitsiMediaDevices {
+class JitsiMediaDevices extends Listenable {
     /**
      * Initializes a {@code JitsiMediaDevices} object. There will be a single
      * instance of this class.
      */
     constructor() {
-        this._eventEmitter = new EventEmitter();
+        super();
         this._permissions = {};
 
         RTC.addListener(
             RTCEvents.DEVICE_LIST_CHANGED,
             devices =>
-                this._eventEmitter.emit(
+                this.eventEmitter.emit(
                     JitsiMediaDevicesEvents.DEVICE_LIST_CHANGED,
                     devices));
 
                 ...this._permissions,
                 ...permissions
             };
-            this._eventEmitter.emit(JitsiMediaDevicesEvents.PERMISSIONS_CHANGED, this._permissions);
+            this.eventEmitter.emit(JitsiMediaDevicesEvents.PERMISSIONS_CHANGED, this._permissions);
 
             if (this._permissions[MediaType.AUDIO] || this._permissions[MediaType.VIDEO]) {
                 // Triggering device list update when the permissiions are granted in order to update
     setAudioOutputDevice(deviceId) {
         return RTC.setAudioOutputDevice(deviceId);
     }
-
-    /**
-     * Adds an event handler.
-     * @param {string} event - event name
-     * @param {function} handler - event handler
-     */
-    addEventListener(event, handler) {
-        this._eventEmitter.addListener(event, handler);
-    }
-
-    /**
-     * Removes event handler.
-     * @param {string} event - event name
-     * @param {function} handler - event handler
-     */
-    removeEventListener(event, handler) {
-        this._eventEmitter.removeListener(event, handler);
-    }
-
-    /**
-     * Emits an event.
-     * @param {string} event - event name
-     */
-    emitEvent(event, ...args) {
-        this._eventEmitter.emit(event, ...args);
-    }
 }
 
 export default new JitsiMediaDevices();

JitsiMeetJS.ts

 
         if (firePermissionPrompt && !RTC.arePermissionsGrantedForAvailableDevices()) {
             // @ts-ignore
-            JitsiMediaDevices.emitEvent(JitsiMediaDevicesEvents.PERMISSION_PROMPT_IS_SHOWN, browser.getName());
+            JitsiMediaDevices.emit(JitsiMediaDevicesEvents.PERMISSION_PROMPT_IS_SHOWN, browser.getName());
         } else if (fireSlowPromiseEvent) {
             window.setTimeout(() => {
                 if (!promiseFulfilled) {
-                    JitsiMediaDevices.emitEvent(JitsiMediaDevicesEvents.SLOW_GET_USER_MEDIA);
+                    JitsiMediaDevices.emit(JitsiMediaDevicesEvents.SLOW_GET_USER_MEDIA);
                 }
             }, USER_MEDIA_SLOW_PROMISE_TIMEOUT);
         }

modules/RTC/CodecSelection.spec.js

-import EventEmitter from 'events';
-
 import * as JitsiConferenceEvents from '../../JitsiConferenceEvents.ts';
 import Listenable from '../util/Listenable.js';
 import JingleSessionPC from '../xmpp/JingleSessionPC.js';
         };
 
         this.activeMediaSession = undefined;
-        this.eventEmitter = new EventEmitter();
         this.mediaSessions = [];
         this.participants = [];
         this._signalingLayer = new MockSignalingLayerImpl();

modules/RTC/JitsiTrack.js

 import { getLogger } from '@jitsi/logger';
-import EventEmitter from 'events';
 
 import * as JitsiTrackEvents from '../../JitsiTrackEvents';
 import { MediaType } from '../../service/RTC/MediaType';
 import browser from '../browser';
+import EventEmitter from '../util/EventEmitter';
 
 import RTCUtils from './RTCUtils';
 
             videoType) {
         super();
 
-        // aliases for addListener/removeListener
-        this.addEventListener = this.addListener;
-        this.removeEventListener = this.off = this.removeListener;
-
         /**
          * Array with the HTML elements that are displaying the streams.
          * @type {Array}

modules/RTC/RTCUtils.js

 import { getLogger } from '@jitsi/logger';
-import EventEmitter from 'events';
 import clonedeep from 'lodash.clonedeep';
 import 'webrtc-adapter';
 
 
 const logger = getLogger(__filename);
 
-const eventEmitter = new EventEmitter();
-
 const AVAILABLE_DEVICES_POLL_INTERVAL_TIME = 3000; // ms
 
 /**
     return constraints;
 }
 
-/**
- * Updates the granted permissions based on the options we requested and the
- * streams we received.
- * @param um the options we requested to getUserMedia.
- * @param stream the stream we received from calling getUserMedia.
- */
-function updateGrantedPermissions(um, stream) {
-    const audioTracksReceived
-        = Boolean(stream) && stream.getAudioTracks().length > 0;
-    const videoTracksReceived
-        = Boolean(stream) && stream.getVideoTracks().length > 0;
-    const grantedPermissions = {};
-
-    if (um.indexOf('video') !== -1) {
-        grantedPermissions.video = videoTracksReceived;
-    }
-    if (um.indexOf('audio') !== -1) {
-        grantedPermissions.audio = audioTracksReceived;
-    }
-
-    eventEmitter.emit(RTCEvents.PERMISSIONS_CHANGED, grantedPermissions);
-}
-
 /**
  * Checks if new list of available media devices differs from previous one.
  * @param {MediaDeviceInfo[]} newDevices - list of new devices.
     });
 }
 
-
-/**
- * Update known devices.
- *
- * @param {Array<Object>} pds - The new devices.
- * @returns {void}
- *
- * NOTE: Use this function as a shared callback to handle both the devicechange event  and the polling implementations.
- * This prevents duplication and works around a chrome bug (verified to occur on 68) where devicechange fires twice in
- * a row, which can cause async post devicechange processing to collide.
- */
-function updateKnownDevices(pds) {
-    if (compareAvailableMediaDevices(pds)) {
-        onMediaDevicesListChanged(pds);
-    }
-}
-
-/**
- * Event handler for the 'devicechange' event.
- *
- * @param {MediaDeviceInfo[]} devices - list of media devices.
- * @emits RTCEvents.DEVICE_LIST_CHANGED
- */
-function onMediaDevicesListChanged(devicesReceived) {
-    availableDevices = devicesReceived.slice(0);
-    logger.info('list of media devices has changed:', availableDevices);
-
-    sendDeviceListToAnalytics(availableDevices);
-
-    // Used by tracks to update the real device id before the consumer of lib-jitsi-meet receives the new device list.
-    eventEmitter.emit(RTCEvents.DEVICE_LIST_WILL_CHANGE, availableDevices);
-
-    eventEmitter.emit(RTCEvents.DEVICE_LIST_CHANGED, availableDevices);
-}
-
 /**
  *
  */
 class RTCUtils extends Listenable {
-    /**
-     *
-     */
-    constructor() {
-        super(eventEmitter);
-    }
-
     /**
      * Depending on the browser, sets difference instance methods for
      * interacting with user media and adds methods to native WebRTC-related
                 logger.debug('Available devices: ', availableDevices);
                 sendDeviceListToAnalytics(availableDevices);
 
-                eventEmitter.emit(
+                this.eventEmitter.emit(
                     RTCEvents.DEVICE_LIST_AVAILABLE,
                     availableDevices);
 
     enumerateDevices(callback) {
         navigator.mediaDevices.enumerateDevices()
             .then(devices => {
-                updateKnownDevices(devices);
+                this._updateKnownDevices(devices);
                 callback(devices);
             })
             .catch(error => {
                 logger.warn(`Failed to  enumerate devices. ${error}`);
-                updateKnownDevices([]);
+                this._updateKnownDevices([]);
                 callback([]);
             });
     }
             navigator.mediaDevices.getUserMedia(constraints)
                 .then(stream => {
                     logger.log('onUserMediaSuccess');
-                    updateGrantedPermissions(umDevices, stream);
+                    this._updateGrantedPermissions(umDevices, stream);
                     if (!timeoutExpired) {
                         if (typeof gumTimeout !== 'undefined') {
                             clearTimeout(gumTimeout);
                     }
 
                     if (jitsiError.name === JitsiTrackErrors.PERMISSION_DENIED) {
-                        updateGrantedPermissions(umDevices, undefined);
+                        this._updateGrantedPermissions(umDevices, undefined);
                     }
 
                     // else {
         return missingDevices;
     }
 
+    /**
+     * Event handler for the 'devicechange' event.
+     *
+     * @param {MediaDeviceInfo[]} devices - list of media devices.
+     * @emits RTCEvents.DEVICE_LIST_CHANGED
+     */
+    _onMediaDevicesListChanged(devicesReceived) {
+        availableDevices = devicesReceived.slice(0);
+        logger.info('list of media devices has changed:', availableDevices);
+
+        sendDeviceListToAnalytics(availableDevices);
+
+        // Used by tracks to update the real device id before the consumer of lib-jitsi-meet receives the
+        // new device list.
+        this.eventEmitter.emit(RTCEvents.DEVICE_LIST_WILL_CHANGE, availableDevices);
+
+        this.eventEmitter.emit(RTCEvents.DEVICE_LIST_CHANGED, availableDevices);
+    }
+
+    /**
+     * Update known devices.
+     *
+     * @param {Array<Object>} pds - The new devices.
+     * @returns {void}
+     *
+     * NOTE: Use this function as a shared callback to handle both the devicechange event and the
+     * polling implementations.
+     * This prevents duplication and works around a chrome bug (verified to occur on 68) where devicechange
+     * fires twice in a row, which can cause async post devicechange processing to collide.
+     */
+    _updateKnownDevices(pds) {
+        if (compareAvailableMediaDevices(pds)) {
+            this._onMediaDevicesListChanged(pds);
+        }
+    }
+
+    /**
+     * Updates the granted permissions based on the options we requested and the
+     * streams we received.
+     * @param um the options we requested to getUserMedia.
+     * @param stream the stream we received from calling getUserMedia.
+     */
+    _updateGrantedPermissions(um, stream) {
+        const audioTracksReceived
+            = Boolean(stream) && stream.getAudioTracks().length > 0;
+        const videoTracksReceived
+            = Boolean(stream) && stream.getVideoTracks().length > 0;
+        const grantedPermissions = {};
+
+        if (um.indexOf('video') !== -1) {
+            grantedPermissions.video = videoTracksReceived;
+        }
+        if (um.indexOf('audio') !== -1) {
+            grantedPermissions.audio = audioTracksReceived;
+        }
+
+        this.eventEmitter.emit(RTCEvents.PERMISSIONS_CHANGED, grantedPermissions);
+    }
+
     /**
      * Gets streams from specified device types. This function intentionally
      * ignores errors for upstream to catch and handle instead.
 
                 logger.log(`Audio output device set to ${deviceId}`);
 
-                eventEmitter.emit(RTCEvents.AUDIO_OUTPUT_DEVICE_CHANGED,
+                this.eventEmitter.emit(RTCEvents.AUDIO_OUTPUT_DEVICE_CHANGED,
                     deviceId);
             });
     }

modules/RTCStats/RTCStats.ts

 
 import rtcstatsInit from '@jitsi/rtcstats/rtcstats';
 import traceInit from '@jitsi/rtcstats/trace-ws';
-import EventEmitter from 'events';
 
 import {
     CONFERENCE_JOINED,
 import JitsiConference from '../../JitsiConference';
 import { IRTCStatsConfiguration } from './interfaces';
 import { RTC_STATS_PC_EVENT, RTC_STATS_WC_DISCONNECTED } from './RTCStatsEvents';
+import EventEmitter from '../util/EventEmitter';
 
 const logger = getLogger(__filename);
 

modules/detection/NoAudioSignalDetection.js

-import EventEmitter from 'events';
-
 import * as JitsiConferenceEvents from '../../JitsiConferenceEvents';
 import * as JitsiTrackEvents from '../../JitsiTrackEvents';
+import EventEmitter from '../util/EventEmitter';
 
 import * as DetectionEvents from './DetectionEvents';
 

modules/detection/TrackVADEmitter.js

-import EventEmitter from 'events';
-
 import RTC from '../RTC/RTC';
+import EventEmitter from '../util/EventEmitter';
 import { createAudioContext } from '../webaudio/WebAudioUtils';
 
 import { VAD_SCORE_PUBLISHED } from './DetectionEvents';

modules/detection/VADAudioAnalyser.js

 import { getLogger } from '@jitsi/logger';
-import { EventEmitter } from 'events';
 
 import * as JitsiConferenceEvents from '../../JitsiConferenceEvents';
+import EventEmitter from '../util/EventEmitter';
 
 import { DETECTOR_STATE_CHANGE, VAD_SCORE_PUBLISHED } from './DetectionEvents';
 import TrackVADEmitter from './TrackVADEmitter';

modules/detection/VADNoiseDetection.js

-import { EventEmitter } from 'events';
-
+import EventEmitter from '../util/EventEmitter';
 import { calculateAverage, filterPositiveValues } from '../util/MathUtil';
 
 import { DETECTOR_STATE_CHANGE, VAD_NOISY_DEVICE } from './DetectionEvents';

modules/detection/VADReportingService.js

 import { getLogger } from '@jitsi/logger';
-import EventEmitter from 'events';
+
+import EventEmitter from '../util/EventEmitter';
 
 import * as DetectionEvents from './DetectionEvents';
 import TrackVADEmitter from './TrackVADEmitter';

modules/detection/VADTalkMutedDetection.js

-import { EventEmitter } from 'events';
-
+import EventEmitter from '../util/EventEmitter';
 import { calculateAverage } from '../util/MathUtil';
 
 import { DETECTOR_STATE_CHANGE, VAD_TALK_WHILE_MUTED } from './DetectionEvents';

modules/statistics/SpeakerStatsCollector.spec.js

-import EventEmitter from 'events';
-
 import JitsiConference from '../../JitsiConference';
 import * as JitsiConferenceEvents from '../../JitsiConferenceEvents';
 import JitsiParticipant from '../../JitsiParticipant';
+import EventEmitter from '../util/EventEmitter';
 
 import SpeakerStats from './SpeakerStats';
 import SpeakerStatsCollector from './SpeakerStatsCollector';

modules/statistics/statistics.js

-import EventEmitter from 'events';
-
 import * as JitsiConferenceEvents from '../../JitsiConferenceEvents';
 import { JitsiTrackEvents } from '../../JitsiTrackEvents';
 import { FEEDBACK } from '../../service/statistics/AnalyticsEvents';
 import * as StatisticsEvents from '../../service/statistics/Events';
 import RTCStats from '../RTCStats/RTCStats';
 import browser from '../browser';
+import EventEmitter from '../util/EventEmitter';
 import WatchRTC from '../watchRTC/WatchRTC';
 
 import analytics from './AnalyticsAdapter';

modules/util/EventEmitter.js

+import { EventEmitter as NodeEventEmitter } from 'events';
+
+/**
+ * The class creates our own EventEmitter instance
+ */
+export default class EventEmitter extends NodeEventEmitter {
+    /**
+     * Creates new instance.
+     * @constructor
+     */
+    constructor() {
+        super();
+
+        // aliases for addListener/removeListener
+        this.addEventListener = this.addListener;
+        this.removeEventListener = this.removeListener;
+    }
+}

modules/util/Listenable.js

-import EventEmitter from 'events';
+import EventEmitter from './EventEmitter';
 
 /**
  * The class implements basic event operations - add/remove listener.
 export default class Listenable {
     /**
      * Creates new instance.
-     * @param {EventEmitter} eventEmitter
      * @constructor
      */
-    constructor(eventEmitter = new EventEmitter()) {
-        this.eventEmitter = eventEmitter;
+    constructor() {
+        this.eventEmitter = new EventEmitter();
 
         // aliases for addListener/removeListener
         this.addEventListener = this.on = this.addListener;
     }
 
     /**
-     * Adds new listener.
+     * Adds new cancellable listener.
      * @param {String} eventName the name of the event
      * @param {Function} listener the listener.
      * @returns {Function} - The unsubscribe function.
      */
-    addListener(eventName, listener) {
-        this.eventEmitter.addListener(eventName, listener);
+    addCancellableListener(eventName, listener) {
+        this.addListener(eventName, listener);
+
+        return () => this.removeListener(eventName, listener);
+    }
 
-        return () => this.removeEventListener(eventName, listener);
+    /**
+     * Adds new listener.
+     * @param {String} eventName the name of the event
+     * @param {Function} listener the listener.
+     * @returns {EventEmitter} - The unsubscribe function.
+     */
+    addListener(eventName, listener) {
+        return this.eventEmitter.addListener(eventName, listener);
     }
 
     /**
      * @param {String} eventName the name of the event that triggers the
      * listener
      * @param {Function} listener the listener.
+     * @returns {EventEmitter} - The unsubscribe function.
      */
     removeListener(eventName, listener) {
-        this.eventEmitter.removeListener(eventName, listener);
+        return this.eventEmitter.removeListener(eventName, listener);
+    }
+
+    /**
+     * Emits an event.
+     * @param {string} event - event name
+     */
+    emit(event, ...args) {
+        this.eventEmitter.emit(event, ...args);
     }
 }

modules/xmpp/ResumeTask.js

         this._resumeRetryN += 1;
 
         this._networkOnlineListener
-            = NetworkInfo.addEventListener(
+            = NetworkInfo.addCancellableListener(
                 NETWORK_INFO_EVENT,
                 ({ isOnline }) => {
                     if (isOnline) {

package.json

     "build:webpack": "LIB_JITSI_MEET_COMMIT_HASH=$(git rev-parse --short HEAD 2>/dev/null) webpack",
     "build:webpack-dev": "webpack --mode development",
     "build:tsc": "tsc --build --clean && tsc",
-    "gen-types": "tsc --declaration --declarationDir types/auto --emitDeclarationOnly",
+    "gen-types": "tsc --declaration --emitDeclarationOnly --out index.js",
     "lint": "eslint .",
     "lint-fix": "eslint . --fix",
     "postinstall": "patch-package",
   "module": "dist/esm/JitsiMeetJS.js",
   "files": [
     "dist",
-    "types"
+    "types",
+    "index.d.ts"
   ],
   "license": "Apache-2.0"
 }

types/hand-crafted/JitsiMediaDevices.d.ts

   isMultipleAudioInputSupported: () => boolean;
   getAudioOutputDevice: () => string;
   setAudioOutputDevice: ( deviceId: string ) => Promise<unknown>; // TODO:
-  addEventListener: ( event: string, handler: unknown ) => void; // TODO: identify the enum for the event types and the strongly typed handlers
-  removeEventListener: ( event: string, handler: unknown ) => void; // TODO: identify the enum for the event types and the strongly typed handlers
-  emitEvent: ( event: string, ...args: unknown[] ) => void; // TODO: identify the enum for the event types
 }
 
 declare var _default: JitsiMediaDevices;
-export default _default;
+export default _default;