@webex/plugin-meetings 3.10.0-next.3 → 3.10.0-next.30

package/dist/types/meetings/index.d.ts

@@ -5,10 +5,17 @@ import { WebexPlugin } from '@webex/webex-core';
 import { DeviceRegistrationOptions } from '@webex/internal-plugin-device';
 import * as mediaHelpersModule from '@webex/media-helpers';
 import 'webrtc-adapter';
-import { DESTINATION_TYPE } from '../constants';
+import { LOCUSEVENT, DESTINATION_TYPE } from '../constants';
 import { CallStateForMetrics } from '../meeting';
 import Reachability from '../reachability';
 import { INoiseReductionEffect, IVirtualBackgroundEffect, MeetingRegistrationStatus } from './meetings.types';
+import { HashTreeMessage } from '../hashTree/hashTreeParser';
+export type LocusEvent = {
+    eventType: LOCUSEVENT;
+    locusUrl?: string;
+    locus?: any;
+    stateElementsMessage?: HashTreeMessage;
+};
 /**
  * Meetings Ready Event
  * Emitted when the meetings instance on webex is ready
@@ -129,7 +136,7 @@ export default class Meetings extends WebexPlugin {
      * @private
      * @memberof Meetings
      */
-    getCorrespondingMeetingByLocus(data: any): any;
+    getCorrespondingMeetingByLocus(data: LocusEvent): any;
     /**
      * handle locus events and takes meeting actions with them as they come in
      * @param {Object} data a locus event

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

@@ -84,5 +84,7 @@ declare const BEHAVIORAL_METRICS: {
     VERIFY_REGISTRATION_ID_ERROR: string;
     JOIN_FORBIDDEN_ERROR: string;
     MEDIA_ISSUE_DETECTED: string;
+    LOCUS_CLASSIC_VS_HASH_TREE_MISMATCH: string;
+    LOCUS_HASH_TREE_UNSUPPORTED_OPERATION: string;
 };
 export { BEHAVIORAL_METRICS as default };

package/dist/types/reachability/clusterReachability.d.ts

@@ -23,115 +23,64 @@ export declare const Events: {
 export type Events = Enum<typeof Events>;
 /**
  * A class that handles reachability checks for a single cluster.
- * It emits events from Events enum
+ * Creates and orchestrates ReachabilityPeerConnection instance(s).
+ * Listens to events and emits them to consumers.
+ *
+ * When enablePerUdpUrlReachability is true:
+ *   - Creates one ReachabilityPeerConnection for each UDP URL
+ *   - Creates one ReachabilityPeerConnection for all TCP and TLS URLs together
+ * Otherwise:
+ *   - Creates a single ReachabilityPeerConnection for all URLs
  */
 export declare class ClusterReachability extends EventsScope {
-    private numUdpUrls;
-    private numTcpUrls;
-    private numXTlsUrls;
-    private result;
-    private pc?;
-    private defer;
-    private startTimestamp;
-    private srflxIceCandidates;
+    private reachabilityPeerConnection;
+    private reachabilityPeerConnectionsForUdp;
     readonly isVideoMesh: boolean;
     readonly name: any;
     readonly reachedSubnets: Set<string>;
+    private enablePerUdpUrlReachability;
+    private udpResultEmitted;
     /**
      * Constructor for ClusterReachability
      * @param {string} name cluster name
      * @param {ClusterNode} clusterInfo information about the media cluster
+     * @param {boolean} enablePerUdpUrlReachability whether to create separate peer connections per UDP URL
      */
-    constructor(name: string, clusterInfo: ClusterNode);
+    constructor(name: string, clusterInfo: ClusterNode, enablePerUdpUrlReachability?: boolean);
     /**
-     * Gets total elapsed time, can be called only after start() is called
-     * @returns {Number} Milliseconds
-     */
-    private getElapsedTime;
-    /**
-     * Generate peerConnection config settings
-     * @param {ClusterNode} cluster
-     * @returns {RTCConfiguration} peerConnectionConfig
-     */
-    private buildPeerConnectionConfig;
-    /**
-     * Creates an RTCPeerConnection
+     * Initializes a single ReachabilityPeerConnection for all protocols
      * @param {ClusterNode} clusterInfo information about the media cluster
-     * @returns {RTCPeerConnection} peerConnection
-     */
-    private createPeerConnection;
-    /**
-     * @returns {ClusterReachabilityResult} reachability result for this cluster
-     */
-    getResult(): ClusterReachabilityResult;
-    /**
-     * Closes the peerConnection
-     *
      * @returns {void}
      */
-    private closePeerConnection;
+    private initializeSingleReachabilityPeerConnection;
     /**
-     * Resolves the defer, indicating that reachability checks for this cluster are completed
-     *
-     * @returns {void}
-     */
-    private finishReachabilityCheck;
-    /**
-     * Aborts the cluster reachability checks by closing the peer connection
-     *
-     * @returns {void}
-     */
-    abort(): void;
-    /**
-     * Adds public IP (client media IPs)
-     * @param {string} protocol
-     * @param {string} publicIP
-     * @returns {void}
-     */
-    private addPublicIP;
-    /**
-     * Registers a listener for the iceGatheringStateChange event
-     *
-     * @returns {void}
-     */
-    private registerIceGatheringStateChangeListener;
-    /**
-     * Saves the latency in the result for the given protocol and marks it as reachable,
-     * emits the "resultReady" event if this is the first result for that protocol,
-     * emits the "clientMediaIpsUpdated" event if we already had a result and only found
-     * a new client IP
-     *
-     * @param {string} protocol
-     * @param {number} latency
-     * @param {string|null} [publicIp]
-     * @param {string|null} [serverIp]
+     * Initializes per-URL UDP reachability checks:
+     * - One ReachabilityPeerConnection per UDP URL
+     * - One ReachabilityPeerConnection for all TCP and TLS URLs together
+     * @param {ClusterNode} clusterInfo information about the media cluster
      * @returns {void}
      */
-    private saveResult;
+    private initializePerUdpUrlReachabilityCheck;
     /**
-     * Determines NAT Type.
-     *
-     * @param {RTCIceCandidate} candidate
+     * Sets up event listeners for a ReachabilityPeerConnection instance
+     * @param {ReachabilityPeerConnection} rpc the ReachabilityPeerConnection instance
+     * @param {boolean} isUdpPerUrl whether this is a per-URL UDP instance
      * @returns {void}
      */
-    private determineNatType;
+    private setupReachabilityPeerConnectionEventListeners;
     /**
-     * Registers a listener for the icecandidate event
-     *
-     * @returns {void}
+     * Gets the aggregated reachability result for this cluster.
+     * @returns {ClusterReachabilityResult} reachability result for this cluster
      */
-    private registerIceCandidateListener;
+    getResult(): ClusterReachabilityResult;
     /**
-     * Starts the process of doing UDP and TCP reachability checks on the media cluster.
-     * XTLS reachability checking is not supported.
-     *
-     * @returns {Promise}
+     * Starts the process of doing UDP, TCP, and XTLS reachability checks on the media cluster.
+     * @returns {Promise<ClusterReachabilityResult>}
      */
     start(): Promise<ClusterReachabilityResult>;
     /**
-     * Starts the process of gathering ICE candidates
-     *
-     * @returns {Promise} promise that's resolved once reachability checks for this cluster are completed or timeout is reached
+     * Aborts the cluster reachability checks
+     * @returns {void}
      */
-    private gatherIceCandidates;
+    abort(): void;
 }

