Coding style

For lack of a better word/phrase, I'm calling all changes coding style.
I'm targeting readability through naming and syntax.

.jshintignore

 # The following are checked by ESLint with the maximum configuration which
 # supersedes JSHint.
 flow-typed/
-react/
 modules/API/
 modules/transport/
+react/
 
 # The following are checked by ESLint with the minimum configuration which does
 # not supersede JSHint but take advantage of advanced language features such as

modules/API/API.js

         'email': APP.conference.changeLocalEmail,
         'avatar-url': APP.conference.changeLocalAvatarUrl
     };
-    transport.on('event', event => {
-        const { name, data } = event;
-
+    transport.on('event', ({ data, name }) => {
         if (name && commands[name]) {
             commands[name](...data);
 
      * module.
      * @returns {void}
      */
-    init(options = {}) {
-        if (!shouldBeEnabled() && !options.forceEnable) {
+    init({ forceEnable } = {}) {
+        if (!shouldBeEnabled() && !forceEnable) {
             return;
         }
 
         /**
          * Current status (enabled/disabled) of API.
+         *
+         * @private
+         * @type {boolean}
          */
-        this.enabled = true;
+        this._enabled = true;
 
         APP.conference.addListener(
             JitsiMeetConferenceEvents.DESKTOP_SHARING_ENABLED_CHANGED,
      * @returns {void}
      */
     _sendEvent(name, data = {}) {
-        if (this.enabled) {
+        if (this._enabled) {
             transport.sendEvent({
-                name,
-                data
+                data,
+                name
             });
         }
     }
      * @param {Object} options - Object with the message properties.
      * @returns {void}
      */
-    notifyReceivedChatMessage(options = {}) {
-        const { id, nick, body, ts } = options;
-
+    notifyReceivedChatMessage({ body, id, nick, ts } = {}) {
         if (APP.conference.isLocalId(id)) {
             return;
         }
 
         this._sendEvent('incoming-message', {
             from: id,
-            nick,
             message: body,
+            nick,
             stamp: ts
         });
     }
      */
     notifyDisplayNameChanged(id, displayname) {
         this._sendEvent('display-name-change', {
-            id,
-            displayname
+            displayname,
+            id
         });
     }
 
      * @returns {void}
      */
     dispose() {
-        if (this.enabled) {
-            this.enabled = false;
+        if (this._enabled) {
+            this._enabled = false;
             APP.conference.removeListener(
                 JitsiMeetConferenceEvents.DESKTOP_SHARING_ENABLED_CHANGED,
                 onDesktopSharingEnabledChanged);

modules/API/constants.js

 /**
  * JitsiMeetExternalAPI id - unique for a webpage.
  */
-export const API_ID
-    = getConfigParamsFromUrl().jitsi_meet_external_api_id;
+export const API_ID = getConfigParamsFromUrl().jitsi_meet_external_api_id;

modules/API/external/external_api.js

 
     for (const key in config) { // eslint-disable-line guard-for-in
         try {
-            params.push(`${key}=${
-                encodeURIComponent(JSON.stringify(config[key]))}`);
+            params.push(
+                `${key}=${encodeURIComponent(JSON.stringify(config[key]))}`);
         } catch (e) {
             console.warn(`Error encoding ${key}: ${e}`);
         }
      */
     _setupListeners() {
 
-        this._transport.on('event', event => {
-            const { name, data } = event;
-
+        this._transport.on('event', ({ data, name }) => {
             if (name === 'participant-joined') {
                 changeParticipantNumber(this, 1);
-            }
-
-            if (name === 'participant-left') {
+            } else if (name === 'participant-left') {
                 changeParticipantNumber(this, -1);
             }
 
             return;
         }
         this._transport.sendEvent({
-            name: commands[name],
-            data: args
+            data: args,
+            name: commands[name]
         });
     }
 

modules/remotecontrol/Receiver.js

-/* global APP, JitsiMeetJS, interfaceConfig, config */
+/* global APP, config, interfaceConfig, JitsiMeetJS */
+
 import * as JitsiMeetConferenceEvents from '../../ConferenceEvents';
 import {
     DISCO_REMOTE_CONTROL_FEATURE,
 
 import RemoteControlParticipant from "./RemoteControlParticipant";
 
-const logger = require("jitsi-meet-logger").getLogger(__filename);
 const ConferenceEvents = JitsiMeetJS.events.conference;
+const logger = require("jitsi-meet-logger").getLogger(__filename);
 
 /**
  * This class represents the receiver party for a remote controller session.
         this._hangupListener = this._onHangup.bind(this);
         // We expect here that even if we receive the supported event earlier
         // it will be cached and we'll receive it.
-        transport.on('event', data => {
-            if(data.name === REMOTE_CONTROL_EVENT_TYPE) {
-                this._onRemoteControlAPIEvent(data.event);
+        transport.on('event', ({ event, name }) => {
+            if(name === REMOTE_CONTROL_EVENT_TYPE) {
+                this._onRemoteControlAPIEvent(event);
 
                 return true;
             }
         }
         this._sendRemoteControlEvent(userId, {
             type: EVENT_TYPES.permissions,
-            action: action
+            action
         });
     }
 
      */
     _onRemoteControlAPIEvent(event) {
         switch(event.type) {
-            case EVENT_TYPES.supported:
-                this._onRemoteControlSupported();
-                break;
-            case EVENT_TYPES.permissions:
-                this._onRemoteControlPermissionsEvent(
-                    event.userId, event.action);
-                break;
+        case EVENT_TYPES.supported:
+            this._onRemoteControlSupported();
+            break;
+        case EVENT_TYPES.permissions:
+            this._onRemoteControlPermissionsEvent(event.userId, event.action);
+            break;
         }
     }
 

modules/remotecontrol/RemoteControl.js

      * enabled or not.
      */
     init() {
-        if(config.disableRemoteControl || this.initialized
-            || !APP.conference.isDesktopSharingEnabled) {
+        if(config.disableRemoteControl
+                || this.initialized
+                || !APP.conference.isDesktopSharingEnabled) {
             return;
         }
         logger.log("Initializing remote control.");
      * the user supports remote control and with false if not.
      */
     checkUserRemoteControlSupport(user) {
-        return user.getFeatures().then(features =>
-            features.has(DISCO_REMOTE_CONTROL_FEATURE), () => false
+        return user.getFeatures().then(
+            features => features.has(DISCO_REMOTE_CONTROL_FEATURE),
+            () => false
         );
     }
 }

modules/transport/PostMessageTransportBackend.js

 import Postis from 'postis';
 
+/**
+ * The default options for postis.
+ *
+ * @type {Object}
+ */
+const DEFAULT_POSTIS_OPTIONS = {
+    window: window.opener || window.parent
+};
+
 /**
  * The list of methods of incomming postis messages that we have to support for
  * backward compatability for the users that are directly sending messages to
  *
  * @type {string[]}
  */
-const legacyIncomingMethods = [ 'display-name', 'toggle-audio', 'toggle-video',
-    'toggle-film-strip', 'toggle-chat', 'toggle-contact-list',
-    'toggle-share-screen', 'video-hangup', 'email', 'avatar-url' ];
+const LEGACY_INCOMING_METHODS = [
+    'avatar-url',
+    'display-name',
+    'email',
+    'toggle-audio',
+    'toggle-chat',
+    'toggle-contact-list',
+    'toggle-film-strip',
+    'toggle-share-screen',
+    'toggle-video',
+    'video-hangup'
+];
 
 /**
  * The list of methods of outgoing postis messages that we have to support for
  *
  * @type {string[]}
  */
-const legacyOutgoingMethods = [ 'display-name-change', 'incoming-message',
-    'outgoing-message', 'participant-joined', 'participant-left',
-    'video-ready-to-close', 'video-conference-joined',
-    'video-conference-left' ];
+const LEGACY_OUTGOING_METHODS = [
+    'display-name-change',
+    'incoming-message',
+    'outgoing-message',
+    'participant-joined',
+    'participant-left',
+    'video-conference-joined',
+    'video-conference-left',
+    'video-ready-to-close'
+];
 
 /**
  * The postis method used for all messages.
  */
 const POSTIS_METHOD_NAME = 'data';
 
-/**
- * The default options for postis.
- *
- * @type {Object}
- */
-const defaultPostisOptions = {
-    window: window.opener || window.parent
-};
-
 /**
  * Implements message transport using the postMessage API.
  */
      * @param {Object} options - Optional parameters for configuration of the
      * transport.
      */
-    constructor(options = {}) {
-        const postisOptions = Object.assign({}, defaultPostisOptions,
-            options.postisOptions);
-
-        this.postis = Postis(postisOptions);
+    constructor({ enableLegacyFormat, postisOptions } = {}) {
+        this.postis = Postis({
+            ...DEFAULT_POSTIS_OPTIONS,
+            ...postisOptions
+        });
 
-        this._enableLegacyFormat = options.enableLegacyFormat;
+        this._enableLegacyFormat = enableLegacyFormat;
 
         if (!this._enableLegacyFormat) {
             // backward compatability
-            legacyIncomingMethods.forEach(method =>
-                this.postis.listen(method,
-                    params => this._onPostisDataReceived(method, params)));
+            LEGACY_INCOMING_METHODS.forEach(method =>
+                this.postis.listen(
+                    method,
+                    params => this._legacyDataReceiveCallback(method, params)));
         }
 
-        this.postis.listen(POSTIS_METHOD_NAME, data =>
-            this._dataReceivedCallBack(data));
-
-        this._dataReceivedCallBack = () => {
-            // do nothing until real callback is set;
+        this._receiveCallback = () => {
+            // Do nothing until a callback is set by the consumer of
+            // PostMessageTransportBackend via setReceiveCallback.
         };
+
+        this.postis.listen(
+            POSTIS_METHOD_NAME,
+            data => this._receiveCallback(data));
     }
 
     /**
      * @param {Any} params - The params property from postis data object.
      * @returns {void}
      */
-    _onPostisDataReceived(method, params = {}) {
-        const newData = {
+    _legacyDataReceiveCallback(method, params = {}) {
+        this._receiveCallback({
             data: {
                 name: method,
                 data: params
             }
-        };
-
-        this._dataReceivedCallBack(newData);
+        });
     }
 
     /**
      * @param {Object} data - The data to be sent.
      * @returns {void}
      */
-    _sendLegacyData(data) {
-        const method = data.name;
-
-        if (method && legacyOutgoingMethods.indexOf(method) !== -1) {
+    _sendLegacyData({ data, name }) {
+        if (name && LEGACY_OUTGOING_METHODS.indexOf(name) !== -1) {
             this.postis.send({
-                method,
-                params: data.data
+                method: name,
+                params: data
             });
         }
     }
      * @param {Function} callback - The new callback.
      * @returns {void}
      */
-    setDataReceivedCallback(callback) {
-        this._dataReceivedCallBack = callback;
+    setReceiveCallback(callback) {
+        this._receiveCallback = callback;
     }
 }

modules/transport/Transport.js

      * @param {Object} options - Optional parameters for configuration of the
      * transport.
      */
-    constructor(options = {}) {
-        const { transport } = options;
-
+    constructor({ transport } = {}) {
         this._requestID = 0;
 
         this._responseHandlers = new Map();
             this.emit('request', data.data, (result, error) => {
                 this._transport.send({
                     type: MESSAGE_TYPE_RESPONSE,
-                    result,
                     error,
-                    id: data.id
+                    id: data.id,
+                    result
                 });
             });
         } else {
      */
     emit(eventName, ...args) {
         const listenersForEvent = this._listeners.get(eventName);
-
-        if (!listenersForEvent || listenersForEvent.size === 0) {
-            this._unprocessedMessages.add(args);
-
-            return false;
-        }
-
         let isProcessed = false;
 
-        listenersForEvent.forEach(listener => {
-            isProcessed = listener(...args) || isProcessed;
-        });
+        if (listenersForEvent && listenersForEvent.size) {
+            listenersForEvent.forEach(listener => {
+                isProcessed = listener(...args) || isProcessed;
+            });
+        }
 
         if (!isProcessed) {
             this._unprocessedMessages.add(args);
         }
+
+        return isProcessed;
     }
 
     /**
     /**
      * Removes all listeners, or those of the specified eventName.
      *
-     * @param {string} [eventName] -  The name of the event.
+     * @param {string} eventName - The name of the event.
      * @returns {Transport} References to the instance of Transport class, so
      * that calls can be chained.
      */
         if (!this._transport) {
             return Promise.reject(new Error('No transport defined!'));
         }
+
         this._requestID++;
+
         const id = this._requestID;
 
         return new Promise((resolve, reject) => {
-            this._responseHandlers.set(this._requestID, response => {
-                const { result, error } = response;
-
+            this._responseHandlers.set(this._requestID, ({ error, result }) => {
                 if (result) {
                     resolve(result);
                 } else if (error) {
             });
 
             this._transport.send({
-                id,
                 type: MESSAGE_TYPE_REQUEST,
-                data
+                data,
+                id
             });
         });
     }
      */
     setTransport(transport) {
         this._disposeTransport();
+
         this._transport = transport;
-        this._transport.setDataReceivedCallback(
-            this._onDataReceived.bind(this));
+        this._transport.setReceiveCallback(this._onDataReceived.bind(this));
     }
 }

modules/transport/index.js

 const postisOptions = {};
 
 if (typeof API_ID === 'number') {
-    postisOptions.scope
-        = `jitsi_meet_external_api_${API_ID}`;
+    postisOptions.scope = `jitsi_meet_external_api_${API_ID}`;
 }
 
 export const transport = new Transport({