ESLint

Our JSHint configuration is not extensive and we have excluded multiple
files from linting. Additionally, we have seen JSHint to be unable to
parse newer ECMAScript features such as the object spread operator
(proposal).

On the other hand, we have seen ESLint to beautifully work on React and
React Native source code in addition to ES2015 and later. Introduce
ESLint alongside JSHint as an intermediate step to eventually switching
from JSHint to ESLint.

As our source code does not fully follow even the JSHint rules we have,
it is very difficult to introduce ESLint with many rules. At the
beginning, introduce it with as little rules as possible. Morever,
ESLint is able to automatically fix certain rule offenders so once we
have ESLint merged we can incrementally add new rules while keeping our
commits' modification on as little subjects as possible.

.eslintignore

+# The build artifacts of the lib-jiti-meet project.
+lib-jitsi-meet.js
+lib-jitsi-meet.js.map
+lib-jitsi-meet.min.js
+lib-jitsi-meet.min.map
+
+# Third-party source code which we (1) do not want to modify or (2) try to
+# modify as little as possible.
+libs/*
+modules/RTC/adapter.screenshare.js
+
+# ESLint will by default ignore its own configuration file. However, there does
+# not seem to be a reason why we will want to risk being inconsistent with our
+# remaining JavaScript source code.
+!.eslintrc.js

.eslintrc.js

+module.exports = {
+    'env': {
+        'browser': true,
+        'commonjs': true,
+        'es6': true
+    },
+    'extends': 'eslint:recommended',
+    'globals': {
+        // The globals that (1) are accessed but not defined within many of our
+        // files, (2) are certainly defined, and (3) we would like to use
+        // without explicitly specifying them (using a comment) inside of our
+        // files.
+        '__filename': false
+    },
+    'parserOptions': {
+        'sourceType': 'module'
+    },
+    'rules': {
+        'new-cap': [
+            'error',
+            {
+                'capIsNew': false // Behave like JSHint's newcap.
+            }
+        ],
+        // While it is considered a best practice to avoid using methods on
+        // console in JavaScript that is designed to be executed in the browser
+        // and ESLint includes the rule among its set of recommended rules, (1)
+        // the general practice is to strip such calls before pushing to
+        // production and (2) we prefer to utilize console in lib-jitsi-meet
+        // (and jitsi-meet).
+        'no-console': 'off',
+        'semi': 'error'
+    }
+};

JitsiConference.js

 /* global Strophe, $, Promise */
-/* jshint -W101 */
+
 var logger = require("jitsi-meet-logger").getLogger(__filename);
 var RTC = require("./modules/RTC/RTC");
 var XMPPEvents = require("./service/xmpp/XMPPEvents");
         this.statistics = new Statistics(this.xmpp, {
             callStatsID: this.options.config.callStatsID,
             callStatsSecret: this.options.config.callStatsSecret,
-            callStatsSecret: this.options.config.callStatsSecret,
             callStatsCustomScriptUrl:
                 this.options.config.callStatsCustomScriptUrl,
             roomName: this.options.name
             this.eventEmitter.emit(JitsiConferenceEvents.TALK_WHILE_MUTED);
         });
     }
-}
+};
 
 /**
  * Joins the conference.
     }
 
     this.room = null;
-}
+};
+
 /**
  * Leaves the conference.
  * @returns {Promise}
         this.statistics.sendScreenSharingEvent(false);
 
     this.eventEmitter.emit(JitsiConferenceEvents.TRACK_REMOVED, track);
-}
+};
 
 /**
  * Removes JitsiLocalTrack object to the conference.
         jingleSession.initialize(false /* initiator */,this.room);
     } catch (error) {
         GlobalOnErrorHandler.callErrorHandler(error);
-    };
+    }
 
     this.rtc.onIncommingCall(jingleSession);
     // Add local Tracks to the ChatRoom
  */
 JitsiConference.prototype.getRecordingState = function () {
     return (this.room) ? this.room.getRecordingState() : undefined;
-}
+};
 
 /**
  * Returns the url of the recorded video.
  */
 JitsiConference.prototype.getRecordingURL = function () {
     return (this.room) ? this.room.getRecordingURL() : null;
-}
+};
 
 /**
  * Starts/stops the recording
     this.eventEmitter.emit(
         JitsiConferenceEvents.RECORDER_STATE_CHANGED, "error",
         new Error("The conference is not created yet!"));
-}
+};
 
 /**
  * Returns true if the SIP calls are supported and false otherwise
     if(this.room)
         return this.room.isSIPCallingSupported();
     return false;
-}
+};
 
 /**
  * Dials a number.
     if(this.room)
         return this.room.dial(number);
     return new Promise(function(resolve, reject){
-        reject(new Error("The conference is not created yet!"))});
-}
+        reject(new Error("The conference is not created yet!"));});
+};
 
 /**
  * Hangup an existing call
     if(this.room)
         return this.room.hangup();
     return new Promise(function(resolve, reject){
-        reject(new Error("The conference is not created yet!"))});
-}
+        reject(new Error("The conference is not created yet!"));});
+};
 
 /**
  * Returns the phone number for joining the conference.
     if(this.room)
         return this.room.getPhoneNumber();
     return null;
-}
+};
 
 /**
  * Returns the pin for joining the conference with phone.
     if(this.room)
         return this.room.getPhonePin();
     return null;
-}
+};
 
 /**
  * Returns the connection state for the current room. Its ice connection state
     if(this.room)
         return this.room.getConnectionState();
     return null;
-}
+};
 
 /**
  * Make all new participants mute their audio/video on join.
 JitsiConference.prototype.sendFeedback =
 function(overallFeedback, detailedFeedback){
     this.statistics.sendFeedback(overallFeedback, detailedFeedback);
-}
+};
 
 /**
  * Returns true if the callstats integration is enabled, otherwise returns
  */
 JitsiConference.prototype.isCallstatsEnabled = function () {
     return this.statistics.isCallstatsEnabled();
-}
+};
 
 
 /**
     }
     this.statistics.associateStreamWithVideoTag(
         ssrc, track.isLocal(), track.getUsageLabel(), container.id);
-}
+};
 
 /**
  * Reports detected audio problem with the media stream related to the passed
             id: mtrack.id,
             label: mtrack.label,
             muted: mtrack.muted
-        }
+        };
         logger.log("enabled: ", mtrack.enabled);
         logger.log("id: ", mtrack.id);
         logger.log("label: ", mtrack.label);
  */
 JitsiConference.prototype.sendEndpointMessage = function (to, payload) {
     this.rtc.sendDataChannelMessage(to, payload);
-}
+};
 
 /**
  * Sends broadcast message via the datachannels.
  */
 JitsiConference.prototype.broadcastEndpointMessage = function (payload) {
     this.sendEndpointMessage("", payload);
-}
+};
 
 module.exports = JitsiConference;