package/dist/types/reachability/reachability.types.d.ts

@@ -1,4 +1,15 @@
-import { IP_VERSION } from '../constants';
+import { IP_VERSION, Enum } from '../constants';
+export type Protocol = 'udp' | 'tcp' | 'xtls';
+/**
+ * Events emitted by ReachabilityPeerConnection
+ */
+export declare const ReachabilityPeerConnectionEvents: {
+    readonly resultReady: "resultReady";
+    readonly clientMediaIpsUpdated: "clientMediaIpsUpdated";
+    readonly natTypeUpdated: "natTypeUpdated";
+    readonly reachedSubnets: "reachedSubnets";
+};
+export type ReachabilityPeerConnectionEvents = Enum<typeof ReachabilityPeerConnectionEvents>;
 export type TransportResult = {
     result: 'reachable' | 'unreachable' | 'untested';
     latencyInMilliseconds?: number;

package/dist/types/reachability/reachabilityPeerConnection.d.ts

@@ -0,0 +1,111 @@
+import { ClusterNode } from './request';
+import EventsScope from '../common/events/events-scope';
+import { ClusterReachabilityResult } from './reachability.types';
+/**
+ * A class to handle RTCPeerConnection lifecycle and ICE candidate gathering for reachability checks.
+ * It will do all the work like PeerConnection lifecycle, candidate processing, result management, and event emission.
+ */
+export declare class ReachabilityPeerConnection extends EventsScope {
+    numUdpUrls: number;
+    numTcpUrls: number;
+    numXTlsUrls: number;
+    private pc;
+    private defer;
+    private startTimestamp;
+    private srflxIceCandidates;
+    private clusterName;
+    private result;
+    private emittedSubnets;
+    /**
+     * Constructor for ReachabilityPeerConnection
+     * @param {string} clusterName name of the cluster
+     * @param {ClusterNode} clusterInfo information about the media cluster
+     */
+    constructor(clusterName: string, clusterInfo: ClusterNode);
+    /**
+     * Gets total elapsed time, can be called only after start() is called
+     * @returns {number} Milliseconds
+     */
+    private getElapsedTime;
+    /**
+     * Generate peerConnection config settings
+     * @param {ClusterNode} cluster
+     * @returns {RTCConfiguration} peerConnectionConfig
+     */
+    private static buildPeerConnectionConfig;
+    /**
+     * Creates an RTCPeerConnection
+     * @param {ClusterNode} clusterInfo information about the media cluster
+     * @returns {RTCPeerConnection|null} peerConnection
+     */
+    private createPeerConnection;
+    /**
+     * @returns {ClusterReachabilityResult} reachability result for this instance
+     */
+    getResult(): ClusterReachabilityResult;
+    /**
+     * Closes the peerConnection
+     * @returns {void}
+     */
+    private closePeerConnection;
+    /**
+     * Resolves the defer, indicating that reachability checks for this cluster are completed
+     *
+     * @returns {void}
+     */
+    private finishReachabilityCheck;
+    /**
+     * Aborts the cluster reachability checks by closing the peer connection
+     *
+     * @returns {void}
+     */
+    abort(): void;
+    /**
+     * Adds public IP (client media IPs)
+     * @param {string} protocol
+     * @param {string} publicIp
+     * @returns {void}
+     */
+    private addPublicIp;
+    /**
+     * Registers a listener for the iceGatheringStateChange event
+     *
+     * @returns {void}
+     */
+    private registerIceGatheringStateChangeListener;
+    /**
+     * Saves the latency in the result for the given protocol and marks it as reachable,
+     * emits the "resultReady" event if this is the first result for that protocol,
+     * emits the "clientMediaIpsUpdated" event if we already had a result and only found
+     * a new client IP
+     *
+     * @param {string} protocol
+     * @param {number} latency
+     * @param {string|null} [publicIp]
+     * @param {string|null} [serverIp]
+     * @returns {void}
+     */
+    private saveResult;
+    /**
+     * Determines NAT type by analyzing server reflexive candidate patterns
+     * @param {RTCIceCandidate} candidate server reflexive candidate
+     * @returns {void}
+     */
+    private determineNatTypeForSrflxCandidate;
+    /**
+     * Registers a listener for the icecandidate event
+     *
+     * @returns {void}
+     */
+    private registerIceCandidateListener;
+    /**
+     * Starts the process of doing UDP, TCP, and XTLS reachability checks.
+     * @returns {Promise<ClusterReachabilityResult>}
+     */
+    start(): Promise<ClusterReachabilityResult>;
+    /**
+     * Starts the process of gathering ICE candidates
+     * @returns {Promise} promise that's resolved once reachability checks are completed or timeout is reached
+     */
+    private gatherIceCandidates;
+}

package/dist/webinar/collection.js

@@ -21,7 +21,7 @@ var WebinarCollection = /*#__PURE__*/function () {
     (0, _defineProperty2.default)(this, "mainIndex", 'sessionId');
     this.webinarInfo = {};
   }
-  (0, _createClass2.default)(WebinarCollection, [{
+  return (0, _createClass2.default)(WebinarCollection, [{
     key: "set",
     value: function set(id, info) {
       this.webinarInfo[id] = info;
@@ -37,7 +37,6 @@ var WebinarCollection = /*#__PURE__*/function () {
       return this.webinarInfo[id];
     }
   }]);
-  return WebinarCollection;
 }();
 var _default = exports.default = WebinarCollection;
 //# sourceMappingURL=collection.js.map

package/dist/webinar/collection.js.map

@@ -1 +1 @@
-{"version":3,"names":["_constants","require","WebinarCollection","_classCallCheck2","default","_defineProperty2","MEETINGS","webinarInfo","_createClass2","key","value","set","id","info","get","_default","exports"],"sources":["collection.ts"],"sourcesContent":["/*!\n * Copyright (c) 2015-2023 Cisco Systems, Inc. See LICENSE file.\n */\n\nimport {MEETINGS} from '../constants';\n\nclass WebinarCollection {\n  webinarInfo: any;\n\n  namespace = MEETINGS;\n\n  mainIndex = 'sessionId';\n\n  constructor() {\n    this.webinarInfo = {};\n  }\n\n  set(id, info) {\n    this.webinarInfo[id] = info;\n  }\n\n  /**\n   * @param {String} id\n   * @returns {Member}\n   */\n  get(id: string) {\n    return this.webinarInfo[id];\n  }\n}\n\nexport default WebinarCollection;\n"],"mappings":";;;;;;;;;;;AAIA,IAAAA,UAAA,GAAAC,OAAA;AAJA;AACA;AACA;AAFA,IAMMC,iBAAiB;EAOrB,SAAAA,kBAAA,EAAc;IAAA,IAAAC,gBAAA,CAAAC,OAAA,QAAAF,iBAAA;IAAA,IAAAG,gBAAA,CAAAD,OAAA;IAAA,IAAAC,gBAAA,CAAAD,OAAA,qBAJFE,mBAAQ;IAAA,IAAAD,gBAAA,CAAAD,OAAA,qBAER,WAAW;IAGrB,IAAI,CAACG,WAAW,GAAG,CAAC,CAAC;EACvB;EAAC,IAAAC,aAAA,CAAAJ,OAAA,EAAAF,iBAAA;IAAAO,GAAA;IAAAC,KAAA,EAED,SAAAC,IAAIC,EAAE,EAAEC,IAAI,EAAE;MACZ,IAAI,CAACN,WAAW,CAACK,EAAE,CAAC,GAAGC,IAAI;IAC7B;;IAEA;AACF;AACA;AACA;EAHE;IAAAJ,GAAA;IAAAC,KAAA,EAIA,SAAAI,IAAIF,EAAU,EAAE;MACd,OAAO,IAAI,CAACL,WAAW,CAACK,EAAE,CAAC;IAC7B;EAAC;EAAA,OAAAV,iBAAA;AAAA;AAAA,IAAAa,QAAA,GAAAC,OAAA,CAAAZ,OAAA,GAGYF,iBAAiB"}
+{"version":3,"names":["_constants","require","WebinarCollection","_classCallCheck2","default","_defineProperty2","MEETINGS","webinarInfo","_createClass2","key","value","set","id","info","get","_default","exports"],"sources":["collection.ts"],"sourcesContent":["/*!\n * Copyright (c) 2015-2023 Cisco Systems, Inc. See LICENSE file.\n */\n\nimport {MEETINGS} from '../constants';\n\nclass WebinarCollection {\n  webinarInfo: any;\n\n  namespace = MEETINGS;\n\n  mainIndex = 'sessionId';\n\n  constructor() {\n    this.webinarInfo = {};\n  }\n\n  set(id, info) {\n    this.webinarInfo[id] = info;\n  }\n\n  /**\n   * @param {String} id\n   * @returns {Member}\n   */\n  get(id: string) {\n    return this.webinarInfo[id];\n  }\n}\n\nexport default WebinarCollection;\n"],"mappings":";;;;;;;;;;;AAIA,IAAAA,UAAA,GAAAC,OAAA;AAJA;AACA;AACA;AAFA,IAMMC,iBAAiB;EAOrB,SAAAA,kBAAA,EAAc;IAAA,IAAAC,gBAAA,CAAAC,OAAA,QAAAF,iBAAA;IAAA,IAAAG,gBAAA,CAAAD,OAAA;IAAA,IAAAC,gBAAA,CAAAD,OAAA,qBAJFE,mBAAQ;IAAA,IAAAD,gBAAA,CAAAD,OAAA,qBAER,WAAW;IAGrB,IAAI,CAACG,WAAW,GAAG,CAAC,CAAC;EACvB;EAAC,WAAAC,aAAA,CAAAJ,OAAA,EAAAF,iBAAA;IAAAO,GAAA;IAAAC,KAAA,EAED,SAAAC,GAAGA,CAACC,EAAE,EAAEC,IAAI,EAAE;MACZ,IAAI,CAACN,WAAW,CAACK,EAAE,CAAC,GAAGC,IAAI;IAC7B;;IAEA;AACF;AACA;AACA;EAHE;IAAAJ,GAAA;IAAAC,KAAA,EAIA,SAAAI,GAAGA,CAACF,EAAU,EAAE;MACd,OAAO,IAAI,CAACL,WAAW,CAACK,EAAE,CAAC;IAC7B;EAAC;AAAA;AAAA,IAAAG,QAAA,GAAAC,OAAA,CAAAZ,OAAA,GAGYF,iBAAiB","ignoreList":[]}