ref: move 'jwt' feature to 'base'

conference.js

 function maybeRedirectToWelcomePage(options) {
     // if close page is enabled redirect to it, without further action
     if (config.enableClosePage) {
-        const { isGuest } = APP.store.getState()['features/jwt'];
+        const { isGuest } = APP.store.getState()['features/base/jwt'];
 
         // save whether current user is guest or not, before navigating
         // to close page

connection.js

  */
 function connect(id, password, roomName) {
     const connectionConfig = Object.assign({}, config);
-    const { issuer, jwt } = APP.store.getState()['features/jwt'];
+    const { issuer, jwt } = APP.store.getState()['features/base/jwt'];
 
     connectionConfig.bosh += '?room=' + roomName;
 
 
     return connect(id, password, roomName).catch(err => {
         if (retry) {
-            const { issuer, jwt } = APP.store.getState()['features/jwt'];
+            const { issuer, jwt } = APP.store.getState()['features/base/jwt'];
 
             if (err === ConnectionErrors.PASSWORD_REQUIRED
                     && (!jwt || issuer === 'anonymous')) {

modules/API/API.js

 // @flow
 
 import * as JitsiMeetConferenceEvents from '../../ConferenceEvents';
-import { parseJWTFromURLParams } from '../../react/features/jwt';
+import { parseJWTFromURLParams } from '../../react/features/base/jwt';
 import { getJitsiMeetTransport } from '../transport';
 
 import { API_ID } from './constants';

modules/UI/authentication/AuthHandler.js

 /* global APP, config, JitsiMeetJS, Promise */
 
 import { openConnection } from '../../../connection';
-import { setJWT } from '../../../react/features/jwt';
+import { setJWT } from '../../../react/features/base/jwt';
 import UIUtil from '../util/UIUtil';
 
 import LoginDialog from './LoginDialog';

react/features/analytics/functions.js

                 roomName: state['features/base/conference'].room,
                 userAgent: navigator.userAgent
             };
-            const { group, server } = state['features/jwt'];
+            const { group, server } = state['features/base/jwt'];
 
             if (server) {
                 permanentProperties.server = server;

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

     return (dispatch: Dispatch<*>, getState: Function) => {
         const state = getState();
         const options = _constructOptions(state);
-        const { issuer, jwt } = state['features/jwt'];
+        const { issuer, jwt } = state['features/base/jwt'];
         const connection
             = new JitsiMeetJS.JitsiConnection(
                 options.appId,

react/features/jwt/actions.js → react/features/base/jwt/actions.js

  */
 export function setCallOverlayVisible(callOverlayVisible: boolean) {
     return (dispatch: Dispatch<*>, getState: Function) => {
-        getState()['features/jwt'].callOverlayVisible === callOverlayVisible
+        getState()['features/base/jwt']
+            .callOverlayVisible === callOverlayVisible
             || dispatch({
                 type: SET_CALL_OVERLAY_VISIBLE,
                 callOverlayVisible

react/features/jwt/components/CallOverlay.js → react/features/base/jwt/components/CallOverlay.js

 import React, { Component } from 'react';
 import { connect } from 'react-redux';
 
-import { Audio } from '../../base/media';
-import { Avatar } from '../../base/participants';
-import { Container, Text } from '../../base/react';
-import UIEvents from '../../../../service/UI/UIEvents';
+import { Audio } from '../../media';
+import { Avatar } from '../../participants';
+import { Container, Text } from '../../react';
+import UIEvents from '../../../../../service/UI/UIEvents';
 
 import styles from './styles';
 
          * @private
          * @type {Object}
          */
-        _callee: state['features/jwt'].callee
+        _callee: state['features/base/jwt'].callee
     };
 }
 

react/features/jwt/components/styles.native.js → react/features/base/jwt/components/styles.native.js

-import { ColorPalette, createStyleSheet } from '../../base/styles';
+import { ColorPalette, createStyleSheet } from '../../styles';
 
 export default createStyleSheet({
     // XXX The names bellow were preserved for the purposes of compatibility

react/features/jwt/functions.js → react/features/base/jwt/functions.js

 /* @flow */
 
-import { parseURLParams } from '../base/config';
+import { parseURLParams } from '../config';
 
 /**
  * Retrieves the JSON Web Token (JWT), if any, defined by a specific

react/features/jwt/middleware.js → react/features/base/jwt/middleware.js

     CONFERENCE_LEFT,
     CONFERENCE_WILL_LEAVE,
     SET_ROOM
-} from '../base/conference';
-import { SET_CONFIG } from '../base/config';
-import { SET_LOCATION_URL } from '../base/connection';
-import { LIB_INIT_ERROR } from '../base/lib-jitsi-meet';
+} from '../conference';
+import { SET_CONFIG } from '../config';
+import { SET_LOCATION_URL } from '../connection';
+import { LIB_INIT_ERROR } from '../lib-jitsi-meet';
 import {
     getLocalParticipant,
     getParticipantCount,
     PARTICIPANT_JOINED
-} from '../base/participants';
-import { MiddlewareRegistry } from '../base/redux';
+} from '../participants';
+import { MiddlewareRegistry } from '../redux';
 
 import { setCallOverlayVisible, setJWT } from './actions';
 import { SET_JWT } from './actionTypes';
     const result = next(action);
 
     const state = getState();
-    const stateFeaturesJWT = state['features/jwt'];
+    const stateFeaturesJWT = state['features/base/jwt'];
     let callOverlayVisible;
 
     if (stateFeaturesJWT.callee) {

react/features/jwt/reducer.js → react/features/base/jwt/reducer.js

-import { equals, set, ReducerRegistry } from '../base/redux';
+import { equals, set, ReducerRegistry } from '../redux';
 
 import { SET_CALL_OVERLAY_VISIBLE, SET_JWT } from './actionTypes';
 
  * @returns {Object} The next redux state which is the result of reducing the
  * specified {@code action}.
  */
-ReducerRegistry.register('features/jwt', (state = _INITIAL_STATE, action) => {
+ReducerRegistry.register(
+'features/base/jwt', (state = _INITIAL_STATE, action) => {
     switch (action.type) {
     case SET_CALL_OVERLAY_VISIBLE:
         return set(state, 'callOverlayVisible', action.callOverlayVisible);

react/features/base/react/components/web/Watermarks.js

  * }}
  */
 function _mapStateToProps(state) {
-    const { isGuest } = state['features/jwt'];
+    const { isGuest } = state['features/base/jwt'];
 
     return {
         /**

react/features/conference/route.js

  */
 function _setTokenData() {
     const state = APP.store.getState();
-    const { caller } = state['features/jwt'];
+    const { caller } = state['features/base/jwt'];
 
     if (caller) {
         const { avatarUrl, avatar, email, name } = caller;

react/features/filmstrip/middleware.js

 /* @flow */
 
 import { MiddlewareRegistry } from '../base/redux';
-import { SET_CALL_OVERLAY_VISIBLE } from '../jwt';
+import { SET_CALL_OVERLAY_VISIBLE } from '../base/jwt';
 
 import Filmstrip from '../../../modules/UI/videolayout/Filmstrip';
 
     case SET_CALL_OVERLAY_VISIBLE:
         if (typeof APP !== 'undefined') {
             const oldValue
-                = Boolean(getState()['features/jwt'].callOverlayVisible);
+                = Boolean(getState()['features/base/jwt'].callOverlayVisible);
             const result = next(action);
             const newValue
-                = Boolean(getState()['features/jwt'].callOverlayVisible);
+                = Boolean(getState()['features/base/jwt'].callOverlayVisible);
 
             oldValue === newValue
 

react/features/invite/components/AddPeopleDialog.web.js

         _conference: conference,
         _inviteServiceUrl: inviteServiceUrl,
         _inviteUrl: getInviteURL(state),
-        _jwt: state['features/jwt'].jwt,
+        _jwt: state['features/base/jwt'].jwt,
         _peopleSearchQueryTypes: peopleSearchQueryTypes,
         _peopleSearchUrl: peopleSearchUrl
     };

react/features/invite/components/InfoDialog.web.js

 function _mapStateToProps(state) {
     return {
         _inviteURL: getInviteURL(state),
-        _showAddPeople: !state['features/jwt'].isGuest
+        _showAddPeople: !state['features/base/jwt'].isGuest
     };
 }
 

react/features/invite/components/InviteButton.web.js

 function _mapStateToProps(state) {
     const { conference } = state['features/base/conference'];
     const { enableUserRolesBasedOnToken } = state['features/base/config'];
-    const { isGuest } = state['features/jwt'];
+    const { isGuest } = state['features/base/jwt'];
 
     return {
         _isAddToCallAvailable:

react/features/mobile/callkit/middleware.js

     CallKit.startCall(conference.callUUID, url.toString(), hasVideo)
         .then(() => {
             const { room } = state['features/base/conference'];
-            const { callee } = state['features/jwt'];
+            const { callee } = state['features/base/jwt'];
 
             CallKit.updateCall(
                 conference.callUUID,

react/features/notifications/components/NotificationsContainer.web.js

     const isAnyOverlayVisible = (connectionEstablished && haveToReload)
         || isMediaPermissionPromptVisible
         || suspendDetected
-        || state['features/jwt'].callOverlayVisible;
+        || state['features/base/jwt'].callOverlayVisible;
 
     const { enabled, notifications } = state['features/notifications'];
 

react/features/overlay/components/OverlayContainer.js

 import React, { Component } from 'react';
 import { connect } from 'react-redux';
 
-import { CallOverlay } from '../../jwt';
+import { CallOverlay } from '../../base/jwt';
 
 import PageReloadFilmstripOnlyOverlay from './PageReloadFilmstripOnlyOverlay';
 import PageReloadOverlay from './PageReloadOverlay';
          * @private
          * @type {boolean}
          */
-        _callOverlayVisible: Boolean(state['features/jwt'].callOverlayVisible),
+        _callOverlayVisible:
+            Boolean(state['features/base/jwt'].callOverlayVisible),
 
         /**
          * The indicator which determines whether the status of the

react/features/toolbox/actions.web.js

 
         if (!force
                 && (hovered
-                    || state['features/jwt'].callOverlayVisible
+                    || state['features/base/jwt'].callOverlayVisible
                     || SideContainerToggler.isVisible())) {
             dispatch(
                 setToolboxTimeout(

react/features/toolbox/components/ProfileButton.web.js

  */
 function _mapStateToProps(state) {
     return {
-        _unclickable: !state['features/jwt'].isGuest
+        _unclickable: !state['features/base/jwt'].isGuest
     };
 }
 

react/features/toolbox/components/SecondaryToolbar.web.js

  * @private
  */
 function _mapStateToProps(state: Object): Object {
-    const { isGuest } = state['features/jwt'];
+    const { isGuest } = state['features/base/jwt'];
     const { secondaryToolbarButtons, visible } = state['features/toolbox'];
     const { callStatsID } = state['features/base/config'];