@webex/plugin-meetings 3.10.0-next.13 → 3.10.0-next.15

package/dist/locus-info/types.js.map

@@ -1 +1 @@
-{"version":3,"names":[],"sources":["types.ts"],"sourcesContent":["import {HtMeta} from '../hashTree/types';\n\nexport type LocusDTO = {\n  controls?: any;\n  fullState?: {\n    active: boolean;\n    count: number;\n    lastActive: string;\n    locked: boolean;\n    sessionId: string;\n    seessionIds: string[];\n    startTime: number;\n    state: string;\n    type: string;\n  };\n  host?: {\n    id: string;\n    incomingCallProtocols: any[];\n    isExternal: boolean;\n    name: string;\n    orgId: string;\n  };\n  htMeta?: HtMeta;\n  info?: any;\n  jsSdkMeta?: {\n    removedParticipantIds: string[]; // list of ids of participants that are removed in the last update\n  };\n  links?: any;\n  mediaShares?: any[];\n  meetings?: any[];\n  participants: any[];\n  replaces?: any[];\n  self?: any;\n  sequence?: {\n    dirtyParticipants: number;\n    entries: number[];\n    rangeEnd: number;\n    rangeStart: number;\n    sequenceHash: number;\n    sessionToken: string;\n    since: string;\n    totalParticipants: number;\n  };\n  syncUrl?: string;\n  url?: string;\n};\n"],"mappings":"","ignoreList":[]}
+{"version":3,"names":[],"sources":["types.ts"],"sourcesContent":["import {HtMeta} from '../hashTree/types';\n\nexport type LocusFullState = {\n  active: boolean;\n  count: number;\n  lastActive: string;\n  locked: boolean;\n  sessionId: string;\n  seessionIds: string[];\n  startTime: number;\n  state: string;\n  type: string;\n};\n\nexport type LocusDTO = {\n  controls?: any;\n  fullState?: LocusFullState;\n  host?: {\n    id: string;\n    incomingCallProtocols: any[];\n    isExternal: boolean;\n    name: string;\n    orgId: string;\n  };\n  htMeta?: HtMeta;\n  info?: any;\n  jsSdkMeta?: {\n    removedParticipantIds: string[]; // list of ids of participants that are removed in the last update\n  };\n  links?: any;\n  mediaShares?: any[];\n  meetings?: any[];\n  participants: any[];\n  replaces?: any[];\n  self?: any;\n  sequence?: {\n    dirtyParticipants: number;\n    entries: number[];\n    rangeEnd: number;\n    rangeStart: number;\n    sequenceHash: number;\n    sessionToken: string;\n    since: string;\n    totalParticipants: number;\n  };\n  syncUrl?: string;\n  url?: string;\n};\n"],"mappings":"","ignoreList":[]}

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

@@ -0,0 +1,8 @@
+export declare const EMPTY_HASH = "99aa06d3014798d86001c324468d497f";
+export declare const DataSetNames: {
+    MAIN: string;
+    ATTENDEES: string;
+    ATD_ACTIVE: string;
+    ATD_UNMUTED: string;
+    SELF: string;
+};

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

