[flow] Take advantage of flow-typed

.eslintrc.js

         'commonjs': true,
         'es6': true
     },
-    'extends': 'eslint:recommended',
+    'extends': [
+        'eslint:recommended',
+        'plugin:flowtype/recommended'
+    ],
     'globals': {
         // The globals that (1) are accessed but not defined within many of our
         // files, (2) are certainly defined, and (3) we would like to use
         },
         'sourceType': 'module'
     },
+    'plugins': [
+        'flowtype'
+    ],
     'rules': {
         'new-cap': [
             'error',

package.json

     "clean-css": "^3.0.0",
     "css-loader": "*",
     "eslint": "^3.14.1",
+    "eslint-plugin-flowtype": "^2.30.0",
     "eslint-plugin-import": "^2.2.0",
     "eslint-plugin-jsdoc": "*",
     "eslint-plugin-react": "*",

react/features/base/connection/actions.native.js

+/* @flow */
+
+import type { Dispatch } from 'redux';
+
 import { conferenceWillLeave } from '../conference';
 import JitsiMeetJS from '../lib-jitsi-meet';
 
 /**
  * Opens new connection.
  *
- * @returns {Promise<JitsiConnection>}
+ * @returns {Function}
  */
 export function connect() {
-    return (dispatch, getState) => {
+    return (dispatch: Dispatch<*>, getState: Function) => {
         const state = getState();
         const connectionOptions
             = state['features/base/connection'].connectionOptions;
          * @param {string} message - Disconnect reason.
          * @returns {void}
          */
-        function connectionDisconnected(message) {
+        function connectionDisconnected(message: string) {
             connection.removeEventListener(
                     JitsiConnectionEvents.CONNECTION_DISCONNECTED,
                     connectionDisconnected);
  * @returns {Function}
  */
 export function disconnect() {
-    return (dispatch, getState) => {
+    return (dispatch: Dispatch<*>, getState: Function) => {
         const state = getState();
         const conference = state['features/base/conference'].conference;
         const connection = state['features/base/connection'].connection;
  *      domain: string
  *  }}
  */
-export function setDomain(domain) {
+export function setDomain(domain: string) {
     return {
         type: SET_DOMAIN,
         domain
  *     message: string
  * }}
  */
-function _connectionDisconnected(connection, message) {
+function _connectionDisconnected(connection, message: string) {
     return {
         type: CONNECTION_DISCONNECTED,
         connection,
  *     error: string
  * }}
  */
-function _connectionFailed(connection, error) {
+function _connectionFailed(connection, error: string) {
     return {
         type: CONNECTION_FAILED,
         connection,

react/features/base/connection/actions.web.js

-/* global APP, JitsiMeetJS */
+/* @flow */
+
+import type { Dispatch } from 'redux';
 
 import UIEvents from '../../../../service/UI/UIEvents';
 
 import { SET_DOMAIN } from './actionTypes';
 import './reducer';
 
+declare var APP: Object;
+declare var JitsiMeetJS: Object;
+
 const JitsiConferenceEvents = JitsiMeetJS.events.conference;
 const logger = require('jitsi-meet-logger').getLogger(__filename);
 
  * @returns {Promise<JitsiConnection>}
  */
 export function connect() {
-    return (dispatch, getState) => {
+    return (dispatch: Dispatch<*>, getState: Function) => {
         const state = getState();
 
         // XXX Lib-jitsi-meet does not accept uppercase letters.
  *      domain: string
  *  }}
  */
-export function setDomain(domain) {
+export function setDomain(domain: string) {
     return {
         type: SET_DOMAIN,
         domain

react/features/base/media/actions.js

+/* @flow */
+
+import type { Dispatch } from 'redux';
+
 import {
     SET_AUDIO_MUTED,
     SET_CAMERA_FACING_MODE,
  *      muted: boolean
  *  }}
  */
-export function setAudioMuted(muted) {
+export function setAudioMuted(muted: boolean) {
     return {
         type: SET_AUDIO_MUTED,
         muted
  *      cameraFacingMode: CAMERA_FACING_MODE
  *  }}
  */
-export function setCameraFacingMode(cameraFacingMode) {
+export function setCameraFacingMode(cameraFacingMode: CAMERA_FACING_MODE) {
     return {
         type: SET_CAMERA_FACING_MODE,
         cameraFacingMode
  *      muted: boolean
  *  }}
  */
-export function setVideoMuted(muted) {
+export function setVideoMuted(muted: boolean) {
     return {
         type: SET_VIDEO_MUTED,
         muted
  * @returns {Function}
  */
 export function toggleAudioMuted() {
-    return (dispatch, getState) => {
+    return (dispatch: Dispatch<*>, getState: Function) => {
         const muted = getState()['features/base/media'].audio.muted;
 
         return dispatch(setAudioMuted(!muted));
  * @returns {Function}
  */
 export function toggleCameraFacingMode() {
-    return (dispatch, getState) => {
+    return (dispatch: Dispatch<*>, getState: Function) => {
         let cameraFacingMode
             = getState()['features/base/media'].video.facingMode;
 
  * @returns {Function}
  */
 export function toggleVideoMuted() {
-    return (dispatch, getState) => {
+    return (dispatch: Dispatch<*>, getState: Function) => {
         const muted = getState()['features/base/media'].video.muted;
 
         return dispatch(setVideoMuted(!muted));

react/features/base/react/functions.js

 /* @flow */
 
+/* eslint-disable flowtype/space-before-type-colon */
+
 /**
  * Prevents further propagation of the events to be handler by a specific event
  * handler/listener in the capturing and bubbling phases.
  */
 export function stopEventPropagation<T>(eventHandler: (ev: Event) => T)
         : (ev: Event) => T {
-    return (ev: Event) => {
+
+/* eslint-enable flowtype/space-before-type-colon */
+
+    return (ev: Event): T => {
         const r = eventHandler(ev);
 
         // React Native does not propagate the press event so, for the sake of

react/features/base/redux/ReducerRegistry.js

+/* @flow */
+
 import { combineReducers } from 'redux';
+import type { Reducer } from 'redux';
+
+/**
+ * The type of the dictionary/map which associates a reducer (function) with the
+ * name of he Redux state property managed by the reducer.
+ */
+declare type NameReducerMap<S, A> = { [name: string]: Reducer<S, A> };
 
 /**
  * A registry for Redux reducers, allowing features to register themselves
  * without needing to create additional inter-feature dependencies.
  */
 class ReducerRegistry {
+    _elements: NameReducerMap<*, *>;
+
     /**
      * Creates a ReducerRegistry instance.
      */
         /**
          * The set of registered reducers, keyed based on the field each reducer
          * will manage.
+         *
+         * @private
+         * @type {NameReducerMap}
          */
         this._elements = {};
     }
      * included (such as reducers from third-party modules).
      * @returns {Function}
      */
-    combineReducers(additional = {}) {
+    combineReducers(additional: NameReducerMap<*, *> = {}) {
         return combineReducers({
             ...this._elements,
             ...additional
      *
      * @param {string} name - The field in the state object that will be managed
      * by the provided reducer.
-     * @param {Function} reducer - A Redux reducer.
+     * @param {Reducer} reducer - A Redux reducer.
      * @returns {void}
      */
-    register(name, reducer) {
+    register(name: string, reducer: Reducer<*, *>) {
         this._elements[name] = reducer;
     }
 }