[eslint] object-property-newline

.eslintrc.js

         'no-whitespace-before-property': 2,
         'object-curly-newline': 0,
         'object-curly-spacing': [ 'error', 'always' ],
+        'object-property-newline': 2,
         'one-var': 0,
         'one-var-declaration-per-line': 0,
         'operator-assignment': 0,

JitsiConference.js

     this.authEnabled = false;
     this.startAudioMuted = false;
     this.startVideoMuted = false;
-    this.startMutedPolicy = { audio: false, video: false };
+    this.startMutedPolicy = {
+        audio: false,
+        video: false
+    };
     this.availableDevices = {
         audio: undefined,
         video: undefined
         // remove previously set nickname
         this.room.removeFromPresence('nick');
 
-        this.room.addToPresence('nick', { attributes: { xmlns: 'http://jabber.org/protocol/nick' }, value: name });
+        this.room.addToPresence('nick', {
+            attributes: { xmlns: 'http://jabber.org/protocol/nick' },
+            value: name
+        });
         this.room.sendPresence();
     }
 };

JitsiConferenceEventManager.js

     conference.room.addListener(XMPPEvents.LOCAL_UFRAG_CHANGED,
         ufrag => {
             Statistics.sendLog(
-                JSON.stringify({ id: 'local_ufrag', value: ufrag }));
+                JSON.stringify({ id: 'local_ufrag',
+                    value: ufrag }));
         });
     conference.room.addListener(XMPPEvents.REMOTE_UFRAG_CHANGED,
         ufrag => {
             Statistics.sendLog(
-                JSON.stringify({ id: 'remote_ufrag', value: ufrag }));
+                JSON.stringify({ id: 'remote_ufrag',
+                    value: ufrag }));
         });
 
     chatRoom.addPresenceListener('startmuted', (data, from) => {

JitsiConnection.js

                     `connection.disconnected.${msg}`);
             }
             Statistics.sendLog(
-                JSON.stringify({ id: 'connection.disconnected', msg }));
+                JSON.stringify({ id: 'connection.disconnected',
+                    msg }));
         });
 }
 
  * @returns {JitsiConference} returns the new conference object.
  */
 JitsiConnection.prototype.initJitsiConference = function(name, options) {
-    return new JitsiConference({ name, config: options, connection: this });
+    return new JitsiConference({ name,
+        config: options,
+        connection: this });
 };
 
 /**

modules/RTC/RTCUtils.js

  * @param {bool} firefox_fake_device
  */
 function getConstraints(um, options) {
-    const constraints = { audio: false, video: false };
+    const constraints = { audio: false,
+        video: false };
 
     // Don't mix new and old style settings for Chromium as this leads
     // to TypeError in new Chromium versions. @see
 
     if (um.indexOf('video') >= 0) {
         // same behaviour as true
-        constraints.video = { mandatory: {}, optional: [] };
+        constraints.video = { mandatory: {},
+            optional: [] };
 
         if (options.cameraDeviceId) {
             if (isNewStyleConstraintsSupported) {
             }
         } else {
             // same behaviour as true
-            constraints.audio = { mandatory: {}, optional: [] };
+            constraints.audio = { mandatory: {},
+                optional: [] };
             if (options.micDeviceId) {
                 if (isNewStyleConstraintsSupported) {
                     // New style of setting device id.
     if (options.bandwidth) {
         if (!constraints.video) {
             // same behaviour as true
-            constraints.video = { mandatory: {}, optional: [] };
+            constraints.video = { mandatory: {},
+                optional: [] };
         }
         constraints.video.optional.push({ bandwidth: options.bandwidth });
     }
                     const err = new JitsiTrackError(ex, null, [ 'audiooutput' ]);
 
                     GlobalOnErrorHandler.callUnhandledRejectionHandler(
-                        { promise: this, reason: err });
+                        { promise: this,
+                            reason: err });
 
                     logger.warn('Failed to set audio output device for the '
                         + 'element. Default audio output device will be used '

modules/RTC/TraceablePeerConnection.js

  * - groups - Array of the groups associated with the stream.
  */
 TraceablePeerConnection.prototype.generateNewStreamSSRCInfo = function() {
-    let ssrcInfo = { ssrcs: [], groups: [] };
+    let ssrcInfo = { ssrcs: [],
+        groups: [] };
 
     if (!this.options.disableSimulcast
         && this.simulcast.isSupported()) {

modules/connectivity/ConnectionQuality.js

  * See media/engine/simulcast.ss from webrtc.org
  */
 const kSimulcastFormats = [
-    { width: 1920, height: 1080, layers: 3, max: 5000, target: 4000, min: 800 },
-    { width: 1280, height: 720, layers: 3, max: 2500, target: 2500, min: 600 },
-    { width: 960, height: 540, layers: 3, max: 900, target: 900, min: 450 },
-    { width: 640, height: 360, layers: 2, max: 700, target: 500, min: 150 },
-    { width: 480, height: 270, layers: 2, max: 450, target: 350, min: 150 },
-    { width: 320, height: 180, layers: 1, max: 200, target: 150, min: 30 }
+    { width: 1920,
+        height: 1080,
+        layers: 3,
+        max: 5000,
+        target: 4000,
+        min: 800 },
+    { width: 1280,
+        height: 720,
+        layers: 3,
+        max: 2500,
+        target: 2500,
+        min: 600 },
+    { width: 960,
+        height: 540,
+        layers: 3,
+        max: 900,
+        target: 900,
+        min: 450 },
+    { width: 640,
+        height: 360,
+        layers: 2,
+        max: 700,
+        target: 500,
+        min: 150 },
+    { width: 480,
+        height: 270,
+        layers: 2,
+        max: 450,
+        target: 350,
+        min: 150 },
+    { width: 320,
+        height: 180,
+        layers: 1,
+        max: 200,
+        target: 150,
+        min: 30 }
 ];
 
 /**

modules/statistics/CallStats.js

     } else {
         CallStats.reportsQueue.push({
             type: reportType.EVENT,
-            data: { event, eventData }
+            data: { event,
+                eventData }
         });
         CallStats._checkInitialize();
     }
     } else {
         CallStats.reportsQueue.push({
             type: reportType.ERROR,
-            data: { type, error: e, pc }
+            data: { type,
+                error: e,
+                pc }
         });
         CallStats._checkInitialize();
     }

modules/statistics/RTPStatsCollector.js

             if (!conferenceStatsTransport.some(
                     t =>
                         t.ip == ip && t.type == type && t.localip == localip)) {
-                conferenceStatsTransport.push({ ip, type, localip });
+                conferenceStatsTransport.push({ ip,
+                    type,
+                    localip });
             }
             continue;
         }
             'upload': bitrateSentKbps
         });
 
-        const resolution = { height: null, width: null };
+        const resolution = { height: null,
+            width: null };
 
         try {
             let height, width;
     this.eventEmitter.emit(StatisticsEvents.BYTE_SENT_STATS, byteSentStats);
 
     this.conferenceStats.bitrate
-      = { 'upload': bitrateUpload, 'download': bitrateDownload };
+      = { 'upload': bitrateUpload,
+          'download': bitrateDownload };
 
     this.conferenceStats.packetLoss = {
         total:

modules/statistics/statistics.js

         this.callstats.sendFeedback(overall, detailed);
     }
     Statistics.analytics.sendEvent('feedback.rating',
-        { value: overall, detailed });
+        { value: overall,
+            detailed });
 };
 
 Statistics.LOCAL_JID = require('../../service/statistics/constants').LOCAL_JID;
  */
 Statistics.sendEventToAll = function(eventName, data) {
     this.analytics.sendEvent(eventName, data);
-    Statistics.sendLog(JSON.stringify({ name: eventName, data }));
+    Statistics.sendLog(JSON.stringify({ name: eventName,
+        data }));
 };
 
 module.exports = Statistics;

modules/xmpp/Caps.js

         const node = caps.getAttribute('node');
         const oldVersion = this.jidToVersion[from];
 
-        this.jidToVersion[from] = { version, node };
+        this.jidToVersion[from] = { version,
+            node };
         if (oldVersion && oldVersion.version !== version) {
             this.eventEmitter.emit(XMPPEvents.PARTCIPANT_FEATURES_CHANGED,
                 from);

modules/xmpp/ChatRoom.js

         this.noBridgeAvailable = false;
         this.options = options || {};
         this.moderator = new Moderator(this.roomjid, this.xmpp, this.eventEmitter,
-            { connection: this.xmpp.options, conference: this.options });
+            { connection: this.xmpp.options,
+                conference: this.options });
         this.initPresenceMap();
         this.lastPresences = {};
         this.phoneNumber = null;
      */
     doLeave() {
         logger.log('do leave', this.myroomjid);
-        const pres = $pres({ to: this.myroomjid, type: 'unavailable' });
+        const pres = $pres({ to: this.myroomjid,
+            type: 'unavailable' });
 
         this.presMap.length = 0;
 
     discoRoomInfo() {
       // https://xmpp.org/extensions/xep-0045.html#disco-roominfo
 
-        const getInfo = $iq({ type: 'get', to: this.roomjid })
+        const getInfo = $iq({ type: 'get',
+            to: this.roomjid })
         .c('query', { xmlns: Strophe.NS.DISCO_INFO });
 
         this.connection.sendIQ(getInfo, result => {
     createNonAnonymousRoom() {
         // http://xmpp.org/extensions/xep-0045.html#createroom-reserved
 
-        const getForm = $iq({ type: 'get', to: this.roomjid })
+        const getForm = $iq({ type: 'get',
+            to: this.roomjid })
             .c('query', { xmlns: 'http://jabber.org/protocol/muc#owner' })
-            .c('x', { xmlns: 'jabber:x:data', type: 'submit' });
+            .c('x', { xmlns: 'jabber:x:data',
+                type: 'submit' });
 
         const self = this;
 
                 return;
             }
 
-            const formSubmit = $iq({ to: self.roomjid, type: 'set' })
+            const formSubmit = $iq({ to: self.roomjid,
+                type: 'set' })
                 .c('query', { xmlns: 'http://jabber.org/protocol/muc#owner' });
 
-            formSubmit.c('x', { xmlns: 'jabber:x:data', type: 'submit' });
+            formSubmit.c('x', { xmlns: 'jabber:x:data',
+                type: 'submit' });
 
             formSubmit.c('field', { 'var': 'FORM_TYPE' })
                 .c('value')
     }
 
     sendMessage(body, nickname) {
-        const msg = $msg({ to: this.roomjid, type: 'groupchat' });
+        const msg = $msg({ to: this.roomjid,
+            type: 'groupchat' });
 
         msg.c('body', body).up();
         if (nickname) {
     }
 
     setSubject(subject) {
-        const msg = $msg({ to: this.roomjid, type: 'groupchat' });
+        const msg = $msg({ to: this.roomjid,
+            type: 'groupchat' });
 
         msg.c('subject', subject);
         this.connection.send(msg);
     }
 
     kick(jid) {
-        const kickIQ = $iq({ to: this.roomjid, type: 'set' })
+        const kickIQ = $iq({ to: this.roomjid,
+            type: 'set' })
             .c('query', { xmlns: 'http://jabber.org/protocol/muc#admin' })
-            .c('item', { nick: Strophe.getResourceFromJid(jid), role: 'none' })
+            .c('item', { nick: Strophe.getResourceFromJid(jid),
+                role: 'none' })
             .c('reason').t('You have been kicked.').up().up().up();
 
         this.connection.sendIQ(
     lockRoom(key, onSuccess, onError, onNotSupported) {
         // http://xmpp.org/extensions/xep-0045.html#roomconfig
         this.connection.sendIQ(
-            $iq({ to: this.roomjid, type: 'get' }).c('query', { xmlns: 'http://jabber.org/protocol/muc#owner' }),
+            $iq({ to: this.roomjid,
+                type: 'get' }).c('query', { xmlns: 'http://jabber.org/protocol/muc#owner' }),
             res => {
                 if ($(res).find('>query>x[xmlns="jabber:x:data"]>field[var="muc#roomconfig_roomsecret"]').length) {
                     const formsubmit
-                        = $iq({ to: this.roomjid, type: 'set' })
+                        = $iq({ to: this.roomjid,
+                            type: 'set' })
                             .c('query', { xmlns: 'http://jabber.org/protocol/muc#owner' });
 
-                    formsubmit.c('x', { xmlns: 'jabber:x:data', type: 'submit' });
+                    formsubmit.c('x', { xmlns: 'jabber:x:data',
+                        type: 'submit' });
                     formsubmit.c('field', { 'var': 'FORM_TYPE' }).c('value').t('http://jabber.org/protocol/muc#roomconfig').up().up();
                     formsubmit.c('field', { 'var': 'muc#roomconfig_roomsecret' }).c('value').t(key).up().up();
                     // Fixes a bug in prosody 0.9.+ https://code.google.com/p/lxmppd/issues/detail?id=373
     muteParticipant(jid, mute) {
         logger.info('set mute', mute);
         const iqToFocus = $iq(
-            { to: this.focusMucJid, type: 'set' })
+            { to: this.focusMucJid,
+                type: 'set' })
             .c('mute', {
                 xmlns: 'http://jitsi.org/jitmeet/audio',
                 jid

modules/xmpp/JingleSessionPC.js

 
     sendIceCandidates(candidates) {
         logger.log('sendIceCandidates', candidates);
-        const cand = $iq({ to: this.peerjid, type: 'set' })
+        const cand = $iq({ to: this.peerjid,
+            type: 'set' })
             .c('jingle', { xmlns: 'urn:xmpp:jingle:1',
                 action: 'transport-info',
                 initiator: this.initiator,
      *        or when the request has timed out.
      */
     sendTransportAccept(localSDP, success, failure) {
-        let transportAccept = $iq({ to: this.peerjid, type: 'set' })
+        let transportAccept = $iq({ to: this.peerjid,
+            type: 'set' })
             .c('jingle', {
                 xmlns: 'urn:xmpp:jingle:1',
                 action: 'transport-accept',
     sendTransportReject(success, failure) {
         // Send 'transport-reject', so that the focus will
         // know that we've failed
-        let transportReject = $iq({ to: this.peerjid, type: 'set' })
+        let transportReject = $iq({ to: this.peerjid,
+            type: 'set' })
             .c('jingle', {
                 xmlns: 'urn:xmpp:jingle:1',
                 action: 'transport-reject',
     terminate(reason, text, success, failure) {
         this.state = JingleSessionState.ENDED;
 
-        let sessionTerminate = $iq({ to: this.peerjid, type: 'set' })
+        let sessionTerminate = $iq({ to: this.peerjid,
+            type: 'set' })
             .c('jingle', {
                 xmlns: 'urn:xmpp:jingle:1',
                 action: 'session-terminate',
 
         // send source-remove IQ.
         let sdpDiffer = new SDPDiffer(new_sdp, old_sdp);
-        const remove = $iq({ to: this.peerjid, type: 'set' })
+        const remove = $iq({ to: this.peerjid,
+            type: 'set' })
             .c('jingle', {
                 xmlns: 'urn:xmpp:jingle:1',
                 action: 'source-remove',
 
         // send source-add IQ.
         sdpDiffer = new SDPDiffer(old_sdp, new_sdp);
-        const add = $iq({ to: this.peerjid, type: 'set' })
+        const add = $iq({ to: this.peerjid,
+            type: 'set' })
             .c('jingle', {
                 xmlns: 'urn:xmpp:jingle:1',
                 action: 'source-add',

modules/xmpp/SDP.js

             tmp = lines[i].split(' ');
             const semantics = tmp.shift().substr(8);
 
-            elem.c('group', { xmlns: 'urn:xmpp:jingle:apps:grouping:0', semantics });
+            elem.c('group', { xmlns: 'urn:xmpp:jingle:apps:grouping:0',
+                semantics });
             for (j = 0; j < tmp.length; j++) {
                 elem.c('content', { name: tmp[j] }).up();
             }
             ssrc = false;
         }
 
-        elem.c('content', { creator: thecreator, name: mline.media });
+        elem.c('content', { creator: thecreator,
+            name: mline.media });
         const amidline = SDPUtil.find_line(this.media[i], 'a=mid:');
 
         if (amidline) {
 
             if (ssrc) {
                 // new style mapping
-                elem.c('source', { ssrc, xmlns: 'urn:xmpp:jingle:apps:rtp:ssma:0' });
+                elem.c('source', { ssrc,
+                    xmlns: 'urn:xmpp:jingle:apps:rtp:ssma:0' });
                 // FIXME: group by ssrc and support multiple different ssrcs
                 const ssrclines = SDPUtil.find_lines(this.media[i], 'a=ssrc:');
 
                         if (linessrc != ssrc) {
                             elem.up();
                             ssrc = linessrc;
-                            elem.c('source', { ssrc, xmlns: 'urn:xmpp:jingle:apps:rtp:ssma:0' });
+                            elem.c('source', { ssrc,
+                                xmlns: 'urn:xmpp:jingle:apps:rtp:ssma:0' });
                         }
                         const kv = line.substr(idx + 1);
 
                     });
                 } else {
                     elem.up();
-                    elem.c('source', { ssrc, xmlns: 'urn:xmpp:jingle:apps:rtp:ssma:0' });
+                    elem.c('source', { ssrc,
+                        xmlns: 'urn:xmpp:jingle:apps:rtp:ssma:0' });
                     elem.c('parameter');
                     elem.attrs({
                         name: 'cname',
                     if (msid !== null) {
                         msid = SDPUtil.filter_special_chars(msid);
                         elem.c('parameter');
-                        elem.attrs({ name: 'msid', value: msid });
+                        elem.attrs({ name: 'msid',
+                            value: msid });
                         elem.up();
                         elem.c('parameter');
-                        elem.attrs({ name: 'mslabel', value: msid });
+                        elem.attrs({ name: 'mslabel',
+                            value: msid });
                         elem.up();
                         elem.c('parameter');
-                        elem.attrs({ name: 'label', value: msid });
+                        elem.attrs({ name: 'label',
+                            value: msid });
                         elem.up();
                     }
                 }
                     const ssrcs = line.substr(14 + semantics.length).split(' ');
 
                     if (ssrcs.length) {
-                        elem.c('ssrc-group', { semantics, xmlns: 'urn:xmpp:jingle:apps:rtp:ssma:0' });
+                        elem.c('ssrc-group', { semantics,
+                            xmlns: 'urn:xmpp:jingle:apps:rtp:ssma:0' });
                         ssrcs.forEach(ssrc => elem.c('source', { ssrc }).up());
                         elem.up();
                     }
         const tmp = SDPUtil.parse_rtcpfb(line);
 
         if (tmp.type == 'trr-int') {
-            elem.c('rtcp-fb-trr-int', { xmlns: 'urn:xmpp:jingle:apps:rtp:rtcp-fb:0', value: tmp.params[0] });
+            elem.c('rtcp-fb-trr-int', { xmlns: 'urn:xmpp:jingle:apps:rtp:rtcp-fb:0',
+                value: tmp.params[0] });
             elem.up();
         } else {
-            elem.c('rtcp-fb', { xmlns: 'urn:xmpp:jingle:apps:rtp:rtcp-fb:0', type: tmp.type });
+            elem.c('rtcp-fb', { xmlns: 'urn:xmpp:jingle:apps:rtp:rtcp-fb:0',
+                type: tmp.type });
             if (tmp.params.length > 0) {
                 elem.attrs({ 'subtype': tmp.params[0] });
             }

modules/xmpp/SDPDiffer.js

         modify.c('content', { name: media.mid });
 
         modify.c('description',
-                 { xmlns: 'urn:xmpp:jingle:apps:rtp:1', media: media.mid });
+            { xmlns: 'urn:xmpp:jingle:apps:rtp:1',
+                media: media.mid });
         // FIXME: not completely sure this operates on blocks and / or handles
         // different ssrcs correctly
         // generate sources from lines

modules/xmpp/SDPUtil.js

             const value = parts[i].split('=')[1];
 
             if (key && value) {
-                data.push({ name: key, value });
+                data.push({ name: key,
+                    value });
             } else if (key) {
                 // rfc 4733 (DTMF) style stuff
-                data.push({ name: '', value: key });
+                data.push({ name: '',
+                    value: key });
             }
         }
 

modules/xmpp/moderator.js

 
 Moderator.prototype.createConferenceIq = function() {
     // Generate create conference IQ
-    const elem = $iq({ to: this.getFocusComponent(), type: 'set' });
+    const elem = $iq({ to: this.getFocusComponent(),
+        type: 'set' });
 
     // Session Id used for authentication
     const sessionId = Settings.getSessionId();
  * @param failureCb
  */
 Moderator.prototype._getLoginUrl = function(popup, urlCb, failureCb) {
-    const iq = $iq({ to: this.getFocusComponent(), type: 'get' });
+    const iq = $iq({ to: this.getFocusComponent(),
+        type: 'get' });
     const attrs = {
         xmlns: 'http://jitsi.org/protocol/focus',
         room: this.roomName,
 };
 
 Moderator.prototype.logout = function(callback) {
-    const iq = $iq({ to: this.getFocusComponent(), type: 'set' });
+    const iq = $iq({ to: this.getFocusComponent(),
+        type: 'set' });
     const sessionId = Settings.getSessionId();
 
     if (!sessionId) {

modules/xmpp/recording.js

 
     // FIXME jibri does not accept IQ without 'url' attribute set ?
         const iq
-            = $iq({ to: this.focusMucJid, type: 'set' })
+            = $iq({ to: this.focusMucJid,
+                type: 'set' })
                 .c('jibri', {
                     'xmlns': 'http://jitsi.org/protocol/jibri',
                     'action': state === Recording.status.ON
             errCallback(new Error('Invalid state!'));
         }
 
-        const iq = $iq({ to: this.jirecon, type: 'set' })
+        const iq = $iq({ to: this.jirecon,
+            type: 'set' })
         .c('recording', { xmlns: 'http://jitsi.org/protocol/jirecon',
             action: state === Recording.status.ON
                 ? Recording.action.START
 // with the new recording state, according to the IQ.
 Recording.prototype.setRecordingColibri
 = function(state, callback, errCallback, options) {
-    const elem = $iq({ to: this.focusMucJid, type: 'set' });
+    const elem = $iq({ to: this.focusMucJid,
+        type: 'set' });
 
     elem.c('conference', {
         xmlns: 'http://jitsi.org/protocol/colibri'
     });
-    elem.c('recording', { state, token: options.token });
+    elem.c('recording', { state,
+        token: options.token });
 
     const self = this;
 

modules/xmpp/strophe.jingle.js

         // TODO: implement refresh via updateIce as described in
         //      https://code.google.com/p/webrtc/issues/detail?id=1650
         this.connection.sendIQ(
-            $iq({ type: 'get', to: this.connection.domain })
+            $iq({ type: 'get',
+                to: this.connection.domain })
                 .c('services', { xmlns: 'urn:xmpp:extdisco:1' })
                 .c('service', { host: `turn.${this.connection.domain}` }),
             res => {

modules/xmpp/strophe.ping.js

      *        argument.
      */
     ping(jid, success, error, timeout) {
-        const iq = $iq({ type: 'get', to: jid });
+        const iq = $iq({ type: 'get',
+            to: jid });
 
         iq.c('ping', { xmlns: Strophe.NS.PING });
         this.connection.sendIQ(iq, success, error, timeout);