Prepare for eslint 4

modules/UI/side_pannels/chat/Chat.js

 
         $('#chatconversation').append(
             '<div class="errorMessage"><b>Error: </b>' + 'Your message' +
-            (originalText? (' \"'+ originalText + '\"') : "") +
+            (originalText? (` "${originalText}"`) : "") +
             ' was not sent.' +
             (errorMessage? (' Reason: ' + errorMessage) : '') +  '</div>');
         $('#chatconversation').animate(

react/features/app/functions.native.js

     // hipchat.com
     let regex
         = new RegExp(
-                `^${_URI_PROTOCOL_PATTERN}//hipchat\\.com/video/call/`,
-                'gi');
+            `^${_URI_PROTOCOL_PATTERN}//hipchat\\.com/video/call/`,
+            'gi');
     let match = regex.exec(uri);
 
     if (!match) {
         // enso.me
         regex
             = new RegExp(
-                    `^${_URI_PROTOCOL_PATTERN}//enso\\.me/(?:call|meeting)/`,
-                    'gi');
+                `^${_URI_PROTOCOL_PATTERN}//enso\\.me/(?:call|meeting)/`,
+                'gi');
         match = regex.exec(uri);
     }
     if (match) {

react/features/base/conference/actions.js

     // Dispatches into features/base/conference follow:
 
     conference.on(
-            JitsiConferenceEvents.CONFERENCE_FAILED,
-            (...args) => dispatch(conferenceFailed(conference, ...args)));
+        JitsiConferenceEvents.CONFERENCE_FAILED,
+        (...args) => dispatch(conferenceFailed(conference, ...args)));
     conference.on(
-            JitsiConferenceEvents.CONFERENCE_JOINED,
-            (...args) => dispatch(conferenceJoined(conference, ...args)));
+        JitsiConferenceEvents.CONFERENCE_JOINED,
+        (...args) => dispatch(conferenceJoined(conference, ...args)));
     conference.on(
-            JitsiConferenceEvents.CONFERENCE_LEFT,
-            (...args) => dispatch(conferenceLeft(conference, ...args)));
+        JitsiConferenceEvents.CONFERENCE_LEFT,
+        (...args) => dispatch(conferenceLeft(conference, ...args)));
 
     conference.on(
-            JitsiConferenceEvents.LOCK_STATE_CHANGED,
-            (...args) => dispatch(lockStateChanged(conference, ...args)));
+        JitsiConferenceEvents.LOCK_STATE_CHANGED,
+        (...args) => dispatch(lockStateChanged(conference, ...args)));
 
     // Dispatches into features/base/tracks follow:
 
     conference.on(
-            JitsiConferenceEvents.TRACK_ADDED,
-            t => t && !t.isLocal() && dispatch(trackAdded(t)));
+        JitsiConferenceEvents.TRACK_ADDED,
+        t => t && !t.isLocal() && dispatch(trackAdded(t)));
     conference.on(
-            JitsiConferenceEvents.TRACK_REMOVED,
-            t => t && !t.isLocal() && dispatch(trackRemoved(t)));
+        JitsiConferenceEvents.TRACK_REMOVED,
+        t => t && !t.isLocal() && dispatch(trackRemoved(t)));
 
     // Dispatches into features/base/participants follow:
 
     conference.on(
-            JitsiConferenceEvents.DOMINANT_SPEAKER_CHANGED,
-            (...args) => dispatch(dominantSpeakerChanged(...args)));
+        JitsiConferenceEvents.DOMINANT_SPEAKER_CHANGED,
+        (...args) => dispatch(dominantSpeakerChanged(...args)));
 
     conference.on(
-            JitsiConferenceEvents.PARTICIPANT_CONN_STATUS_CHANGED,
-            (...args) => dispatch(participantConnectionStatusChanged(...args)));
+        JitsiConferenceEvents.PARTICIPANT_CONN_STATUS_CHANGED,
+        (...args) => dispatch(participantConnectionStatusChanged(...args)));
 
     conference.on(
-            JitsiConferenceEvents.USER_JOINED,
-            (id, user) => dispatch(participantJoined({
-                id,
-                name: user.getDisplayName(),
-                role: user.getRole()
-            })));
+        JitsiConferenceEvents.USER_JOINED,
+        (id, user) => dispatch(participantJoined({
+            id,
+            name: user.getDisplayName(),
+            role: user.getRole()
+        })));
     conference.on(
-            JitsiConferenceEvents.USER_LEFT,
-            (...args) => dispatch(participantLeft(...args)));
+        JitsiConferenceEvents.USER_LEFT,
+        (...args) => dispatch(participantLeft(...args)));
     conference.on(
-            JitsiConferenceEvents.USER_ROLE_CHANGED,
-            (...args) => dispatch(participantRoleChanged(...args)));
+        JitsiConferenceEvents.USER_ROLE_CHANGED,
+        (...args) => dispatch(participantRoleChanged(...args)));
 
     conference.addCommandListener(
-            AVATAR_ID_COMMAND,
-            (data, id) => dispatch(participantUpdated({
-                id,
-                avatarID: data.value
-            })));
+        AVATAR_ID_COMMAND,
+        (data, id) => dispatch(participantUpdated({
+            id,
+            avatarID: data.value
+        })));
     conference.addCommandListener(
-            AVATAR_URL_COMMAND,
-            (data, id) => dispatch(participantUpdated({
-                id,
-                avatarURL: data.value
-            })));
+        AVATAR_URL_COMMAND,
+        (data, id) => dispatch(participantUpdated({
+            id,
+            avatarURL: data.value
+        })));
     conference.addCommandListener(
-            EMAIL_COMMAND,
-            (data, id) => dispatch(participantUpdated({
-                id,
-                email: data.value
-            })));
+        EMAIL_COMMAND,
+        (data, id) => dispatch(participantUpdated({
+            id,
+            email: data.value
+        })));
 }
 
 /**

react/features/base/connection/actions.native.js

                 });
 
         connection.addEventListener(
-                JitsiConnectionEvents.CONNECTION_DISCONNECTED,
-                _onConnectionDisconnected);
+            JitsiConnectionEvents.CONNECTION_DISCONNECTED,
+            _onConnectionDisconnected);
         connection.addEventListener(
-                JitsiConnectionEvents.CONNECTION_ESTABLISHED,
-                _onConnectionEstablished);
+            JitsiConnectionEvents.CONNECTION_ESTABLISHED,
+            _onConnectionEstablished);
         connection.addEventListener(
-                JitsiConnectionEvents.CONNECTION_FAILED,
-                _onConnectionFailed);
+            JitsiConnectionEvents.CONNECTION_FAILED,
+            _onConnectionFailed);
 
         connection.connect();
 
          */
         function _onConnectionDisconnected(message: string) {
             connection.removeEventListener(
-                    JitsiConnectionEvents.CONNECTION_DISCONNECTED,
-                    _onConnectionDisconnected);
+                JitsiConnectionEvents.CONNECTION_DISCONNECTED,
+                _onConnectionDisconnected);
 
             dispatch(_connectionDisconnected(connection, message));
         }
          */
         function unsubscribe() {
             connection.removeEventListener(
-                    JitsiConnectionEvents.CONNECTION_ESTABLISHED,
-                    _onConnectionEstablished);
+                JitsiConnectionEvents.CONNECTION_ESTABLISHED,
+                _onConnectionEstablished);
             connection.removeEventListener(
-                    JitsiConnectionEvents.CONNECTION_FAILED,
-                    _onConnectionFailed);
+                JitsiConnectionEvents.CONNECTION_FAILED,
+                _onConnectionFailed);
         }
     };
 }

