@webex/plugin-meetings 3.0.0-beta.4 → 3.0.0-beta.400

package/src/statsAnalyzer/mqaUtil.ts

@@ -0,0 +1,440 @@
+/* eslint-disable no-param-reassign, prefer-destructuring */
+
+import {mean, max} from 'lodash';
+
+import {STATS} from '../constants';
+
+/**
+ * Get the totals of a certain value from a certain media type.
+ *
+ * @param {object} stats - The large stats object.
+ * @param {string} sendrecvType - "send" or "recv".
+ * @param {string} baseMediaType - audio or video _and_ share or non-share.
+ * @param {string} value - The value we want to get the totals of.
+ * @returns {number}
+ */
+const getTotalValueFromBaseType = (
+  stats: object,
+  sendrecvType: string,
+  baseMediaType: string,
+  value: string
+): number =>
+  Object.keys(stats)
+    .filter((mt) => mt.includes(baseMediaType))
+    .reduce((acc, mt) => acc + (stats[mt]?.[sendrecvType]?.[value] || 0), 0);
+
+export const getAudioReceiverMqa = ({
+  audioReceiver,
+  statsResults,
+  lastMqaDataSent,
+  baseMediaType,
+}) => {
+  const sendrecvType = STATS.RECEIVE_DIRECTION;
+
+  const getLastTotalValue = (value: string) =>
+    getTotalValueFromBaseType(lastMqaDataSent, sendrecvType, baseMediaType, value);
+  const getTotalValue = (value: string) =>
+    getTotalValueFromBaseType(statsResults, sendrecvType, baseMediaType, value);
+
+  const lastPacketsReceived = getLastTotalValue('totalPacketsReceived');
+  const lastPacketsLost = getLastTotalValue('totalPacketsLost');
+  const lastBytesReceived = getLastTotalValue('totalBytesReceived');
+  const lastFecPacketsReceived = getLastTotalValue('fecPacketsReceived');
+  const lastFecPacketsDiscarded = getLastTotalValue('fecPacketsDiscarded');
+
+  const totalPacketsReceived = getTotalValue('totalPacketsReceived');
+  const packetsLost = getTotalValue('totalPacketsLost');
+  const totalBytesReceived = getTotalValue('totalBytesReceived');
+  const totalFecPacketsReceived = getTotalValue('fecPacketsReceived');
+  const totalFecPacketsDiscarded = getTotalValue('fecPacketsDiscarded');
+
+  audioReceiver.common.common.direction =
+    statsResults[Object.keys(statsResults).find((mediaType) => mediaType.includes(baseMediaType))]
+      ?.direction || 'inactive';
+  audioReceiver.common.common.isMain = !baseMediaType.includes('-share');
+  audioReceiver.common.transportType = statsResults.connectionType.local.transport;
+
+  // add rtpPacket info inside common as also for call analyzer
+  audioReceiver.common.rtpPackets = totalPacketsReceived - lastPacketsReceived;
+
+  // Hop by hop are numbers and not percentage so we compare on what we sent the last min
+  // collect the packets received for the last min
+  const totalPacketsLost = packetsLost - lastPacketsLost;
+  audioReceiver.common.mediaHopByHopLost = totalPacketsLost;
+  audioReceiver.common.rtpHopByHopLost = totalPacketsLost;
+
+  const fecRecovered =
+    totalFecPacketsReceived -
+    lastFecPacketsReceived -
+    (totalFecPacketsDiscarded - lastFecPacketsDiscarded);
+  audioReceiver.common.fecPackets = fecRecovered;
+
+  audioReceiver.common.rtpBitrate = ((totalBytesReceived - lastBytesReceived) * 8) / 60 || 0;
+};
+
+export const getAudioReceiverStreamMqa = ({
+  audioReceiverStream,
+  statsResults,
+  lastMqaDataSent,
+  mediaType,
+}) => {
+  const sendrecvType = STATS.RECEIVE_DIRECTION;
+
+  const lastPacketsDecoded = lastMqaDataSent[mediaType]?.[sendrecvType].totalSamplesDecoded || 0;
+  const lastSamplesReceived = lastMqaDataSent[mediaType]?.[sendrecvType].totalSamplesReceived || 0;
+  const lastConcealedSamples = lastMqaDataSent[mediaType]?.[sendrecvType].concealedSamples || 0;
+  const lastBytesReceived = lastMqaDataSent[mediaType]?.[sendrecvType].totalBytesReceived || 0;
+  const lastFecPacketsReceived = lastMqaDataSent[mediaType]?.[sendrecvType].fecPacketsReceived || 0;
+  const lastFecPacketsDiscarded =
+    lastMqaDataSent[mediaType]?.[sendrecvType].fecPacketsDiscarded || 0;
+  const lastPacketsReceived = lastMqaDataSent[mediaType]?.[sendrecvType].totalPacketsReceived || 0;
+  const lastPacketsLost = lastMqaDataSent[mediaType]?.[sendrecvType].totalPacketsLost || 0;
+
+  const {csi} = statsResults[mediaType];
+  if (csi && !audioReceiverStream.common.csi.includes(csi)) {
+    audioReceiverStream.common.csi.push(csi);
+  }
+
+  audioReceiverStream.common.rtpPackets =
+    statsResults[mediaType][sendrecvType].totalPacketsReceived - lastPacketsReceived || 0;
+
+  audioReceiverStream.common.maxRtpJitter =
+    // @ts-ignore
+    max(statsResults[mediaType][sendrecvType].meanRtpJitter) * 1000 || 0;
+  audioReceiverStream.common.meanRtpJitter =
+    mean(statsResults[mediaType][sendrecvType].meanRtpJitter) * 1000 || 0;
+  audioReceiverStream.common.rtpJitter = audioReceiverStream.common.maxRtpJitter;
+
+  // Fec packets do come in as part of the FEC only for audio
+  const fecRecovered =
+    statsResults[mediaType][sendrecvType].fecPacketsReceived -
+    lastFecPacketsReceived -
+    (statsResults[mediaType][sendrecvType].fecPacketsDiscarded - lastFecPacketsDiscarded);
+
+  audioReceiverStream.common.rtpEndToEndLost =
+    statsResults[mediaType][sendrecvType].totalPacketsLost - lastPacketsLost - fecRecovered || 0;
+
+  audioReceiverStream.common.framesDropped =
+    statsResults[mediaType][sendrecvType].totalSamplesDecoded - lastPacketsDecoded || 0;
+  audioReceiverStream.common.renderedFrameRate =
+    (audioReceiverStream.common.framesDropped * 100) / 60 || 0;
+
+  audioReceiverStream.common.framesReceived =
+    statsResults[mediaType][sendrecvType].totalSamplesReceived - lastSamplesReceived || 0;
+  audioReceiverStream.common.concealedFrames =
+    statsResults[mediaType][sendrecvType].concealedSamples - lastConcealedSamples || 0;
+  audioReceiverStream.common.receivedBitrate =
+    ((statsResults[mediaType][sendrecvType].totalBytesReceived - lastBytesReceived) * 8) / 60 || 0;
+};
+
+export const getAudioSenderMqa = ({audioSender, statsResults, lastMqaDataSent, baseMediaType}) => {
+  const sendrecvType = STATS.SEND_DIRECTION;
+
+  const getLastTotalValue = (value: string) =>
+    getTotalValueFromBaseType(lastMqaDataSent, sendrecvType, baseMediaType, value);
+  const getTotalValue = (value: string) =>
+    getTotalValueFromBaseType(statsResults, sendrecvType, baseMediaType, value);
+
+  const lastPacketsSent = getLastTotalValue('totalPacketsSent');
+  const lastPacketsLostTotal = getLastTotalValue('totalPacketsLostOnReceiver');
+
+  const totalPacketsLostOnReceiver = getTotalValue('totalPacketsLostOnReceiver');
+  const totalPacketsSent = getTotalValue('totalPacketsSent');
+
+  const meanRemoteJitter = Object.keys(statsResults)
+    .filter((mt) => mt.includes(baseMediaType))
+    .reduce((acc, mt) => acc.concat(statsResults[mt][sendrecvType].meanRemoteJitter), []);
+  const meanRoundTripTime = Object.keys(statsResults)
+    .filter((mt) => mt.includes(baseMediaType))
+    .reduce((acc, mt) => acc.concat(statsResults[mt][sendrecvType].meanRoundTripTime), []);
+
+  audioSender.common.common.direction =
+    statsResults[Object.keys(statsResults).find((mediaType) => mediaType.includes(baseMediaType))]
+      ?.direction || 'inactive';
+  audioSender.common.common.isMain = !baseMediaType.includes('-share');
+  audioSender.common.transportType = statsResults.connectionType.local.transport;
+
+  audioSender.common.maxRemoteJitter = max(meanRemoteJitter) * 1000 || 0;
+  audioSender.common.meanRemoteJitter = mean(meanRemoteJitter) * 1000 || 0;
+
+  audioSender.common.rtpPackets = totalPacketsSent - lastPacketsSent || 0;
+  // audioSender.streams[0].common.rtpPackets = audioSender.common.rtpPackets;
+  // From candidate-pair
+  audioSender.common.availableBitrate = getTotalValueFromBaseType(
+    statsResults,
+    sendrecvType,
+    baseMediaType,
+    'availableOutgoingBitrate'
+  );
+  // Calculate based on how much packets lost of received compated to how to the client sent
+
+  const totalPacketsLostForaMin = totalPacketsLostOnReceiver - lastPacketsLostTotal;
+  audioSender.common.remoteLossRate =
+    totalPacketsSent - lastPacketsSent > 0
+      ? (totalPacketsLostForaMin * 100) / (totalPacketsSent - lastPacketsSent)
+      : 0; // This is the packets sent with in last min
+
+  audioSender.common.maxRoundTripTime = max(meanRoundTripTime) * 1000 || 0;
+  audioSender.common.meanRoundTripTime = mean(meanRoundTripTime) * 1000 || 0;
+  audioSender.common.roundTripTime = audioSender.common.maxRoundTripTime;
+
+  // Calculate the outgoing bitrate
+  const totalBytesSentInaMin =
+    getTotalValueFromBaseType(statsResults, sendrecvType, baseMediaType, 'totalBytesSent') -
+    getTotalValueFromBaseType(lastMqaDataSent, sendrecvType, baseMediaType, 'totalBytesSent');
+
+  audioSender.common.rtpBitrate = totalBytesSentInaMin ? (totalBytesSentInaMin * 8) / 60 : 0;
+};
+
+export const getAudioSenderStreamMqa = ({
+  audioSenderStream,
+  statsResults,
+  lastMqaDataSent,
+  mediaType,
+}) => {
+  const sendrecvType = STATS.SEND_DIRECTION;
+
+  const lastBytesSent = lastMqaDataSent[mediaType]?.[sendrecvType].totalBytesSent || 0;
+  const lastFramesEncoded = lastMqaDataSent[mediaType]?.[sendrecvType].totalKeyFramesEncoded || 0;
+  const lastFirCount = lastMqaDataSent[mediaType]?.[sendrecvType].totalFirCount || 0;
+  const lastPacketsSent = lastMqaDataSent[mediaType]?.[sendrecvType].totalPacketsSent || 0;
+
+  const {csi} = statsResults[mediaType];
+  if (csi && !audioSenderStream.common.csi.includes(csi)) {
+    audioSenderStream.common.csi.push(csi);
+  }
+
+  audioSenderStream.common.rtpPackets =
+    statsResults[mediaType][sendrecvType].totalPacketsSent - lastPacketsSent || 0;
+
+  const totalBytesSentInaMin = statsResults[mediaType][sendrecvType].totalBytesSent - lastBytesSent;
+  audioSenderStream.common.transmittedBitrate = totalBytesSentInaMin
+    ? (totalBytesSentInaMin * 8) / 60
+    : 0;
+
+  audioSenderStream.transmittedKeyFrames =
+    statsResults[mediaType][sendrecvType].totalKeyFramesEncoded - lastFramesEncoded || 0;
+  audioSenderStream.requestedKeyFrames =
+    statsResults[mediaType][sendrecvType].totalFirCount - lastFirCount || 0;
+};
+
+export const getVideoReceiverMqa = ({
+  videoReceiver,
+  statsResults,
+  lastMqaDataSent,
+  baseMediaType,
+}) => {
+  const sendrecvType = STATS.RECEIVE_DIRECTION;
+
+  const getLastTotalValue = (value: string) =>
+    getTotalValueFromBaseType(lastMqaDataSent, sendrecvType, baseMediaType, value);
+  const getTotalValue = (value: string) =>
+    getTotalValueFromBaseType(statsResults, sendrecvType, baseMediaType, value);
+
+  const lastPacketsReceived = getLastTotalValue('totalPacketsReceived');
+  const lastPacketsLost = getLastTotalValue('totalPacketsLost');
+  const lastBytesReceived = getLastTotalValue('totalBytesReceived');
+
+  const packetsLost = getTotalValue('totalPacketsLost');
+  const totalPacketsReceived = getTotalValue('totalPacketsReceived');
+  const totalBytesReceived = getTotalValue('totalBytesReceived');
+
+  const meanRemoteJitter = Object.keys(statsResults)
+    .filter((mt) => mt.includes(baseMediaType))
+    .reduce((acc, mt) => acc.concat(statsResults[mt][sendrecvType].meanRemoteJitter), []);
+
+  videoReceiver.common.common.direction =
+    statsResults[Object.keys(statsResults).find((mediaType) => mediaType.includes(baseMediaType))]
+      ?.direction || 'inactive';
+  videoReceiver.common.common.isMain = !baseMediaType.includes('-share');
+  videoReceiver.common.transportType = statsResults.connectionType.local.transport;
+
+  // collect the packets received for the last min
+  videoReceiver.common.rtpPackets = totalPacketsReceived - lastPacketsReceived || 0;
+
+  // Hop by hop are numbers and not percentage so we compare on what we sent the last min
+  // this is including packet lost
+  const totalPacketsLost = packetsLost - lastPacketsLost;
+  videoReceiver.common.mediaHopByHopLost = totalPacketsLost;
+  videoReceiver.common.rtpHopByHopLost = totalPacketsLost;
+
+  // calculate this values
+  videoReceiver.common.maxRemoteJitter = max(meanRemoteJitter) * 1000 || 0;
+  videoReceiver.common.meanRemoteJitter = mean(meanRemoteJitter) * 1000 || 0;
+
+  // Calculate the outgoing bitrate
+  const totalBytesReceivedInaMin = totalBytesReceived - lastBytesReceived;
+
+  videoReceiver.common.rtpBitrate = totalBytesReceivedInaMin
+    ? (totalBytesReceivedInaMin * 8) / 60
+    : 0;
+};
+
+export const getVideoReceiverStreamMqa = ({
+  videoReceiverStream,
+  statsResults,
+  lastMqaDataSent,
+  mediaType,
+}) => {
+  const sendrecvType = STATS.RECEIVE_DIRECTION;
+
+  const lastPacketsReceived = lastMqaDataSent[mediaType]?.[sendrecvType].totalPacketsReceived || 0;
+  const lastPacketsLost = lastMqaDataSent[mediaType]?.[sendrecvType].totalPacketsLost || 0;
+  const lastBytesReceived = lastMqaDataSent[mediaType]?.[sendrecvType].totalBytesReceived || 0;
+  const lastFramesReceived = lastMqaDataSent[mediaType]?.[sendrecvType].framesReceived || 0;
+  const lastFramesDecoded = lastMqaDataSent[mediaType]?.[sendrecvType].framesDecoded || 0;
+  const lastFramesDropped = lastMqaDataSent[mediaType]?.[sendrecvType].framesDropped || 0;
+  const lastKeyFramesDecoded = lastMqaDataSent[mediaType]?.[sendrecvType].keyFramesDecoded || 0;
+  const lastPliCount = lastMqaDataSent[mediaType]?.[sendrecvType].totalPliCount || 0;
+
+  const {csi} = statsResults[mediaType];
+  if (csi && !videoReceiverStream.common.csi.includes(csi)) {
+    videoReceiverStream.common.csi.push(csi);
+  }
+
+  videoReceiverStream.common.rtpPackets =
+    statsResults[mediaType][sendrecvType].totalPacketsReceived - lastPacketsReceived || 0;
+
+  const totalPacketLoss =
+    statsResults[mediaType][sendrecvType].totalPacketsLost - lastPacketsLost || 0;
+
+  // End to end packetloss is after recovery
+  videoReceiverStream.common.rtpEndToEndLost = totalPacketLoss;
+
+  videoReceiverStream.common.rtpJitter =
+    // @ts-ignore
+    max(statsResults[mediaType][sendrecvType].meanRemoteJitter) * 1000 || 0;
+
+  const totalBytesReceivedInaMin =
+    statsResults[mediaType][sendrecvType].totalBytesReceived - lastBytesReceived;
+  videoReceiverStream.common.receivedBitrate = totalBytesReceivedInaMin
+    ? (totalBytesReceivedInaMin * 8) / 60
+    : 0;
+
+  const totalFrameReceivedInaMin =
+    statsResults[mediaType][sendrecvType].framesReceived - lastFramesReceived;
+  const totalFrameDecodedInaMin =
+    statsResults[mediaType][sendrecvType].framesDecoded - lastFramesDecoded;
+
+  videoReceiverStream.common.receivedFrameRate = Math.round(
+    totalFrameReceivedInaMin ? totalFrameReceivedInaMin / 60 : 0
+  );
+  videoReceiverStream.common.renderedFrameRate = Math.round(
+    totalFrameDecodedInaMin ? totalFrameDecodedInaMin / 60 : 0
+  );
+
+  videoReceiverStream.common.framesDropped =
+    statsResults[mediaType][sendrecvType].framesDropped - lastFramesDropped || 0;
+  videoReceiverStream.receivedHeight = statsResults[mediaType][sendrecvType].height || 0;
+  videoReceiverStream.receivedWidth = statsResults[mediaType][sendrecvType].width || 0;
+  videoReceiverStream.receivedFrameSize =
+    (videoReceiverStream.receivedHeight * videoReceiverStream.receivedWidth) / 256;
+
+  videoReceiverStream.receivedKeyFrames =
+    statsResults[mediaType][sendrecvType].keyFramesDecoded - lastKeyFramesDecoded || 0;
+  videoReceiverStream.requestedKeyFrames =
+    statsResults[mediaType][sendrecvType].totalPliCount - lastPliCount || 0;
+};
+
+export const getVideoSenderMqa = ({videoSender, statsResults, lastMqaDataSent, baseMediaType}) => {
+  const sendrecvType = STATS.SEND_DIRECTION;
+
+  const getLastTotalValue = (value: string) =>
+    getTotalValueFromBaseType(lastMqaDataSent, sendrecvType, baseMediaType, value);
+  const getTotalValue = (value: string) =>
+    getTotalValueFromBaseType(statsResults, sendrecvType, baseMediaType, value);
+
+  const lastPacketsSent = getLastTotalValue('totalPacketsSent');
+  const lastBytesSent = getLastTotalValue('totalBytesSent');
+  const lastPacketsLostTotal = getLastTotalValue('totalPacketsLostOnReceiver');
+
+  const totalPacketsLostOnReceiver = getTotalValue('totalPacketsLostOnReceiver');
+  const totalPacketsSent = getTotalValue('totalPacketsSent');
+  const totalBytesSent = getTotalValue('totalBytesSent');
+  const availableOutgoingBitrate = getTotalValue('availableOutgoingBitrate');
+
+  videoSender.common.common.direction =
+    statsResults[Object.keys(statsResults).find((mediaType) => mediaType.includes(baseMediaType))]
+      ?.direction || 'inactive';
+  videoSender.common.common.isMain = !baseMediaType.includes('-share');
+  videoSender.common.transportType = statsResults.connectionType.local.transport;
+
+  const meanRemoteJitter = Object.keys(statsResults)
+    .filter((mt) => mt.includes(baseMediaType))
+    .reduce((acc, mt) => acc.concat(statsResults[mt][sendrecvType].meanRemoteJitter), []);
+  const meanRoundTripTime = Object.keys(statsResults)
+    .filter((mt) => mt.includes(baseMediaType))
+    .reduce((acc, mt) => acc.concat(statsResults[mt][sendrecvType].meanRoundTripTime), []);
+
+  // @ts-ignore
+  videoSender.common.maxRemoteJitter = max(meanRemoteJitter) * 1000 || 0;
+  videoSender.common.meanRemoteJitter = mean(meanRemoteJitter) * 1000 || 0;
+
+  videoSender.common.rtpPackets = totalPacketsSent - lastPacketsSent;
+  videoSender.common.availableBitrate = availableOutgoingBitrate;
+
+  // Calculate based on how much packets lost of received compated to how to the client sent
+  const totalPacketsLostForaMin = totalPacketsLostOnReceiver - lastPacketsLostTotal;
+
+  videoSender.common.remoteLossRate =
+    totalPacketsSent - lastPacketsSent > 0
+      ? (totalPacketsLostForaMin * 100) / (totalPacketsSent - lastPacketsSent)
+      : 0; // This is the packets sent with in last min || 0;
+
+  videoSender.common.maxRoundTripTime = max(meanRoundTripTime) * 1000 || 0;
+  videoSender.common.meanRoundTripTime = mean(meanRoundTripTime) * 1000 || 0;
+  videoSender.common.roundTripTime = videoSender.common.maxRoundTripTime;
+
+  // Calculate the outgoing bitrate
+  const totalBytesSentInaMin = totalBytesSent - lastBytesSent;
+
+  videoSender.common.rtpBitrate = totalBytesSentInaMin ? (totalBytesSentInaMin * 8) / 60 : 0;
+};
+
+export const getVideoSenderStreamMqa = ({
+  videoSenderStream,
+  statsResults,
+  lastMqaDataSent,
+  mediaType,
+}) => {
+  const sendrecvType = STATS.SEND_DIRECTION;
+
+  const lastPacketsSent = lastMqaDataSent[mediaType]?.[sendrecvType].totalPacketsSent || 0;
+  const lastBytesSent = lastMqaDataSent[mediaType]?.[sendrecvType].totalBytesSent || 0;
+  const lastKeyFramesEncoded =
+    lastMqaDataSent[mediaType]?.[sendrecvType].totalKeyFramesEncoded || 0;
+  const lastFirCount = lastMqaDataSent[mediaType]?.[sendrecvType].totalFirCount || 0;
+  const lastFramesSent = lastMqaDataSent[mediaType]?.[sendrecvType].framesSent || 0;
+
+  const {csi} = statsResults[mediaType];
+  if (csi && !videoSenderStream.common.csi.includes(csi)) {
+    videoSenderStream.common.csi.push(csi);
+  }
+
+  videoSenderStream.common.rtpPackets =
+    statsResults[mediaType][sendrecvType].totalPacketsSent - lastPacketsSent || 0;
+
+  // Calculate the outgoing bitrate
+  const totalBytesSentInaMin = statsResults[mediaType][sendrecvType].totalBytesSent - lastBytesSent;
+
+  videoSenderStream.common.transmittedBitrate = totalBytesSentInaMin
+    ? (totalBytesSentInaMin * 8) / 60
+    : 0;
+
+  videoSenderStream.transmittedKeyFrames =
+    statsResults[mediaType][sendrecvType].totalKeyFramesEncoded - lastKeyFramesEncoded || 0;
+  videoSenderStream.requestedKeyFrames =
+    statsResults[mediaType][sendrecvType].totalFirCount - lastFirCount || 0;
+
+  // From tracks //TODO: calculate a proper one
+  const totalFrameSentInaMin =
+    statsResults[mediaType][sendrecvType].framesSent - (lastFramesSent || 0);
+
+  videoSenderStream.common.transmittedFrameRate = Math.round(
+    totalFrameSentInaMin ? totalFrameSentInaMin / 60 : 0
+  );
+  videoSenderStream.transmittedHeight = statsResults[mediaType][sendrecvType].height || 0;
+  videoSenderStream.transmittedWidth = statsResults[mediaType][sendrecvType].width || 0;
+  videoSenderStream.transmittedFrameSize =
+    (videoSenderStream.transmittedHeight * videoSenderStream.transmittedWidth) / 256;
+};

