fix(optimise): mapStateToProps for some components (#5085)

react/features/chrome-extension-banner/components/ChromeExtensionBanner.web.js

 
 declare var interfaceConfig: Object;
 
+const emptyObject = {};
+
 /**
  * Local storage key name for flag telling if user checked 'Don't show again' checkbox on the banner
  * If the user checks this before closing the banner, next time he will access a jitsi domain
  */
 const _mapStateToProps = state => {
     return {
-        bannerCfg: state['features/base/config'].chromeExtensionBanner || {},
+        // Using emptyObject so that we don't change the reference every time when _mapStateToProps is called.
+        bannerCfg: state['features/base/config'].chromeExtensionBanner || emptyObject,
         conference: getCurrentConference(state),
         iAmRecorder: state['features/base/config'].iAmRecorder
     };

react/features/filmstrip/components/web/Toolbar.js

 
 declare var interfaceConfig: Object;
 
+// XXX: We are not currently using state here, but in the future, when
+// interfaceConfig is part of redux we will. This has to be retrieved from the store.
+const visibleButtons = new Set(interfaceConfig.TOOLBAR_BUTTONS);
+
 /**
  * The type of the React {@code Component} props of {@link Toolbar}.
  */
     // interfaceConfig is part of redux we will.
 
     return {
-        _visibleButtons: new Set(interfaceConfig.TOOLBAR_BUTTONS)
+        _visibleButtons: visibleButtons
     };
 }
 

react/features/invite/components/info-dialog/web/InfoDialog.js

     /**
      * The redux representation of the local participant.
      */
-    _localParticipant: Object,
+    _localParticipantName: ?string,
 
     /**
      * The current location url of the conference.
      * @returns {string}
      */
     _getTextToCopy() {
-        const { _localParticipant, liveStreamViewURL, t } = this.props;
+        const { _localParticipantName, liveStreamViewURL, t } = this.props;
         const _inviteURL = _decodeRoomURI(this.props._inviteURL);
 
-        let invite = _localParticipant && _localParticipant.name
-            ? t('info.inviteURLFirstPartPersonal', { name: _localParticipant.name })
+        let invite = _localParticipantName
+            ? t('info.inviteURLFirstPartPersonal', { name: _localParticipantName })
             : t('info.inviteURLFirstPartGeneral');
 
         invite += t('info.inviteURLSecondPart', {
  *     _conference: Object,
  *     _conferenceName: string,
  *     _inviteURL: string,
+ *     _localParticipantName: ?string,
  *     _locationURL: string,
  *     _locked: string,
  *     _password: string
         password,
         room
     } = state['features/base/conference'];
+    const localParticipant = getLocalParticipant(state);
 
     return {
         _canEditPassword: isLocalParticipantModerator(state, state['features/base/config'].lockRoomGuestEnabled),
         _conferenceName: room,
         _passwordNumberOfDigits: state['features/base/config'].roomPasswordNumberOfDigits,
         _inviteURL: getInviteURL(state),
-        _localParticipant: getLocalParticipant(state),
+        _localParticipantName: localParticipant?.name,
         _locationURL: state['features/base/connection'].locationURL,
         _locked: locked,
         _password: password

react/features/invite/components/info-dialog/web/InfoDialogButton.js

     _liveStreamViewURL: ?string,
 
     /**
-     * The number of real participants in the call. If in a lonely call, the
+     * True if the number of real participants in the call is less than 2. If in a lonely call, the
      * {@code InfoDialog} will be automatically shown.
      */
-    _participantCount: number,
+    _isLonelyCall: boolean,
 
     /**
      * Whether or not the toolbox, in which this component exists, is visible.
             showDialog: (props._toolboxVisible && state.showDialog)
                 || (!state.hasConnectedToConference
                     && props._isConferenceJoined
-                    && props._participantCount < 2
+                    && props._isLonelyCall
                     && props._toolboxVisible
                     && !props._disableAutoShow)
         };
  *     _disableAutoShow: boolean,
  *     _isConferenceIsJoined: boolean,
  *     _liveStreamViewURL: string,
- *     _participantCount: number,
+ *     _isLonelyCall: boolean,
  *     _toolboxVisible: boolean
  * }}
  */
         _liveStreamViewURL:
             currentLiveStreamingSession
                 && currentLiveStreamingSession.liveStreamViewURL,
-        _participantCount: getParticipantCount(state),
+        _isLonelyCall: getParticipantCount(state) < 2,
         _toolboxVisible: state['features/toolbox'].visible
     };
 }

react/features/subtitles/components/AbstractCaptions.js

      * Mapped by id just to have the keys for convenience during the rendering
      * process.
      */
-    _transcripts: Map<string, string>
+    _transcripts: ?Map<string, string>
 };
 
 /**
     render() {
         const { _requestingSubtitles, _transcripts } = this.props;
 
-        if (!_requestingSubtitles || !_transcripts.size) {
+        if (!_requestingSubtitles || !_transcripts || !_transcripts.size) {
             return null;
         }
 
  */
 export function _abstractMapStateToProps(state: Object) {
     const { _requestingSubtitles } = state['features/subtitles'];
+    const transcripts = _constructTranscripts(state);
 
     return {
         _requestingSubtitles,
-        _transcripts: _constructTranscripts(state)
+
+        // avoid rerenders by setting to props new empty Map instances.
+        _transcripts: transcripts.size === 0 ? undefined : transcripts
     };
 }

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

 declare var APP: Object;
 declare var interfaceConfig: Object;
 
+// XXX: We are not currently using state here, but in the future, when
+// interfaceConfig is part of redux we will. This will have to be retrieved from the store.
+const visibleButtons = new Set(interfaceConfig.TOOLBAR_BUTTONS);
+
 /**
  * Implements the conference toolbox on React/Web.
  *
             || sharedVideoStatus === 'start'
             || sharedVideoStatus === 'pause',
         _visible: isToolboxVisible(state),
-
-        // XXX: We are not currently using state here, but in the future, when
-        // interfaceConfig is part of redux we will.
-        _visibleButtons: new Set(interfaceConfig.TOOLBAR_BUTTONS)
+        _visibleButtons: visibleButtons
     };
 }