react/features/base/connection/actions.web.js

             APP.UI.initConference();
 
             APP.UI.addListener(
-                    UIEvents.LANG_CHANGED,
-                    language => APP.translation.setLanguage(language));
+                UIEvents.LANG_CHANGED,
+                language => APP.translation.setLanguage(language));
 
             APP.keyboardshortcut.init();
 

react/features/base/i18n/functions.js

     // Use the default list of namespaces.
     return (
         reactI18nextTranslate([ 'main', 'languages' ], { wait: true })(
-                component));
+            component));
 }
 
 /**

react/features/base/i18n/i18next.js

 
 // Add default language which is preloaded from the source code.
 i18next.addResourceBundle(
-        DEFAULT_LANGUAGE,
-        'main',
-        MAIN_RESOURCES,
-        /* deep */ true,
-        /* overwrite */ true);
+    DEFAULT_LANGUAGE,
+    'main',
+    MAIN_RESOURCES,
+    /* deep */ true,
+    /* overwrite */ true);
 i18next.addResourceBundle(
-        DEFAULT_LANGUAGE,
-        'languages',
-        LANGUAGES_RESOURCES,
-        /* deep */ true,
-        /* overwrite */ true);
+    DEFAULT_LANGUAGE,
+    'languages',
+    LANGUAGES_RESOURCES,
+    /* deep */ true,
+    /* overwrite */ true);
 
 export default i18next;