JitsiConferenceEventManager.js

         });
 
     chatRoom.addListener(XMPPEvents.CONNECTION_ICE_FAILED,
-        function (pc) {
+        function () {
             chatRoom.eventEmitter.emit(
                 XMPPEvents.CONFERENCE_SETUP_FAILED,
                 new Error("ICE fail"));

JitsiConnection.js

 var JitsiConference = require("./JitsiConference");
-import * as JitsiConnectionErrors from "./JitsiConnectionErrors";
 import * as JitsiConnectionEvents from "./JitsiConnectionEvents";
 import XMPP from "./modules/xmpp/xmpp";
 var Statistics = require("./modules/statistics/statistics");
         options = {};
 
     this.xmpp.connect(options.id, options.password);
-}
+};
 
 /**
  * Attach to existing connection. Can be used for optimizations. For example:
  */
 JitsiConnection.prototype.attach = function (options) {
     this.xmpp.attach(options);
-}
+};
 
 /**
  * Disconnect the client from the server.
     var x = this.xmpp;
 
     x.disconnect.apply(x, arguments);
-}
+};
 
 /**
  * This method allows renewal of the tokens if they are expiring.
  */
 JitsiConnection.prototype.setToken = function (token) {
     this.token = token;
-}
+};
 
 /**
  * Creates and joins new conference.
         = new JitsiConference({name: name, config: options, connection: this});
     this.conferences[name] = conference;
     return conference;
-}
+};
 
 /**
  * Subscribes the passed listener to the event.
  */
 JitsiConnection.prototype.addEventListener = function (event, listener) {
     this.xmpp.addListener(event, listener);
-}
+};
 
 /**
  * Unsubscribes the passed handler.
  */
 JitsiConnection.prototype.removeEventListener = function (event, listener) {
     this.xmpp.removeListener(event, listener);
-}
+};
 
 /**
  * Returns measured connectionTimes.

JitsiMediaDevices.js

      * Emits an event.
      * @param {string} event - event name
      */
-    emitEvent: function (event) {
+    emitEvent: function (event) { // eslint-disable-line no-unused-vars
         eventEmitter.emit.apply(eventEmitter, arguments);
     }
 };

JitsiMeetJS.js

     var order = Resolutions[resolution].order;
     var res = null;
     var resName = null;
-    for(var i in Resolutions) {
+    for(let i in Resolutions) {
         var tmp = Resolutions[i];
         if (!res || (res.order < tmp.order && tmp.order < order)) {
             resName = i;
     mediaDevices: JitsiMediaDevices,
     analytics: null,
     init: function (options) {
-        var logObject, attr;
+        let logObject, attr;
         Statistics.init(options);
         this.analytics = Statistics.analytics;
 
                 id: "component_version",
                 component: "lib-jitsi-meet",
                 version: this.version
-            }
+            };
             Statistics.sendLog(JSON.stringify(logObject));
         }
 
                     "getUserMedia.success", options), options);
 
                 if(!RTC.options.disableAudioLevels)
