Remove duplication

react/features/app/components/AbstractApp.js

      * @inheritdoc
      */
     componentWillMount() {
-        const dispatch = this._getStore().dispatch;
+        const { dispatch } = this._getStore();
 
         dispatch(appWillMount(this));
 
      * @inheritdoc
      */
     componentWillUnmount() {
-        const dispatch = this._getStore().dispatch;
+        const { dispatch } = this._getStore();
 
         dispatch(localParticipantLeft());
 

react/features/app/functions.native.js

 
 import { isRoomValid } from '../base/conference';
 import { RouteRegistry } from '../base/react';
+import { toState } from '../base/redux';
 import { Conference } from '../conference';
 import { Entryway } from '../welcome';
 
  * @returns {Route}
  */
 export function _getRouteToRender(stateOrGetState: Object | Function) {
-    const state
-        = typeof stateOrGetState === 'function'
-            ? stateOrGetState()
-            : stateOrGetState;
-    const { room } = state['features/base/conference'];
-    const component = isRoomValid(room) ? Conference : Entryway;
+    const { room } = toState(stateOrGetState)['features/base/conference'];
+    const component = isRoomValid(room) ? Conference : WelcomePage;
 
     return RouteRegistry.getRouteByComponent(component);
 }

react/features/app/functions.web.js

 /* @flow */
 
 import { Platform } from '../base/react';
+import { toState } from '../base/redux';
 import {
     NoMobileApp,
     PluginRequiredBrowser,
  * render.
  *
  * @private
- * @param {Object} state - Object containing current Redux state.
+ * @param {Object} state - Object containing current redux state.
  * @returns {ReactElement|void}
  * @type {Function[]}
  */
      * app even if the browser supports the app (e.g. Google Chrome with
      * WebRTC support on Android).
      *
-     * @param {Object} state - Redux state of the app.
+     * @param {Object} state - The redux state of the app.
      * @returns {UnsupportedMobileBrowser|void} If the rule is satisfied then
      * we should intercept existing component by UnsupportedMobileBrowser.
      */
 ];
 
 /**
- * Determines which route is to be rendered in order to depict a specific Redux
+ * Determines which route is to be rendered in order to depict a specific redux
  * store.
  *
- * @param {(Object|Function)} stateOrGetState - Redux state or Regux getState()
- * method.
+ * @param {(Object|Function)} stateOrGetState - The redux state or
+ * {@link getState} function.
  * @returns {Route}
  */
 export function _getRouteToRender(stateOrGetState: Object | Function) {
 /**
  * Intercepts route components based on a {@link _INTERCEPT_COMPONENT_RULES}.
  *
- * @param {Object|Function} stateOrGetState - Either Redux state object or
- * getState() function.
+ * @param {Object|Function} stateOrGetState - The redux state or
+ * {@link getState} function.
  * @param {ReactElement} component - Current route component to render.
  * @private
  * @returns {ReactElement} If any of the pre-defined rules is satisfied, returns
  * intercepted component.
  */
 function _interceptComponent(
-        stateOrGetState: Object,
+        stateOrGetState: Object | Function,
         component: ReactElement<*>) {
     let result;
-    const state
-        = typeof stateOrGetState === 'function'
-            ? stateOrGetState()
-            : stateOrGetState;
+    const state = toState(stateOrGetState);
 
     for (const rule of _INTERCEPT_COMPONENT_RULES) {
         result = rule(state);

react/features/base/connection/functions.js

 /* @flow */
 
+import { toState } from '../redux';
+
 /**
  * Retrieves a simplified version of the conference/location URL stripped of URL
  * params (i.e. query/search and hash) which should be used for sending invites.
  * @returns {string|undefined}
  */
 export function getInviteURL(stateOrGetState: Function | Object): ?string {
-    const state
-        = typeof stateOrGetState === 'function'
-            ? stateOrGetState()
-            : stateOrGetState;
+    const state = toState(stateOrGetState);
     const locationURL
         = state instanceof URL
             ? state
             : state['features/base/connection'].locationURL;
-    let inviteURL;
-
-    if (locationURL) {
-        inviteURL = getURLWithoutParams(locationURL).href;
-    }
 
-    return inviteURL;
+    return locationURL ? getURLWithoutParams(locationURL).href : undefined;
 }
 
 /**

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

                 // then it doesn't sound like what expected.
                 && nodePrototype !== Object.getPrototypeOf({})) {
             // Override console.log.
-            const console = global.console;
+            const { console } = global;
 
             if (console) {
                 const loggerLevels = require('jitsi-meet-logger').levels;

react/features/base/participants/functions.js

+/* @flow */
+
+import { toState } from '../redux';
+
 import { DEFAULT_AVATAR_RELATIVE_PATH } from './constants';
 
 declare var config: Object;
  * @param {string} [participant.avatarURL] - Participant's avatar URL.
  * @param {string} [participant.email] - Participant's e-mail address.
  * @param {string} [participant.id] - Participant's ID.
+ * @public
  * @returns {string} The URL of the image for the avatar of the specified
  * participant.
- *
- * @public
  */
-export function getAvatarURL(participant) {
+export function getAvatarURL({ avatarID, avatarURL, email, id }: {
+        avatarID: string,
+        avatarURL: string,
+        email: string,
+        id: string
+}) {
     // If disableThirdPartyRequests disables third-party avatar services, we are
     // restricted to a stock image of ours.
     if (typeof config === 'object' && config.disableThirdPartyRequests) {
         return DEFAULT_AVATAR_RELATIVE_PATH;
     }
 
-    const { avatarID, avatarURL, email, id } = participant;
-
     // If an avatarURL is specified, then obviously there's nothing to generate.
     if (avatarURL) {
         return avatarURL;
  * features/base/participants state.
  * @returns {(Participant|undefined)}
  */
-export function getLocalParticipant(stateOrGetState) {
+export function getLocalParticipant(stateOrGetState: Object | Function) {
     const participants = _getParticipants(stateOrGetState);
 
     return participants.find(p => p.local);
  * @private
  * @returns {(Participant|undefined)}
  */
-export function getParticipantById(stateOrGetState, id) {
+export function getParticipantById(
+        stateOrGetState: Object | Function,
+        id: string) {
     const participants = _getParticipants(stateOrGetState);
 
     return participants.find(p => p.id === id);
  * features/base/participants state.
  * @returns {number}
  */
-export function getParticipantCount(stateOrGetState) {
+export function getParticipantCount(stateOrGetState: Object | Function) {
     const participants = _getParticipants(stateOrGetState);
     const realParticipants = participants.filter(p => !p.isBot);
 
  * features/base/participants state.
  * @returns {(Participant|undefined)}
  */
-export function getPinnedParticipant(stateOrGetState) {
+export function getPinnedParticipant(stateOrGetState: Object | Function) {
     const participants = _getParticipants(stateOrGetState);
 
     return participants.find(p => p.pinned);
  * @returns {Participant[]}
  */
 function _getParticipants(stateOrGetState) {
-    if (Array.isArray(stateOrGetState)) {
-        return stateOrGetState;
-    }
-
-    const state
-        = typeof stateOrGetState === 'function'
-            ? stateOrGetState()
-            : stateOrGetState;
-
-    return state['features/base/participants'] || [];
+    return (
+        Array.isArray(stateOrGetState)
+            ? stateOrGetState
+            : toState(stateOrGetState)['features/base/participants'] || []);
 }

react/features/base/redux/functions.js

+/* @flow */
+
 import _ from 'lodash';
 
 /**
  * from the specified target by setting the specified properties to the
  * specified values.
  */
-export function assign(target, source) {
+export function assign(target: Object, source: Object) {
     let t = target;
 
     for (const property in source) { // eslint-disable-line guard-for-in
  * @returns {boolean} True if {@code a} equals {@code b} (according to deep
  * comparison); false, otherwise.
  */
-export function equals(a, b) {
+export function equals(a: any, b: any) {
     return _.isEqual(a, b);
 }
 
  * constructed from the specified <tt>state</tt> by setting the specified
  * <tt>property</tt> to the specified <tt>value</tt>.
  */
-export function set(state, property, value) {
+export function set(state: Object, property: string, value: any) {
     return _set(state, property, value, /* copyOnWrite */ true);
 }
 
  * <tt>state</tt> by setting the specified <tt>property</tt> to the specified
  * <tt>value</tt>.
  */
-function _set(state, property, value, copyOnWrite) {
+function _set(
+        state: Object,
+        property: string,
+        value: any,
+        copyOnWrite: boolean) {
     // Delete state properties that are to be set to undefined. (It is a matter
     // of personal preference, mostly.)
     if (typeof value === 'undefined'
 }
 
 /* eslint-enable max-params */
+
+/**
+ * If the specified <tt>stateOrGetState</tt> is a function, it is presumed to be
+ * the redux {@link getState} function, it is invoked, and its return value is
+ * returned; otherwise, <tt>stateOrGetState</tt> is presumed to be the redux
+ * state and is returned.
+ *
+ * @param {Object|Function} stateOrGetState - The redux state or
+ * {@link getState} function.
+ * @returns {Object} The redux state.
+ */
+export function toState(stateOrGetState: Object | Function) {
+    return (
+        typeof stateOrGetState === 'function'
+            ? stateOrGetState()
+            : stateOrGetState);
+}

react/index.native.js

      * @inheritdoc
      */
     componentWillReceiveProps({ url }) {
-        if (!equals(this.props.url, url)) {
-            this.setState({ url: url || null });
-        }
+        equals(this.props.url, url) || this.setState({ url: url || null });
     }
 
     /**