@@ -0,0 +1,129 @@
+import { ObjectType } from './types';
+export type LeafDataItem = {
+    type: ObjectType;
+    id: number;
+    version: number;
+};
+/**
+ * HashTree is a data structure that organizes items into leaves based on their IDs,
+ */
+declare class HashTree {
+    leaves: Array<Record<string, Record<number, LeafDataItem>>>;
+    leafHashes: Array<string>;
+    readonly numLeaves: number;
+    /**
+     * Constructs a new HashTree.
+     * @param {LeafDataItem[]} leafData Initial data to populate the tree.
+     * @param {number} numLeaves The number of leaf nodes in the tree. Must be 0 or a power of 2.
+     * @throws {Error} If numLeaves is not 0 or a power of 2.
+     */
+    constructor(leafData: LeafDataItem[], numLeaves: number);
+    /**
+     * Internal logic for adding or updating an item, without computing the leaf hash.
+     * @param {LeafDataItem} item The item to add or update.
+     * @returns {{put: boolean, index: (number|null)}} Object indicating if put and the leaf index.
+     * @private
+     */
+    private _putItemInternal;
+    /**
+     * Adds or updates a single item in the hash tree.
+     * @param {LeafDataItem} item The item to add or update.
+     * @returns {boolean} True if the item was added or updated, false otherwise (e.g., older version or tree has 0 leaves).
+     */
+    putItem(item: LeafDataItem): boolean;
+    /**
+     * Adds or updates multiple items in the hash tree.
+     * @param {LeafDataItem[]} items The array of items to add or update.
+     * @returns {boolean[]} An array of booleans indicating success for each item.
+     */
+    putItems(items: LeafDataItem[]): boolean[];
+    /**
+     * Internal logic for removing an item, without computing the leaf hash.
+     * @param {LeafDataItem} item The item to remove.
+     * @returns {{removed: boolean, index: (number|null)}} Object indicating if removed and the leaf index.
+     * @private
+     */
+    private _removeItemInternal;
+    /**
+     * Removes a single item from the hash tree.
+     * The removal is based on matching type, id, and the provided item's version
+     * being greater than or equal to the existing item's version.
+     * @param {LeafDataItem} item The item to remove.
+     * @returns {boolean} True if the item was removed, false otherwise.
+     */
+    removeItem(item: LeafDataItem): boolean;
+    /**
+     * Removes multiple items from the hash tree.
+     * @param {LeafDataItem[]} items The array of items to remove.
+     * @returns {boolean[]} An array of booleans indicating success for each item.
+     */
+    removeItems(items: LeafDataItem[]): boolean[];
+    /**
+     * Updates multiple items in the hash tree.
+     * This method can handle both updating and removing items based on the `operation` flag.
+     *
+     * @param {object[]} itemUpdates An array of objects containing `operation` flag and the `item` to update.
+     * @returns {boolean[]} An array of booleans indicating success for each operation.
+     */
+    updateItems(itemUpdates: {
+        operation: 'update' | 'remove';
+        item: LeafDataItem;
+    }[]): boolean[];
+    /**
+     * Computes the hash for a specific leaf.
+     * The hash is based on the sorted items within the leaf.
+     * @param {number} index The index of the leaf to compute the hash for.
+     * @returns {void}
+     */
+    computeLeafHash(index: number): void;
+    /**
+     * Computes all internal and leaf node hashes of the tree.
+     * Internal node hashes are computed bottom-up from the leaf hashes.
+     * @returns {string[]} An array of hash strings, with internal node hashes first, followed by leaf hashes.
+     * Returns `[EMPTY_HASH]` if the tree has 0 leaves.
+     */
+    computeTreeHashes(): string[];
+    /**
+     * Returns all hashes in the tree (internal nodes then leaf nodes).
+     * @returns {string[]} An array of hash strings.
+     */
+    getHashes(): string[];
+    /**
+     * Computes and returns the hash value of the root node.
+     * @returns {string} The root hash of the entire tree. Returns `EMPTY_HASH` if the tree has 0 leaves.
+     */
+    getRootHash(): string;
+    /**
+     * Gets the number of leaves in the tree.
+     * @returns {number} The number of leaves.
+     */
+    getLeafCount(): number;
+    /**
+     * Calculates the total number of items stored in the tree.
+     * @returns {number} The total number of items.
+     */
+    getTotalItemCount(): number;
+    /**
+     * Retrieves all data items from a specific leaf.
+     * @param {number} leafIndex The index of the leaf.
+     * @returns {LeafDataItem[]} An array of LeafDataItem in the specified leaf, sorted by ID,
+     * or an empty array if the index is invalid or leaf is empty.
+     */
+    getLeafData(leafIndex: number): LeafDataItem[];
+    /**
+     * Resizes the HashTree to have a new number of leaf nodes, redistributing all existing items.
+     * @param {number} newNumLeaves The new number of leaf nodes (must be 0 or a power of 2).
+     * @returns {boolean} true if the tree was resized, false if the size didn't change.
+     * @throws {Error} if newNumLeaves is not 0 or a power of 2.
+     */
+    resize(newNumLeaves: number): boolean;
+    /**
+     * Compares the tree's leaf hashes with an external set of hashes and returns the indices of differing leaf nodes.
+     * The externalHashes array is expected to contain all node hashes (internal followed by leaves),
+     * similar to the output of getHashes().
+     * @param {string[]} externalHashes An array of hash strings (internal node hashes then leaf hashes).
+     * @returns {number[]} An array of indices of the leaf nodes that have different hashes.
+     */
+    diffHashes(externalHashes: string[]): number[];
+}
+export default HashTree;

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

@@ -1,3 +1,4 @@
+import HashTree from './hashTree';
 import { Enum } from '../constants';
 import { HtMeta } from './types';
 import { LocusDTO } from '../locus-info/types';
@@ -28,6 +29,7 @@ export interface HashTreeMessage {
     locusUrl: string;
 }
 interface InternalDataSet extends DataSet {
+    hashTree?: HashTree;
     timer?: ReturnType<typeof setTimeout>;
 }
 type WebexRequestMethod = (options: Record<string, any>) => Promise<any>;
