[eslint] array-bracket-spacing

.eslintrc.js

         'no-unused-vars': 2,
 
         // Stylistic issues group
+        'array-bracket-spacing': [
+            'error',
+            'always',
+            { 'objectsInArrays': true }
+        ],
         'brace-style': 2,
         'comma-style': 2,
         'eol-last': 2,

doc/example/example.js

         localTracks[1].dispose();
         localTracks.pop();
     }
-    JitsiMeetJS.createLocalTracks({devices: isVideo ? ['video'] : ['desktop']})
+    JitsiMeetJS.createLocalTracks({devices: isVideo ? [ 'video' ] : [ 'desktop' ]})
         .then(tracks => {
             localTracks.push(tracks[0]);
             localTracks[1].addEventListener(JitsiMeetJS.events.track.TRACK_MUTE_CHANGED,
     desktopSharingChromeDisabled: false,
     // The media sources to use when using screen sharing with the Chrome
     // extension.
-    desktopSharingChromeSources: ['screen', 'window'],
+    desktopSharingChromeSources: [ 'screen', 'window' ],
     // Required version of Chrome extension
     desktopSharingChromeMinExtVersion: '0.1',
 
             onDeviceListChanged);
 
         connection.connect();
-        JitsiMeetJS.createLocalTracks({devices: ['audio', 'video']})
+        JitsiMeetJS.createLocalTracks({devices: [ 'audio', 'video' ]})
             .then(onLocalTracks)
             .catch(error => {
                 throw error;

karma.conf.js

 
     // frameworks to use
     // available frameworks: https://npmjs.org/browse/keyword/karma-adapter
-        frameworks: ['jasmine'],
+        frameworks: [ 'jasmine' ],
 
 
     // list of files / patterns to load in the browser
     // available preprocessors:
     //  https://npmjs.org/browse/keyword/karma-preprocessor
         preprocessors: {
-            './JitsiMeetJS.js': ['webpack'],
-            './**/*.spec.js': ['webpack']
+            './JitsiMeetJS.js': [ 'webpack' ],
+            './**/*.spec.js': [ 'webpack' ]
         },
 
 
     // test results reporter to use
     // possible values: 'dots', 'progress'
     // available reporters: https://npmjs.org/browse/keyword/karma-reporter
-        reporters: ['progress'],
+        reporters: [ 'progress' ],
 
 
     // web server port
     // start these browsers
     // available browser launchers:
     // https://npmjs.org/browse/keyword/karma-launcher
-        browsers: ['Chrome'],
+        browsers: [ 'Chrome' ],
 
 
     // Continuous Integration mode

modules/RTC/RTCUtils.js

                 constraints.audio = {
                     mandatory: {},
                     deviceId: options.micDeviceId, // new style
-                    optional: [{
+                    optional: [ {
                         sourceId: options.micDeviceId // old style
-                    }]};
+                    } ]};
             } else {
                 constraints.audio = true;
             }
 function wrapGetUserMedia(getUserMedia) {
     return function(constraints, successCallback, errorCallback) {
         getUserMedia(constraints, stream => {
-            maybeApply(successCallback, [stream]);
+            maybeApply(successCallback, [ stream ]);
             if (!getUserMediaStatus.initialized) {
                 getUserMediaStatus.initialized = true;
                 getUserMediaStatus.callbacks.forEach(callback => callback());
                 getUserMediaStatus.callbacks.length = 0;
             }
         }, error => {
-            maybeApply(errorCallback, [error]);
+            maybeApply(errorCallback, [ error ]);
         });
     };
 }
                 && audioOutputChanged) {
             element.setSinkId(rtcUtils.getAudioOutputDevice())
                 .catch(function(ex) {
-                    const err = new JitsiTrackError(ex, null, ['audiooutput']);
+                    const err = new JitsiTrackError(ex, null, [ 'audiooutput' ]);
 
                     GlobalOnErrorHandler.callUnhandledRejectionHandler(
                         {promise: this, reason: err});
                 resolve(handleLocalStream(stream, options.resolution));
             };
 
-            options.devices = options.devices || ['audio', 'video'];
+            options.devices = options.devices || [ 'audio', 'video' ];
             if(!screenObtainer.isSupported()
                 && options.devices.indexOf('desktop') !== -1) {
                 reject(new Error('Desktop sharing is not supported!'));
                 };
 
                 const deviceGUM = {
-                    'audio': GUM.bind(self, ['audio']),
-                    'video': GUM.bind(self, ['video'])
+                    'audio': GUM.bind(self, [ 'audio' ]),
+                    'video': GUM.bind(self, [ 'video' ])
                 };
 
                 if(screenObtainer.isSupported()) {

modules/RTC/ScreenObtainer.js

                             );
                         } else {
                             jitsiError = new JitsiTrackError(
-                                error, constraints, ['desktop']);
+                                error, constraints, [ 'desktop' ]);
                         }
                         (typeof onFailure === 'function')
                             && onFailure(jitsiError);
  * 'about:config'.
  */
 function obtainWebRTCScreen(options, streamCallback, failCallback) {
-    gumFunction(['screen'], streamCallback, failCallback);
+    gumFunction([ 'screen' ], streamCallback, failCallback);
 }
 
 /**
 function onGetStreamResponse(response, onSuccess, onFailure) {
     if (response.streamId) {
         gumFunction(
-            ['desktop'],
+            [ 'desktop' ],
             stream => onSuccess(stream),
             onFailure,
             { desktopStream: response.streamId });

modules/RTC/TraceablePeerConnection.js

         });
     } else {
         ssrcInfo = {
-            ssrcs: [SDPUtil.generateSsrc()],
+            ssrcs: [ SDPUtil.generateSsrc() ],
             groups: []
         };
     }
 
             ssrcInfo.ssrcs.push(rtxSsrc);
             ssrcInfo.groups.push({
-                ssrcs: [primarySsrc, rtxSsrc],
+                ssrcs: [ primarySsrc, rtxSsrc ],
                 semantics: 'FID'
             });
         }

modules/xmpp/Caps.js

 /**
  * The property
  */
-const IDENTITY_PROPERTIES = ['category', 'type', 'lang', 'name'];
-const IDENTITY_PROPERTIES_FOR_COMPARE = ['category', 'type', 'lang'];
+const IDENTITY_PROPERTIES = [ 'category', 'type', 'lang', 'name' ];
+const IDENTITY_PROPERTIES_FOR_COMPARE = [ 'category', 'type', 'lang' ];
 const HASH = 'sha-1';
 
 function compareIdentities(a, b) {

modules/xmpp/JingleSessionPC.js

                 }
                 this.drip_container.push(candidate);
             } else {
-                this.sendIceCandidates([candidate]);
+                this.sendIceCandidates([ candidate ]);
             }
         } else {
             logger.log('sendIceCandidate: last candidate.');

modules/xmpp/RtxModifier.spec.js

     const videoMLine = parsedSdp.media.find(m => m.type === 'video');
 
     if (numVideoSsrcs(parsedSdp) === 1) {
-        return [videoMLine.ssrcs[0].id];
+        return [ videoMLine.ssrcs[0].id ];
     }
     const simGroups = getVideoGroups(parsedSdp, 'SIM');
 

modules/xmpp/SDPDiffer.js

 
                 if (otherSsrcGroup.semantics == mySsrcGroup.semantics
                     && arrayEquals.apply(otherSsrcGroup.ssrcs,
-                                      [mySsrcGroup.ssrcs])) {
+                                      [ mySsrcGroup.ssrcs ])) {
 
                     matched = true;
                     break;

modules/xmpp/SDPUtil.js

         const streamCount = parts.length > 2 ? parts[2] : null;
 
 
-        return [sctpPort, protocol, streamCount];// SCTP port
+        return [ sctpPort, protocol, streamCount ];// SCTP port
     },
     build_rtpmap(el) {
         let line = `a=rtpmap:${el.getAttribute('id')} ${el.getAttribute('name')}/${el.getAttribute('clockrate')}`;
         return candidate;
     },
     build_icecandidate(cand) {
-        let line = [`a=candidate:${cand.foundation}`, cand.component, cand.protocol, cand.priority, cand.ip, cand.port, 'typ', cand.type].join(' ');
+        let line = [ `a=candidate:${cand.foundation}`, cand.component, cand.protocol, cand.priority, cand.ip, cand.port, 'typ', cand.type ].join(' ');
 
         line += ' ';
         switch (cand.type) {

modules/xmpp/strophe.logger.js

     }
 
     log_incoming(stanza) {
-        this.log.push([new Date().getTime(), 'incoming', stanza]);
+        this.log.push([ new Date().getTime(), 'incoming', stanza ]);
     }
 
     log_outgoing(stanza) {
-        this.log.push([new Date().getTime(), 'outgoing', stanza]);
+        this.log.push([ new Date().getTime(), 'outgoing', stanza ]);
     }
 }