@webex/plugin-meetings 3.11.0-next.27 → 3.11.0-next.29

package/dist/types/config.d.ts

@@ -76,6 +76,9 @@ declare const _default: {
         stopIceGatheringAfterFirstRelayCandidate: boolean;
         enableAudioTwccForMultistream: boolean;
         enablePerUdpUrlReachability: boolean;
+        locus: {
+            excludedDataSets: string[];
+        };
     };
 };
 export default _default;

package/dist/types/hashTree/hashTreeParser.d.ts

@@ -59,6 +59,7 @@ declare class HashTreeParser {
     visibleDataSets: VisibleDataSetInfo[];
     debugId: string;
     heartbeatIntervalMs?: number;
+    private excludedDataSets;
     /**
      * Constructor for HashTreeParser
      * @param {Object} options
@@ -73,6 +74,7 @@ declare class HashTreeParser {
         webexRequest: WebexRequestMethod;
         locusInfoUpdateCallback: LocusInfoUpdateCallback;
         debugId: string;
+        excludedDataSets?: string[];
     });
     /**
      * Checks if the given data set name is in the list of visible data sets
@@ -80,6 +82,18 @@ declare class HashTreeParser {
      * @returns {Boolean} True if the data set is visible, false otherwise
      */
     private isVisibleDataSet;
+    /**
+     * Checks if the given data set name is in the excluded list
+     * @param {string} dataSetName data set name to check
+     * @returns {boolean} True if the data set is excluded, false otherwise
+     */
+    private isExcludedDataSet;
+    /**
+     * Adds a data set to the visible data sets list, unless it is in the excluded list.
+     * @param {VisibleDataSetInfo} dataSetInfo data set info to add
+     * @returns {boolean} True if the data set was added, false if it was excluded
+     */
+    private addToVisibleDataSetsList;
     /**
      * Initializes a new visible data set by creating a hash tree for it, adding it to all the internal structures,
      * and sending an initial sync request to Locus with empty leaf data - that will trigger Locus to gives us all the data

package/dist/webinar/index.js

@@ -506,7 +506,7 @@ var Webinar = _webexCore.WebexPlugin.extend({
       }, _callee8);
     }))();
   },
-  version: "3.11.0-next.27"
+  version: "3.11.0-next.29"
 });
 var _default = exports.default = Webinar;
 //# sourceMappingURL=index.js.map

package/package.json

@@ -93,5 +93,5 @@
   "//": [
     "TODO: upgrade jwt-decode when moving to node 18"
   ],
-  "version": "3.11.0-next.27"
+  "version": "3.11.0-next.29"
 }

package/src/config.ts

@@ -101,5 +101,8 @@ export default {
     stopIceGatheringAfterFirstRelayCandidate: false,
     enableAudioTwccForMultistream: false,
     enablePerUdpUrlReachability: false, // true: separate peer connection per each UDP URL; false: single peer connection for all URLs
+    locus: {
+      excludedDataSets: ['attendees'], // attendees data set only applies to webinar attendees and we never really need that
+    },
   },
 };

package/src/hashTree/hashTreeParser.ts

@@ -91,6 +91,7 @@ class HashTreeParser {
   visibleDataSets: VisibleDataSetInfo[];
   debugId: string;
   heartbeatIntervalMs?: number;
+  private excludedDataSets: string[];
 
   /**
    * Constructor for HashTreeParser
@@ -106,14 +107,18 @@ class HashTreeParser {
     webexRequest: WebexRequestMethod;
     locusInfoUpdateCallback: LocusInfoUpdateCallback;
     debugId: string;
+    excludedDataSets?: string[];
   }) {
     const {dataSets, locus} = options.initialLocus; // extract dataSets from initialLocus
 
     this.debugId = options.debugId;
     this.webexRequest = options.webexRequest;
     this.locusInfoUpdateCallback = options.locusInfoUpdateCallback;
+    this.excludedDataSets = options.excludedDataSets || [];
     this.visibleDataSetsUrl = locus?.links?.resources?.visibleDataSets?.url;
-    this.visibleDataSets = cloneDeep(options.metadata?.visibleDataSets || []);
+    this.visibleDataSets = (
+      cloneDeep(options.metadata?.visibleDataSets || []) as VisibleDataSetInfo[]
+    ).filter((vds) => !this.isExcludedDataSet(vds.name));
 
     if (options.metadata?.visibleDataSets?.length === 0) {
       LoggerProxy.logger.warn(
@@ -155,6 +160,34 @@ class HashTreeParser {
     return this.visibleDataSets.some((vds) => vds.name === dataSetName);
   }
 
+  /**
+   * Checks if the given data set name is in the excluded list
+   * @param {string} dataSetName data set name to check
+   * @returns {boolean} True if the data set is excluded, false otherwise
+   */
+  private isExcludedDataSet(dataSetName: string): boolean {
+    return this.excludedDataSets.some((name) => name === dataSetName);
+  }
+
+  /**
+   * Adds a data set to the visible data sets list, unless it is in the excluded list.
+   * @param {VisibleDataSetInfo} dataSetInfo data set info to add
+   * @returns {boolean} True if the data set was added, false if it was excluded
+   */
+  private addToVisibleDataSetsList(dataSetInfo: VisibleDataSetInfo): boolean {
+    if (this.isExcludedDataSet(dataSetInfo.name)) {
+      LoggerProxy.logger.info(
+        `HashTreeParser#addToVisibleDataSetsList --> ${this.debugId} Data set "${dataSetInfo.name}" is in the excluded list, ignoring`
+      );
+
+      return false;
+    }
+
+    this.visibleDataSets.push(dataSetInfo);
+
+    return true;
+  }
+
   /**
    * Initializes a new visible data set by creating a hash tree for it, adding it to all the internal structures,
    * and sending an initial sync request to Locus with empty leaf data - that will trigger Locus to gives us all the data
@@ -180,7 +213,9 @@ class HashTreeParser {
       `HashTreeParser#initializeNewVisibleDataSet --> ${this.debugId} Adding visible data set "${dataSetInfo.name}"`
     );
 
-    this.visibleDataSets.push(visibleDataSetInfo);
+    if (!this.addToVisibleDataSetsList(visibleDataSetInfo)) {
+      return Promise.resolve({updateType: LocusInfoUpdateType.OBJECTS_UPDATED, updatedObjects: []});
+    }
 
     const hashTree = new HashTree([], dataSetInfo.leafCount);
 
@@ -328,10 +363,16 @@ class HashTreeParser {
       }
 
       if (!this.isVisibleDataSet(name)) {
-        this.visibleDataSets.push({
-          name,
-          url,
-        });
+        if (
+          !this.addToVisibleDataSetsList({
+            name,
+            url,
+          })
+        ) {
+          // dataset is excluded, skip it
+          // eslint-disable-next-line no-continue
+          continue;
+        }
       }
 
       if (!this.dataSets[name].hashTree) {
@@ -693,7 +734,9 @@ class HashTreeParser {
     // visibleDataSets can only be changed by Metadata object updates
     updatedObjects.forEach((object) => {
       if (isMetadata(object) && object.data?.visibleDataSets) {
-        const newVisibleDataSets = object.data.visibleDataSets;
+        const newVisibleDataSets = object.data.visibleDataSets.filter(
+          (vds) => !this.isExcludedDataSet(vds.name)
+        );
 
         removedDataSets = this.visibleDataSets.filter(
           (ds) => !newVisibleDataSets.some((nvs) => nvs.name === ds.name)
@@ -805,7 +848,10 @@ class HashTreeParser {
           `HashTreeParser#processVisibleDataSetChanges --> ${this.debugId} Adding visible data set "${ds.name}"`
         );
 
-        this.visibleDataSets.push(ds);
+        if (!this.addToVisibleDataSetsList(ds)) {
+          // eslint-disable-next-line no-continue
+          continue;
+        }
 
         const hashTree = new HashTree([], dataSetInfo.leafCount);
 

package/src/locus-info/index.ts

@@ -379,6 +379,7 @@ export default class LocusInfo extends EventsScope {
       webexRequest: this.webex.request.bind(this.webex),
       locusInfoUpdateCallback: this.updateFromHashTree.bind(this),
       debugId: `HT-${this.meetingId.substring(0, 4)}`,
+      excludedDataSets: this.webex.config.meetings.locus?.excludedDataSets,
     });
   }
 

package/src/meeting/index.ts

@@ -6214,14 +6214,10 @@ export default class Meeting extends StatelessWebexPlugin {
         return undefined;
       }
       // @ts-ignore - Fix type
-      await this.webex.internal.llm.disconnectLLM(
-        isJoined
-          ? {
-              code: 3050,
-              reason: 'done (permanent)',
-            }
-          : undefined
-      );
+      await this.webex.internal.llm.disconnectLLM({
+        code: 3050,
+        reason: 'done (permanent)',
+      });
       // @ts-ignore - Fix type
       this.webex.internal.llm.off('event:relay.event', this.processRelayEvent);
       // @ts-ignore - Fix type

package/test/unit/spec/hashTree/hashTreeParser.ts

@@ -165,7 +165,8 @@ describe('HashTreeParser', () => {
   // Helper to create a HashTreeParser instance with common defaults
   function createHashTreeParser(
     initialLocus: any = exampleInitialLocus,
-    metadata: any = exampleMetadata
+    metadata: any = exampleMetadata,
+    excludedDataSets?: string[]
   ) {
     return new HashTreeParser({
       initialLocus,
@@ -173,6 +174,7 @@ describe('HashTreeParser', () => {
       webexRequest,
       locusInfoUpdateCallback: callback,
       debugId: 'test',
+      excludedDataSets,
     });
   }
 
@@ -353,6 +355,66 @@ describe('HashTreeParser', () => {
     expect(emptySet.hashTree).to.be.undefined;
   });
 
+  it('should exclude datasets listed in excludedDataSets during initialization', () => {
+    const parser = createHashTreeParser(exampleInitialLocus, exampleMetadata, ['atd-unmuted']);
+
+    // 'atd-unmuted' should be excluded from visibleDataSets
+    expect(parser.visibleDataSets.some((vds) => vds.name === 'atd-unmuted')).to.be.false;
+
+    // 'main' and 'self' should still be visible
+    expect(parser.visibleDataSets.some((vds) => vds.name === 'main')).to.be.true;
+    expect(parser.visibleDataSets.some((vds) => vds.name === 'self')).to.be.true;
+
+    // 'atd-unmuted' dataset entry should exist but without a hash tree (because it's not visible)
+    expect(parser.dataSets['atd-unmuted']).to.exist;
+    expect(parser.dataSets['atd-unmuted'].hashTree).to.be.undefined;
+
+    // 'main' and 'self' should have hash trees
+    expect(parser.dataSets.main.hashTree).to.be.instanceOf(HashTree);
+    expect(parser.dataSets.self.hashTree).to.be.instanceOf(HashTree);
+  });
+
+  it('should exclude datasets listed in excludedDataSets when adding new visible datasets', async () => {
+    // Create parser without 'atd-unmuted' in initial metadata visibleDataSets
+    const metadataWithoutAtdUnmuted = {
+      ...exampleMetadata,
+      visibleDataSets: exampleMetadata.visibleDataSets.filter((vds) => vds.name !== 'atd-unmuted'),
+    };
+    const parser = createHashTreeParser(exampleInitialLocus, metadataWithoutAtdUnmuted, [
+      'atd-unmuted',
+    ]);
+
+    // 'atd-unmuted' should not be in visibleDataSets initially
+    expect(parser.visibleDataSets.some((vds) => vds.name === 'atd-unmuted')).to.be.false;
+
+    // Now simulate initializeDataSets which calls addToVisibleDataSetsList
+    const atdUnmutedDataSet = createDataSet('atd-unmuted', 16, 3000);
+
+    mockGetAllDataSetsMetadata(webexRequest, visibleDataSetsUrl, [
+      createDataSet('main', 16, 1000),
+      createDataSet('self', 1, 2000),
+      atdUnmutedDataSet,
+    ]);
+
+    mockSyncRequest(
+      webexRequest,
+      'https://locus-a.wbx2.com/locus/api/v1/loci/97d64a5f/datasets/atd-unmuted'
+    );
+
+    const message = {
+      dataSets: [createDataSet('main', 16, 1000)],
+      visibleDataSetsUrl,
+      locusUrl,
+    };
+    await parser.initializeFromMessage(message);
+
+    // 'atd-unmuted' should still not be in visibleDataSets because it is excluded
+    expect(parser.visibleDataSets.some((vds) => vds.name === 'atd-unmuted')).to.be.false;
+    // but 'main' and 'self' should be there
+    expect(parser.visibleDataSets.some((vds) => vds.name === 'main')).to.be.true;
+    expect(parser.visibleDataSets.some((vds) => vds.name === 'self')).to.be.true;
+  });
+
   // helper method, needed because both initializeFromMessage and initializeFromGetLociResponse
   // do almost exactly the same thing
   const testInitializationOfDatasetsAndHashTrees = async (testCallback) => {

package/test/unit/spec/meeting/index.js

@@ -12744,7 +12744,10 @@ describe('plugin-meetings', () => {
 
           const result = await meeting.updateLLMConnection();
 
-          assert.calledWith(webex.internal.llm.disconnectLLM, undefined);
+          assert.calledWith(webex.internal.llm.disconnectLLM, {
+            code: 3050,
+            reason: 'done (permanent)',
+          });
           assert.notCalled(webex.internal.llm.registerAndConnect);
           assert.equal(result, undefined);
           assert.calledWithExactly(