-                    for(var i = 0; i < tracks.length; i++) {
-                        var track = tracks[i];
+                    for(let i = 0; i < tracks.length; i++) {
+                        const track = tracks[i];
                         var mStream = track.getOriginalStream();
                         if(track.getType() === MediaType.AUDIO){
                             Statistics.startLocalStats(mStream,
                 var currentlyAvailableMediaDevices
                     = RTC.getCurrentlyAvailableMediaDevices();
                 if (currentlyAvailableMediaDevices) {
-                    for(var i = 0; i < tracks.length; i++) {
-                        var track = tracks[i];
+                    for(let i = 0; i < tracks.length; i++) {
+                        const track = tracks[i];
                         track._setRealDeviceIdFromDeviceList(
                             currentlyAvailableMediaDevices);
                     }
                     // User cancelled action is not really an error, so only
                     // log it as an event to avoid having conference classified
                     // as partially failed
-                    var logObject = {
+                    const logObject = {
                         id: "chrome_extension_user_canceled",
                         message: error.message
                     };
                         "getUserMedia.userCancel.extensionInstall");
                 } else if (JitsiTrackErrors.NOT_FOUND === error.name) {
                     // logs not found devices with just application log to cs
-                    var logObject = {
+                    const logObject = {
                         id: "usermedia_missing_device",
                         status: error.gum.devices
                     };

connection_optimization/external_connect.js

  * callback is going to receive one parameter which is going to be JS error
  * object with a reason for failure in it.
  */
-function createConnectionExternally(webserviceUrl, success_callback,
-    error_callback) {
+function createConnectionExternally( // eslint-disable-line no-unused-vars
+        webserviceUrl,
+        success_callback,
+        error_callback) {
     if (!window.XMLHttpRequest) {
         error_callback(new Error("XMLHttpRequest is not supported!"));
         return;

doc/example/example.js

+/* global $, JitsiMeetJS */
+
 var options = {
     hosts: {
         domain: 'jitsi-meet.example.com',
     },
     bosh: '//jitsi-meet.example.com/http-bind', // FIXME: use xep-0156 for that
     clientNode: 'http://jitsi.org/jitsimeet', // The name of client node advertised in XEP-0115 'c' stanza
-}
+};
 
 var confOptions = {
     openSctp: true
-}
-
+};
 
 var isJoined = false;
 
         return;
     var tracks = remoteTracks[id];
     for(var i = 0; i< tracks.length; i++)
-        tracks[i].detach($("#" + id + tracks[i].getType()))
+        tracks[i].detach($("#" + id + tracks[i].getType()));
 }
 
 /**
             room.getPhonePin());
     });
     room.join();
-};
+}
 
 /**
  * This function is called when the connection fail.
  */
-function onConnectionFailed(){console.error("Connection Failed!")};
+function onConnectionFailed() {
+    console.error("Connection Failed!");
+}
 
 /**
  * This function is called when the connection fail.
     room.leave();
     connection.disconnect();
 }
+
 var isVideo = true;
-function switchVideo() {
+function switchVideo() { // eslint-disable-line no-unused-vars
     isVideo = !isVideo;
     if(localTracks[1]) {
         localTracks[1].dispose();
         });
 }
 
-function changeAudioOutput(selected) {
+function changeAudioOutput(selected) { // eslint-disable-line no-unused-vars
     JitsiMeetJS.mediaDevices.setAudioOutputDevice(selected.value);
 }
 
 $(window).bind('beforeunload', unload);
 $(window).bind('unload', unload);
 
-
-
 // JitsiMeetJS.setLogLevel(JitsiMeetJS.logLevels.ERROR);
 var initOptions = {
     disableAudioLevels: true,
     desktopSharingFirefoxMaxVersionExtRequired: -1,
     // The URL to the Firefox extension for desktop sharing.
     desktopSharingFirefoxExtensionURL: null
-}
+};
 JitsiMeetJS.init(initOptions).then(function(){
     connection = new JitsiMeetJS.JitsiConnection(null, null, options);
 
     console.log(error);
 });
 
-
 if (JitsiMeetJS.mediaDevices.isDeviceChangeAvailable('output')) {
     JitsiMeetJS.mediaDevices.enumerateDevices(function(devices) {
         var audioOutputDevices = devices.filter(function(d) { return d.kind === 'audiooutput'; });
 
             $('#audioOutputSelectWrapper').show();
         }
-    })
+    });
 }
 
 var connection = null;

modules/RTC/DataChannels.js

-/* global config, APP, Strophe */
-
 // cache datachannels to avoid garbage collection
 // https://code.google.com/p/chromium/issues/detail?id=405545
 
 var RTCEvents = require("../../service/RTC/RTCEvents");
 var GlobalOnErrorHandler = require("../util/GlobalOnErrorHandler");
 
-
 /**
  * Binds "ondatachannel" event listener to given PeerConnection instance.
  * @param peerConnection WebRTC peer connection instance.
      var msgData = event.data;
      logger.info("Got My Data Channel Message:", msgData, dataChannel);
      };*/
-};
-
+}
 
 /**
  * Callback triggered by PeerConnection when new data channel is opened
     };
 
     dataChannel.onerror = function (error) {
-        var e = new Error("Data Channel Error:" + error);
         // FIXME: this one seems to be generated a bit too often right now
         // so we are temporarily commenting it before we have more clarity
         // on which of the errors we absolutely need to report
-        //GlobalOnErrorHandler.callErrorHandler(e);
+        //GlobalOnErrorHandler.callErrorHandler(
+        //        new Error("Data Channel Error:" + error));
         logger.error("Data Channel Error:", error, dataChannel);
     };
 
     })) {
         throw new Error("No opened data channels found!");
     }
-}
+};
 
 /**
  * Sends message via the datachannels.
         to: to,
         msgPayload: payload
     });
-}
+};
 
 module.exports = DataChannels;

modules/RTC/JitsiLocalTrack.js

         this._noDataFromSourceTimeout = null;
     }
     this._setHandler("track_unmute", undefined);
-}
+};
 
 /**
  * Called when potential camera issue is detected. Clears the handlers and
     this._clearNoDataFromSourceMuteResources();
     if(this._checkForCameraIssues())
         this._fireNoDataFromSourceEvent();
-}
+};
 
 /**
  * Fires JitsiTrackEvents.NO_DATA_FROM_SOURCE and logs it to analytics and
 JitsiLocalTrack.prototype._fireNoDataFromSourceEvent = function () {
     this.eventEmitter.emit(JitsiTrackEvents.NO_DATA_FROM_SOURCE);
     Statistics.sendEventToAll(this.getType() + ".no_data_from_source");
-}
+};
 
 /**
  * Sets real device ID by comparing track information with device information.
         }.bind(this), 3000);
         this._testByteSent = false;
     }
-}
+};
 
 /**
  * Returns facing mode for video track from camera. For other cases (e.g. audio
     this.stopStreamInProgress = true;
     RTCUtils.stopMediaStream(this.stream);
     this.stopStreamInProgress = false;
-}
+};
 
 /**
  * Detects camera issues on ended and mute events from MediaStreamTrack.
         return false;
 
     return !this._isReceivingData();
-}
+};
 
 /**
  * Checks whether the attached MediaStream is reveiving data from source or
     return this.stream.getTracks().some(track =>
         ((!("readyState" in track) || track.readyState === "live")
             && (!("muted" in track) || track.muted === false)));
-}
+};
 
 module.exports = JitsiLocalTrack;

modules/RTC/JitsiRemoteTrack.js

-/* global __filename, module */
-var logger = require("jitsi-meet-logger").getLogger(__filename);
+/* global Strophe */
 
 var JitsiTrack = require("./JitsiTrack");
 import * as JitsiTrackEvents from "../../JitsiTrackEvents";
+var logger = require("jitsi-meet-logger").getLogger(__filename);
 var RTCBrowserType = require("./RTCBrowserType");
 var RTCEvents = require("../../service/RTC/RTCEvents");
 var Statistics = require("../statistics/statistics");

modules/RTC/JitsiTrack.js

 /* global __filename, module */
 var logger = require("jitsi-meet-logger").getLogger(__filename);
 var RTCBrowserType = require("./RTCBrowserType");
-var RTCEvents = require("../../service/RTC/RTCEvents");
 var RTCUtils = require("./RTCUtils");
 import * as JitsiTrackEvents from "../../JitsiTrackEvents";
 var EventEmitter = require("events");
             track[trackHandler2Prop[type]] = handler;
         }, this);
     }
-}
+};
 
 /**
  * Sets the stream property of JitsiTrack object and sets all stored handlers
         typeof(this.handlers[type]) === "function" &&
             this._setHandler(type, this.handlers[type]);
     }, this);
-}
+};
 
 /**
  * Returns the type (audio or video) of this track.
  *        method has been called previously on video or audio HTML element.
  * @private
  */
+// eslint-disable-next-line no-unused-vars
 JitsiTrack.prototype._attachTTFMTracker = function (container) {
 };
 

modules/RTC/RTC.js

-/* global __filename, APP, module */
+/* global Strophe */
+
 var logger = require("jitsi-meet-logger").getLogger(__filename);
 var EventEmitter = require("events");