react/features/base/i18n/middleware.js

  * @returns {Object} The new state that is the result of the reduction of the
  * specified action.
  */
-function _setConfig({ dispatch, getState }, next, action) {
+function _setConfig({ getState }, next, action) {
     const oldValue = getState()['features/base/config'];
     const result = next(action);
     const newValue = getState()['features/base/config'];

react/features/base/lib-jitsi-meet/native/polyfills-browser.js

     if (typeof global.document === 'undefined') {
         const document
             = new DOMParser().parseFromString(
-                    '<html><head></head><body></body></html>',
-                    'text/xml');
+                '<html><head></head><body></body></html>',
+                'text/xml');
 
         // document.addEventListener
         //
                         // Parse the content string.
                         const d
                             = new DOMParser().parseFromString(
-                                    `<div>${innerHTML}</div>`,
-                                    'text/xml');
+                                `<div>${innerHTML}</div>`,
+                                'text/xml');
 
                         // Assign the resulting nodes as children of the
                         // element.
                     if (responseText) {
                         responseXML
                             = new DOMParser().parseFromString(
-                                    responseText,
-                                    'text/xml');
+                                responseText,
+                                'text/xml');
                     }
 
                     return responseXML;

react/features/base/react/RouteRegistry.js

         });
     }
 
-/* eslint-disable no-undef */
+    /* eslint-disable no-undef */
 
     /**
      * Returns registered route by name if any.
      */
     getRouteByComponent(component: Class<Component<*>>) {
 
-/* eslint-enable no-undef */
+        /* eslint-enable no-undef */
 
         const route = this._elements.find(r => r.component === component);
 
     register(route: Route) {
         if (this._elements.includes(route)) {
             throw new Error(
-                    `Route ${String(route.component)} is registered already!`);
+                `Route ${String(route.component)} is registered already!`);
         }
 
         this._elements.push(route);

react/features/conference/components/Conference.native.js

 }
 
 export default reactReduxConnect(_mapStateToProps, _mapDispatchToProps)(
-        Conference);
+    Conference);

react/features/device-selection/components/DeviceSelectionDialog.js

      * @static
      */
     static propTypes = {
-       /**
+        /**
          * All known audio and video devices split by type. This prop comes from
          * the app state.
          */

react/features/device-selection/components/DeviceSelectionDialogBase.js

      * @static
      */
     static propTypes = {
-       /**
+        /**
          * All known audio and video devices split by type. This prop comes from
          * the app state.
          */

react/features/invite/middleware.js

 
     switch (action.type) {
     case UPDATE_DIAL_IN_NUMBERS_FAILED:
-        logger.error('Error encountered while fetching dial-in numbers:',
-           action.error);
+        logger.error(
+            'Error encountered while fetching dial-in numbers:',
+            action.error);
         break;
     }
 

react/features/jwt/middleware.js

 
                 callOverlayVisible
                     = Boolean(
-                            participants
-                                && participants.length === 1
-                                && participants[0].local);
+                        participants
+                            && participants.length === 1
+                            && participants[0].local);
 
                 // However, the CallDialog is not to be displayed/visible again
                 // after all remote participants leave.

react/features/large-video/actions.js

             const id = largeVideo.participantId;
             const videoTrack
                 = getTrackByMediaTypeAndParticipant(
-                        tracks,
-                        MEDIA_TYPE.VIDEO,
-                        id);
+                    tracks,
+                    MEDIA_TYPE.VIDEO,
+                    id);
 
             try {
                 conference.selectParticipant(
-                        videoTrack && videoTrack.videoType === VIDEO_TYPE.CAMERA
-                            ? id
-                            : null);
+                    videoTrack && videoTrack.videoType === VIDEO_TYPE.CAMERA
+                        ? id
+                        : null);
             } catch (err) {
                 _handleParticipantError(err);
             }

react/features/mobile/audio-mode/middleware.js

             AudioMode.setMode(mode)
                 .catch(err =>
                     console.error(
-                            `Failed to set audio mode ${String(mode)}: `
-                                + `${err}`));
+                        `Failed to set audio mode ${String(mode)}: ${err}`));
         }
     }
 

