@webex/plugin-meetings 2.60.0-next.9 → 2.60.1

package/test/unit/spec/stats-analyzer/index.js

@@ -2,12 +2,10 @@ import 'jsdom-global/register';
 import chai from 'chai';
 import chaiAsPromised from 'chai-as-promised';
 import sinon from 'sinon';
-import {ConnectionState} from '@webex/internal-media-core';
 
 import {StatsAnalyzer, EVENTS} from '../../../../src/statsAnalyzer';
 import NetworkQualityMonitor from '../../../../src/networkQualityMonitor';
 import testUtils from '../../../utils/testUtils';
-import {MEDIA_DEVICES, _UNKNOWN_} from '@webex/plugin-meetings/src/constants';
 
 const {assert} = chai;
 
@@ -25,15 +23,14 @@ describe('plugin-meetings', () => {
       };
 
       const defaultStats = {
-        resolutions: {},
         internal: {
-          'video-send-1': {
+          video: {
             send: {
               totalPacketsLostOnReceiver: 10,
             },
           },
         },
-        'video-send-1': {
+        video: {
           send: {
             packetsSent: 2,
             meanRemoteJitter: [],
@@ -54,12 +51,7 @@ describe('plugin-meetings', () => {
       beforeEach(() => {
         const networkQualityMonitor = new NetworkQualityMonitor(initialConfig);
 
-        statsAnalyzer = new StatsAnalyzer(
-          initialConfig,
-          () => ({}),
-          networkQualityMonitor,
-          defaultStats
-        );
+        statsAnalyzer = new StatsAnalyzer(initialConfig, networkQualityMonitor, defaultStats);
 
         sandBoxSpy = sandbox.spy(
           statsAnalyzer.networkQualityMonitor,
@@ -72,12 +64,12 @@ describe('plugin-meetings', () => {
       });
 
       it('should trigger determineUplinkNetworkQuality with specific arguments', async () => {
-        await statsAnalyzer.parseGetStatsResult(statusResult, 'video-send-1', true);
+        await statsAnalyzer.parseGetStatsResult(statusResult, 'video');
 
         assert.calledOnce(statsAnalyzer.networkQualityMonitor.determineUplinkNetworkQuality);
         assert(
           sandBoxSpy.calledWith({
-            mediaType: 'video-send-1',
+            mediaType: 'video',
             remoteRtpResults: statusResult,
             statsAnalyzerCurrentStats: statsAnalyzer.statsResults,
           })
@@ -90,7 +82,22 @@ describe('plugin-meetings', () => {
       let pc;
       let networkQualityMonitor;
       let statsAnalyzer;
-      let mqeData;
+      const statusResultOutboundRTP = {
+        type: 'outbound-rtp',
+        frameHeight: 720,
+        frameWidth: 1280,
+        packetsLost: 11,
+        framesSent: 105,
+        hugeFramesSent: 1,
+        framesEncoded: 102,
+        rttThreshold: 501,
+        jitterThreshold: 501,
+        jitterBufferDelay: 288.131459,
+        jitterBufferEmittedCount: 4013,
+        trackIdentifier: '6bbf5506-6a7e-4397-951c-c05b72ab0ace',
+        bytesSent: 1233,
+        totalPacketsSent: 100,
+      };
 
       let receivedEventsData = {
         local: {},
@@ -118,145 +125,61 @@ describe('plugin-meetings', () => {
         // bytesReceived and bytesSent need to be non-zero in order for StatsAnalyzer to parse any other values
         fakeStats = {
           audio: {
-            senders: [
-              {
-                localTrackLabel: 'fake-microphone',
-                report: [
-                  {
-                    type: 'outbound-rtp',
-                    packetsSent: 0,
-                    bytesSent: 1,
-                  },
-                  {
-                    type: 'candidate-pair',
-                    state: 'succeeded',
-                    localCandidateId: 'fake-candidate-id'
-                  },
-                  {
-                    type: 'candidate-pair',
-                    state: 'failed',
-                    localCandidateId: 'bad-candidate-id'
-                  },
-                  {
-                    type: 'local-candidate',
-                    id: 'fake-candidate-id',
-                    protocol: 'tcp'
-                  },
-                ],
-              },
-            ],
-            receivers: [
-              {
-                report: [
-                  {
-                    type: 'inbound-rtp',
-                    packetsReceived: 0,
-                    bytesReceived: 1,
-                  },
-                  {
-                    type: 'candidate-pair',
-                    state: 'succeeded',
-                    localCandidateId: 'fake-candidate-id'
-                  },
-                  {
-                    type: 'candidate-pair',
-                    state: 'failed',
-                    localCandidateId: 'bad-candidate-id'
-                  },
-                  {
-                    type: 'local-candidate',
-                    id: 'fake-candidate-id',
-                    protocol: 'tcp'
-                  },
-                ],
-              },
-            ],
+            receiver: {
+              type: 'inbound-rtp',
+              packetsReceived: 0,
+              bytesReceived: 1,
+            },
+            sender: {
+              type: 'outbound-rtp',
+              packetsSent: 0,
+              bytesSent: 1,
+            },
           },
           video: {
-            senders: [
-              {
-                localTrackLabel: 'fake-camera',
-                report: [
-                  {
-                    type: 'outbound-rtp',
-                    framesSent: 1500,
-                    bytesSent: 1,
-                  },
-                  {
-                    type: 'candidate-pair',
-                    state: 'succeeded',
-                    localCandidateId: 'fake-candidate-id'
-                  },
-                  {
-                    type: 'candidate-pair',
-                    state: 'failed',
-                    localCandidateId: 'bad-candidate-id'
-                  },
-                  {
-                    type: 'local-candidate',
-                    id: 'fake-candidate-id',
-                    protocol: 'tcp'
-                  },
-                ],
-              },
-            ],
-            receivers: [
-              {
-                report: [
-                  {
-                    type: 'inbound-rtp',
-                    framesDecoded: 0,
-                    bytesReceived: 1,
-                    frameHeight: 720,
-                    frameWidth: 1280,
-                    framesReceived: 1500,
-                  },
-                  {
-                    type: 'candidate-pair',
-                    state: 'succeeded',
-                    localCandidateId: 'fake-candidate-id'
-                  },
-                  {
-                    type: 'candidate-pair',
-                    state: 'failed',
-                    localCandidateId: 'bad-candidate-id'
-                  },
-                  {
-                    type: 'local-candidate',
-                    id: 'fake-candidate-id',
-                    protocol: 'tcp'
-                  },
-                ],
-              },
-            ],
+            receiver: {
+              type: 'inbound-rtp',
+              framesDecoded: 0,
+              bytesReceived: 1,
+            },
+            sender: {
+              type: 'outbound-rtp',
+              framesSent: 0,
+              bytesSent: 1,
+            },
           },
         };
 
         pc = {
-          getConnectionState: sinon.stub().returns(ConnectionState.Connected),
-          getTransceiverStats: sinon.stub().resolves({
-            audio: {
-              senders: [fakeStats.audio.senders[0]],
-              receivers: [fakeStats.audio.receivers[0]],
+          audioTransceiver: {
+            sender: {
+              getStats: sinon.stub().resolves([fakeStats.audio.sender]),
             },
-            video: {
-              senders: [fakeStats.video.senders[0]],
-              receivers: [fakeStats.video.receivers[0]],
+            receiver: {
+              getStats: sinon.stub().resolves([fakeStats.audio.receiver]),
             },
-            screenShareAudio: {
-              senders: [],
-              receivers: [],
+          },
+          videoTransceiver: {
+            sender: {
+              getStats: sinon.stub().resolves([fakeStats.video.sender]),
+            },
+            receiver: {
+              getStats: sinon.stub().resolves([fakeStats.video.receiver]),
             },
-            screenShareVideo: {
-              senders: [],
-              receivers: [],
+          },
+          shareTransceiver: {
+            sender: {
+              getStats: sinon.stub().resolves([]),
             },
-          }),
+            receiver: {
+              getStats: sinon.stub().resolves([]),
+            },
+          },
         };
 
         networkQualityMonitor = new NetworkQualityMonitor(initialConfig);
 
-        statsAnalyzer = new StatsAnalyzer(initialConfig, () => ({}), networkQualityMonitor);
+        statsAnalyzer = new StatsAnalyzer(initialConfig, networkQualityMonitor);
 
         statsAnalyzer.on(EVENTS.LOCAL_MEDIA_STARTED, (data) => {
           receivedEventsData.local.started = data;
@@ -270,8 +193,11 @@ describe('plugin-meetings', () => {
         statsAnalyzer.on(EVENTS.REMOTE_MEDIA_STOPPED, (data) => {
           receivedEventsData.remote.stopped = data;
         });
-        statsAnalyzer.on(EVENTS.MEDIA_QUALITY, ({data}) => {
-          mqeData = data;
+        statsAnalyzer.on(EVENTS.NO_FRAMES_SENT, (data) => {
+          receivedEventsData.noFramesSent = data;
+        });
+        statsAnalyzer.on(EVENTS.NO_VIDEO_ENCODED, (data) => {
+          receivedEventsData.noVideoEncoded = data;
         });
       });
 
@@ -299,12 +225,6 @@ describe('plugin-meetings', () => {
         assert.deepEqual(receivedEventsData.remote.stopped, expected.remote?.stopped);
       };
 
-      const checkMqeData = () => {
-        assert.strictEqual(mqeData.videoReceive[0].streams[0].receivedFrameSize, 3600);
-        assert.strictEqual(mqeData.videoReceive[0].streams[0].receivedHeight, 720);
-        assert.strictEqual(mqeData.videoReceive[0].streams[0].receivedWidth, 1280);
-      };
-
       it('emits LOCAL_MEDIA_STARTED and LOCAL_MEDIA_STOPPED events for audio', async () => {
         await startStatsAnalyzer({expected: {sendAudio: true}});
 
@@ -312,7 +232,7 @@ describe('plugin-meetings', () => {
         checkReceivedEvent({expected: {}});
 
         // setup a mock to return some values higher the previous ones
-        fakeStats.audio.senders[0].report[0].packetsSent += 10;
+        fakeStats.audio.sender.packetsSent += 10;
 
         await progressTime();
 
@@ -332,7 +252,7 @@ describe('plugin-meetings', () => {
         checkReceivedEvent({expected: {}});
 
         // setup a mock to return some values higher the previous ones
-        fakeStats.video.senders[0].report[0].framesSent += 1;
+        fakeStats.video.sender.framesSent += 1;
 
         await progressTime();
 
@@ -352,7 +272,7 @@ describe('plugin-meetings', () => {
         checkReceivedEvent({expected: {}});
 
         // setup a mock to return some values higher the previous ones
-        fakeStats.audio.receivers[0].report[0].packetsReceived += 5;
+        fakeStats.audio.receiver.packetsReceived += 5;
 
         await progressTime();
         // check that we got the REMOTE_MEDIA_STARTED event for audio
@@ -372,7 +292,7 @@ describe('plugin-meetings', () => {
         checkReceivedEvent({expected: {}});
 
         // setup a mock to return some values higher the previous ones
-        fakeStats.video.receivers[0].report[0].framesDecoded += 1;
+        fakeStats.video.receiver.framesDecoded += 1;
 
         await progressTime();
         // check that we got the REMOTE_MEDIA_STARTED event for video
@@ -385,67 +305,133 @@ describe('plugin-meetings', () => {
         checkReceivedEvent({expected: {remote: {stopped: {type: 'video'}}}});
       });
 
-      it('emits the correct MEDIA_QUALITY events', async () => {
+      const checkStats = (type) => {
+        const statsResult = {
+          height: 720,
+          width: 1280,
+          jitterBufferDelay: 288.131459,
+          jitterBufferEmittedCount: 4013,
+          trackIdentifier: '6bbf5506-6a7e-4397-951c-c05b72ab0ace',
+          avgJitterDelay: 0.07179951632195365,
+        };
+        if (type === 'inbound-rtp') {
+          statsResult.framesDecoded = 4013;
+          statsResult.framesDropped = 0;
+          statsResult.framesReceived = 4016;
+          assert.deepEqual(statsAnalyzer.statsResults.resolutions.video.recv, statsResult);
+        } else if (type === 'outbound-rtp') {
+          statsResult.framesSent = 105;
+          statsResult.hugeFramesSent = 1;
+          assert.deepEqual(statsAnalyzer.statsResults.resolutions.video.send, statsResult);
+        }
+      };
+
+      it('processes track results and populate statsResults.resolutions object when type is inbound-rtp with video', async () => {
+        await startStatsAnalyzer({expected: {receiveVideo: true}});
+        const statusResultInboundRTP = {
+          type: 'inbound-rtp',
+          frameHeight: 720,
+          frameWidth: 1280,
+          packetsLost: 11,
+          rttThreshold: 501,
+          jitterThreshold: 501,
+          framesDecoded: 4013,
+          framesDropped: 0,
+          framesReceived: 4016,
+          jitterBufferDelay: 288.131459,
+          jitterBufferEmittedCount: 4013,
+          trackIdentifier: '6bbf5506-6a7e-4397-951c-c05b72ab0ace',
+        };
+        await statsAnalyzer.parseGetStatsResult(statusResultInboundRTP, 'video');
+        checkStats('inbound-rtp');
+      });
+      it('processes track results and populate statsResults.resolutions object when type is outbound-rtp with video', async () => {
         await startStatsAnalyzer({expected: {receiveVideo: true}});
 
-        await progressTime();
+        await statsAnalyzer.parseGetStatsResult(statusResultOutboundRTP, 'video');
+        checkStats('outbound-rtp');
+      });
 
-        // Check that the mqe data has been emitted and is correctly computed.
-        checkMqeData();
+      it('doesnot processes track results with audio', async () => {
+        await startStatsAnalyzer({expected: {receiveAudio: true}});
+        await statsAnalyzer.parseGetStatsResult(statusResultOutboundRTP, 'audio');
+        assert.deepEqual(statsAnalyzer.statsResults.resolutions.audio, undefined);
       });
 
-      it('emits the correct transportType in MEDIA_QUALITY events', async () => {
-        await startStatsAnalyzer({expected: {receiveVideo: true}});
+      it('emits NO_FRAMES_ENCODED when frames are not being encoded', async () => {
+        const expected = {mediaType: 'video'};
+        await startStatsAnalyzer({expected: {sendVideo: true}});
 
-        await progressTime();
+        statsAnalyzer.lastStatsResults.video.send = {framesEncoded: 102, totalPacketsSent: 106};
+
+        await statsAnalyzer.parseGetStatsResult(statusResultOutboundRTP, 'video');
 
-        assert.strictEqual(mqeData.audioTransmit[0].common.transportType, 'TCP');
-        assert.strictEqual(mqeData.videoReceive[0].common.transportType, 'TCP');
+        statsAnalyzer.compareLastStatsResult();
+        assert.deepEqual(receivedEventsData.noVideoEncoded, expected);
       });
 
-      it('emits the correct transportType in MEDIA_QUALITY events when using a TURN server', async () => {
-        fakeStats.audio.senders[0].report[3].relayProtocol = 'tls';
-        fakeStats.video.senders[0].report[3].relayProtocol = 'tls';
-        fakeStats.audio.receivers[0].report[3].relayProtocol = 'tls';
-        fakeStats.video.receivers[0].report[3].relayProtocol = 'tls';
+      it('emits NO_FRAMES_SENT when frames are not being sent but frames are being encoded', async () => {
+        await startStatsAnalyzer({expected: {sendVideo: true}});
 
-        await startStatsAnalyzer({expected: {receiveVideo: true}});
+        const expected = {mediaType: 'video'};
 
-        await progressTime();
+        statsAnalyzer.lastStatsResults.video.send = {
+          framesEncoded: 10,
+          framesSent: 105,
+          totalPacketsSent: 106,
+        };
+        await statsAnalyzer.parseGetStatsResult(statusResultOutboundRTP, 'video');
 
-        assert.strictEqual(mqeData.audioTransmit[0].common.transportType, 'TLS');
-        assert.strictEqual(mqeData.videoReceive[0].common.transportType, 'TLS');
+        statsAnalyzer.compareLastStatsResult();
+        assert.deepEqual(receivedEventsData.noFramesSent, expected);
       });
 
-      it('emits the correct peripherals in MEDIA_QUALITY events', async () => {
-        await startStatsAnalyzer({expected: {receiveVideo: true}});
+      it('doesnot emits NO_FRAMES_SENT when last emitted event is LOCAL_MEDIA_STOPPED', async () => {
+        statsAnalyzer.lastEmittedStartStopEvent.video.local = EVENTS.LOCAL_MEDIA_STOPPED;
 
-        await progressTime();
+        await startStatsAnalyzer({expected: {sendVideo: true}});
+        await statsAnalyzer.parseGetStatsResult(statusResultOutboundRTP, 'video');
 
-        assert.strictEqual(mqeData.intervalMetadata.peripherals.find((val) => val.name === MEDIA_DEVICES.MICROPHONE).information, 'fake-microphone');
-        assert.strictEqual(mqeData.intervalMetadata.peripherals.find((val) => val.name === MEDIA_DEVICES.CAMERA).information, 'fake-camera');
+        statsAnalyzer.compareLastStatsResult();
+        assert.deepEqual(receivedEventsData.noFramesSent, undefined);
       });
 
-      it('emits the correct peripherals in MEDIA_QUALITY events when localTrackLabel is undefined', async () => {
-        fakeStats.audio.senders[0].localTrackLabel = undefined;
-        fakeStats.video.senders[0].localTrackLabel = undefined;
+      it('emits NO_FRAMES_ENCODED when frames are not being encoded for share', async () => {
+        const expected = {mediaType: 'share'};
+        await startStatsAnalyzer({expected: {sendShare: true}});
 
-        await startStatsAnalyzer({expected: {receiveVideo: true}});
+        statsAnalyzer.lastStatsResults.share.send = {framesEncoded: 102, totalPacketsSent: 106};
 
-        await progressTime();
+        await statsAnalyzer.parseGetStatsResult(statusResultOutboundRTP, 'share');
 
-        assert.strictEqual(mqeData.intervalMetadata.peripherals.find((val) => val.name === MEDIA_DEVICES.MICROPHONE).information, _UNKNOWN_);
-        assert.strictEqual(mqeData.intervalMetadata.peripherals.find((val) => val.name === MEDIA_DEVICES.CAMERA).information, _UNKNOWN_);
+        statsAnalyzer.compareLastStatsResult();
+        assert.deepEqual(receivedEventsData.noVideoEncoded, expected);
       });
 
-      it('emits the correct frameRate', async () => {
-        await startStatsAnalyzer({expected: {receiveVideo: true}});
+      it('emits NO_FRAMES_SENT when frames are not being sent but frames are being encoded for share', async () => {
+        const expected = {mediaType: 'share'};
+        await startStatsAnalyzer({expected: {sendShare: true}});
 
-        await progressTime();
-        assert.strictEqual(mqeData.videoReceive[0].streams[0].common.receivedFrameRate, 25);
-        fakeStats.video.receivers[0].framesReceived = 3000;
-        await progressTime();
-        assert.strictEqual(mqeData.videoReceive[0].streams[0].common.receivedFrameRate, 25);
+        statsAnalyzer.lastStatsResults.share.send = {
+          framesEncoded: 10,
+          framesSent: 105,
+          totalPacketsSent: 106,
+        };
+
+        await statsAnalyzer.parseGetStatsResult(statusResultOutboundRTP, 'share');
+
+        statsAnalyzer.compareLastStatsResult();
+        assert.deepEqual(receivedEventsData.noFramesSent, expected);
+      });
+
+      it('doesnot emits NO_FRAMES_SENT when last emitted event is LOCAL_MEDIA_STOPPED for share', async () => {
+        statsAnalyzer.lastEmittedStartStopEvent.video.local = EVENTS.LOCAL_MEDIA_STOPPED;
+
+        await startStatsAnalyzer({expected: {sendShare: true}});
+        await statsAnalyzer.parseGetStatsResult(statusResultOutboundRTP, 'share');
+
+        statsAnalyzer.compareLastStatsResult();
+        assert.deepEqual(receivedEventsData.noFramesSent, undefined);
       });
     });
   });

package/test/utils/testUtils.js

@@ -1,3 +1,5 @@
+import {assert} from '@webex/test-helper-chai';
+import {Defer} from '@webex/common';
 
 const max = 30000;
 const waitForSpy = (spy, event) => {
@@ -193,7 +195,49 @@ const delayedTest = (callback, timeout) =>
     }, timeout);
   });
 
+const addMedia = (user) => {
+  const mediaReadyPromises = {
+    local: new Defer(),
+    remoteAudio: new Defer(),
+    remoteVideo: new Defer(),
+  };
+  const mediaReady = (media) => {
+    if (!media) {
+      return;
+    }
+    if (mediaReadyPromises[media.type]) {
+      mediaReadyPromises[media.type].resolve();
+    }
+  };
+
+  user.meeting.on('media:ready', mediaReady);
 
+  return user.meeting
+    .getMediaStreams({
+      sendAudio: true,
+      sendVideo: true,
+      sendShare: false,
+    })
+    .then(([localStream, localShare]) =>
+      user.meeting.addMedia({
+        mediaSettings: {
+          sendAudio: true,
+          sendVideo: true,
+          sendShare: false,
+          receiveShare: true,
+          receiveAudio: true,
+          receiveVideo: true,
+        },
+        localShare,
+        localStream,
+      })
+    )
+    .then(() => Promise.all(Object.values(mediaReadyPromises).map((defer) => defer.promise)))
+    .then(() => {
+      assert.exists(user.meeting.mediaProperties.audioTrack, 'audioTrack not present');
+      assert.exists(user.meeting.mediaProperties.videoTrack, 'videoTrack not present');
+    });
+};
 
 const waitUntil = (waitTime) =>
   new Promise((resolve) => {
@@ -235,6 +279,7 @@ export default {
   waitForEvents,
   checkParticipantUpdatedStatus,
   delayedPromise,
+  addMedia,
   waitUntil,
   delayedTest,
   flushPromises,

package/test/utils/webex-config.js

@@ -57,10 +57,6 @@ Config.webex = {
       enabled: true,
     },
     enableRtx: true,
-    experimental: {
-      enableMediaNegotiatedEvent: true,
-      enableUnifiedMeetings: true,
-    },
   },
   people: {
     showAllTypes: true,

package/test/utils/webex-test-users.js

@@ -8,7 +8,6 @@ const config = require('./webex-config');
 
 // Include the plugins which you feel will be used by the webex instance
 require('@webex/internal-plugin-mercury');
-require('@webex/internal-plugin-llm');
 require('@webex/internal-plugin-user');
 require('@webex/internal-plugin-device');
 require('@webex/internal-plugin-conversation');
@@ -17,11 +16,9 @@ require('@webex/plugin-people');
 require('@webex/plugin-rooms');
 require('@webex/plugin-meetings');
 
-const generateTestUsers = (options = {}) => {
-  options.config = options.config || {};
-  options.config.orgId = options.config.orgId || process.env.WEBEX_CONVERGED_ORG_ID;
-
-  return testUser.create(options)
+const generateTestUsers = (options) =>
+  testUser
+    .create({count: options.count})
     .then(async (userSet) => {
       if (userSet.length !== options.count) {
         return Promise.reject(new Error('Test users not created'));
@@ -54,7 +51,6 @@ const generateTestUsers = (options = {}) => {
     .catch((error) => {
       console.error('#generateTestUsers=>ERROR', error);
     });
-};
 
 const reserveCMR = (user) =>
   user.webex

package/dist/annotation/annotation.types.d.ts

@@ -1,42 +0,0 @@
-import { ANNOTATION_POLICY } from './constants';
-/**
- * Type for an StrokeData Object
- */
-type StrokeData = {
-    deviceId: string;
-    toUserId: string;
-    requesterId: string;
-    content: string;
-    shareInstanceId: string;
-    encryptionKeyUrl: string;
-    version: string;
-};
-type RequestData = {
-    toUserId: string;
-    toDeviceUrl: string;
-    shareInstanceId: string;
-};
-type CommandRequestBody = {
-    actionType: string;
-    resourceType: string;
-    shareInstanceId: string;
-    receivers?: any[];
-};
-/**
- * Type for an annotation Object include annotation version and privilege
- */
-type AnnotationInfo = {
-    version: string;
-    policy: ANNOTATION_POLICY;
-};
-interface IAnnotationChannel {
-    acceptRequest: (approval: any) => undefined | Promise<void>;
-    declineRequest: (approval: any) => undefined | Promise<void>;
-    closeAnnotation: (requestData: RequestData) => undefined | Promise<void>;
-    approveAnnotation: (requestData: RequestData) => undefined | Promise<void>;
-    cancelApproveAnnotation: (requestData: RequestData, approval: any) => undefined | Promise<void>;
-    sendStrokeData: (strokeData: StrokeData) => void;
-    approvalUrlUpdate: (approvalUrl: string) => void;
-    locusUrlUpdate: (locusUrl: string) => void;
-}
-export type { StrokeData, RequestData, CommandRequestBody, IAnnotationChannel, AnnotationInfo };

package/dist/annotation/annotation.types.js

@@ -1,7 +0,0 @@
-"use strict";
-
-var _Object$defineProperty = require("@babel/runtime-corejs2/core-js/object/define-property");
-_Object$defineProperty(exports, "__esModule", {
-  value: true
-});
-//# sourceMappingURL=annotation.types.js.map

package/dist/annotation/annotation.types.js.map

@@ -1 +0,0 @@
-{"version":3,"names":[],"sources":["annotation.types.ts"],"sourcesContent":["import {ANNOTATION_POLICY} from './constants';\n\n/**\n * Type for an StrokeData Object\n */\ntype StrokeData = {\n  deviceId: string;\n  toUserId: string;\n  requesterId: string;\n  content: string;\n  shareInstanceId: string;\n  encryptionKeyUrl: string;\n  version: string;\n};\n\ntype RequestData = {\n  toUserId: string;\n  toDeviceUrl: string;\n  shareInstanceId: string;\n};\n\ntype CommandRequestBody = {\n  actionType: string;\n  resourceType: string;\n  shareInstanceId: string;\n  receivers?: any[];\n};\n/**\n * Type for an annotation Object include annotation version and privilege\n */\ntype AnnotationInfo = {\n  version: string;\n  policy: ANNOTATION_POLICY;\n};\n\ninterface IAnnotationChannel {\n  // === below is for presenter\n  acceptRequest: (approval) => undefined | Promise<void>;\n  declineRequest: (approval) => undefined | Promise<void>;\n  closeAnnotation: (requestData: RequestData) => undefined | Promise<void>;\n  // === below is for attendee\n  approveAnnotation: (requestData: RequestData) => undefined | Promise<void>;\n  cancelApproveAnnotation: (requestData: RequestData, approval) => undefined | Promise<void>;\n  sendStrokeData: (strokeData: StrokeData) => void;\n  // =====\n  approvalUrlUpdate: (approvalUrl: string) => void;\n  locusUrlUpdate: (locusUrl: string) => void;\n}\n\nexport type {StrokeData, RequestData, CommandRequestBody, IAnnotationChannel, AnnotationInfo};\n"],"mappings":""}