-var RTCBrowserType = require("./RTCBrowserType");
 var RTCEvents = require("../../service/RTC/RTCEvents.js");
 var RTCUtils = require("./RTCUtils.js");
-var JitsiTrack = require("./JitsiTrack");
 var JitsiLocalTrack = require("./JitsiLocalTrack.js");
 import JitsiTrackError from "../../JitsiTrackError";
 import * as JitsiTrackErrors from "../../JitsiTrackErrors";
 };
 
 RTC.removeListener = function (eventType, listener) {
-    RTCUtils.removeListener(eventType, listener)
+    RTCUtils.removeListener(eventType, listener);
 };
 
 RTC.isRTCReady = function () {
     if (track) {
         track.setMute(isMuted);
     }
-}
+};
 
 /**
  * Handles remote track video type events
     if (videoTrack) {
         videoTrack._setVideoType(value);
     }
-}
+};
 
 /**
  * Sends message via the datachannels.
     } else {
         throw new Error("Data channels support is disabled!");
     }
-}
+};
 
 module.exports = RTC;

modules/RTC/RTCUIHelper.js

-/* global $, __filename */
+/* global $ */
+
 var logger = require("jitsi-meet-logger").getLogger(__filename);
 var RTCBrowserType = require("./RTCBrowserType");
-var RTC = require('./RTC');
 
 var RTCUIHelper = {
 
      */
     setAutoPlay: function (streamElement, autoPlay) {
         if (!RTCBrowserType.isIExplorer()) {
-            streamElement.autoplay = true;
+            streamElement.autoplay = autoPlay;
         }
     }
 };

modules/RTC/RTCUtils.js

-/* global config, require, attachMediaStream, getUserMedia,
-   RTCPeerConnection, RTCSessionDescription, RTCIceCandidate, MediaStreamTrack,
-   mozRTCPeerConnection, mozRTCSessionDescription, mozRTCIceCandidate,
-   webkitRTCPeerConnection, webkitMediaStream, webkitURL
+/* global $,
+          attachMediaStream,
+          MediaStreamTrack,
+          RTCIceCandidate,
+          RTCPeerConnection,
+          RTCSessionDescription,
+          mozRTCIceCandidate,
+          mozRTCPeerConnection,
+          mozRTCSessionDescription,
+          webkitMediaStream,
+          webkitRTCPeerConnection,
+          webkitURL
 */
-/* jshint -W101 */
 
 var logger = require("jitsi-meet-logger").getLogger(__filename);
 var RTCBrowserType = require("./RTCBrowserType");
 var EventEmitter = require("events");
 var screenObtainer = require("./ScreenObtainer");
 import JitsiTrackError from "../../JitsiTrackError";
-import * as JitsiTrackErrors from "../../JitsiTrackErrors";
 var MediaType = require("../../service/RTC/MediaType");
 var VideoType = require("../../service/RTC/VideoType");
 var CameraFacingMode = require("../../service/RTC/CameraFacingMode");
         if (audioVideo) {
             var audioTracks = audioVideo.getAudioTracks();
             if (audioTracks.length) {
+                // eslint-disable-next-line new-cap
                 audioStream = new webkitMediaStream();
                 for (var i = 0; i < audioTracks.length; i++) {
                     audioStream.addTrack(audioTracks[i]);
 
             var videoTracks = audioVideo.getVideoTracks();
             if (videoTracks.length) {
+                // eslint-disable-next-line new-cap
                 videoStream = new webkitMediaStream();
                 for (var j = 0; j < videoTracks.length; j++) {
                     videoStream.addTrack(videoTracks[j]);
         }
 
         return res;
-    }
+    };
 }
 
 /**
                     }
                     return SDPUtil.filter_special_chars(id);
                 };
+                /* eslint-disable no-native-reassign */
                 RTCSessionDescription = mozRTCSessionDescription;
                 RTCIceCandidate = mozRTCIceCandidate;
+                /* eslint-enable no-native-reassign */
             } else if (RTCBrowserType.isChrome() ||
                     RTCBrowserType.isOpera() ||
                     RTCBrowserType.isNWJS() ||
                 //AdapterJS.WebRTCPlugin.setLogLevel(
                 //    AdapterJS.WebRTCPlugin.PLUGIN_LOG_LEVELS.VERBOSE);
                 var self = this;
-                AdapterJS.webRTCReady(function (isPlugin) {
+                AdapterJS.webRTCReady(function () {
 
                     self.peerconnection = RTCPeerConnection;
                     self.getUserMedia = window.getUserMedia;
                 });
             } else {
                 var errmsg = 'Browser does not appear to be WebRTC-capable';
-                try {
-                    logger.error(errmsg);
-                } catch (e) {
-                }
+                logger.error(errmsg);
                 reject(new Error(errmsg));
                 return;
             }
     **/
     getUserMediaWithConstraints: function ( um, success_callback, failure_callback, options) {
         options = options || {};
-        var resolution = options.resolution;
         var constraints = getConstraints(um, options);
 
         logger.info("Get media constraints", constraints);
                                 // set to not ask for permissions)
                                 self.getUserMediaWithConstraints(
                                     devices,
-                                    function (stream) {
+                                    function () {
                                         // we already failed to obtain this
                                         // media, so we are not supposed in any
                                         // way to receive success for this call

modules/RTC/ScreenObtainer.js

 /* global chrome, $, alert */
-/* jshint -W003 */
+
 var logger = require("jitsi-meet-logger").getLogger(__filename);
 var RTCBrowserType = require("./RTCBrowserType");
 var AdapterJS = require("./adapter.screenshare");
  * The error returned by chrome when trying to start inline installation from
  * popup.
  */
-var CHROME_EXTENSION_POPUP_ERROR =
-    "Inline installs can not be initiated from pop-up windows.";
+const CHROME_EXTENSION_POPUP_ERROR
+    = "Inline installs can not be initiated from pop-up windows.";
 
 /**
  * The error message returned by chrome when the extension is installed.
  */
-var CHROME_NO_EXTENSION_ERROR_MSG =
-    "Could not establish connection. Receiving end does not exist.";
+const CHROME_NO_EXTENSION_ERROR_MSG // eslint-disable-line no-unused-vars
+    = "Could not establish connection. Receiving end does not exist.";
 
 /**
  * Handles obtaining a stream from a screen capture on different browsers.

modules/statistics/AnalyticsAdapter.js

         }
     }
     try {
-        this.analytics.sendEvent(
-            action, data, label, this.browserName);
-    } catch (ignored) {}
+        this.analytics.sendEvent(action, data, label, this.browserName);
+    } catch (ignored) { // eslint-disable-line no-empty
+    }
 };
 
 /**
     }
 };
 
-module.exports = new AnalyticsAdapter();
+module.exports = new AnalyticsAdapter();

modules/statistics/CallStats.js

 var CallStats = _try_catch(function(jingleSession, Settings, options) {
     try{
         CallStats.feedbackEnabled = false;
-        callStats = new callstats($, io, jsSHA);
+        callStats = new callstats($, io, jsSHA); // eslint-disable-line new-cap
 
         this.session = jingleSession;
         this.peerconnection = jingleSession.peerconnection.peerconnection;

modules/statistics/LocalStatsCollector.js

-/* global config */
 /**
  * Provides statistics for the local stream.
  */

modules/statistics/RTPStatsCollector.js

 /* global require */
-/* jshint -W101 */
 
 var GlobalOnErrorHandler = require("../util/GlobalOnErrorHandler");
 var logger = require("jitsi-meet-logger").getLogger(__filename);
         // example, if item has a stat property of type function, then it's very
         // likely that whoever defined it wanted you to call it in order to
         // retrieve the value associated with a specific key.
-        itemStatByKey = function (item, key) { return item.stat(key) };
+        itemStatByKey = function (item, key) { return item.stat(key); };
         break;
     case RTCBrowserType.RTC_BROWSER_REACT_NATIVE:
         // The implementation provided by react-native-webrtc follows the
         };
         break;
     default:
-        itemStatByKey = function (item, key) { return item[key] };
+        itemStatByKey = function (item, key) { return item[key]; };
     }
 
     // Compose the 2 functions defined above to get a function which retrieves
     // the value from a specific report returned by RTCPeerConnection#getStats
     // associated with a specific LibJitsiMeet browser-agnostic name.
     return function (item, name) {
-        return itemStatByKey(item, keyFromName(name))
+        return itemStatByKey(item, keyFromName(name));
     };
 };
 
             var conferenceStatsTransport = this.conferenceStats.transport;
             if(!conferenceStatsTransport.some(function (t) { return (
                         t.ip == ip && t.type == type && t.localip == localip
-                    )})) {
+                    );})) {
                 conferenceStatsTransport.push(
                     {ip: ip, type: type, localip: localip});
             }

