[eslint] require-jsdoc

.eslintrc.js

@@ -231,6 +231,16 @@ module.exports = {
         'padded-blocks': 0,
         'quote-props': 0,
         'quotes': [ 'error', 'single' ],
+        'require-jsdoc': [
+            'error',
+            {
+                'require': {
+                    'ClassDeclaration': true,
+                    'FunctionDeclaration': true,
+                    'MethodDefinition': true
+                }
+            }
+        ],
         'semi': [ 'error', 'always' ],
         'semi-spacing': 2,
         'sort-vars': 2,

JitsiMeetJS.js

@@ -31,6 +31,10 @@ const logger = Logger.getLogger(__filename);
 // JitsiMediaDevicesEvents.PERMISSION_PROMPT_IS_SHOWN event
 const USER_MEDIA_PERMISSION_PROMPT_TIMEOUT = 500;
 
+/**
+ *
+ * @param resolution
+ */
 function getLowerResolution(resolution) {
     if (!Resolutions[resolution]) {
         return null;

JitsiParticipant.js

@@ -205,6 +205,9 @@ export default class JitsiParticipant {
         return this._role;
     }
 
+    /**
+     *
+     */
     supportsDTMF() {
         return this._supportsDTMF;
     }

doc/example/example.js

@@ -108,6 +108,10 @@ function onConferenceJoined() {
     }
 }
 
+/**
+ *
+ * @param id
+ */
 function onUserLeft(id) {
     console.log('user left');
     if (!remoteTracks[id]) {
@@ -190,6 +194,9 @@ function disconnect() {
         disconnect);
 }
 
+/**
+ *
+ */
 function unload() {
     for (let i = 0; i < localTracks.length; i++) {
         localTracks[i].stop();
@@ -200,6 +207,9 @@ function unload() {
 
 let isVideo = true;
 
+/**
+ *
+ */
 function switchVideo() { // eslint-disable-line no-unused-vars
     isVideo = !isVideo;
     if (localTracks[1]) {
@@ -222,6 +232,10 @@ function switchVideo() { // eslint-disable-line no-unused-vars
         .catch(error => console.log(error));
 }
 
+/**
+ *
+ * @param selected
+ */
 function changeAudioOutput(selected) { // eslint-disable-line no-unused-vars
     JitsiMeetJS.mediaDevices.setAudioOutputDevice(selected.value);
 }

modules/DTMF/JitsiDTMFManager.js

@@ -1,5 +1,10 @@
 const logger = require('jitsi-meet-logger').getLogger(__filename);
 
+/**
+ *
+ * @param localAudio
+ * @param peerConnection
+ */
 function JitsiDTMFManager(localAudio, peerConnection) {
     const audioTrack = localAudio.getTrack();
 
@@ -11,7 +16,6 @@ function JitsiDTMFManager(localAudio, peerConnection) {
     logger.debug('Initialized DTMFSender');
 }
 
-
 JitsiDTMFManager.prototype.sendTones = function(tones, duration, pause) {
     this.dtmfSender.insertDTMF(tones, duration || 200, pause || 200);
 };

modules/RTC/RTC.js

@@ -15,6 +15,11 @@ import VideoType from '../../service/RTC/VideoType';
 
 const logger = getLogger(__filename);
 
+/**
+ *
+ * @param tracksInfo
+ * @param options
+ */
 function createLocalTracks(tracksInfo, options) {
     const newTracks = [];
     let deviceId = null;
@@ -41,7 +46,15 @@ function createLocalTracks(tracksInfo, options) {
     return newTracks;
 }
 
+/**
+ *
+ */
 export default class RTC extends Listenable {
+    /**
+     *
+     * @param conference
+     * @param options
+     */
     constructor(conference, options = {}) {
         super();
         this.conference = conference;
@@ -198,24 +211,44 @@ export default class RTC extends Listenable {
         }
     }
 
+    /**
+     *
+     * @param eventType
+     * @param listener
+     */
     static addListener(eventType, listener) {
         RTCUtils.addListener(eventType, listener);
     }
 
+    /**
+     *
+     * @param eventType
+     * @param listener
+     */
     static removeListener(eventType, listener) {
         RTCUtils.removeListener(eventType, listener);
     }
 
+    /**
+     *
+     */
     static isRTCReady() {
         return RTCUtils.isRTCReady();
     }
 
+    /**
+     *
+     * @param options
+     */
     static init(options = {}) {
         this.options = options;
 
         return RTCUtils.init(this.options);
     }
 
+    /**
+     *
+     */
     static getDeviceAvailability() {
         return RTCUtils.getDeviceAvailability();
     }
@@ -269,6 +302,10 @@ export default class RTC extends Listenable {
 
     }
 
+    /**
+     *
+     * @param track
+     */
     addLocalTrack(track) {
         if (!track) {
             throw new Error('track must not be null nor undefined');
@@ -401,6 +438,10 @@ export default class RTC extends Listenable {
         return Promise.all(mutePromises);
     }
 
+    /**
+     *
+     * @param track
+     */
     removeLocalTrack(track) {
         const pos = this.localTracks.indexOf(track);
 
@@ -546,14 +587,26 @@ export default class RTC extends Listenable {
         return toBeRemoved;
     }
 
+    /**
+     *
+     */
     static getPCConstraints() {
         return RTCUtils.pcConstraints;
     }
 
+    /**
+     *
+     * @param elSelector
+     * @param stream
+     */
     static attachMediaStream(elSelector, stream) {
         return RTCUtils.attachMediaStream(elSelector, stream);
     }
 
+    /**
+     *
+     * @param stream
+     */
     static getStreamID(stream) {
         return RTCUtils.getStreamID(stream);
     }
@@ -682,6 +735,11 @@ export default class RTC extends Listenable {
         }
     }
 
+    /**
+     *
+     * @param resource
+     * @param audioLevel
+     */
     setAudioLevel(resource, audioLevel) {
         if (!resource) {
             return;

modules/RTC/RTCBrowserType.js

@@ -197,8 +197,10 @@ const RTCBrowserType = {
     // Add version getters for other browsers when needed
 };
 
-// detectOpera() must be called before detectChrome() !!!
-// otherwise Opera wil be detected as Chrome
+/**
+ * detectOpera() must be called before detectChrome() !!!
+ * otherwise Opera wil be detected as Chrome
+ */
 function detectChrome() {
     if (navigator.webkitGetUserMedia) {
         currentBrowser = RTCBrowserType.RTC_BROWSER_CHROME;
@@ -216,6 +218,9 @@ function detectChrome() {
     return null;
 }
 
+/**
+ *
+ */
 function detectOpera() {
     const userAgent = navigator.userAgent;
 
@@ -231,6 +236,9 @@ function detectOpera() {
     return null;
 }
 
+/**
+ *
+ */
 function detectFirefox() {
     if (navigator.mozGetUserMedia) {
         currentBrowser = RTCBrowserType.RTC_BROWSER_FIREFOX;
@@ -245,6 +253,9 @@ function detectFirefox() {
     return null;
 }
 
+/**
+ *
+ */
 function detectSafari() {
     if (/^((?!chrome).)*safari/i.test(navigator.userAgent)) {
         currentBrowser = RTCBrowserType.RTC_BROWSER_SAFARI;
@@ -257,6 +268,9 @@ function detectSafari() {
     return null;
 }
 
+/**
+ *
+ */
 function detectIE() {
     let version;
     const ua = window.navigator.userAgent;
@@ -310,6 +324,9 @@ function detectElectron() {
     return null;
 }
 
+/**
+ *
+ */
 function detectNWJS() {
     const userAgent = navigator.userAgent;
 
@@ -325,6 +342,9 @@ function detectNWJS() {
     return null;
 }
 
+/**
+ *
+ */
 function detectReactNative() {
     const match
         = navigator.userAgent.match(/\b(react[ \t_-]*native)(?:\/(\S+))?/i);
@@ -353,6 +373,9 @@ function detectReactNative() {
     return version;
 }
 
+/**
+ *
+ */
 function detectBrowser() {
     let version;
     const detectors = [

modules/RTC/RTCUtils.js

@@ -62,14 +62,16 @@ const isAudioOutputDeviceChangeAvailable
 
 let currentlyAvailableMediaDevices;
 
-let rawEnumerateDevicesWithCallback;
-
 /**
  * "rawEnumerateDevicesWithCallback" will be initialized only after WebRTC is
  * ready. Otherwise it is too early to assume that the devices listing is not
  * supported.
  */
+let rawEnumerateDevicesWithCallback;
 
+/**
+ *
+ */
 function initRawEnumerateDevicesWithCallback() {
     rawEnumerateDevicesWithCallback = navigator.mediaDevices
         && navigator.mediaDevices.enumerateDevices
@@ -105,6 +107,11 @@ const isDeviceChangeEventSupported = false;
 
 let rtcReady = false;
 
+/**
+ *
+ * @param constraints
+ * @param resolution
+ */
 function setResolutionConstraints(constraints, resolution) {
     const isAndroid = RTCBrowserType.isAndroid();
 
@@ -358,6 +365,10 @@ function compareAvailableMediaDevices(newDevices) {
                 .sort()
                 .join(''));
 
+    /**
+     *
+     * @param info
+     */
     function mediaDeviceInfoToJSON(info) {
         return JSON.stringify({
             kind: info.kind,
@@ -664,12 +675,21 @@ function defaultSetVideoSrc(element, stream) {
     element.src = src || '';
 }
 
-// Options parameter is to pass config options. Currently uses only "useIPv6".
+/**
+ *
+ */
 class RTCUtils extends Listenable {
+    /**
+     *
+     */
     constructor() {
         super(eventEmitter);
     }
 
+    /**
+     *
+     * @param options
+     */
     init(options) {
         if (typeof options.disableAEC === 'boolean') {
             disableAEC = options.disableAEC;
@@ -1119,14 +1139,23 @@ class RTCUtils extends Listenable {
         });
     }
 
+    /**
+     *
+     */
     getDeviceAvailability() {
         return devices;
     }
 
+    /**
+     *
+     */
     isRTCReady() {
         return rtcReady;
     }
 
+    /**
+     *
+     */
     _isDeviceListAvailable() {
         if (!rtcReady) {
             throw new Error('WebRTC not ready yet');
@@ -1327,6 +1356,10 @@ function rejectWithWebRTCNotSupported(errorMessage, reject) {
 
 const rtcUtils = new RTCUtils();
 
+/**
+ *
+ * @param options
+ */
 function obtainDevices(options) {
     if (!options.devices || options.devices.length === 0) {
         return options.successCallback(options.streams || {});
@@ -1350,9 +1383,13 @@ function obtainDevices(options) {
         });
 }
 
-// In case of IE we continue from 'onReady' callback
-// passed to RTCUtils constructor. It will be invoked by Temasys plugin
-// once it is initialized.
+/**
+ * In case of IE we continue from 'onReady' callback passed to RTCUtils
+ * constructor. It will be invoked by Temasys plugin once it is initialized.
+ *
+ * @param options
+ * @param GUM
+ */
 function onReady(options, GUM) {
     rtcReady = true;
     eventEmitter.emit(RTCEvents.RTC_READY, true);

modules/RTC/ScreenObtainer.js

@@ -406,6 +406,11 @@ function isUpdateRequired(minVersion, extVersion) {
     }
 }
 
+/**
+ *
+ * @param callback
+ * @param options
+ */
 function checkChromeExtInstalled(callback, options) {
     if (typeof chrome === 'undefined' || !chrome || !chrome.runtime) {
         // No API, so no extension for sure
@@ -440,6 +445,12 @@ function checkChromeExtInstalled(callback, options) {
     );
 }
 
+/**
+ *
+ * @param options
+ * @param streamCallback
+ * @param failCallback
+ */
 function doGetStreamFromExtension(options, streamCallback, failCallback) {
     // Sends 'getStream' msg to the extension.
     // Extension id must be defined in the config.
@@ -482,6 +493,10 @@ function initInlineInstalls(options) {
         getWebStoreInstallUrl(options));
 }
 
+/**
+ *
+ * @param options
+ */
 function initChromeExtension(options) {
     // Initialize Chrome extension inline installs
     initInlineInstalls(options);

modules/TalkMutedDetection.js

@@ -1,5 +1,8 @@
 import * as JitsiConferenceEvents from '../JitsiConferenceEvents';
 
+/**
+ *
+ */
 export default class TalkMutedDetection {
     /**
      * Creates TalkMutedDetection

modules/connectivity/ConnectionQuality.js

@@ -145,6 +145,12 @@ function rampUp(millisSinceStart) {
  * value of 0% indicates a poor connection.
  */
 export default class ConnectionQuality {
+    /**
+     *
+     * @param conference
+     * @param eventEmitter
+     * @param options
+     */
     constructor(conference, eventEmitter, options) {
         this.eventEmitter = eventEmitter;
 

modules/connectivity/ParticipantConnectionStatus.js

@@ -189,6 +189,11 @@ export default class ParticipantConnectionStatus {
         }
     }
 
+    /**
+     *
+     * @param participant
+     * @param newStatus
+     */
     _changeConnectionStatus(participant, newStatus) {
         if (participant.isConnectionActive() !== newStatus) {
 

modules/settings/Settings.js

@@ -17,10 +17,16 @@ function getLocalStorage() {
     return global.localStorage;
 }
 
+/**
+ *
+ */
 function _p8() {
     return `${Math.random().toString(16)}000000000`.substr(2, 8);
 }
 
+/**
+ *
+ */
 function generateUniqueId() {
     return _p8() + _p8() + _p8() + _p8();
 }
@@ -49,7 +55,13 @@ function generateCallStatsUsername() {
     return username;
 }
 
+/**
+ *
+ */
 class Settings {
+    /**
+     *
+     */
     constructor() {
         const localStorage = getLocalStorage();
 

modules/statistics/AnalyticsAdapter.js

@@ -2,6 +2,9 @@
  * Interface for analytics handlers.
  */
 class AnalyticsAbstract {
+    /**
+     *
+     */
     sendEvent() {} // eslint-disable-line no-empty-function
 }
 
@@ -10,6 +13,9 @@ class AnalyticsAbstract {
  * @extends AnalyticsAbstract
  */
 class CacheAnalytics extends AnalyticsAbstract {
+    /**
+     *
+     */
     constructor() {
         super();
 
@@ -50,6 +56,9 @@ const cacheAnalytics = new CacheAnalytics();
  * This class will store and manage the handlers that are going to be used.
  */
 class AnalyticsAdapter {
+    /**
+     *
+     */
     constructor() {
         this.analyticsHandlers = new Set();
 

modules/statistics/CallStats.js

@@ -486,6 +486,12 @@ CallStats.dispose = function() {
 };
 
 /* eslint-disable no-invalid-this */
+
+/**
+ *
+ * @param err
+ * @param msg
+ */
 function initCallback(err, msg) {
     logger.log(`CallStats Status: err=${err} msg=${msg}`);
 

modules/statistics/RTPStatsCollector.js

@@ -122,6 +122,9 @@ SsrcStats.prototype.resetBitrate = function() {
     this.bitrate.upload = 0;
 };
 
+/**
+ *
+ */
 function ConferenceStats() {
 
     /**
@@ -402,6 +405,11 @@ StatsCollector.prototype.processStatsReport = function() {
 
     const getStatValue = this._getStatValue;
 
+    /**
+     *
+     * @param report
+     * @param name
+     */
     function getNonNegativeStat(report, name) {
         let value = getStatValue(report, name);
 

modules/statistics/statistics.js

@@ -16,13 +16,17 @@ import * as StatisticsEvents from '../../service/statistics/Events';
  */
 let isCallstatsLoaded = false;
 
-// Since callstats.io is a third party, we cannot guarantee the quality of their
-// service. More specifically, their server may take noticeably long time to
-// respond. Consequently, it is in our best interest (in the sense that the
-// intergration of callstats.io is pretty important to us but not enough to
-// allow it to prevent people from joining a conference) to (1) start
-// downloading their API as soon as possible and (2) do the downloading
-// asynchronously.
+/**
+ * Since callstats.io is a third party, we cannot guarantee the quality of their
+ * service. More specifically, their server may take noticeably long time to
+ * respond. Consequently, it is in our best interest (in the sense that the
+ * intergration of callstats.io is pretty important to us but not enough to
+ * allow it to prevent people from joining a conference) to (1) start
+ * downloading their API as soon as possible and (2) do the downloading
+ * asynchronously.
+ *
+ * @param customScriptUrl
+ */
 function loadCallStatsAPI(customScriptUrl) {
     if (!isCallstatsLoaded) {
         ScriptUtil.loadScript(
@@ -81,6 +85,11 @@ Statistics.init = function(options) {
 
 };
 
+/**
+ *
+ * @param xmpp
+ * @param options
+ */
 function Statistics(xmpp, options) {
     this.rtpStats = null;
     this.eventEmitter = new EventEmitter();

modules/xmpp/Caps.js

@@ -9,6 +9,11 @@ const IDENTITY_PROPERTIES = [ 'category', 'type', 'lang', 'name' ];
 const IDENTITY_PROPERTIES_FOR_COMPARE = [ 'category', 'type', 'lang' ];
 const HASH = 'sha-1';
 
+/**
+ *
+ * @param a
+ * @param b
+ */
 function compareIdentities(a, b) {
     let res = 0;
 

modules/xmpp/ChatRoom.js

@@ -83,10 +83,21 @@ function filterNodeFromPresenceJSON(pres, nodeName) {
 // of chaining function calls, allow long function call chains.
 /* eslint-disable newline-per-chained-call */
 
+/**
+ *
+ */
 export default class ChatRoom extends Listenable {
 
     /* eslint-disable max-params */
 
+    /**
+     *
+     * @param connection
+     * @param jid
+     * @param password
+     * @param XMPP
+     * @param options
+     */
     constructor(connection, jid, password, XMPP, options) {
         super();
         this.xmpp = XMPP;
@@ -120,6 +131,9 @@ export default class ChatRoom extends Listenable {
 
     /* eslint-enable max-params */
 
+    /**
+     *
+     */
     initPresenceMap() {
         this.presMap.to = this.myroomjid;
         this.presMap.xns = 'http://jabber.org/protocol/muc';
@@ -136,6 +150,10 @@ export default class ChatRoom extends Listenable {
         this.addVideoInfoToPresence(false);
     }
 
+    /**
+     *
+     * @param devices
+     */
     updateDeviceAvailability(devices) {
         this.presMap.nodes.push({
             'tagName': 'devices',
@@ -152,11 +170,19 @@ export default class ChatRoom extends Listenable {
         });
     }
 
+    /**
+     *
+     * @param password
+     */
     join(password) {
         this.password = password;
         this.moderator.allocateConferenceFocus(() => this.sendPresence(true));
     }
 
+    /**
+     *
+     * @param fromJoin
+     */
     sendPresence(fromJoin) {
         const to = this.presMap.to;
 
@@ -220,6 +246,9 @@ export default class ChatRoom extends Listenable {
         this.connection.flush();
     }
 
+    /**
+     *
+     */
     discoRoomInfo() {
       // https://xmpp.org/extensions/xep-0045.html#disco-roominfo
 
@@ -243,7 +272,9 @@ export default class ChatRoom extends Listenable {
         });
     }
 
-
+    /**
+     *
+     */
     createNonAnonymousRoom() {
         // http://xmpp.org/extensions/xep-0045.html#createroom-reserved
 
@@ -289,6 +320,10 @@ export default class ChatRoom extends Listenable {
         });
     }
 
+    /**
+     *
+     * @param pres
+     */
     onPresence(pres) {
         const from = pres.getAttribute('from');
 
@@ -490,6 +525,11 @@ export default class ChatRoom extends Listenable {
         this.participantPropertyListener = listener;
     }
 
+    /**
+     *
+     * @param node
+     * @param from
+     */
     processNode(node, from) {
         // make sure we catch all errors coming from any handler
         // otherwise we can remove the presence handler from strophe
@@ -509,6 +549,11 @@ export default class ChatRoom extends Listenable {
         }
     }
 
+    /**
+     *
+     * @param body
+     * @param nickname
+     */
     sendMessage(body, nickname) {
         const msg = $msg({ to: this.roomjid,
             type: 'groupchat' });
@@ -524,6 +569,10 @@ export default class ChatRoom extends Listenable {
         this.eventEmitter.emit(XMPPEvents.SENDING_CHAT_MESSAGE, body);
     }
 
+    /**
+     *
+     * @param subject
+     */
     setSubject(subject) {
         const msg = $msg({ to: this.roomjid,
             type: 'groupchat' });
@@ -551,6 +600,11 @@ export default class ChatRoom extends Listenable {
         this.moderator.onMucMemberLeft(jid);
     }
 
+    /**
+     *
+     * @param pres
+     * @param from
+     */
     onPresenceUnavailable(pres, from) {
         // room destroyed ?
         if ($(pres).find('>x[xmlns="http://jabber.org/protocol/muc#user"]'
@@ -617,6 +671,11 @@ export default class ChatRoom extends Listenable {
         }
     }
 
+    /**
+     *
+     * @param msg
+     * @param from
+     */
     onMessage(msg, from) {
         const nick
             = $(msg).find('>nick[xmlns="http://jabber.org/protocol/nick"]')
@@ -676,6 +735,11 @@ export default class ChatRoom extends Listenable {
         }
     }
 
+    /**
+     *
+     * @param pres
+     * @param from
+     */
     onPresenceError(pres, from) {
         if ($(pres)
                 .find(
@@ -715,6 +779,10 @@ export default class ChatRoom extends Listenable {
         }
     }
 
+    /**
+     *
+     * @param jid
+     */
     kick(jid) {
         const kickIQ = $iq({ to: this.roomjid,
             type: 'set' })
@@ -731,6 +799,13 @@ export default class ChatRoom extends Listenable {
 
     /* eslint-disable max-params */
 
+    /**
+     *
+     * @param key
+     * @param onSuccess
+     * @param onError
+     * @param onNotSupported
+     */
     lockRoom(key, onSuccess, onError, onNotSupported) {
         // http://xmpp.org/extensions/xep-0045.html#roomconfig
         this.connection.sendIQ(
@@ -791,22 +866,40 @@ export default class ChatRoom extends Listenable {
 
     /* eslint-enable max-params */
 
+    /**
+     *
+     * @param key
+     * @param values
+     */
     addToPresence(key, values) {
         values.tagName = key;
         this.removeFromPresence(key);
         this.presMap.nodes.push(values);
     }
 
+    /**
+     *
+     * @param key
+     */
     removeFromPresence(key) {
         const nodes = this.presMap.nodes.filter(node => key !== node.tagName);
 
         this.presMap.nodes = nodes;
     }
 
+    /**
+     *
+     * @param name
+     * @param handler
+     */
     addPresenceListener(name, handler) {
         this.presHandlers[name] = handler;
     }
 
+    /**
+     *
+     * @param name
+     */
     removePresenceListener(name) {
         delete this.presHandlers[name];
     }
@@ -829,10 +922,17 @@ export default class ChatRoom extends Listenable {
         return null;
     }
 
+    /**
+     *
+     */
     isModerator() {
         return this.role === 'moderator';
     }
 
+    /**
+     *
+     * @param peerJid
+     */
     getMemberRole(peerJid) {
         if (this.members[peerJid]) {
             return this.members[peerJid].role;
@@ -841,6 +941,11 @@ export default class ChatRoom extends Listenable {
         return null;
     }
 
+    /**
+     *
+     * @param mute
+     * @param callback
+     */
     setVideoMute(mute, callback) {
         this.sendVideoInfoPresence(mute);
         if (callback) {
@@ -848,10 +953,19 @@ export default class ChatRoom extends Listenable {
         }
     }
 
+    /**
+     *
+     * @param mute
+     * @apram callback
+     */
     setAudioMute(mute, callback) {
         return this.sendAudioInfoPresence(mute, callback);
     }
 
+    /**
+     *
+     * @param mute
+     */
     addAudioInfoToPresence(mute) {
         this.removeFromPresence('audiomuted');
         this.addToPresence('audiomuted',
@@ -860,6 +974,11 @@ export default class ChatRoom extends Listenable {
                 value: mute.toString() });
     }
 
+    /**
+     *
+     * @param mute
+     * @param callback
+     */
     sendAudioInfoPresence(mute, callback) {
         this.addAudioInfoToPresence(mute);
         if (this.connection) {
@@ -870,6 +989,10 @@ export default class ChatRoom extends Listenable {
         }
     }
 
+    /**
+     *
+     * @param mute
+     */
     addVideoInfoToPresence(mute) {
         this.removeFromPresence('videomuted');
         this.addToPresence('videomuted',
@@ -878,6 +1001,10 @@ export default class ChatRoom extends Listenable {
                 value: mute.toString() });
     }
 
+    /**
+     *
+     * @param mute
+     */
     sendVideoInfoPresence(mute) {
         this.addVideoInfoToPresence(mute);
         if (!this.connection) {
@@ -1037,6 +1164,10 @@ export default class ChatRoom extends Listenable {
             error => logger.log('set mute error', error));
     }
 
+    /**
+     *
+     * @param iq
+     */
     onMute(iq) {
         const from = iq.getAttribute('from');
 
@@ -1069,6 +1200,10 @@ export default class ChatRoom extends Listenable {
             const timeout = setTimeout(() => onMucLeft(true), 5000);
             const eventEmitter = this.eventEmitter;
 
+            /**
+             *
+             * @param doReject
+             */
             function onMucLeft(doReject = false) {
                 eventEmitter.removeListener(XMPPEvents.MUC_LEFT, onMucLeft);
                 clearTimeout(timeout);

modules/xmpp/ConnectionPlugin.js

@@ -10,10 +10,18 @@ function getConnectionPluginDefinition(base = class {}) {
      * Base class for strophe connection plugins.
      */
     return class extends base {
+        /**
+         *
+         */
         constructor(...args) {
             super(...args);
             this.connection = null;
         }
+
+        /**
+         *
+         * @param connection
+         */
         init(connection) {
             this.connection = connection;
         }

modules/xmpp/JingleSession.js

@@ -4,7 +4,7 @@ import * as JingleSessionState from './JingleSessionState';
 
 const logger = getLogger(__filename);
 
-/*
+/**
  * JingleSession provides an API to manage a single Jingle session. We will
  * have different implementations depending on the underlying interface used
  * (i.e. WebRTC and ORTC) and here we hold the code common to all of them.
@@ -99,15 +99,20 @@ export default class JingleSession {
      * {@link initialize}.
      * @protected
      */
-    doInitialize() { } // eslint-disable-line no-empty-function
+    doInitialize() {} // eslint-disable-line no-empty-function
+
+    /* eslint-disable no-unused-vars, no-empty-function */
 
     /**
      * Adds the ICE candidates found in the 'contents' array as remote
      * candidates?
      * Note: currently only used on transport-info
+     *
+     * @param contents
      */
-    // eslint-disable-next-line no-unused-vars, no-empty-function
-    addIceCandidates(contents) { }
+    addIceCandidates(contents) {}
+
+    /* eslint-enable no-unused-vars, no-empty-function */
 
     /**
      * Returns current state of this <tt>JingleSession</tt> instance.
@@ -117,21 +122,23 @@ export default class JingleSession {
         return this.state;
     }
 
+    /* eslint-disable no-unused-vars, no-empty-function */
+
     /**
      * Handles an 'add-source' event.
      *
      * @param contents an array of Jingle 'content' elements.
      */
-    // eslint-disable-next-line no-unused-vars, no-empty-function
-    addSources(contents) { }
+    addSources(contents) {}
 
     /**
      * Handles a 'remove-source' event.
      *
      * @param contents an array of Jingle 'content' elements.
      */
-    // eslint-disable-next-line no-unused-vars, no-empty-function
-    removeSources(contents) { }
+    removeSources(contents) {}
+
+    /* eslint-disable max-params */
 
     /**
      * Terminates this Jingle session by sending session-terminate
@@ -142,8 +149,9 @@ export default class JingleSession {
      * @param failure a callback called when either timeout occurs or ERROR
      * response is received.
      */
-    // eslint-disable-next-line max-params, no-unused-vars, no-empty-function
-    terminate(reason, text, success, failure) { }
+    terminate(reason, text, success, failure) {}
+
+    /* eslint-enable max-params */
 
     /**
      * Handles an offer from the remote peer (prepares to accept a session).
@@ -154,6 +162,7 @@ export default class JingleSession {
      * error object with details(which is meant more to be printed to the logger
      * than analysed in the code, as the error is unrecoverable anyway)
      */
-    // eslint-disable-next-line no-unused-vars, no-empty-function
-    acceptOffer(jingle, success, failure) { }
+    acceptOffer(jingle, success, failure) {}
+
+    /* eslint-enable no-unused-vars, no-empty-function */
 }

modules/xmpp/JingleSessionPC.js

@@ -22,6 +22,9 @@ import * as JingleSessionState from './JingleSessionState';
  */
 const IQ_TIMEOUT = 10000;
 
+/**
+ *
+ */
 export default class JingleSessionPC extends JingleSession {
 
     /* eslint-disable max-params */
@@ -108,6 +111,9 @@ export default class JingleSessionPC extends JingleSession {
 
     /* eslint-enable max-params */
 
+    /**
+     *
+     */
     doInitialize() {
         this.lasticecandidate = false;
 
@@ -244,6 +250,10 @@ export default class JingleSessionPC extends JingleSession {
         };
     }
 
+    /**
+     *
+     * @param candidate
+     */
     sendIceCandidate(candidate) {
         const localSDP = new SDP(this.peerconnection.localDescription.sdp);
 
@@ -286,6 +296,10 @@ export default class JingleSessionPC extends JingleSession {
         }
     }
 
+    /**
+     *
+     * @param candidates
+     */
     sendIceCandidates(candidates) {
         logger.log('sendIceCandidates', candidates);
         const cand = $iq({ to: this.peerjid,
@@ -357,6 +371,10 @@ export default class JingleSessionPC extends JingleSession {
             }), IQ_TIMEOUT);
     }
 
+    /**
+     *
+     * @param contents
+     */
     readSsrcInfo(contents) {
         $(contents).each((i1, content) => {
             const ssrcs
@@ -672,6 +690,11 @@ export default class JingleSessionPC extends JingleSession {
 
     /* eslint-enable max-params */
 
+    /**
+     *
+     * @param reasonCondition
+     * @param reasonText
+     */
     onTerminated(reasonCondition, reasonText) {
         this.state = 'ended';
 
@@ -1492,6 +1515,11 @@ export default class JingleSessionPC extends JingleSession {
         };
     }
 
+    /**
+     *
+     * @param session
+     * @param error
+     */
     static onJingleFatalError(session, error) {
         if (this.room) {
             this.room.eventEmitter.emit(

modules/xmpp/SDP.js

@@ -2,7 +2,10 @@
 
 const SDPUtil = require('./SDPUtil');
 
-// SDP STUFF
+/**
+ *
+ * @param sdp
+ */
 function SDP(sdp) {
     const media = sdp.split('\r\nm=');
 

modules/xmpp/SDPDiffer.js

@@ -1,6 +1,11 @@
 const SDPUtil = require('./SDPUtil');
 
 // this could be useful in Array.prototype.
+/**
+ *
+ * @param array1
+ * @param array2
+ */
 function arrayEquals(array1, array2) {
     // if the other array is a falsy value, return
     if (!array2) {
@@ -29,6 +34,11 @@ function arrayEquals(array1, array2) {
     return true;
 }
 
+/**
+ *
+ * @param mySDP
+ * @param otherSDP
+ */
 function SDPDiffer(mySDP, otherSDP) {
     this.mySDP = mySDP;
     this.otherSDP = otherSDP;

modules/xmpp/SdpTransformUtil.js

@@ -53,6 +53,9 @@ class MLineWrap {
         this.mLine = mLine;
     }
 
+    /**
+     *
+     */
     get _ssrcs() {
         if (!this.mLine.ssrcs) {
             this.mLine.ssrcs = [];

modules/xmpp/moderator.js

@@ -8,6 +8,10 @@ const GlobalOnErrorHandler = require('../util/GlobalOnErrorHandler');
 
 import Settings from '../settings/Settings';
 
+/**
+ *
+ * @param step
+ */
 function createExpBackoffTimer(step) {
     let count = 1;
 
@@ -30,6 +34,13 @@ function createExpBackoffTimer(step) {
 
 /* eslint-disable max-params */
 
+/**
+ *
+ * @param roomName
+ * @param xmpp
+ * @param emitter
+ * @param options
+ */
 function Moderator(roomName, xmpp, emitter, options) {
     this.roomName = roomName;
     this.xmppService = xmpp;
@@ -51,8 +62,11 @@ function Moderator(roomName, xmpp, emitter, options) {
 
     this.connection = this.xmppService.connection;
 
-    // FIXME:
-    // Message listener that talks to POPUP window
+    // FIXME: Message listener that talks to POPUP window
+    /**
+     *
+     * @param event
+     */
     function listener(event) {
         if (event.data && event.data.sessionId) {
             if (event.origin !== window.location.origin) {

modules/xmpp/recording.js

@@ -8,6 +8,15 @@ const GlobalOnErrorHandler = require('../util/GlobalOnErrorHandler');
 
 /* eslint-disable max-params */
 
+/**
+ *
+ * @param type
+ * @param eventEmitter
+ * @param connection
+ * @param focusMucJid
+ * @param jirecon
+ * @param roomjid
+ */
 function Recording(
         type,
         eventEmitter,

modules/xmpp/strophe.emuc.js

@@ -11,13 +11,24 @@ import ChatRoom from './ChatRoom';
 import { ConnectionPluginListenable } from './ConnectionPlugin';
 import XMPPEvents from '../../service/xmpp/XMPPEvents';
 
+/**
+ *
+ */
 class MucConnectionPlugin extends ConnectionPluginListenable {
+    /**
+     *
+     * @param xmpp
+     */
     constructor(xmpp) {
         super();
         this.xmpp = xmpp;
         this.rooms = {};
     }
 
+    /**
+     *
+     * @param connection
+     */
     init(connection) {
         super.init(connection);
 
@@ -34,6 +45,12 @@ class MucConnectionPlugin extends ConnectionPluginListenable {
             'http://jitsi.org/jitmeet/audio', 'iq', 'set', null, null);
     }
 
+    /**
+     *
+     * @param jid
+     * @param password
+     * @param options
+     */
     createRoom(jid, password, options) {
         const roomJid = Strophe.getBareJidFromJid(jid);
 
@@ -51,12 +68,20 @@ class MucConnectionPlugin extends ConnectionPluginListenable {
         return this.rooms[roomJid];
     }
 
+    /**
+     *
+     * @param jid
+     */
     doLeave(jid) {
         this.eventEmitter.emit(
             XMPPEvents.EMUC_ROOM_REMOVED, this.rooms[jid]);
         delete this.rooms[jid];
     }
 
+    /**
+     *
+     * @param pres
+     */
     onPresence(pres) {
         const from = pres.getAttribute('from');
 
@@ -82,6 +107,10 @@ class MucConnectionPlugin extends ConnectionPluginListenable {
         return true;
     }
 
+    /**
+     *
+     * @param pres
+     */
     onPresenceUnavailable(pres) {
         const from = pres.getAttribute('from');
         const room = this.rooms[Strophe.getBareJidFromJid(from)];
@@ -95,6 +124,10 @@ class MucConnectionPlugin extends ConnectionPluginListenable {
         return true;
     }
 
+    /**
+     *
+     * @param pres
+     */
     onPresenceError(pres) {
         const from = pres.getAttribute('from');
         const room = this.rooms[Strophe.getBareJidFromJid(from)];
@@ -108,6 +141,10 @@ class MucConnectionPlugin extends ConnectionPluginListenable {
         return true;
     }
 
+    /**
+     *
+     * @param msg
+     */
     onMessage(msg) {
         // FIXME: this is a hack. but jingle on muc makes nickchanges hard
         const from = msg.getAttribute('from');
@@ -122,6 +159,10 @@ class MucConnectionPlugin extends ConnectionPluginListenable {
         return true;
     }
 
+    /**
+     *
+     * @param iq
+     */
     onMute(iq) {
         const from = iq.getAttribute('from');
         const room = this.rooms[Strophe.getBareJidFromJid(from)];
@@ -136,6 +177,10 @@ class MucConnectionPlugin extends ConnectionPluginListenable {
     }
 }
 
+/**
+ *
+ * @param XMPP
+ */
 export default function(XMPP) {
     Strophe.addConnectionPlugin('emuc', new MucConnectionPlugin(XMPP));
 }

modules/xmpp/strophe.jingle.js

@@ -13,7 +13,15 @@ import ConnectionPlugin from './ConnectionPlugin';
 // function call chains.
 /* eslint-disable newline-per-chained-call */
 
+/**
+ *
+ */
 class JingleConnectionPlugin extends ConnectionPlugin {
+    /**
+     *
+     * @param xmpp
+     * @param eventEmitter
+     */
     constructor(xmpp, eventEmitter) {
         super();
         this.xmpp = xmpp;
@@ -30,12 +38,20 @@ class JingleConnectionPlugin extends ConnectionPlugin {
         };
     }
 
+    /**
+     *
+     * @param connection
+     */
     init(connection) {
         super.init(connection);
         this.connection.addHandler(this.onJingle.bind(this),
             'urn:xmpp:jingle:1', 'iq', 'set', null, null);
     }
 
+    /**
+     *
+     * @param iq
+     */
     onJingle(iq) {
         const sid = $(iq).find('jingle').attr('sid');
         const action = $(iq).find('jingle').attr('action');
@@ -186,6 +202,12 @@ class JingleConnectionPlugin extends ConnectionPlugin {
         return true;
     }
 
+    /**
+     *
+     * @param sid
+     * @param reasonCondition
+     * @param reasonText
+     */
     terminate(sid, reasonCondition, reasonText) {
         if (this.sessions.hasOwnProperty(sid)) {
             if (this.sessions[sid].state !== 'ended') {
@@ -195,6 +217,9 @@ class JingleConnectionPlugin extends ConnectionPlugin {
         }
     }
 
+    /**
+     *
+     */
     getStunAndTurnCredentials() {
         // get stun and turn configuration from server via xep-0215
         // uses time-limited credentials as described in

modules/xmpp/strophe.logger.js

@@ -5,26 +5,44 @@ import ConnectionPlugin from './ConnectionPlugin';
  *  Logs raw stanzas and makes them available for download as JSON
  */
 class StropheLogger extends ConnectionPlugin {
+    /**
+     *
+     */
     constructor() {
         super();
         this.log = [];
     }
 
+    /**
+     *
+     * @param connection
+     */
     init(connection) {
         super.init(connection);
         this.connection.rawInput = this.logIncoming.bind(this);
         this.connection.rawOutput = this.logOutgoing.bind(this);
     }
 
+    /**
+     *
+     * @param stanza
+     */
     logIncoming(stanza) {
         this.log.push([ new Date().getTime(), 'incoming', stanza ]);
     }
 
+    /**
+     *
+     * @param stanza
+     */
     logOutgoing(stanza) {
         this.log.push([ new Date().getTime(), 'outgoing', stanza ]);
     }
 }
 
+/**
+ *
+ */
 export default function() {
     Strophe.addConnectionPlugin('logger', new StropheLogger());
 }

modules/xmpp/strophe.ping.js

@@ -141,6 +141,10 @@ class PingConnectionPlugin extends ConnectionPlugin {
     }
 }
 
+/**
+ *
+ * @param xmpp
+ */
 export default function(xmpp) {
     Strophe.addConnectionPlugin('ping', new PingConnectionPlugin(xmpp));
 }

modules/xmpp/strophe.rayo.js

@@ -7,7 +7,14 @@ import ConnectionPlugin from './ConnectionPlugin';
 
 const RAYO_XMLNS = 'urn:xmpp:rayo:1';
 
+/**
+ *
+ */
 class RayoConnectionPlugin extends ConnectionPlugin {
+    /**
+     *
+     * @param connection
+     */
     init(connection) {
         super.init(connection);
 
@@ -15,12 +22,24 @@ class RayoConnectionPlugin extends ConnectionPlugin {
             this.onRayo.bind(this), RAYO_XMLNS, 'iq', 'set', null, null);
     }
 
+    /**
+     *
+     * @param iq
+     */
     onRayo(iq) {
         logger.info('Rayo IQ', iq);
     }
 
     /* eslint-disable max-params */
 
+    /**
+     *
+     * @param to
+     * @param from
+     * @param roomName
+     * @param roomPass
+     * @param focusMucJid
+     */
     dial(to, from, roomName, roomPass, focusMucJid) {
         return new Promise((resolve, reject) => {
             if (!focusMucJid) {
@@ -71,6 +90,9 @@ class RayoConnectionPlugin extends ConnectionPlugin {
 
     /* eslint-enable max-params */
 
+    /**
+     *
+     */
     hangup() {
         return new Promise((resolve, reject) => {
             if (!this.callResource) {
@@ -102,6 +124,9 @@ class RayoConnectionPlugin extends ConnectionPlugin {
     }
 }
 
+/**
+ *
+ */
 export default function() {
     Strophe.addConnectionPlugin('rayo', new RayoConnectionPlugin());
 }

modules/xmpp/strophe.util.js

@@ -41,6 +41,9 @@ const resetLastErrorStatusRegExpr = /request id \d+.\d+ got 200/;
 const lastErrorStatusRegExpr
     = /request errored, status: (\d+), number of errors: \d+/;
 
+/**
+ *
+ */
 export default function() {
 
     Strophe.log = function(level, msg) {

modules/xmpp/xmpp.js

@@ -16,6 +16,11 @@ import initStropheLogger from './strophe.logger';
 import Listenable from '../util/Listenable';
 import Caps from './Caps';
 
+/**
+ *
+ * @param token
+ * @param bosh
+ */
 function createConnection(token, bosh = '/http-bind') {
     // Append token as URL param
     if (token) {
@@ -26,7 +31,15 @@ function createConnection(token, bosh = '/http-bind') {
     return new Strophe.Connection(bosh);
 }
 
+/**
+ *
+ */
 export default class XMPP extends Listenable {
+    /**
+     *
+     * @param options
+     * @param token
+     */
     constructor(options, token) {
         super();
         this.connection = null;
@@ -95,6 +108,9 @@ export default class XMPP extends Listenable {
         }
     }
 
+    /**
+     *
+     */
     getConnection() {
         return this.connection;
     }
@@ -203,6 +219,11 @@ export default class XMPP extends Listenable {
         }
     }
 
+    /**
+     *
+     * @param jid
+     * @param password
+     */
     _connect(jid, password) {
         // connection.connect() starts the connection process.
         //
@@ -254,6 +275,11 @@ export default class XMPP extends Listenable {
             this.connectionHandler.bind(this, options.password));
     }
 
+    /**
+     *
+     * @param jid
+     * @param password
+     */
     connect(jid, password) {
         this.connectParams = {
             jid,
@@ -280,6 +306,11 @@ export default class XMPP extends Listenable {
         return this._connect(jid, password);
     }
 
+    /**
+     *
+     * @param roomName
+     * @param options
+     */
     createRoom(roomName, options) {
         // By default MUC nickname is the resource part of the JID
         let mucNickname = Strophe.getNodeFromJid(this.connection.jid);
@@ -324,18 +355,33 @@ export default class XMPP extends Listenable {
         return (this.connection.logger || {}).log || null;
     }
 
+    /**
+     *
+     */
     dial(...args) {
         this.connection.rayo.dial(...args);
     }
 
+    /**
+     *
+     * @param jid
+     * @param mute
+     */
     setMute(jid, mute) {
         this.connection.moderate.setMute(jid, mute);
     }
 
+    /**
+     *
+     * @param jid
+     */
     eject(jid) {
         this.connection.moderate.eject(jid);
     }
 
+    /**
+     *
+     */
     getSessions() {
         return this.connection.jingle.sessions;
     }
@@ -391,6 +437,9 @@ export default class XMPP extends Listenable {
         }
     }
 
+    /**
+     *
+     */
     _initStrophePlugins() {
         initEmuc(this);
         initJingle(this, this.eventEmitter);