@@ -69,6 +71,30 @@ declare class HashTreeParser {
         locusInfoUpdateCallback: LocusInfoUpdateCallback;
         debugId: string;
     });
+    /**
+     * 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
+     * from that dataset (in the response or via messages).
+     *
+     * @param {DataSet} dataSet The new data set to be added
+     * @returns {Promise}
+     */
+    private initializeNewVisibleDataSet;
+    /**
+     * Sends a special sync request to Locus with all leaves empty - this is a way to get all the data for a given dataset.
+     *
+     * @param {string} datasetName - name of the dataset for which to send the request
+     * @param {string} debugText - text to include in logs
+     * @returns {Promise}
+     */
+    private sendInitializationSyncRequestToLocus;
+    /**
+     * Queries Locus for information about all the data sets
+     *
+     * @param {string} url - url from which we can get info about all data sets
+     * @returns {Promise}
+     */
+    private getAllDataSetsMetadata;
     /**
      * Initializes the hash tree parser from a message received from Locus.
      *
@@ -86,6 +112,39 @@ declare class HashTreeParser {
      * @returns {Promise}
      */
     initializeFromGetLociResponse(locus: LocusDTO): Promise<void>;
+    /**
+     * Initializes data sets by doing an initialization sync on each visible data set that doesn't have a hash tree yet.
+     *
+     * @param {DataSet[]} dataSets Array of DataSet objects to initialize
+     * @param {string} debugText Text to include in logs for debugging purposes
+     * @returns {Promise}
+     */
+    private initializeDataSets;
+    /**
+     * Each dataset exists at a different place in the dto
+     * iterate recursively over the locus and if it has a htMeta key,
+     * create an object with the type, id and version and add it to the appropriate leafData array
+     *
+     * @param {any} locus - The current part of the locus being processed
+     * @param {Object} [options]
+     * @param {boolean} [options.copyData=false] - Whether to copy the data for each leaf into returned result
+     * @returns {any} - An object mapping dataset names to arrays of leaf data
+     */
+    private analyzeLocusHtMeta;
+    /**
+     * Checks if the provided hash tree message indicates the end of the meeting and that there won't be any more updates.
+     *
+     * @param {HashTreeMessage} message - The hash tree message to check
+     * @returns {boolean} - Returns true if the message indicates the end of the meeting, false otherwise
+     */
+    private isEndMessage;
+    /**
+     * Handles the root hash heartbeat message
+     *
+     * @param {RootHashMessage} message - The root hash heartbeat message
+     * @returns {void}
+     */
+    private handleRootHashHeartBeatMessage;
     /**
      * This method should be called when we receive a partial locus DTO that contains dataSets and htMeta information
      * It updates the hash trees with the new leaf data based on the received Locus
@@ -97,6 +156,58 @@ declare class HashTreeParser {
         dataSets?: Array<DataSet>;
         locus: any;
     }): void;
+    /**
+     * Updates the internal data set information based on the received data set from Locus.
+     *
+     * @param {DataSet} receivedDataSet - The latest data set information received from Locus to update the internal state.
+     * @returns {void}
+     */
+    private updateDataSetInfo;
+    /**
+     * Checks for changes in the visible data sets based on the updated objects.
+     * @param {HashTreeObject[]} updatedObjects - The list of updated hash tree objects.
+     * @returns {Object} An object containing the removed and added visible data sets.
+     */
+    private checkForVisibleDataSetChanges;
+    /**
+     * Deletes the hash tree for the specified data set.
+     *
+     * @param {string} dataSetName name of the data set to delete
+     * @returns {void}
+     */
+    private deleteHashTree;
+    /**
+     * Adds entries to the passed in updateObjects array
+     * for the changes that result from removing visible data sets and creates hash
+     * trees for the new visible data sets, but without populating the hash trees.
+     *
+     * This function is synchronous. If we are missing information about some new
+     * visible data sets and they require async initialization, the names of these data sets
+     * are returned in an array.
+     *
+     * @param {string[]} removedDataSets - The list of removed data sets.
+     * @param {string[]} addedDataSets - The list of added data sets.
+     * @param {HashTreeObject[]} updatedObjects - The list of updated hash tree objects to which changes will be added.
+     * @returns {string[]} names of data sets that couldn't be initialized synchronously
+     */
+    private processVisibleDataSetChanges;
+    /**
+     * Adds entries to the passed in updateObjects array
+     * for the changes that result from adding and removing visible data sets.
+     *
+     * @param {HashTreeMessage} message - The hash tree message that triggered the visible data set changes.
+     * @param {string[]} addedDataSets - The list of added data sets.
+     * @returns {Promise<void>}
+     */
+    private initializeNewVisibleDataSets;
+    /**
+     * Parses incoming hash tree messages, updates the hash trees and returns information about the changes
+     *
+     * @param {HashTreeMessage} message - The hash tree message containing data sets and objects to be processed
+     * @param {string} [debugText] - Optional debug text to include in logs
+     * @returns {Promise}
+     */
+    private parseMessage;
     /**
      * Handles incoming hash tree messages, updates the hash trees and calls locusInfoUpdateCallback
      *
@@ -105,5 +216,45 @@ declare class HashTreeParser {
      * @returns {void}
      */
     handleMessage(message: HashTreeMessage, debugText?: string): Promise<void>;