modules/transcription/audioRecorder.js

-/* global APP, MediaRecorder, MediaStream, webkitMediaStream*/
+/* global MediaRecorder, MediaStream, webkitMediaStream */
+
 var RecordingResult = require("./recordingResult");
 
 /**
         return new MediaStream();
     }
     else if(typeof(webkitMediaStream) !== 'undefined') {
-        return new webkitMediaStream();
+        return new webkitMediaStream(); // eslint-disable-line new-cap
     }
     else {
         throw new Error("cannot create a clean mediaStream");
 /**
  * export the main object audioRecorder
  */
-module.exports = audioRecorder;
+module.exports = audioRecorder;

modules/transcription/transcriptionServices/AbstractTranscriptionService.js

  * @param {function} callback function which will retrieve the answer
  *                            from the service
  */
+// eslint-disable-next-line no-unused-vars
 TranscriptionService.prototype.sendRequest = function(audioBlob, callback) {
     throw new Error("TranscriptionService.sendRequest is abstract");
 };
  *                 formatted
  * @return {Array<Word>} an array of Word objects
  */
+// eslint-disable-next-line no-unused-vars
 TranscriptionService.prototype.formatResponse = function(response){
     throw new Error("TranscriptionService.format is abstract");
 };
  * @param response the response from the server
  * @return {boolean} true if response is valid, false otherwise
  */
+// eslint-disable-next-line no-unused-vars
 TranscriptionService.prototype.verify = function(response){
       throw new Error("TranscriptionService.verify is abstract");
 };
 
-module.exports = TranscriptionService;
+module.exports = TranscriptionService;

modules/transcription/transcriptionServices/SphinxTranscriptionService.js

-/* global config,  XMLHttpRequest, console, APP, JSON */
+/* global config */
 
 var TranscriptionService = require("./AbstractTranscriptionService");
 var Word = require( "../word");
     }
 }
 
-module.exports = SphinxService;
+module.exports = SphinxService;

modules/transcription/word.js

  * An object representing a transcribed word, with some additional information
  * @param word the word 
  * @param begin the time the word was started being uttered
- * @param end the tome the word stopped being uttered
+ * @param end the time the word stopped being uttered
  */
