Simplify, comply w/ coding style

Rename setStateProperties and setStateProperty to assign and set,
respectively. Inspired by Object.assign, _.assign, and _.set.

react/features/base/conference/reducer.js

 import { LOCKED_LOCALLY, LOCKED_REMOTELY } from '../../room-lock';
 
 import { JitsiConferenceErrors } from '../lib-jitsi-meet';
-import {
-    ReducerRegistry,
-    setStateProperties,
-    setStateProperty
-} from '../redux';
+import { assign, ReducerRegistry, set } from '../redux';
 
 import {
     CONFERENCE_FAILED,
             : undefined;
 
     return (
-        setStateProperties(state, {
+        assign(state, {
             audioOnly: undefined,
             audioOnlyVideoMuted: undefined,
             conference: undefined,
     const locked = conference.room.locked ? LOCKED_REMOTELY : undefined;
 
     return (
-        setStateProperties(state, {
+        assign(state, {
             /**
              * The JitsiConference instance represented by the Redux state of
              * the feature base/conference.
     }
 
     return (
-        setStateProperties(state, {
+        assign(state, {
             audioOnly: undefined,
             audioOnlyVideoMuted: undefined,
             conference: undefined,
     }
 
     return (
-        setStateProperties(state, {
+        assign(state, {
             /**
              * The JitsiConference instance which is currently in the process of
              * being left.
         locked = state.locked || LOCKED_REMOTELY;
     }
 
-    return setStateProperties(state, {
+    return assign(state, {
         locked,
         password: action.locked ? state.password : null
     });
  * reduction of the specified action.
  */
 function _setAudioOnly(state, action) {
-    return setStateProperty(state, 'audioOnly', action.audioOnly);
+    return set(state, 'audioOnly', action.audioOnly);
 }
 
 /**
  * reduction of the specified action.
  */
 function _setAudioOnlyVideoMuted(state, action) {
-    return setStateProperty(state, 'audioOnlyVideoMuted', action.muted);
+    return set(state, 'audioOnlyVideoMuted', action.muted);
 }
 
 /**
     case conference.join:
         if (state.passwordRequired === conference) {
             return (
-                setStateProperties(state, {
+                assign(state, {
                     locked: LOCKED_REMOTELY,
 
                     /**
         break;
 
     case conference.lock:
-        return setStateProperties(state, {
+        return assign(state, {
             locked: action.password ? LOCKED_LOCALLY : undefined,
             password: action.password
         });
      *
      * @type {string}
      */
-    return setStateProperty(state, 'room', room);
+    return set(state, 'room', room);
 }

react/features/base/connection/reducer.js

 /* @flow */
 
-import { ReducerRegistry, setStateProperty } from '../redux';
+import { ReducerRegistry, set } from '../redux';
 
 import {
     CONNECTION_DISCONNECTED,
  */
 function _connectionDisconnected(state: Object, action: Object) {
     if (state.connection === action.connection) {
-        return setStateProperty(state, 'connection', undefined);
+        return set(state, 'connection', undefined);
     }
 
     return state;
  * reduction of the specified action.
  */
 function _connectionEstablished(state: Object, action: Object) {
-    return setStateProperty(state, 'connection', action.connection);
+    return set(state, 'connection', action.connection);
 }
 
 /**

react/features/base/dialog/reducer.js

-import { ReducerRegistry, setStateProperties } from '../redux';
+import { assign, ReducerRegistry } from '../redux';
 
-import {
-    HIDE_DIALOG,
-    OPEN_DIALOG
-} from './actionTypes';
+import { HIDE_DIALOG, OPEN_DIALOG } from './actionTypes';
 
 /**
- * Listen for actions which show or hide dialogs.
+ * Reduces redux actions which show or hide dialogs.
  *
- * @param {Object[]} state - Current state.
- * @param {Object} action - Action object.
- * @param {string} action.type - Type of action.
- * @returns {{}}
+ * @param {State} state - The current redux state.
+ * @param {Action} action - The redux action to reduce.
+ * @param {string} action.type - The type of the redux action to reduce..
+ * @returns {State} The next redux state that is the result of reducing the
+ * specified action.
  */
 ReducerRegistry.register('features/base/dialog', (state = {}, action) => {
     switch (action.type) {
     case HIDE_DIALOG:
-        return setStateProperties(state, {
+        return assign(state, {
             component: undefined,
             componentProps: undefined
         });
+
     case OPEN_DIALOG:
-        return setStateProperties(state, {
+        return assign(state, {
             component: action.component,
             componentProps: action.componentProps
         });

react/features/base/lib-jitsi-meet/functions.js

  * @returns {Promise<JitsiLocalTrack>}
  */
 export function createLocalTrack(type, deviceId) {
-    return JitsiMeetJS
-        .createLocalTracks({
-            devices: [ type ],
-            micDeviceId: deviceId,
-            cameraDeviceId: deviceId,
+    return JitsiMeetJS.createLocalTracks({
+        cameraDeviceId: deviceId,
+        devices: [ type ],
 
-            // eslint-disable-next-line camelcase
-            firefox_fake_device: window.config
-                && window.config.firefox_fake_device
-        }).then(([ jitsiLocalTrack ]) => jitsiLocalTrack);
+        // eslint-disable-next-line camelcase
+        firefox_fake_device:
+            window.config && window.config.firefox_fake_device,
+        micDeviceId: deviceId
+    })
+        .then(([ jitsiLocalTrack ]) => jitsiLocalTrack);
 }

react/features/base/lib-jitsi-meet/middleware.js

  * lib-jitsi-meet, and initializes a new one with new config.
  *
  * @param {Store} store - Redux store.
- * @returns {Function}
  * @private
+ * @returns {Function}
  */
 MiddlewareRegistry.register(store => next => action => {
     switch (action.type) {
  * specified action to the specified store.
  * @param {Action} action - The Redux action LIB_INIT_ERROR which is being
  * dispatched in the specified store.
+ * @private
  * @returns {Object} The new state that is the result of the reduction of the
  * specified action.
- * @private
  */
 function _libInitError(store, next, action) {
     const nextState = next(action);
 
-    const error = action.error;
+    const { error } = action;
 
     if (error) {
         let webRTCReady;
  * specified action to the specified store.
  * @param {Action} action - The Redux action SET_CONFIG which is being
  * dispatched in the specified store.
+ * @private
  * @returns {Object} The new state that is the result of the reduction of the
  * specified action.
- * @private
  */
-function _setConfig(store, next, action) {
-    const { dispatch, getState } = store;
+function _setConfig({ dispatch, getState }, next, action) {
     const { initialized } = getState()['features/base/lib-jitsi-meet'];
 
     // XXX Since the config is changing, the library lib-jitsi-meet must be
-    // initialized again with the new config. Consequntly, it may need to be
+    // initialized again with the new config. Consequently, it may need to be
     // disposed of first.
     // TODO Currently, disposeLib actually does not dispose of lib-jitsi-meet
     // because lib-jitsi-meet does not implement such functionality.

react/features/base/participants/reducer.js

-import { ReducerRegistry, setStateProperty } from '../redux';
+import { ReducerRegistry, set } from '../redux';
 import { randomHexString } from '../util';
 
 import {
     case DOMINANT_SPEAKER_CHANGED:
         // Only one dominant speaker is allowed.
         return (
-            setStateProperty(
-                    state,
-                    'dominantSpeaker',
-                    state.id === action.participant.id));
+            set(state, 'dominantSpeaker', state.id === action.participant.id));
 
     case PARTICIPANT_ID_CHANGED:
         if (state.id === action.oldValue) {
 
     case PIN_PARTICIPANT:
         // Currently, only one pinned participant is allowed.
-        return (
-            setStateProperty(
-                    state,
-                    'pinned',
-                    state.id === action.participant.id));
+        return set(state, 'pinned', state.id === action.participant.id);
     }
 
     return state;

react/features/base/redux/functions.js

  * from the specified target by setting the specified properties to the
  * specified values.
  */
-export function setStateProperties(target, source) {
+export function assign(target, source) {
     let t = target;
 
     for (const property in source) { // eslint-disable-line guard-for-in
-        t = setStateProperty(t, property, source[property], t === target);
+        t = set(t, property, source[property], t === target);
     }
 
     return t;
  * constructed from the specified <tt>state</tt> by setting the specified
  * <tt>property</tt> to the specified <tt>value</tt>.
  */
-export function setStateProperty(state, property, value) {
-    return _setStateProperty(state, property, value, /* copyOnWrite */ true);
+export function set(state, property, value) {
+    return _set(state, property, value, /* copyOnWrite */ true);
 }
 
 /* eslint-disable max-params */
  * <tt>state</tt> by setting the specified <tt>property</tt> to the specified
  * <tt>value</tt>.
  */
-function _setStateProperty(state, property, value, copyOnWrite) {
+function _set(state, property, value, copyOnWrite) {
     // Delete state properties that are to be set to undefined. (It is a matter
     // of personal preference, mostly.)
     if (typeof value === 'undefined'

react/features/overlay/reducer.js

 import { CONFERENCE_FAILED } from '../base/conference';
-import {
-    CONNECTION_ESTABLISHED,
-    CONNECTION_FAILED
-} from '../base/connection';
+import { CONNECTION_ESTABLISHED, CONNECTION_FAILED } from '../base/connection';
 import {
     isFatalJitsiConnectionError,
     JitsiConferenceErrors,
     JitsiConnectionErrors
 } from '../base/lib-jitsi-meet';
-import {
-    ReducerRegistry,
-    setStateProperties,
-    setStateProperty
-} from '../base/redux';
+import { assign, ReducerRegistry, set } from '../base/redux';
 
 import {
     MEDIA_PERMISSION_PROMPT_VISIBILITY_CHANGED,
 
     if (error === JitsiConferenceErrors.FOCUS_LEFT
             || error === JitsiConferenceErrors.VIDEOBRIDGE_NOT_AVAILABLE) {
-        return setStateProperties(state, {
+        return assign(state, {
             haveToReload: true,
             isNetworkFailure: false,
             reason: action.errorMessage
  * @private
  */
 function _connectionEstablished(state) {
-    return setStateProperty(state, 'connectionEstablished', true);
+    return set(state, 'connectionEstablished', true);
 }
 
 /**
 
         logger.error(`XMPP connection error: ${errorMessage}`);
 
-        return setStateProperties(state, {
+        return assign(state, {
             haveToReload: true,
 
-
             // From all of the cases above only CONNECTION_DROPPED_ERROR is
             // considered a network type of failure.
             isNetworkFailure:
  * @private
  */
 function _mediaPermissionPromptVisibilityChanged(state, action) {
-    return setStateProperties(state, {
+    return assign(state, {
         browser: action.browser,
         isMediaPermissionPromptVisible: action.isVisible
     });
  * @private
  */
 function _suspendDetected(state) {
-    return setStateProperty(state, 'suspendDetected', true);
+    return set(state, 'suspendDetected', true);
 }