+    /**
+     * Calls the updateInfo callback if there are any updates to report
+     *
+     * @param {Object} updates parsed from a Locus message
+     * @returns {void}
+     */
+    private callLocusInfoUpdateCallback;
+    /**
+     * Calculates a weighted backoff time that should be used for syncs
+     *
+     * @param {Object} backoff - The backoff configuration containing maxMs and exponent
+     * @returns {number} - A weighted backoff time based on the provided configuration, using algorithm supplied by Locus team
+     */
+    private getWeightedBackoffTime;
+    /**
+     * Runs the sync algorithm for the given data set.
+     *
+     * @param {DataSet} receivedDataSet - The data set to run the sync algorithm for.
+     * @returns {void}
+     */
+    private runSyncAlgorithm;
+    /**
+     * Stops all timers for the data sets to prevent any further sync attempts.
+     * @returns {void}
+     */
+    private stopAllTimers;
+    /**
+     * Gets the current hashes from the locus for a specific data set.
+     * @param {string} dataSetName
+     * @returns {string[]}
+     */
+    private getHashesFromLocus;
+    /**
+     * Sends a sync request to Locus for the specified data set.
+     *
+     * @param {InternalDataSet} dataSet The data set to sync.
+     * @param {Record<number, LeafDataItem[]>} mismatchedLeavesData The mismatched leaves data to include in the sync request.
+     * @returns {Promise<HashTreeMessage|null>}
+     */
+    private sendSyncRequestToLocus;
 }
 export default HashTreeParser;

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

@@ -4,8 +4,17 @@ export declare const ObjectType: {
     readonly self: "self";
     readonly locus: "locus";
     readonly mediaShare: "mediashare";
+    readonly info: "info";
+    readonly fullState: "fullstate";
 };
 export type ObjectType = Enum<typeof ObjectType>;
+export declare const ObjectTypeToLocusKeyMap: {
+    info: string;
+    fullstate: string;
+    self: string;
+    participant: string;
+    mediashare: string;
+};
 export interface HtMeta {
     elementId: {
         type: ObjectType;

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

@@ -0,0 +1,9 @@
+/**
+ * Analyzes given part of Locus DTO recursively and delete any nested objects that have their own htMeta
+ *
+ * @param {Object} currentLocusPart part of locus DTO to analyze
+ * @param {Object} parent parent object
+ * @param {string|number} currentKey key of the parent object that currentLocusPart is
+ * @returns {void}
+ */
+export declare const deleteNestedObjectsWithHtMeta: (currentLocusPart: any, parent?: any, currentKey?: string | number) => void;

package/dist/types/locus-info/types.d.ts

@@ -1,17 +1,18 @@
 import { HtMeta } from '../hashTree/types';
+export type LocusFullState = {
+    active: boolean;
+    count: number;
+    lastActive: string;
+    locked: boolean;
+    sessionId: string;
+    seessionIds: string[];
+    startTime: number;
+    state: string;
+    type: string;
+};
 export type LocusDTO = {
     controls?: any;
-    fullState?: {
-        active: boolean;
-        count: number;
-        lastActive: string;
-        locked: boolean;
-        sessionId: string;
-        seessionIds: string[];
-        startTime: number;
-        state: string;
-        type: string;
-    };
+    fullState?: LocusFullState;
     host?: {
         id: string;
         incomingCallProtocols: any[];

package/dist/webinar/index.js

@@ -448,7 +448,7 @@ var Webinar = _webexCore.WebexPlugin.extend({
       }, _callee7);
     }))();
   },
-  version: "3.10.0-next.13"
+  version: "3.10.0-next.15"
 });
 var _default = exports.default = Webinar;
 //# sourceMappingURL=index.js.map

package/package.json