react/features/mobile/background/middleware.js

 
     case APP_WILL_MOUNT:
         store.dispatch(
-                _setAppStateListener(
-                        _onAppStateChange.bind(undefined, store.dispatch)));
+            _setAppStateListener(
+                _onAppStateChange.bind(undefined, store.dispatch)));
         break;
 
     case APP_WILL_UNMOUNT:

react/features/overlay/components/AbstractPageReloadOverlay.js

         // sent to the backed.
         // FIXME: We should dispatch action for this.
         APP.conference.logEvent(
-                'page.reload',
-                /* value */ undefined,
-                /* label */ this.props.reason);
+            'page.reload',
+            /* value */ undefined,
+            /* label */ this.props.reason);
         logger.info(
-                `The conference will be reloaded after ${
-                    this.state.timeoutSeconds} seconds.`);
+            `The conference will be reloaded after ${
+                this.state.timeoutSeconds} seconds.`);
 
         AJS.progressBars.update('#reloadProgressBar', 0);
 
         this._interval
             = setInterval(
-                    () => {
-                        if (this.state.timeLeft === 0) {
-                            if (this._interval) {
-                                clearInterval(this._interval);
-                                this._interval = undefined;
-                            }
-
-                            this.props.dispatch(_reloadNow());
-                        } else {
-                            this.setState(prevState => {
-                                return {
-                                    timeLeft: prevState.timeLeft - 1
-                                };
-                            });
+                () => {
+                    if (this.state.timeLeft === 0) {
+                        if (this._interval) {
+                            clearInterval(this._interval);
+                            this._interval = undefined;
                         }
-                    },
-                    1000);
+
+                        this.props.dispatch(_reloadNow());
+                    } else {
+                        this.setState(prevState => {
+                            return {
+                                timeLeft: prevState.timeLeft - 1
+                            };
+                        });
+                    }
+                },
+                1000);
     }
 
     /**

react/features/overlay/components/ReloadTimer.js

 
         const intervalId
             = setInterval(
-                    () => {
-                        if (this.state.current === this.props.end) {
-                            clearInterval(intervalId);
-                            this.props.onFinish();
-                        } else {
-                            this.setState((prevState, props) => {
-                                return {
-                                    current: prevState.current + props.step
-                                };
-                            });
-                        }
-                    },
-                    Math.abs(this.props.interval) * 1000);
+                () => {
+                    if (this.state.current === this.props.end) {
+                        clearInterval(intervalId);
+                        this.props.onFinish();
+                    } else {
+                        this.setState((prevState, props) => {
+                            return {
+                                current: prevState.current + props.step
+                            };
+                        });
+                    }
+                },
+                Math.abs(this.props.interval) * 1000);
     }
 
     /**
      */
     componentDidUpdate() {
         AJS.progressBars.update(
-                '#reloadProgressBar',
-                Math.abs(this.state.current - this.props.start)
-                    / this.state.time);
+            '#reloadProgressBar',
+            Math.abs(this.state.current - this.props.start) / this.state.time);
     }
 
     /**

react/features/remote-control/components/RemoteControlAuthorizationDialog.js

                 titleKey = 'dialog.remoteControlTitle'
                 width = 'small'>
                 {
-                    this.props.t('dialog.remoteControlRequestMessage',
-                    { user: this.props._displayName })
+                    this.props.t(
+                        'dialog.remoteControlRequestMessage',
+                        { user: this.props._displayName })
                 }
                 {
                     this._getAdditionalMessage()
  */
 function _mapStateToProps(state, ownProps) {
     const { _displayName, participantId } = ownProps;
-    const participant = getParticipantById(
-            state['features/base/participants'], participantId);
+    const participant
+        = getParticipantById(
+            state['features/base/participants'],
+            participantId);
 
     return {
         _displayName: participant ? participant.name : _displayName

react/features/speaker-stats/components/SpeakerStats.js

         );
     }
 
-   /**
+    /**
      * Update the internal state with the latest speaker stats.
      *
      * @returns {void}

react/features/welcome/components/AbstractWelcomePage.js

         if (word.length > 1) {
             animateTimeoutId
                 = setTimeout(
-                        () => {
-                            this._animateRoomnameChanging(
-                                    word.substring(1, word.length));
-                        },
-                        70);
+                    () => {
+                        this._animateRoomnameChanging(
+                            word.substring(1, word.length));
+                    },
+                    70);
         }
 
         this.setState({