package/src/transcription/{index.js → index.ts}

@@ -6,6 +6,12 @@ import {v4 as uuidv4} from 'uuid';
  * @class Transcription
  */
 export default class Transcription {
+  webSocketUrl: any;
+  sessionID: any;
+  members: any;
+  memberCSIs: any;
+  webSocket: any;
+
   /**
    * @param {string} webSocketUrl
    * @param {sessionID} sessionId
@@ -13,7 +19,7 @@ export default class Transcription {
    * @constructor
    * @memberof Transcription
    */
-  constructor(webSocketUrl, sessionId, members) {
+  constructor(webSocketUrl: string, sessionId: any, members: object) {
     this.webSocketUrl = webSocketUrl;
     this.sessionID = sessionId;
     this.members = members;
@@ -32,24 +38,26 @@ export default class Transcription {
    * @param {string} sessionID
    * @returns {void}
    */
-  connect(token) {
+  connect(token: string) {
     this.webSocket.onopen = () => {
-      this.webSocket.send(JSON.stringify({
-        id: uuidv4(),
-        type: 'authorization',
-        data: {token: `Bearer ${token}`},
-        trackingId: `webex-js-sdk_${this.sessionID}${Date.now.toString()}`
-      }));
+      this.webSocket.send(
+        JSON.stringify({
+          id: uuidv4(),
+          type: 'authorization',
+          data: {token: `Bearer ${token}`},
+          trackingId: `webex-js-sdk_${this.sessionID}${Date.now.toString()}`,
+        })
+      );
     };
   }
 
   /**
    * Sets callback to invoke when the web socket connection is closed.
    *
-   * @param {function} callback
+   * @param {Function} callback
    * @returns {void}
    */
-  onCloseSocket(callback) {
+  onCloseSocket(callback: any) {
     if (callback) {
       this.webSocket.onclose = (event) => {
         callback(event);
@@ -61,10 +69,10 @@ export default class Transcription {
    * Sets callback to invoke when a web socket connection error occurs.
    * An event parameter will be send to the callback.
    *
-   * @param {function} callback
+   * @param {Function} callback
    * @returns {void}
    */
-  onErrorSocket(callback) {
+  onErrorSocket(callback: any) {
     if (callback) {
       this.webSocket.onerror = (event) => {
         callback(event);
@@ -79,7 +87,7 @@ export default class Transcription {
    * @param {object} csis
    * @returns {object}
    */
-  getSpeaker(csis) {
+  private getSpeaker(csis: any) {
     for (const csi of csis) {
       const member = this.memberCSIs[csi];
 
@@ -88,31 +96,33 @@ export default class Transcription {
       }
     }
 
-    return Object.values(this.members.membersCollection.members)
-      .find((member) => {
-        const memberCSIs = member.participant.status.csis;
-        let selfIsSpeaking = false;
-
-        for (const csi of csis) {
-          if (memberCSIs.includes(csi)) {
-            this.memberCSIs[csi] = member;
-            selfIsSpeaking = true;
-            break;
-          }
+    return Object.values(this.members.membersCollection.members).find((member: any) => {
+      const memberCSIs = member.participant.status.csis;
+      let selfIsSpeaking = false;
+
+      for (const csi of csis) {
+        if (memberCSIs.includes(csi)) {
+          this.memberCSIs[csi] = member;
+          selfIsSpeaking = true;
+          break;
         }
+      }
 
-        return selfIsSpeaking;
-      });
+      return selfIsSpeaking;
+    });
   }
 
   /**
    * Sends transcription data to given callback as it arrives.
    *
-   * @param {function} callback
+   * @param {Function} callback
    * @returns {void}
    */
-  subscribe(callback) {
-    let data, csis, speaker, transcription;
+  subscribe(callback: any) {
+    let data;
+    let csis;
+    let speaker;
+    let transcription;
 
     this.webSocket.onmessage = (event) => {
       data = JSON.parse(event.data);
@@ -123,15 +133,13 @@ export default class Transcription {
       this.webSocket.send(JSON.stringify({messageID: data.id, type: 'ack'}));
 
       if (transcription) {
-        callback(
-          {
-            id: data.data?.voiceaPayload?.transcript_id,
-            personID: speaker?.id,
-            transcription,
-            timestamp: data.timestamp,
-            type: data?.data?.voiceaPayload?.type
-          }
-        );
+        callback({
+          id: data.data?.voiceaPayload?.transcript_id,
+          personID: speaker?.id,
+          transcription,
+          timestamp: data.timestamp,
+          type: data?.data?.voiceaPayload?.type,
+        });
       }
     };
   }
@@ -144,4 +152,3 @@ export default class Transcription {
     this.webSocket.close();
   }
 }
-

package/src/webinar/collection.ts

@@ -0,0 +1,31 @@
+/*!
+ * Copyright (c) 2015-2023 Cisco Systems, Inc. See LICENSE file.
+ */
+
+import {MEETINGS} from '../constants';
+
+class WebinarCollection {
+  webinarInfo: any;
+
+  namespace = MEETINGS;
+
+  mainIndex = 'sessionId';
+
+  constructor() {
+    this.webinarInfo = {};
+  }
+
+  set(id, info) {
+    this.webinarInfo[id] = info;
+  }
+
+  /**
+   * @param {String} id
+   * @returns {Member}
+   */
+  get(id: string) {
+    return this.webinarInfo[id];
+  }
+}
+
+export default WebinarCollection;

package/src/webinar/index.ts

@@ -0,0 +1,62 @@
+/*!
+ * Copyright (c) 2015-2023 Cisco Systems, Inc. See LICENSE file.
+ */
+import {WebexPlugin} from '@webex/webex-core';
+import {MEETINGS} from '../constants';
+
+import WebinarCollection from './collection';
+
+/**
+ * @class Webinar
+ */
+const Webinar = WebexPlugin.extend({
+  namespace: MEETINGS,
+  collections: {
+    webinar: WebinarCollection,
+  },
+
+  props: {
+    locusUrl: 'string', // appears current webinar's locus url
+    webcastUrl: 'string', // current webinar's webcast url
+    webinarAttendeesSearchingUrl: 'string', // current webinarAttendeesSearching url
+    canManageWebcast: 'boolean', // appears the ability to manage webcast
+  },
+
+  /**
+   * Update the current locus url of the webinar
+   * @param {string} locusUrl // locus url
+   * @returns {void}
+   */
+  locusUrlUpdate(locusUrl) {
+    this.set('locusUrl', locusUrl);
+  },
+
+  /**
+   * Update the current webcast url of the meeting
+   * @param {string} webcastUrl // webcast url
+   * @returns {void}
+   */
+  webcastUrlUpdate(webcastUrl) {
+    this.set('webcastUrl', webcastUrl);
+  },
+
+  /**
+   * Update the current webinarAttendeesSearching url of the meeting
+   * @param {string} webinarAttendeesSearchingUrl // webinarAttendeesSearching url
+   * @returns {void}
+   */
+  webinarAttendeesSearchingUrlUpdate(webinarAttendeesSearchingUrl) {
+    this.set('webinarAttendeesSearchingUrl', webinarAttendeesSearchingUrl);
+  },
+
+  /**
+   * Update whether self has capability to manage start/stop webcast (only host can manage it)
+   * @param {boolean} canManageWebcast
+   * @returns {void}
+   */
+  updateCanManageWebcast(canManageWebcast) {
+    this.set('canManageWebcast', canManageWebcast);
+  },
+});
+
+export default Webinar;