-var Word = function (word, begin, end, name) {
+var Word = function (word, begin, end) {
     this.word = word;
     this.begin = begin;
     this.end = end;
     return this.end;
 };
 
-module.exports = Word;
+module.exports = Word;

modules/util/EventEmitterForwarder.js

-var EventEmitter = require("events");
-
 /**
  * Implements utility to forward events from one eventEmitter to another.
  * @param src {object} instance of EventEmitter or another class that implements

modules/xmpp/ChatRoom.js

 /* global Strophe, $, $pres, $iq, $msg */
-/* jshint -W101,-W069 */
+
 import {getLogger} from "jitsi-meet-logger";
 const logger = getLogger(__filename);
 var XMPPEvents = require("../../service/xmpp/XMPPEvents");
 var Recorder = require("./recording");
 var GlobalOnErrorHandler = require("../util/GlobalOnErrorHandler");
 
-var JIBRI_XMLNS = 'http://jitsi.org/protocol/jibri';
-
 var parser = {
     packet2JSON: function (packet, nodes) {
         var self = this;
-        $(packet).children().each(function (index) {
+        $(packet).children().each(function () {
             var tagName = $(this).prop("tagName");
-            var node = {
+            const node = {
                 tagName: tagName
             };
             node.attributes = {};
         });
     },
     JSON2packet: function (nodes, packet) {
-        for(var i = 0; i < nodes.length; i++) {
-            var node = nodes[i];
+        for(let i = 0; i < nodes.length; i++) {
+            const node = nodes[i];
             if(!node || node === null){
                 continue;
             }
  */
 function filterNodeFromPresenceJSON(pres, nodeName){
     var res = [];
-    for(var i = 0; i < pres.length; i++)
+    for(let i = 0; i < pres.length; i++)
         if(pres[i].tagName === nodeName)
             res.push(pres[i]);
 
         settings, {connection: this.xmpp.options, conference: this.options});
     this.initPresenceMap();
     this.session = null;
-    var self = this;
     this.lastPresences = {};
     this.phoneNumber = null;
     this.phonePin = null;
     member.isHiddenDomain
         = jid && jid.indexOf("@") > 0
             && this.options.hiddenDomain
-                === jid.substring(jid.indexOf("@") + 1, jid.indexOf("/"))
+                === jid.substring(jid.indexOf("@") + 1, jid.indexOf("/"));
 
     $(pres).find(">x").remove();
     var nodes = [];
     parser.packet2JSON(pres, nodes);
     this.lastPresences[from] = nodes;
-    var jibri = null;
+    let jibri = null;
     // process nodes to extract data needed for MUC_JOINED and MUC_MEMBER_JOINED
     // events
-    for(var i = 0; i < nodes.length; i++)
+    for(let i = 0; i < nodes.length; i++)
     {
-        var node = nodes[i];
+        const node = nodes[i];
         switch(node.tagName)
         {
             case "nick":
 
     // after we had fired member or room joined events, lets fire events
     // for the rest info we got in presence
-    for(var i = 0; i < nodes.length; i++)
+    for(let i = 0; i < nodes.length; i++)
     {
-        var node = nodes[i];
+        const node = nodes[i];
         switch(node.tagName)
         {
             case "nick":
                 }
                 break;
             case "jibri-recording-status":
-                var jibri = node;
+                jibri = node;
                 break;
             case "call-control":
                 var att = node.attributes;
             this.recording.handleJibriPresence(this.lastJibri);
     }
     logger.info("Ignore focus: " + from + ", real JID: " + mucJid);
-}
+};
 
 /**
  * Sets the special listener to be used for "command"s whose name starts with
     // If the status code is 110 this means we're leaving and we would like
     // to remove everyone else from our view, so we trigger the event.
     else if (Object.keys(this.members).length > 0) {
-        for (var i in this.members) {
-            var member = this.members[i];
+        for (const i in this.members) {
+            const member = this.members[i];
             delete this.members[i];
             this.onParticipantLeft(i, member.isFocus);
         }
     return this.session.generateNewStreamSSRCInfo();
 };
 
-ChatRoom.prototype.setVideoMute = function (mute, callback, options) {
+ChatRoom.prototype.setVideoMute = function (mute, callback) {
     this.sendVideoInfoPresence(mute);
     if(callback)
         callback(mute);
  */
 ChatRoom.prototype.getRecordingState = function () {
     return (this.recording) ? this.recording.getState() : undefined;
-}
+};
 
 /**
  * Returns the url of the recorded video.
  */
 ChatRoom.prototype.getRecordingURL = function () {
     return (this.recording) ? this.recording.getURL() : null;
-}
+};
 
 /**
  * Starts/stops the recording

modules/xmpp/JingleSession.js

  * Adds the ICE candidates found in the 'contents' array as remote candidates?
  * Note: currently only used on transport-info
  */
+// eslint-disable-next-line no-unused-vars
 JingleSession.prototype.addIceCandidates = function(contents) {};
 
 /**
  *
  * @param contents an array of Jingle 'content' elements.
  */
+// eslint-disable-next-line no-unused-vars
 JingleSession.prototype.addSources = function(contents) {};
 
 /**
  *
  * @param contents an array of Jingle 'content' elements.
  */
+// eslint-disable-next-line no-unused-vars
 JingleSession.prototype.removeSources = function(contents) {};
 
 /**
  * @param reason XMPP Jingle error condition
  * @param text some meaningful error message
  */
+// eslint-disable-next-line no-unused-vars
 JingleSession.prototype.terminate = function(reason, text) {};
 
 /**
  *        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
 JingleSession.prototype.acceptOffer = function(jingle, success, failure) {};
 
 module.exports = JingleSession;

modules/xmpp/JingleSessionPC.js

-/* jshint -W117 */
+/* global $, $iq */
+
 import {getLogger} from "jitsi-meet-logger";
 const logger = getLogger(__filename);
 var JingleSession = require("./JingleSession");
 var TraceablePeerConnection = require("./TraceablePeerConnection");
-var MediaType = require("../../service/RTC/MediaType");
 var SDPDiffer = require("./SDPDiffer");
 var SDPUtil = require("./SDPUtil");
 var SDP = require("./SDP");
     this.peerconnection.onremovestream = function (event) {
         self.remoteStreamRemoved(event.stream);
     };
-    this.peerconnection.onsignalingstatechange = function (event) {
+    this.peerconnection.onsignalingstatechange = function () {
         if (!(self && self.peerconnection)) return;
         if (self.peerconnection.signalingState === 'stable') {
             self.wasstable = true;
         }
     };
     /**
-     * The oniceconnectionstatechange event handler contains the code to execute when the iceconnectionstatechange event,
-     * of type Event, is received by this RTCPeerConnection. Such an event is sent when the value of
+     * The oniceconnectionstatechange event handler contains the code to execute
+     * when the iceconnectionstatechange event, of type Event, is received by
+     * this RTCPeerConnection. Such an event is sent when the value of
      * RTCPeerConnection.iceConnectionState changes.
-     *
-     * @param event the event containing information about the change
      */
-    this.peerconnection.oniceconnectionstatechange = function (event) {
+    this.peerconnection.oniceconnectionstatechange = function () {
         if (!(self && self.peerconnection)) return;
         var now = window.performance.now();
         self.room.connectionTimes["ice.state." +
                 break;
         }
     };
-    this.peerconnection.onnegotiationneeded = function (event) {
+    this.peerconnection.onnegotiationneeded = function () {
         self.room.eventEmitter.emit(XMPPEvents.PEERCONNECTION_READY, self);
     };
 };
 JingleSessionPC.prototype.readSsrcInfo = function (contents) {
     var self = this;
     $(contents).each(function (idx, content) {
-        var name = $(content).attr('name');
-        var mediaType = this.getAttribute('name');
         var ssrcs = $(content).find('description>source[xmlns="urn:xmpp:jingle:apps:rtp:ssma:0"]');
         ssrcs.each(function () {
             var ssrc = this.getAttribute('ssrc');
     // FIXME: dirty waiting
     if (!this.peerconnection.localDescription)
     {
-        logger.warn("addSource - localDescription not ready yet")
+        logger.warn("addSource - localDescription not ready yet");
         setTimeout(function()
             {
                 self.addSource(elem);
     this.removessrc = [];
 
     sdp.raw = sdp.session + sdp.media.join('');
+
     /**
      * Implements a failure callback which reports an error message and an
      * optional error through (1) logger, (2) GlobalOnErrorHandler, and (3)
         }
         GlobalOnErrorHandler.callErrorHandler(new Error(errmsg));
         queueCallback(err);
-    };
+    }
 
     var ufrag = getUfrag(sdp.raw);
     if (ufrag != self.remoteUfrag) {
             errorCallback(error);
         }
     });
-}
+};
 
 /**
  * Generate ssrc info object for a stream with the following properties:
             errorCallback(error);
         }
     });
-}
+};
 
 /**
  * Figures out added/removed ssrcs and send update IQs.
     var ufragLines = sdp.split('\n').filter(function(line) {
         return line.startsWith("a=ice-ufrag:");});
     if (ufragLines.length > 0) {
-        return ufragLines[0].substr("a=ice-ufrag:".length)
+        return ufragLines[0].substr("a=ice-ufrag:".length);
     }
 }
 

modules/xmpp/SDP.js

-/* jshint -W117 */
-import {getLogger} from "jitsi-meet-logger";
-const logger = getLogger(__filename);
+/* global $, APP */
+
 var SDPUtil = require("./SDPUtil");
 
 // SDP STUFF
     });
     this.raw = this.session + this.media.join('');
     return lines;
-}
+};
 // remove lines matching prefix from a media section specified by mediaindex
 // TODO: non-numeric mediaindex could match mid
 SDP.prototype.removeMediaLines = function(mediaindex, prefix) {
     });
     this.raw = this.session + this.media.join('');
     return lines;
-}
+};
 
 // add content's to a jingle element
 SDP.prototype.toJingle = function (elem, thecreator) {
-//    logger.log("SSRC" + ssrcs["audio"] + " - " + ssrcs["video"]);
-    var self = this;
     var i, j, k, mline, ssrc, rtpmap, tmp, lines;
     // new bundle plan
     lines = SDPUtil.find_lines(this.session, 'a=group:');
         }
     }
     elem.up(); // end of transport
-}
+};
 
 SDP.prototype.rtcpFbToJingle = function (mediaindex, elem, payloadtype) { // XEP-0293
     var lines = SDPUtil.find_lines(this.media[mediaindex], 'a=rtcp-fb:' + payloadtype);
 SDP.prototype.jingle2media = function (content) {
     var media = '',
         desc = content.find('description'),
-        ssrc = desc.attr('ssrc'),
         self = this,
         tmp;
     var sctp = content.find(

modules/xmpp/TraceablePeerConnection.js

-/* global $ */
-import {getLogger} from "jitsi-meet-logger";
+/* global mozRTCPeerConnection, webkitRTCPeerConnection */
+
+import { getLogger } from "jitsi-meet-logger";
 const logger = getLogger(__filename);
 var RTC = require('../RTC/RTC');
 var RTCBrowserType = require("../RTC/RTCBrowserType.js");
             var ssrcOperation = SSRCs[0];
             switch(ssrcOperation.type) {
                 case "mute":
-                case "addMuted":
+                case "addMuted": {
                 //FIXME: If we want to support multiple streams we have to add
                 // recv-only ssrcs for the
                 // muted streams on every change until the stream is unmuted
                 // in the SDP
                     if(!bLine.ssrcs)
                         bLine.ssrcs = [];
-                    var groups = ssrcOperation.ssrc.groups;
-                    var ssrc = null;
+                    const groups = ssrcOperation.ssrc.groups;
+                    let ssrc = null;
                     if(groups && groups.length) {
                         ssrc = groups[0].primarySSRC;
                     } else if(ssrcOperation.ssrc.ssrcs &&
                     // only 1 video stream that is muted.
                     this.recvOnlySSRCs[bLine.type] = ssrc;
                     break;
-                case "unmute":
+                }
+                case "unmute": {
                     if(!ssrcOperation.ssrc || !ssrcOperation.ssrc.ssrcs ||
                         !ssrcOperation.ssrc.ssrcs.length)
                         break;
                     var ssrcMap = {};
                     var ssrcLastIdx = ssrcOperation.ssrc.ssrcs.length - 1;
                     for(var i = 0; i < bLine.ssrcs.length; i++) {
-                        var ssrc = bLine.ssrcs[i];
+                        const ssrc = bLine.ssrcs[i];
                         if (ssrc.attribute !== 'msid' &&
                             ssrc.value !== ssrcOperation.msid) {
                             continue;
                         if(ssrcLastIdx < 0)
                             break;
                     }
-                    var groups = ssrcOperation.ssrc.groups;
+                    const groups = ssrcOperation.ssrc.groups;
                     if (typeof bLine.ssrcGroups !== 'undefined' &&
                         Array.isArray(bLine.ssrcGroups) && groups &&
                         groups.length) {
                     // Storing the unmuted SSRCs.
                     permSSRCs.push(ssrcOperation);
                     break;
+                }
                 default:
-                break;
+                    break;
             }
             SSRCs = this.replaceSSRCs[bLine.type].splice(0,1);
         }
 
         if (!Array.isArray(bLine.ssrcs) || bLine.ssrcs.length === 0)
         {
-            var ssrc = this.recvOnlySSRCs[bLine.type]
+            const ssrc = this.recvOnlySSRCs[bLine.type]
                 = this.recvOnlySSRCs[bLine.type] ||
                     RandomUtil.randomInt(1, 0xffffffff);
             bLine.ssrcs = [{
 };
 
 TraceablePeerConnection.prototype.addIceCandidate
+        // eslint-disable-next-line no-unused-vars
         = function (candidate, successCallback, failureCallback) {
     //var self = this;
     this.trace('addIceCandidate', JSON.stringify(candidate, null, ' '));

modules/xmpp/recording.js

-/* global $, $iq, config, connection, focusMucJid, messageHandler,
-   Toolbar, Util, Promise */
-import {getLogger} from "jitsi-meet-logger";
+/* global $, $iq */
+
+import { getLogger } from "jitsi-meet-logger";
 const logger = getLogger(__filename);
 var XMPPEvents = require("../../service/xmpp/XMPPEvents");
 var JitsiRecorderErrors = require("../../JitsiRecorderErrors");
 };
 
 Recording.prototype.setRecordingJirecon =
-    function (state, callback, errCallback, options) {
+    function (state, callback, errCallback) {
 
     if (state == this.state){
         errCallback(new Error("Invalid state!"));

modules/xmpp/strophe.emuc.js

-/* jshint -W117 */
 /* a simple MUC connection plugin
  * can only handle a single MUC room
  */
+
+/* global $, Strophe */
+
 import {getLogger} from "jitsi-meet-logger";
 const logger = getLogger(__filename);
 import ChatRoom from "./ChatRoom";
             const errmsg = "You are already in the room!";
             logger.error(errmsg);
             throw new Error(errmsg);
-            return;
         }
         this.rooms[roomJid] = new ChatRoom(this.connection, jid,
             password, this.xmpp, options, settings);

modules/xmpp/strophe.jingle.js

-/* jshint -W117 */
-import {getLogger} from "jitsi-meet-logger";
+/* global $, $iq, Strophe */
+
+import { getLogger } from "jitsi-meet-logger";
 const logger = getLogger(__filename);
 import JingleSession from "./JingleSessionPC";
 import XMPPEvents from "../../service/xmpp/XMPPEvents";
-import RTCBrowserType from "../RTC/RTCBrowserType";
 import GlobalOnErrorHandler from "../util/GlobalOnErrorHandler";
 import Statistics from "../statistics/statistics";
 import ConnectionPlugin from "./ConnectionPlugin";
         const now = window.performance.now();
         // see http://xmpp.org/extensions/xep-0166.html#concepts-session
         switch (action) {
-            case 'session-initiate':
+            case 'session-initiate': {
                 logger.log("(TIME) received session-initiate:\t", now);
                 const startMuted = $(iq).find('jingle>startmuted');
                 if (startMuted && startMuted.length > 0) {
                 Statistics.analytics.sendEvent(
                     'xmpp.session-initiate', now);
                 break;
-            case 'session-terminate':
+            }
+            case 'session-terminate': {
                 logger.log('terminating...', sess.sid);
                 let reasonCondition = null;
                 let reasonText = null;
                 this.eventEmitter.emit(XMPPEvents.CALL_ENDED,
                     sess, reasonCondition, reasonText);
                 break;
+            }
             case 'transport-replace':
                 logger.info("(TIME) Start transport replace", now);
                 Statistics.analytics.sendEvent(
                             iceservers.push(dict);
                             break;
                         case 'turn':
-                        case 'turns':
+                        case 'turns': {
                             dict.url = type + ':';
                             const username = el.attr('username');
                             // https://code.google.com/p/webrtc/issues/detail?id=1508
                                 || dict.credential;
                             iceservers.push(dict);
                             break;
+                        }
                     }
                 });
                 self.ice_config.iceServers = iceservers;
         const data = {};
         Object.keys(this.sessions).forEach((sid) => {
             const session = self.sessions[sid];
-            const pc = session.peerconnection
+            const pc = session.peerconnection;
             if (pc && pc.updateLog) {
                 // FIXME: should probably be a .dump call
                 data["jingle_" + sid] = {

modules/xmpp/strophe.ping.js

 /* global $, $iq, Strophe */
-import {getLogger} from "jitsi-meet-logger";
+
+import { getLogger } from "jitsi-meet-logger";
 const logger = getLogger(__filename);
-import GlobalOnErrorHandler from "../util/GlobalOnErrorHandler";
-import XMPPEvents from "../../service/xmpp/XMPPEvents";
 import ConnectionPlugin from "./ConnectionPlugin";
+import GlobalOnErrorHandler from "../util/GlobalOnErrorHandler";
 
 /**
  * Ping every 10 sec
             return;
         }
         this.intervalId = window.setInterval(() => {
-            this.ping(remoteJid, (result) => {
+            this.ping(remoteJid, () => {
                 this.failedPings = 0;
             }, (error) => {
                 this.failedPings += 1;

modules/xmpp/strophe.rayo.js

-/* jshint -W117 */
-import {getLogger} from "jitsi-meet-logger";
+/* global $, $iq, Strophe */
+
+import { getLogger } from "jitsi-meet-logger";
 const logger = getLogger(__filename);
 import ConnectionPlugin from "./ConnectionPlugin";
 
                 to: focusMucJid
             });
             req.c('dial', {
-                xmlns: self.RAYO_XMLNS,
+                xmlns: RAYO_XMLNS,
                 to: to,
                 from: from
             });

modules/xmpp/xmpp.js

-/* global $, APP, config, Strophe */
-import {getLogger} from "jitsi-meet-logger";
+/* global $, $msg, Base64, Strophe */
+
+import { getLogger } from "jitsi-meet-logger";
 const logger = getLogger(__filename);
 import EventEmitter from "events";
 import Pako from "pako";
 import RandomUtil from "../util/RandomUtil";
-import RTCEvents from "../../service/RTC/RTCEvents";
-import XMPPEvents from "../../service/xmpp/XMPPEvents";
 import * as JitsiConnectionErrors from "../../JitsiConnectionErrors";
 import * as JitsiConnectionEvents from "../../JitsiConnectionEvents";
-import RTC from "../RTC/RTC";
 import RTCBrowserType from "../RTC/RTCBrowserType";
 import initEmuc from "./strophe.emuc";
 import initJingle from "./strophe.jingle";
     }
 
     return new Strophe.Connection(bosh);
-};
+}
 
 export default class XMPP {
     constructor(options, token) {
 
     removeListener (type, listener) {
         this.eventEmitter.removeListener(type, listener);
-    };
+    }
 
     /**
      * Sends 'data' as a log message to the focus. Returns true iff a message

package.json

     "babel-polyfill": "*",
     "babel-preset-es2015": "*",
     "babel-register": "*",
+    "eslint": "*",
     "jshint": "^2.8.0",
     "precommit-hook": "^3.0.0",
     "string-replace-loader": "*",
   },
   "scripts": {
     "install": "webpack -p",
-    "lint": "jshint .",
+    "lint": "jshint . && eslint .",
     "validate": "npm ls"
   },
   "pre-commit": [