@webex/plugin-meetings 3.0.0-beta.2 → 3.0.0-beta.20

package/src/meeting/request.type.ts

@@ -0,0 +1,13 @@
+import {Reaction} from '../reactions/reactions.type';
+
+export type SendReactionOptions = {
+  reactionChannelUrl: string;
+  reaction: Reaction;
+  participantId: string;
+};
+
+export type ToggleReactionsOptions = {
+  enable: boolean;
+  locusUrl: string;
+  requestingParticipantId: string;
+};

package/src/meeting/{state.js → state.ts}

@@ -13,9 +13,11 @@ const MeetingStateMachine = {
    * @param {Meeting} meetingRef A reference to a meeting instance
    * @returns {StateMachine}
    */
-  create(meetingRef) {
+  create(meetingRef: any) {
     if (!meetingRef) {
-      throw new ParameterError('You must initialize the meeting state machine with a meeting reference.');
+      throw new ParameterError(
+        'You must initialize the meeting state machine with a meeting reference.'
+      );
     }
 
     return new StateMachine({
@@ -24,27 +26,36 @@ const MeetingStateMachine = {
         // when ringing a meeting, it must be first IDLE, because all other states are invalid, it transitions to the RINGING state
         {
           name: MEETING_STATE_MACHINE.TRANSITIONS.RING,
-          from: [MEETING_STATE_MACHINE.STATES.IDLE, MEETING_STATE_MACHINE.STATES.ERROR, MEETING_STATE_MACHINE.STATES.JOINED],
-          to: MEETING_STATE_MACHINE.STATES.RINGING
+          from: [
+            MEETING_STATE_MACHINE.STATES.IDLE,
+            MEETING_STATE_MACHINE.STATES.ERROR,
+            MEETING_STATE_MACHINE.STATES.JOINED,
+          ],
+          to: MEETING_STATE_MACHINE.STATES.RINGING,
         },
         // when joining a meeting, it must be from the RINGING or IDLE state, transitions to JOINED state, 1:1 will go to RINGING,
         // others will go straight to JOINED with this transition
         {
           name: MEETING_STATE_MACHINE.TRANSITIONS.JOIN,
-          from: [MEETING_STATE_MACHINE.STATES.JOINED, MEETING_STATE_MACHINE.STATES.IDLE, MEETING_STATE_MACHINE.STATES.RINGING, MEETING_STATE_MACHINE.STATES.ERROR],
-          to: MEETING_STATE_MACHINE.STATES.JOINED
+          from: [
+            MEETING_STATE_MACHINE.STATES.JOINED,
+            MEETING_STATE_MACHINE.STATES.IDLE,
+            MEETING_STATE_MACHINE.STATES.RINGING,
+            MEETING_STATE_MACHINE.STATES.ERROR,
+          ],
+          to: MEETING_STATE_MACHINE.STATES.JOINED,
         },
         // signify that ringing has stopped and somebody else answered, move state to DECLINED, ANSWERED
         {
           name: MEETING_STATE_MACHINE.TRANSITIONS.REMOTE,
           from: [MEETING_STATE_MACHINE.STATES.JOINED, MEETING_STATE_MACHINE.STATES.ERROR],
           /**
-         * @param {Object} remote
-         * @param {Boolean} remote.remoteAnswered
-         * @param {Boolean} remote.remoteDeclined
-         * @returns {String}
-         */
-          to(remote) {
+           * @param {Object} remote
+           * @param {Boolean} remote.remoteAnswered
+           * @param {Boolean} remote.remoteDeclined
+           * @returns {String}
+           */
+          to(remote: {remoteAnswered: boolean; remoteDeclined: boolean}) {
             // other user answered the call
             if (remote.remoteAnswered) {
               return MEETING_STATE_MACHINE.STATES.ANSWERED;
@@ -56,7 +67,7 @@ const MeetingStateMachine = {
 
             // default
             return MEETING_STATE_MACHINE.STATES.ERROR;
-          }
+          },
         },
         // when leaving a meeting it must be from either the RINGING, JOINED, or ERROR states, and transitions it to the ENDED state
         {
@@ -67,9 +78,9 @@ const MeetingStateMachine = {
             MEETING_STATE_MACHINE.STATES.JOINED,
             MEETING_STATE_MACHINE.STATES.ANSWERED,
             MEETING_STATE_MACHINE.STATES.DECLINED,
-            MEETING_STATE_MACHINE.STATES.ERROR
+            MEETING_STATE_MACHINE.STATES.ERROR,
           ],
-          to: MEETING_STATE_MACHINE.STATES.ENDED
+          to: MEETING_STATE_MACHINE.STATES.ENDED,
         },
         {
           name: MEETING_STATE_MACHINE.TRANSITIONS.END,
@@ -79,33 +90,33 @@ const MeetingStateMachine = {
             MEETING_STATE_MACHINE.STATES.JOINED,
             MEETING_STATE_MACHINE.STATES.ANSWERED,
             MEETING_STATE_MACHINE.STATES.DECLINED,
-            MEETING_STATE_MACHINE.STATES.ERROR
+            MEETING_STATE_MACHINE.STATES.ERROR,
           ],
-          to: MEETING_STATE_MACHINE.STATES.ENDED
+          to: MEETING_STATE_MACHINE.STATES.ENDED,
         },
         {
           name: MEETING_STATE_MACHINE.TRANSITIONS.DECLINE,
           from: [MEETING_STATE_MACHINE.STATES.RINGING, MEETING_STATE_MACHINE.STATES.ERROR],
-          to: MEETING_STATE_MACHINE.STATES.ENDED
+          to: MEETING_STATE_MACHINE.STATES.ENDED,
         },
         // transition from ANY state to ERROR state
         {
           name: MEETING_STATE_MACHINE.TRANSITIONS.FAIL,
           from: '*',
-          to: MEETING_STATE_MACHINE.STATES.ERROR
+          to: MEETING_STATE_MACHINE.STATES.ERROR,
         },
         // fail safe, transition from ANY state to IDLE state
         {
           name: MEETING_STATE_MACHINE.TRANSITIONS.RESET,
           from: '*',
-          to: MEETING_STATE_MACHINE.STATES.IDLE
-        }
+          to: MEETING_STATE_MACHINE.STATES.IDLE,
+        },
       ],
       data: {
         /**
          * The meeting instance to execute all state changes on
          */
-        meeting: meetingRef
+        meeting: meetingRef,
       },
       methods: {
         /**
@@ -114,18 +125,18 @@ const MeetingStateMachine = {
          * @param {Object} stop -- {remoteAnswered: {Boolean}, remoteDeclined: {Boolean}}
          * @returns {Boolean}
          */
-        onRemote(transition, stop) {
+        onRemote(transition: object, stop: object) {
           if (this.meeting) {
             Trigger.trigger(
               this.meeting,
               {
                 file: 'meeting/state',
-                function: 'onRemote'
+                function: 'onRemote',
               },
               EVENT_TRIGGERS.MEETING_RINGING_STOP,
               {
                 id: this.meeting.id,
-                type: stop
+                type: stop,
               }
             );
           }
@@ -136,18 +147,18 @@ const MeetingStateMachine = {
          * @param {String} type -- incoming call === INCOMING / or other meetings have a ring type of JOIN
          * @returns {Boolean}
          */
-        onRing(transition, type) {
+        onRing(transition: object, type: string) {
           if (this.meeting) {
             Trigger.trigger(
               this.meeting,
               {
                 file: 'meeting/state',
-                function: 'onRing'
+                function: 'onRing',
               },
               EVENT_TRIGGERS.MEETING_RINGING,
               {
                 type,
-                id: this.meeting.id
+                id: this.meeting.id,
               }
             );
           }
@@ -158,22 +169,26 @@ const MeetingStateMachine = {
          * @param {Error} error
          * @returns {Boolean}
          */
-        onEnterError(transition, error) {
-          LoggerProxy.logger.error(`Meeting:state#onEnterError --> state->onEnterError#meeting.id: ${this.meeting.id} | Transition '${transition?.transition}' : ${transition?.from} -> ${transition?.to}, with error ${error}. Last states: ${this.history}`);
+        onEnterError(transition: any, error: Error) {
+          LoggerProxy.logger.error(
+            `Meeting:state#onEnterError --> state->onEnterError#meeting.id: ${this.meeting.id} | Transition '${transition?.transition}' : ${transition?.from} -> ${transition?.to}, with error ${error}. Last states: ${this.history}`
+          );
         },
         /**
          * After ANY transition occurs, we want to know what state the meeting moved to for debugging
          * @param {Object} transition
          * @returns {Boolean}
          */
-        onAfterTransition(transition) {
-          LoggerProxy.logger.log(`Meeting:state#onAfterTransition --> state->onAfterTransition#meeting.id: ${this.meeting.id} | Transition '${transition.transition}' : ${transition.from} -> ${transition.to} executed. Last states: ${this.history}`);
-        }
+        onAfterTransition(transition: any) {
+          LoggerProxy.logger.log(
+            `Meeting:state#onAfterTransition --> state->onAfterTransition#meeting.id: ${this.meeting.id} | Transition '${transition.transition}' : ${transition.from} -> ${transition.to} executed. Last states: ${this.history}`
+          );
+        },
       },
       // track the last 25 states entered
-      plugins: [new StateMachineHistory({max: 25})]
+      plugins: [new StateMachineHistory({max: 25})],
     });
-  }
+  },
 };
 
 export default MeetingStateMachine;

package/src/meeting/{util.js → util.ts}

@@ -5,13 +5,15 @@ import Metrics from '../metrics';
 import {eventType, trigger} from '../metrics/config';
 import Media from '../media';
 import LoggerProxy from '../common/logs/logger-proxy';
-import {INTENT_TO_JOIN,
+import {
+  INTENT_TO_JOIN,
   _LEFT_,
   _IDLE_,
   _JOINED_,
   PASSWORD_STATUS,
   DISPLAY_HINTS,
-  FULL_STATE} from '../constants';
+  FULL_STATE,
+} from '../constants';
 import IntentToJoinError from '../common/errors/intent-to-join';
 import JoinMeetingError from '../common/errors/join-meeting';
 import ParameterError from '../common/errors/parameter';
@@ -19,10 +21,10 @@ import PermissionError from '../common/errors/permission';
 import PasswordError from '../common/errors/password-error';
 import CaptchaError from '../common/errors/captcha-error';
 
-const MeetingUtil = {};
+const MeetingUtil: any = {};
 
 MeetingUtil.parseLocusJoin = (response) => {
-  const parsed = {};
+  const parsed: any = {};
 
   // First todo: add check for existance
   parsed.locus = response.body.locus;
@@ -48,30 +50,35 @@ MeetingUtil.remoteUpdateAudioVideo = (audioMuted, videoMuted, meeting) => {
   const localMedias = Media.generateLocalMedias(meeting.mediaId, audioMuted, videoMuted);
 
   if (isEmpty(localMedias)) {
-    return Promise.reject(new ParameterError('You need a media id on the meeting to change remote audio.'));
+    return Promise.reject(
+      new ParameterError('You need a media id on the meeting to change remote audio.')
+    );
   }
 
   Metrics.postEvent({event: eventType.MEDIA_REQUEST, meeting});
 
-  return meeting.meetingRequest.remoteAudioVideoToggle({
-    locusUrl: meeting.locusUrl,
-    selfId: meeting.selfId,
-    localMedias,
-    deviceUrl: meeting.deviceUrl,
-    correlationId: meeting.correlationId,
-    preferTranscoding: !meeting.isMultistream,
-  }).then((response) => {
-    Metrics.postEvent({event: eventType.MEDIA_RESPONSE, meeting});
+  return meeting.meetingRequest
+    .remoteAudioVideoToggle({
+      locusUrl: meeting.locusUrl,
+      selfId: meeting.selfId,
+      localMedias,
+      deviceUrl: meeting.deviceUrl,
+      correlationId: meeting.correlationId,
+      preferTranscoding: !meeting.isMultistream,
+    })
+    .then((response) => {
+      Metrics.postEvent({event: eventType.MEDIA_RESPONSE, meeting});
 
-    return response.body.locus;
-  });
+      return response.body.locus;
+    });
 };
 
 MeetingUtil.hasOwner = (info) => info && info.owner;
 
 MeetingUtil.isOwnerSelf = (owner, selfId) => owner === selfId;
 
-MeetingUtil.isPinOrGuest = (err) => err?.body?.errorCode && INTENT_TO_JOIN.includes(err.body.errorCode);
+MeetingUtil.isPinOrGuest = (err) =>
+  err?.body?.errorCode && INTENT_TO_JOIN.includes(err.body.errorCode);
 
 MeetingUtil.joinMeeting = (meeting, options) => {
   if (!meeting) {
@@ -97,7 +104,8 @@ MeetingUtil.joinMeeting = (meeting, options) => {
       pin: options.pin,
       moveToResource: options.moveToResource,
       preferTranscoding: !meeting.isMultistream,
-      asResourceOccupant: options.asResourceOccupant
+      asResourceOccupant: options.asResourceOccupant,
+      breakoutsSupported: options.breakoutsSupported,
     })
     .then((res) => {
       Metrics.postEvent({
@@ -107,8 +115,8 @@ MeetingUtil.joinMeeting = (meeting, options) => {
           trigger: trigger.LOCI_UPDATE,
           locus: res.body.locus,
           mediaConnections: res.body.mediaConnections,
-          trackingId: res.headers.trackingid
-        }
+          trackingId: res.headers.trackingid,
+        },
       });
 
       return MeetingUtil.parseLocusJoin(res);
@@ -116,8 +124,12 @@ MeetingUtil.joinMeeting = (meeting, options) => {
 };
 
 MeetingUtil.cleanUp = (meeting) => {
+  meeting.breakouts.cleanUp();
+
   // make sure we send last metrics before we close the peerconnection
-  const stopStatsAnalyzer = (meeting.statsAnalyzer) ? meeting.statsAnalyzer.stopAnalyzer() : Promise.resolve();
+  const stopStatsAnalyzer = meeting.statsAnalyzer
+    ? meeting.statsAnalyzer.stopAnalyzer()
+    : Promise.resolve();
 
   return stopStatsAnalyzer
     .then(() => meeting.closeLocalStream())
@@ -131,7 +143,8 @@ MeetingUtil.cleanUp = (meeting) => {
       meeting.unsetPeerConnections();
       meeting.reconnectionManager.cleanUp();
     })
-    .then(() => meeting.stopKeepAlive());
+    .then(() => meeting.stopKeepAlive())
+    .then(() => meeting.updateLLMConnection());
 };
 
 MeetingUtil.disconnectPhoneAudio = (meeting, phoneUrl) => {
@@ -143,7 +156,7 @@ MeetingUtil.disconnectPhoneAudio = (meeting, phoneUrl) => {
     locusUrl: meeting.locusUrl,
     selfId: meeting.selfId,
     correlationId: meeting.correlationId,
-    phoneUrl
+    phoneUrl,
   };
 
   return meeting.meetingRequest
@@ -155,9 +168,7 @@ MeetingUtil.disconnectPhoneAudio = (meeting, phoneUrl) => {
     })
     .catch((err) => {
       LoggerProxy.logger.error(
-        `Meeting:util#disconnectPhoneAudio --> An error occured while disconnecting phone audio in meeting ${
-          meeting.id
-        }, error: ${err}`
+        `Meeting:util#disconnectPhoneAudio --> An error occured while disconnecting phone audio in meeting ${meeting.id}, error: ${err}`
       );
 
       return Promise.reject(err);
@@ -168,7 +179,7 @@ MeetingUtil.disconnectPhoneAudio = (meeting, phoneUrl) => {
 // if you explicity want it not to leave on resource id, pass
 // {resourceId: null}
 // TODO: chris, you can modify this however you want
-MeetingUtil.leaveMeeting = (meeting, options = {}) => {
+MeetingUtil.leaveMeeting = (meeting, options: any = {}) => {
   if (meeting.meetingState === FULL_STATE.INACTIVE) {
     // TODO: clean up if the meeting is already inactive
     return Promise.reject(new MeetingNotActiveError());
@@ -183,7 +194,7 @@ MeetingUtil.leaveMeeting = (meeting, options = {}) => {
     selfId: meeting.selfId,
     correlationId: meeting.correlationId,
     resourceId: meeting.resourceId,
-    deviceUrl: meeting.deviceUrl
+    deviceUrl: meeting.deviceUrl,
   };
 
   const leaveOptions = {...defaultOptions, ...options};
@@ -191,7 +202,8 @@ MeetingUtil.leaveMeeting = (meeting, options = {}) => {
   return meeting.meetingRequest
     .leaveMeeting(leaveOptions)
     .then((response) => {
-      if (response && response.body && response.body.locus) { // && !options.moveMeeting) {
+      if (response && response.body && response.body.locus) {
+        // && !options.moveMeeting) {
         meeting.locusInfo.onFullLocus(response.body.locus);
       }
 
@@ -209,9 +221,7 @@ MeetingUtil.leaveMeeting = (meeting, options = {}) => {
       // 1)  on leave clean up the meeting or simply do a sync on the meeting
       // 2) If the error says meeting is inactive then destroy the meeting object
       LoggerProxy.logger.error(
-        `Meeting:util#leaveMeeting --> An error occured while trying to leave meeting with an id of ${
-          meeting.id
-        }, error: ${err}`
+        `Meeting:util#leaveMeeting --> An error occured while trying to leave meeting with an id of ${meeting.id}, error: ${err}`
       );
 
       return Promise.reject(err);
@@ -221,23 +231,20 @@ MeetingUtil.declineMeeting = (meeting, reason) =>
   meeting.meetingRequest.declineMeeting({
     locusUrl: meeting.locusUrl,
     deviceUrl: meeting.deviceUrl,
-    reason
+    reason,
   });
 
-MeetingUtil.isUserInLeftState = (locusInfo) =>
-  locusInfo.parsedLocus?.self?.state === _LEFT_;
+MeetingUtil.isUserInLeftState = (locusInfo) => locusInfo.parsedLocus?.self?.state === _LEFT_;
 
-MeetingUtil.isUserInIdleState = (locusInfo) =>
-  locusInfo.parsedLocus?.self?.state === _IDLE_;
+MeetingUtil.isUserInIdleState = (locusInfo) => locusInfo.parsedLocus?.self?.state === _IDLE_;
 
-MeetingUtil.isUserInJoinedState = (locusInfo) =>
-  locusInfo.parsedLocus?.self?.state === _JOINED_;
+MeetingUtil.isUserInJoinedState = (locusInfo) => locusInfo.parsedLocus?.self?.state === _JOINED_;
 
 MeetingUtil.isMediaEstablished = (currentMediaStatus) =>
-  currentMediaStatus && (currentMediaStatus.audio || currentMediaStatus.video || currentMediaStatus.share);
-
+  currentMediaStatus &&
+  (currentMediaStatus.audio || currentMediaStatus.video || currentMediaStatus.share);
 
-MeetingUtil.joinMeetingOptions = (meeting, options = {}) => {
+MeetingUtil.joinMeetingOptions = (meeting, options: any = {}) => {
   meeting.resourceId = meeting.resourceId || options.resourceId;
 
   if (meeting.requiredCaptcha) {
@@ -250,7 +257,7 @@ MeetingUtil.joinMeetingOptions = (meeting, options = {}) => {
   if (options.pin) {
     Metrics.postEvent({
       event: eventType.PIN_COLLECTED,
-      meeting
+      meeting,
     });
   }
 
@@ -266,7 +273,7 @@ MeetingUtil.joinMeetingOptions = (meeting, options = {}) => {
       if (MeetingUtil.isPinOrGuest(err)) {
         Metrics.postEvent({
           event: eventType.PIN_PROMPT,
-          meeting
+          meeting,
         });
 
         // request host pin or non host for unclaimed PMR, start of Scenario C
@@ -280,9 +287,7 @@ MeetingUtil.joinMeetingOptions = (meeting, options = {}) => {
 };
 
 MeetingUtil.validateOptions = (options) => {
-  const {
-    sendVideo, sendAudio, sendShare, localStream, localShare
-  } = options;
+  const {sendVideo, sendAudio, sendShare, localStream, localShare} = options;
 
   if (sendVideo && !MeetingUtil.getTrack(localStream).videoTrack) {
     return Promise.reject(new ParameterError('please pass valid video streams'));
@@ -340,71 +345,34 @@ MeetingUtil.getPolicyFromLocusInfo = (locusInfo) =>
   locusInfo.parsedLocus.info &&
   locusInfo.parsedLocus.info.policy;
 
-MeetingUtil.getUserDisplayHintsFromLocusInfo = (locusInfo) => locusInfo?.parsedLocus?.info?.userDisplayHints || [];
-
-MeetingUtil.canInviteNewParticipants = (displayHints) => displayHints.includes(DISPLAY_HINTS.ADD_GUEST);
-
-MeetingUtil.canAdmitParticipant = (displayHints) => displayHints.includes(DISPLAY_HINTS.ROSTER_WAITING_TO_JOIN);
-
-MeetingUtil.canUserLock = (displayHints) => displayHints.includes(DISPLAY_HINTS.LOCK_CONTROL_LOCK) && displayHints.includes(DISPLAY_HINTS.LOCK_STATUS_UNLOCKED);
+MeetingUtil.getUserDisplayHintsFromLocusInfo = (locusInfo) =>
+  locusInfo?.parsedLocus?.info?.userDisplayHints || [];
 
-MeetingUtil.canUserUnlock = (displayHints) => displayHints.includes(DISPLAY_HINTS.LOCK_CONTROL_UNLOCK) && displayHints.includes(DISPLAY_HINTS.LOCK_STATUS_LOCKED);
+MeetingUtil.canInviteNewParticipants = (displayHints) =>
+  displayHints.includes(DISPLAY_HINTS.ADD_GUEST);
 
-MeetingUtil.canUserRecord = (displayHints) => displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_START);
+MeetingUtil.canAdmitParticipant = (displayHints) =>
+  displayHints.includes(DISPLAY_HINTS.ROSTER_WAITING_TO_JOIN);
 
-MeetingUtil.canUserPause = (displayHints) => displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_PAUSE);
+MeetingUtil.canUserLock = (displayHints) =>
+  displayHints.includes(DISPLAY_HINTS.LOCK_CONTROL_LOCK) &&
+  displayHints.includes(DISPLAY_HINTS.LOCK_STATUS_UNLOCKED);
 
-MeetingUtil.canUserResume = (displayHints) => displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_RESUME);
-
-MeetingUtil.canUserStop = (displayHints) => displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_STOP);
-
-MeetingUtil.startRecording = (request, locusUrl, locusInfo) => {
-  const displayHints = MeetingUtil.getUserDisplayHintsFromLocusInfo(locusInfo);
-
-  if (MeetingUtil.canUserRecord(displayHints)) {
-    return request.recordMeeting({locusUrl, recording: true, paused: false});
-  }
-
-  return Promise.reject(new PermissionError('Start recording not allowed, due to moderator property.'));
-};
-
-MeetingUtil.pauseRecording = (request, locusUrl, locusInfo) => {
-  const displayHints = MeetingUtil.getUserDisplayHintsFromLocusInfo(locusInfo);
-
-  if (MeetingUtil.canUserPause(displayHints)) {
-    return request.recordMeeting({locusUrl, recording: true, paused: true});
-  }
-
-  return Promise.reject(new PermissionError('Pause recording not allowed, due to moderator property.'));
-};
-
-MeetingUtil.resumeRecording = (request, locusUrl, locusInfo) => {
-  const displayHints = MeetingUtil.getUserDisplayHintsFromLocusInfo(locusInfo);
-
-  if (MeetingUtil.canUserResume(displayHints)) {
-    return request.recordMeeting({locusUrl, recording: true, paused: false});
-  }
-
-  return Promise.reject(new PermissionError('Resume recording not allowed, due to moderator property.'));
-};
-
-MeetingUtil.stopRecording = (request, locusUrl, locusInfo) => {
-  const displayHints = MeetingUtil.getUserDisplayHintsFromLocusInfo(locusInfo);
-
-  if (MeetingUtil.canUserStop(displayHints)) {
-    return request.recordMeeting({locusUrl, recording: false, paused: false});
-  }
-
-  return Promise.reject(new PermissionError('Stop recording not allowed, due to moderator property.'));
-};
+MeetingUtil.canUserUnlock = (displayHints) =>
+  displayHints.includes(DISPLAY_HINTS.LOCK_CONTROL_UNLOCK) &&
+  displayHints.includes(DISPLAY_HINTS.LOCK_STATUS_LOCKED);
 
 MeetingUtil.canUserRaiseHand = (displayHints) => displayHints.includes(DISPLAY_HINTS.RAISE_HAND);
 
-MeetingUtil.canUserLowerAllHands = (displayHints) => displayHints.includes(DISPLAY_HINTS.LOWER_ALL_HANDS);
+MeetingUtil.canUserLowerAllHands = (displayHints) =>
+  displayHints.includes(DISPLAY_HINTS.LOWER_ALL_HANDS);
 
-MeetingUtil.canUserLowerSomeoneElsesHand = (displayHints) => displayHints.includes(DISPLAY_HINTS.LOWER_SOMEONE_ELSES_HAND);
+MeetingUtil.canUserLowerSomeoneElsesHand = (displayHints) =>
+  displayHints.includes(DISPLAY_HINTS.LOWER_SOMEONE_ELSES_HAND);
 
-MeetingUtil.bothLeaveAndEndMeetingAvailable = (displayHints) => displayHints.includes(DISPLAY_HINTS.LEAVE_TRANSFER_HOST_END_MEETING) || displayHints.includes(DISPLAY_HINTS.LEAVE_END_MEETING);
+MeetingUtil.bothLeaveAndEndMeetingAvailable = (displayHints) =>
+  displayHints.includes(DISPLAY_HINTS.LEAVE_TRANSFER_HOST_END_MEETING) ||
+  displayHints.includes(DISPLAY_HINTS.LEAVE_END_MEETING);
 
 MeetingUtil.lockMeeting = (actions, request, locusUrl) => {
   if (actions && actions.canLock) {
@@ -476,31 +444,60 @@ MeetingUtil.endMeetingForAll = (meeting) => {
     .then(() => MeetingUtil.cleanUp(meeting))
     .catch((err) => {
       LoggerProxy.logger.error(
-        `Meeting:util#endMeetingForAll An error occured while trying to end meeting for all with an id of ${
-          meeting.id
-        }, error: ${err}`
+        `Meeting:util#endMeetingForAll An error occured while trying to end meeting for all with an id of ${meeting.id}, error: ${err}`
       );
 
       return Promise.reject(err);
     });
 };
 
-MeetingUtil.canEnableClosedCaption = (displayHints) => displayHints.includes(DISPLAY_HINTS.CAPTION_START);
+MeetingUtil.canEnableClosedCaption = (displayHints) =>
+  displayHints.includes(DISPLAY_HINTS.CAPTION_START);
+
+MeetingUtil.canStartTranscribing = (displayHints) =>
+  displayHints.includes(DISPLAY_HINTS.TRANSCRIPTION_CONTROL_START);
+
+MeetingUtil.canStopTranscribing = (displayHints) =>
+  displayHints.includes(DISPLAY_HINTS.TRANSCRIPTION_CONTROL_STOP);
+
+MeetingUtil.isClosedCaptionActive = (displayHints) =>
+  displayHints.includes(DISPLAY_HINTS.CAPTION_STATUS_ACTIVE);
+
+MeetingUtil.isWebexAssistantActive = (displayHints) =>
+  displayHints.includes(DISPLAY_HINTS.WEBEX_ASSISTANT_STATUS_ACTIVE);
 
-MeetingUtil.canStartTranscribing = (displayHints) => displayHints.includes(DISPLAY_HINTS.TRANSCRIPTION_CONTROL_START);
+MeetingUtil.canViewCaptionPanel = (displayHints) =>
+  displayHints.includes(DISPLAY_HINTS.ENABLE_CAPTION_PANEL);
 
-MeetingUtil.canStopTranscribing = (displayHints) => displayHints.includes(DISPLAY_HINTS.TRANSCRIPTION_CONTROL_STOP);
+MeetingUtil.isRealTimeTranslationEnabled = (displayHints) =>
+  displayHints.includes(DISPLAY_HINTS.DISPLAY_REAL_TIME_TRANSLATION);
 
-MeetingUtil.isClosedCaptionActive = (displayHints) => displayHints.includes(DISPLAY_HINTS.CAPTION_STATUS_ACTIVE);
+MeetingUtil.canSelectSpokenLanguages = (displayHints) =>
+  displayHints.includes(DISPLAY_HINTS.DISPLAY_NON_ENGLISH_ASR);
 
-MeetingUtil.isWebexAssistantActive = (displayHints) => displayHints.includes(DISPLAY_HINTS.WEBEX_ASSISTANT_STATUS_ACTIVE);
+MeetingUtil.waitingForOthersToJoin = (displayHints) =>
+  displayHints.includes(DISPLAY_HINTS.WAITING_FOR_OTHERS);
 
-MeetingUtil.canViewCaptionPanel = (displayHints) => displayHints.includes(DISPLAY_HINTS.ENABLE_CAPTION_PANEL);
+MeetingUtil.canEnableReactions = (originalValue, displayHints) => {
+  if (displayHints.includes(DISPLAY_HINTS.ENABLE_REACTIONS)) {
+    return true;
+  }
+  if (displayHints.includes(DISPLAY_HINTS.DISABLE_REACTIONS)) {
+    return false;
+  }
 
-MeetingUtil.isRealTimeTranslationEnabled = (displayHints) => displayHints.includes(DISPLAY_HINTS.DISPLAY_REAL_TIME_TRANSLATION);
+  return originalValue;
+};
 
-MeetingUtil.canSelectSpokenLanguages = (displayHints) => displayHints.includes(DISPLAY_HINTS.DISPLAY_NON_ENGLISH_ASR);
+MeetingUtil.canSendReactions = (originalValue, displayHints) => {
+  if (displayHints.includes(DISPLAY_HINTS.REACTIONS_ACTIVE)) {
+    return true;
+  }
+  if (displayHints.includes(DISPLAY_HINTS.REACTIONS_INACTIVE)) {
+    return false;
+  }
 
-MeetingUtil.waitingForOthersToJoin = (displayHints) => displayHints.includes(DISPLAY_HINTS.WAITING_FOR_OTHERS);
+  return originalValue;
+};
 
 export default MeetingUtil;

package/src/meeting-info/{collection.js → collection.ts}

@@ -24,14 +24,18 @@ export default class MeetingInfoCollection extends Collection {
    * @public
    * @memberof MeetingInfoCollection
    */
-  get(id) {
+  public get(id: string) {
+    // @ts-ignore
     if (this.meetingInfos[id]) {
+      // @ts-ignore
       return this.meetingInfos[id];
     }
 
     return find(
+      // @ts-ignore
       this.meetingInfos,
-      (info) => info.sipUrl === id || info.locusId === id || info.userId === id || info.meetingLink === id
+      (info) =>
+        info.sipUrl === id || info.locusId === id || info.userId === id || info.meetingLink === id
     );
   }
 }