@@ -43,12 +43,12 @@
     "@webex/eslint-config-legacy": "0.0.0",
     "@webex/jest-config-legacy": "0.0.0",
     "@webex/legacy-tools": "0.0.0",
-    "@webex/plugin-rooms": "3.10.0-next.5",
-    "@webex/test-helper-chai": "3.8.1-next.11",
-    "@webex/test-helper-mocha": "3.8.1-next.11",
-    "@webex/test-helper-mock-webex": "3.8.1-next.11",
-    "@webex/test-helper-retry": "3.8.1-next.11",
-    "@webex/test-helper-test-users": "3.8.1-next.11",
+    "@webex/plugin-rooms": "3.10.0-next.7",
+    "@webex/test-helper-chai": "3.10.0-next.1",
+    "@webex/test-helper-mocha": "3.10.0-next.1",
+    "@webex/test-helper-mock-webex": "3.10.0-next.1",
+    "@webex/test-helper-retry": "3.10.0-next.1",
+    "@webex/test-helper-test-users": "3.10.0-next.1",
     "chai": "^4.3.4",
     "chai-as-promised": "^7.1.1",
     "eslint": "^8.24.0",
@@ -60,23 +60,23 @@
     "typescript": "^4.7.4"
   },
   "dependencies": {
-    "@webex/common": "3.8.1-next.11",
+    "@webex/common": "3.10.0-next.1",
     "@webex/event-dictionary-ts": "^1.0.1930",
     "@webex/internal-media-core": "2.20.3",
-    "@webex/internal-plugin-conversation": "3.10.0-next.5",
-    "@webex/internal-plugin-device": "3.10.0-next.5",
-    "@webex/internal-plugin-llm": "3.10.0-next.5",
-    "@webex/internal-plugin-mercury": "3.10.0-next.5",
-    "@webex/internal-plugin-metrics": "3.10.0-next.5",
-    "@webex/internal-plugin-support": "3.10.0-next.5",
-    "@webex/internal-plugin-user": "3.10.0-next.5",
-    "@webex/internal-plugin-voicea": "3.10.0-next.7",
-    "@webex/media-helpers": "3.10.0-next.2",
-    "@webex/plugin-people": "3.10.0-next.5",
-    "@webex/plugin-rooms": "3.10.0-next.5",
+    "@webex/internal-plugin-conversation": "3.10.0-next.7",
+    "@webex/internal-plugin-device": "3.10.0-next.7",
+    "@webex/internal-plugin-llm": "3.10.0-next.7",
+    "@webex/internal-plugin-mercury": "3.10.0-next.7",
+    "@webex/internal-plugin-metrics": "3.10.0-next.7",
+    "@webex/internal-plugin-support": "3.10.0-next.7",
+    "@webex/internal-plugin-user": "3.10.0-next.7",
+    "@webex/internal-plugin-voicea": "3.10.0-next.9",
+    "@webex/media-helpers": "3.10.0-next.3",
+    "@webex/plugin-people": "3.10.0-next.7",
+    "@webex/plugin-rooms": "3.10.0-next.7",
     "@webex/ts-sdp": "^1.8.1",
     "@webex/web-capabilities": "^1.7.1",
-    "@webex/webex-core": "3.10.0-next.5",
+    "@webex/webex-core": "3.10.0-next.7",
     "ampersand-collection": "^2.0.2",
     "bowser": "^2.11.0",
     "btoa": "^1.2.1",
@@ -87,10 +87,11 @@
     "jwt-decode": "3.1.2",
     "lodash": "^4.17.21",
     "uuid": "^3.3.2",
-    "webrtc-adapter": "^8.1.2"
+    "webrtc-adapter": "^8.1.2",
+    "xxh3-ts": "^2.0.1"
   },
   "//": [
     "TODO: upgrade jwt-decode when moving to node 18"
   ],
-  "version": "3.10.0-next.13"
+  "version": "3.10.0-next.15"
 }

package/src/hashTree/constants.ts

@@ -0,0 +1,9 @@
+export const EMPTY_HASH = '99aa06d3014798d86001c324468d497f';
+
+export const DataSetNames = {
+  MAIN: 'main', // sent to web client, contains also panelists, over LLM
+  ATTENDEES: 'attendees', // NOT SENT to web client, all the attendees in the locus
+  ATD_ACTIVE: 'atd-active', // only sent to panelists, over LLM; the attendees that have their hands raised or are allowed to unmute themselves
+  ATD_UNMUTED: 'atd-unmuted', // sent to web client, over LLM, not sent to panelists; the attendees that are unmuted
+  SELF: 'self', // sent to web client, over Mercury
+};