@webex/plugin-meetings 3.10.0-next.9 → 3.10.0-set-bitrate.1

package/dist/locus-info/index.js

@@ -1,17 +1,30 @@
 "use strict";
 
+var _typeof = require("@babel/runtime-corejs2/helpers/typeof");
 var _Reflect$construct = require("@babel/runtime-corejs2/core-js/reflect/construct");
+var _Object$keys = require("@babel/runtime-corejs2/core-js/object/keys");
+var _Object$getOwnPropertySymbols = require("@babel/runtime-corejs2/core-js/object/get-own-property-symbols");
+var _Object$getOwnPropertyDescriptor = require("@babel/runtime-corejs2/core-js/object/get-own-property-descriptor");
+var _Object$getOwnPropertyDescriptors = require("@babel/runtime-corejs2/core-js/object/get-own-property-descriptors");
+var _Object$defineProperties = require("@babel/runtime-corejs2/core-js/object/define-properties");
+var _Object$defineProperty = require("@babel/runtime-corejs2/core-js/object/define-property");
 var _Array$from = require("@babel/runtime-corejs2/core-js/array/from");
 var _Symbol = require("@babel/runtime-corejs2/core-js/symbol");
 var _Symbol$iterator = require("@babel/runtime-corejs2/core-js/symbol/iterator");
 var _Array$isArray2 = require("@babel/runtime-corejs2/core-js/array/is-array");
-var _Object$defineProperty = require("@babel/runtime-corejs2/core-js/object/define-property");
+var _WeakMap = require("@babel/runtime-corejs2/core-js/weak-map");
 var _interopRequireDefault = require("@babel/runtime-corejs2/helpers/interopRequireDefault");
 _Object$defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime-corejs2/regenerator"));
+var _map = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/map"));
+var _values = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/object/values"));
+var _assign = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/object/assign"));
+var _stringify = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/json/stringify"));
 var _isArray = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/array/is-array"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/asyncToGenerator"));
 var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/classCallCheck"));
 var _createClass2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/createClass"));
 var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/possibleConstructorReturn"));
@@ -32,11 +45,25 @@ var _mediaSharesUtils = _interopRequireDefault(require("./mediaSharesUtils"));
 var _parser = _interopRequireDefault(require("./parser"));
 var _metrics = _interopRequireDefault(require("../metrics"));
 var _constants2 = _interopRequireDefault(require("../metrics/constants"));
+var _hashTreeParser = _interopRequireWildcard(require("../hashTree/hashTreeParser"));
+var _types = require("../hashTree/types");
+function _interopRequireWildcard(e, t) { if ("function" == typeof _WeakMap) var r = new _WeakMap(), n = new _WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != _typeof(e) && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t2 in e) "default" !== _t2 && {}.hasOwnProperty.call(e, _t2) && ((i = (o = _Object$defineProperty) && _Object$getOwnPropertyDescriptor(e, _t2)) && (i.get || i.set) ? o(f, _t2, i) : f[_t2] = e[_t2]); return f; })(e, t); }
 function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof _Symbol && r[_Symbol$iterator] || r["@@iterator"]; if (!t) { if (_Array$isArray2(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t.return || t.return(); } finally { if (u) throw o; } } }; }
 function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? _Array$from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
 function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function ownKeys(e, r) { var t = _Object$keys(e); if (_Object$getOwnPropertySymbols) { var o = _Object$getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return _Object$getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2.default)(e, r, t[r]); }) : _Object$getOwnPropertyDescriptors ? _Object$defineProperties(e, _Object$getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { _Object$defineProperty(e, r, _Object$getOwnPropertyDescriptor(t, r)); }); } return e; }
 function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? _Reflect$construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
 function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(_Reflect$construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+// list of top level keys in Locus DTO relevant for Hash Tree DTOs processing
+// it does not contain fields specific to classic Locus DTOs like sequence or baseSequence
+var LocusDtoTopLevelKeys = ['controls', 'fullState', 'host', 'info', 'links', 'mediaShares', 'meetings', 'participants', 'replaces', 'self', 'sequence', 'syncUrl', 'url', 'htMeta' // only exists when hash trees are used
+];
+var LocusObjectStateAfterUpdates = {
+  unchanged: 'unchanged',
+  removed: 'removed',
+  updated: 'updated'
+};
 /**
  * @description LocusInfo extends ChildEmitter to convert locusInfo info a private emitter to parent object
  * @export
@@ -65,10 +92,7 @@ var LocusInfo = exports.default = /*#__PURE__*/function (_EventsScope) {
     (0, _defineProperty2.default)(_this, "aclUrl", void 0);
     (0, _defineProperty2.default)(_this, "baseSequence", void 0);
     (0, _defineProperty2.default)(_this, "created", void 0);
-    (0, _defineProperty2.default)(_this, "identities", void 0);
-    (0, _defineProperty2.default)(_this, "membership", void 0);
     (0, _defineProperty2.default)(_this, "participants", void 0);
-    (0, _defineProperty2.default)(_this, "participantsUrl", void 0);
     (0, _defineProperty2.default)(_this, "replaces", void 0);
     (0, _defineProperty2.default)(_this, "scheduledMeeting", void 0);
     (0, _defineProperty2.default)(_this, "sequence", void 0);
@@ -80,12 +104,14 @@ var LocusInfo = exports.default = /*#__PURE__*/function (_EventsScope) {
     (0, _defineProperty2.default)(_this, "info", void 0);
     (0, _defineProperty2.default)(_this, "roles", void 0);
     (0, _defineProperty2.default)(_this, "mediaShares", void 0);
-    (0, _defineProperty2.default)(_this, "replace", void 0);
     (0, _defineProperty2.default)(_this, "url", void 0);
-    (0, _defineProperty2.default)(_this, "services", void 0);
-    (0, _defineProperty2.default)(_this, "resources", void 0);
+    (0, _defineProperty2.default)(_this, "links", void 0);
     (0, _defineProperty2.default)(_this, "mainSessionLocusCache", void 0);
     (0, _defineProperty2.default)(_this, "self", void 0);
+    (0, _defineProperty2.default)(_this, "hashTreeParser", void 0);
+    (0, _defineProperty2.default)(_this, "hashTreeObjectId2ParticipantId", void 0);
+    // mapping of hash tree object ids to participant ids
+    (0, _defineProperty2.default)(_this, "classicVsHashTreeMismatchMetricCounter", 0);
     _this.parsedLocus = {
       states: []
     };
@@ -95,11 +121,13 @@ var LocusInfo = exports.default = /*#__PURE__*/function (_EventsScope) {
     _this.meetingId = meetingId;
     _this.updateMeeting = updateMeeting;
     _this.locusParser = new _parser.default();
+    _this.hashTreeObjectId2ParticipantId = new _map.default();
     return _this;
   }
 
   /**
    * Does a Locus sync. It tries to get the latest delta DTO or if it can't, it falls back to getting the full Locus DTO.
+   * WARNING: This function must not be used for hash tree based Locus meetings.
    *
    * @param {Meeting} meeting
    * @param {boolean} isLocusUrlChanged
@@ -266,17 +294,13 @@ var LocusInfo = exports.default = /*#__PURE__*/function (_EventsScope) {
   }, {
     key: "init",
     value: function init() {
-      var _locus$links, _locus$links2;
       var locus = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
       this.created = locus.created || null;
       this.scheduledMeeting = locus.meeting || null;
-      this.participantsUrl = locus.participantsUrl || null;
       this.replaces = locus.replaces || null;
       this.aclUrl = locus.aclUrl || null;
       this.baseSequence = locus.baseSequence || null;
       this.sequence = locus.sequence || null;
-      this.membership = locus.membership || null;
-      this.identities = locus.identities || null;
       this.participants = locus.participants || null;
 
       /**
@@ -302,35 +326,400 @@ var LocusInfo = exports.default = /*#__PURE__*/function (_EventsScope) {
       this.updateSelf(locus.self);
       this.updateHostInfo(locus.host);
       this.updateMediaShares(locus.mediaShares);
-      this.updateServices((_locus$links = locus.links) === null || _locus$links === void 0 ? void 0 : _locus$links.services);
-      this.updateResources((_locus$links2 = locus.links) === null || _locus$links2 === void 0 ? void 0 : _locus$links2.resources);
+      this.updateLinks(locus.links);
     }
 
     /**
-     * @param {Object} locus
+     * Creates the HashTreeParser instance.
+     * @param {Object} initial locus data
+     * @returns {void}
+     */
+  }, {
+    key: "createHashTreeParser",
+    value: function createHashTreeParser(_ref) {
+      var initialLocus = _ref.initialLocus;
+      return new _hashTreeParser.default({
+        initialLocus: initialLocus,
+        webexRequest: this.webex.request.bind(this.webex),
+        locusInfoUpdateCallback: this.updateFromHashTree.bind(this),
+        debugId: "HT-".concat(this.meetingId.substring(0, 4))
+      });
+    }
+
+    /**
+     * @param {Object} data - data to initialize locus info with. It may be from a join or GET /loci response or from a Mercury event that triggers a creation of meeting object
      * @returns {undefined}
      * @memberof LocusInfo
      */
   }, {
     key: "initialSetup",
-    value: function initialSetup(locus) {
-      this.updateLocusCache(locus);
-      this.onFullLocus(locus);
+    value: (function () {
+      var _initialSetup = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee(data) {
+        var _data$locus, _data$locus$links, _data$locus$links$res, _data$locus$links$res2;
+        var _data$hashTreeMessage, _selfObject$data, selfObject, _data$locus2, _data$locus2$self, _t;
+        return _regenerator.default.wrap(function (_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              _t = data.trigger;
+              _context.next = _t === 'locus-message' ? 1 : _t === 'join-response' ? 6 : _t === 'get-loci-response' ? 7 : 10;
+              break;
+            case 1:
+              if (!data.hashTreeMessage) {
+                _context.next = 4;
+                break;
+              }
+              // we need the SELF object to be in the received message, because it contains visibleDataSets
+              // and these are needed to initialize all the hash trees
+              selfObject = (_data$hashTreeMessage = data.hashTreeMessage.locusStateElements) === null || _data$hashTreeMessage === void 0 ? void 0 : _data$hashTreeMessage.find(function (el) {
+                return (0, _hashTreeParser.isSelf)(el);
+              });
+              if (selfObject !== null && selfObject !== void 0 && (_selfObject$data = selfObject.data) !== null && _selfObject$data !== void 0 && _selfObject$data.visibleDataSets) {
+                _context.next = 2;
+                break;
+              }
+              _loggerProxy.default.logger.warn("Locus-info:index#initialSetup --> cannot initialize HashTreeParser, SELF object with visibleDataSets is missing in the message");
+              throw new Error('SELF object with visibleDataSets is missing in the message');
+            case 2:
+              _loggerProxy.default.logger.info('Locus-info:index#initialSetup --> creating HashTreeParser from message');
+              // first create the HashTreeParser, but don't initialize it with any data yet
+              // pass just a fake locus that contains only the visibleDataSets
+              this.hashTreeParser = this.createHashTreeParser({
+                initialLocus: {
+                  locus: {
+                    self: {
+                      visibleDataSets: selfObject.data.visibleDataSets
+                    }
+                  },
+                  dataSets: [] // empty, because they will be populated in initializeFromMessage() call  // dataSets: data.hashTreeMessage.dataSets,
+                }
+              });
 
-      // Change it to true after it receives it first locus object
-      this.emitChange = true;
-    }
+              // now handle the message - that should populate all the visible datasets
+              _context.next = 3;
+              return this.hashTreeParser.initializeFromMessage(data.hashTreeMessage);
+            case 3:
+              _context.next = 5;
+              break;
+            case 4:
+              // "classic" Locus case, no hash trees involved
+              this.updateLocusCache(data.locus);
+              this.onFullLocus(data.locus, undefined);
+            case 5:
+              return _context.abrupt("continue", 10);
+            case 6:
+              this.updateLocusCache(data.locus);
+              this.onFullLocus(data.locus, undefined, data.dataSets);
+              return _context.abrupt("continue", 10);
+            case 7:
+              if (!((_data$locus = data.locus) !== null && _data$locus !== void 0 && (_data$locus$links = _data$locus.links) !== null && _data$locus$links !== void 0 && (_data$locus$links$res = _data$locus$links.resources) !== null && _data$locus$links$res !== void 0 && (_data$locus$links$res2 = _data$locus$links$res.visibleDataSets) !== null && _data$locus$links$res2 !== void 0 && _data$locus$links$res2.url)) {
+                _context.next = 9;
+                break;
+              }
+              _loggerProxy.default.logger.info('Locus-info:index#initialSetup --> creating HashTreeParser from get-loci-response');
+              // first create the HashTreeParser, but don't initialize it with any data yet
+              // pass just a fake locus that contains only the visibleDataSets
+              this.hashTreeParser = this.createHashTreeParser({
+                initialLocus: {
+                  locus: {
+                    self: {
+                      visibleDataSets: (_data$locus2 = data.locus) === null || _data$locus2 === void 0 ? void 0 : (_data$locus2$self = _data$locus2.self) === null || _data$locus2$self === void 0 ? void 0 : _data$locus2$self.visibleDataSets
+                    }
+                  },
+                  dataSets: [] // empty, because we don't have them yet
+                }
+              });
 
+              // now initialize all the data
+              _context.next = 8;
+              return this.hashTreeParser.initializeFromGetLociResponse(data.locus);
+            case 8:
+              _context.next = 10;
+              break;
+            case 9:
+              // "classic" Locus case, no hash trees involved
+              this.updateLocusCache(data.locus);
+              this.onFullLocus(data.locus, undefined);
+            case 10:
+              // Change it to true after it receives it first locus object
+              this.emitChange = true;
+            case 11:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this);
+      }));
+      function initialSetup(_x) {
+        return _initialSetup.apply(this, arguments);
+      }
+      return initialSetup;
+    }()
     /**
      * Handles HTTP response from Locus API call.
      * @param {Meeting} meeting meeting object
      * @param {LocusApiResponseBody} responseBody body of the http response from Locus API call
      * @returns {void}
      */
+    )
   }, {
     key: "handleLocusAPIResponse",
     value: function handleLocusAPIResponse(meeting, responseBody) {
-      this.handleLocusDelta(responseBody.locus, meeting);
+      if (this.hashTreeParser) {
+        if (!responseBody.dataSets) {
+          this.sendClassicVsHashTreeMismatchMetric(meeting, "expected hash tree dataSets in API response but they are missing");
+          // continuing as we can still manage without responseBody.dataSets, but this is very suspicious
+        }
+        _loggerProxy.default.logger.info('Locus-info:index#handleLocusAPIResponse --> passing Locus API response to HashTreeParser: ', responseBody);
+        // update the data in our hash trees
+        this.hashTreeParser.handleLocusUpdate(responseBody);
+      } else {
+        if (responseBody.dataSets) {
+          this.sendClassicVsHashTreeMismatchMetric(meeting, "unexpected hash tree dataSets in API response");
+        }
+        // classic Locus delta
+        this.handleLocusDelta(responseBody.locus, meeting);
+      }
+    }
+
+    /**
+     *
+     * @param {HashTreeObject} object data set object
+     * @param {any} locus
+     * @returns {void}
+     */
+  }, {
+    key: "updateLocusFromHashTreeObject",
+    value: function updateLocusFromHashTreeObject(object, locus) {
+      var _this4 = this;
+      var type = object.htMeta.elementId.type.toLowerCase();
+      var addParticipantObject = function addParticipantObject(obj) {
+        if (!locus.participants) {
+          locus.participants = [];
+        }
+        locus.participants.push(obj.data);
+        _this4.hashTreeObjectId2ParticipantId.set(obj.htMeta.elementId.id, obj.data.id);
+      };
+      switch (type) {
+        case _types.ObjectType.locus:
+          {
+            if (!object.data) {
+              // not doing anything here, as we need Locus to always be there (at least some fields)
+              // and that's already taken care of in updateFromHashTree()
+              _loggerProxy.default.logger.info("Locus-info:index#updateLocusFromHashTreeObject --> LOCUS object removed, version=".concat(object.htMeta.elementId.version));
+              return locus;
+            }
+            // replace the main locus
+
+            // The Locus object we receive from backend has empty participants array,
+            // and may have (although it shouldn't) other fields that are managed by other ObjectTypes
+            // like "fullState" or "info", so we're making sure to delete them here
+            var locusObjectFromData = object.data;
+            (0, _values.default)(_types.ObjectTypeToLocusKeyMap).forEach(function (locusDtoKey) {
+              delete locusObjectFromData[locusDtoKey];
+            });
+            locus = _objectSpread(_objectSpread({}, locus), locusObjectFromData);
+            _loggerProxy.default.logger.info("Locus-info:index#updateLocusFromHashTreeObject --> LOCUS object updated to version=".concat(object.htMeta.elementId.version));
+            break;
+          }
+        case _types.ObjectType.mediaShare:
+          if (object.data) {
+            var _object$data$floor, _object$data$floor2, _object$data$floor2$b, _locus$mediaShares;
+            _loggerProxy.default.logger.info("Locus-info:index#updateLocusFromHashTreeObject --> mediaShare id=".concat(object.htMeta.elementId.id, " name='").concat(object.data.name, "' updated ").concat(object.data.name === 'content' ? "floor=".concat((_object$data$floor = object.data.floor) === null || _object$data$floor === void 0 ? void 0 : _object$data$floor.disposition, ", ").concat((_object$data$floor2 = object.data.floor) === null || _object$data$floor2 === void 0 ? void 0 : (_object$data$floor2$b = _object$data$floor2.beneficiary) === null || _object$data$floor2$b === void 0 ? void 0 : _object$data$floor2$b.id) : '', " version=").concat(object.htMeta.elementId.version));
+            var existingMediaShare = (_locus$mediaShares = locus.mediaShares) === null || _locus$mediaShares === void 0 ? void 0 : _locus$mediaShares.find(function (ms) {
+              return ms.htMeta.elementId.id === object.htMeta.elementId.id;
+            });
+            if (existingMediaShare) {
+              (0, _assign.default)(existingMediaShare, object.data);
+            } else {
+              locus.mediaShares = locus.mediaShares || [];
+              locus.mediaShares.push(object.data);
+            }
+          } else {
+            var _locus$mediaShares2;
+            _loggerProxy.default.logger.info("Locus-info:index#updateLocusFromHashTreeObject --> mediaShare id=".concat(object.htMeta.elementId.id, " removed, version=").concat(object.htMeta.elementId.version));
+            locus.mediaShares = (_locus$mediaShares2 = locus.mediaShares) === null || _locus$mediaShares2 === void 0 ? void 0 : _locus$mediaShares2.filter(function (ms) {
+              return ms.htMeta.elementId.id !== object.htMeta.elementId.id;
+            });
+          }
+          break;
+        case _types.ObjectType.participant:
+          _loggerProxy.default.logger.info("Locus-info:index#updateLocusFromHashTreeObject --> participant id=".concat(object.htMeta.elementId.id, " ").concat(object.data ? 'updated' : 'removed', " version=").concat(object.htMeta.elementId.version));
+          if (object.data) {
+            addParticipantObject(object);
+          } else {
+            var participantId = this.hashTreeObjectId2ParticipantId.get(object.htMeta.elementId.id);
+            if (!locus.jsSdkMeta) {
+              locus.jsSdkMeta = {
+                removedParticipantIds: []
+              };
+            }
+            locus.jsSdkMeta.removedParticipantIds.push(participantId);
+            this.hashTreeObjectId2ParticipantId.delete(object.htMeta.elementId.id);
+          }
+          break;
+        case _types.ObjectType.links:
+        case _types.ObjectType.info:
+        case _types.ObjectType.fullState:
+        case _types.ObjectType.self:
+          if (!object.data) {
+            // self without data is handled inside HashTreeParser and results in LocusInfoUpdateType.MEETING_ENDED, so we should never get here
+            // all other types info, fullstate, etc - Locus should never send them without data
+            _loggerProxy.default.logger.warn("Locus-info:index#updateLocusFromHashTreeObject --> received ".concat(type, " object without data, this is not expected! version=").concat(object.htMeta.elementId.version));
+          } else {
+            var _locus$info, _object$data$controls, _object$data$controls2, _object$data$controls3;
+            _loggerProxy.default.logger.info("Locus-info:index#updateLocusFromHashTreeObject --> ".concat(type, " object updated to version ").concat(object.htMeta.elementId.version));
+            var locusDtoKey = _types.ObjectTypeToLocusKeyMap[type];
+            locus[locusDtoKey] = object.data;
+
+            /* Hash tree based webinar attendees don't receive a Participant object for themselves from Locus,
+               but a lot of existing code in SDK and web app expects a member object for self to exist,
+               so whenever SELF changes for a webinar attendee, we copy it into a participant object.
+               We can do it, because SELF has always all the same properties as a participant object.
+            */
+            if (type === _types.ObjectType.self && (_locus$info = locus.info) !== null && _locus$info !== void 0 && _locus$info.isWebinar && (_object$data$controls = object.data.controls) !== null && _object$data$controls !== void 0 && (_object$data$controls2 = _object$data$controls.role) !== null && _object$data$controls2 !== void 0 && (_object$data$controls3 = _object$data$controls2.roles) !== null && _object$data$controls3 !== void 0 && _object$data$controls3.find(function (r) {
+              return r.type === _constants.SELF_ROLES.ATTENDEE && r.hasRole;
+            })) {
+              _loggerProxy.default.logger.info("Locus-info:index#updateLocusFromHashTreeObject --> webinar attendee: creating participant object from self");
+              addParticipantObject(object);
+            }
+          }
+          break;
+        default:
+          _loggerProxy.default.logger.warn("Locus-info:index#updateLocusFromHashTreeObject --> received unsupported object type ".concat(type));
+          break;
+      }
+      return locus;
+    }
+
+    /**
+     * Sends a metric when we receive something from Locus that uses hash trees while we
+     * expect classic deltas or the other way around.
+     * @param {Meeting} meeting
+     * @param {string} message
+     * @returns {void}
+     */
+  }, {
+    key: "sendClassicVsHashTreeMismatchMetric",
+    value: function sendClassicVsHashTreeMismatchMetric(meeting, message) {
+      _loggerProxy.default.logger.warn("Locus-info:index#sendClassicVsHashTreeMismatchMetric --> classic vs hash tree mismatch! ".concat(message));
+
+      // we don't want to flood the metrics system
+      if (this.classicVsHashTreeMismatchMetricCounter < 5) {
+        _metrics.default.sendBehavioralMetric(_constants2.default.LOCUS_CLASSIC_VS_HASH_TREE_MISMATCH, {
+          correlationId: meeting.correlationId,
+          message: message
+        });
+        this.classicVsHashTreeMismatchMetricCounter += 1;
+      }
+    }
+
+    /**
+     * Handles a hash tree message received from Locus.
+     *
+     * @param {Meeting} meeting - The meeting object
+     * @param {eventType} eventType - The event type
+     * @param {HashTreeMessage} message incoming hash tree message
+     * @returns {void}
+     */
+  }, {
+    key: "handleHashTreeMessage",
+    value: function handleHashTreeMessage(meeting, eventType, message) {
+      if (eventType !== _constants.LOCUSEVENT.HASH_TREE_DATA_UPDATED) {
+        this.sendClassicVsHashTreeMismatchMetric(meeting, "got ".concat(eventType, ", expected ").concat(_constants.LOCUSEVENT.HASH_TREE_DATA_UPDATED));
+        return;
+      }
+      this.hashTreeParser.handleMessage(message);
+    }
+
+    /**
+     * Callback registered with HashTreeParser to receive locus info updates.
+     * Updates our locus info based on the data parsed by the hash tree parser.
+     *
+     * @param {LocusInfoUpdateType} updateType - The type of update received.
+     * @param {Object} [data] - Additional data for the update, if applicable.
+     * @returns {void}
+     */
+  }, {
+    key: "updateFromHashTree",
+    value: function updateFromHashTree(updateType, data) {
+      var _this5 = this;
+      switch (updateType) {
+        case _hashTreeParser.LocusInfoUpdateType.OBJECTS_UPDATED:
+          {
+            // initialize our new locus
+            var locus = {
+              participants: [],
+              jsSdkMeta: {
+                removedParticipantIds: []
+              }
+            };
+
+            // first go over all the updates and check what happens with the main locus object
+            var locusObjectStateAfterUpdates = LocusObjectStateAfterUpdates.unchanged;
+            data.updatedObjects.forEach(function (object) {
+              if (object.htMeta.elementId.type.toLowerCase() === _types.ObjectType.locus) {
+                if (locusObjectStateAfterUpdates === LocusObjectStateAfterUpdates.updated) {
+                  var _object$data;
+                  // this code doesn't supported it right now,
+                  // cases for "updated" followed by "removed", or multiple "updated" would need more handling
+                  // but these should never happen
+                  _loggerProxy.default.logger.warn("Locus-info:index#updateFromHashTree --> received multiple LOCUS objects in one update, this is unexpected!");
+                  _metrics.default.sendBehavioralMetric(_constants2.default.LOCUS_HASH_TREE_UNSUPPORTED_OPERATION, {
+                    locusUrl: ((_object$data = object.data) === null || _object$data === void 0 ? void 0 : _object$data.url) || _this5.url,
+                    message: object.data ? 'multiple LOCUS object updates' : 'LOCUS object update followed by removal'
+                  });
+                }
+                if (object.data) {
+                  locusObjectStateAfterUpdates = LocusObjectStateAfterUpdates.updated;
+                } else {
+                  locusObjectStateAfterUpdates = LocusObjectStateAfterUpdates.removed;
+                }
+              }
+            });
+
+            // if Locus object is unchanged or removed, we need to keep using the existing locus
+            // because the rest of the locusInfo code expects locus to always be present (with at least some of the fields)
+            // if it gets updated, we only need to have the fields that are not part of "locus" object (like "info" or "mediaShares")
+            // so that when Locus object gets updated, if the new one is missing some field, that field will
+            // be removed from our locusInfo
+            if (locusObjectStateAfterUpdates === LocusObjectStateAfterUpdates.unchanged || locusObjectStateAfterUpdates === LocusObjectStateAfterUpdates.removed) {
+              // copy over all of existing locus except participants
+              LocusDtoTopLevelKeys.forEach(function (key) {
+                if (key !== 'participants') {
+                  locus[key] = (0, _lodash.cloneDeep)(_this5[key]);
+                }
+              });
+            } else {
+              // initialize only the fields that are not part of main "Locus" object
+              // (except participants, which need to stay empty - that means "no participant changes")
+              (0, _values.default)(_types.ObjectTypeToLocusKeyMap).forEach(function (locusDtoKey) {
+                if (locusDtoKey !== 'participants') {
+                  locus[locusDtoKey] = (0, _lodash.cloneDeep)(_this5[locusDtoKey]);
+                }
+              });
+            }
+            _loggerProxy.default.logger.info("Locus-info:index#updateFromHashTree --> LOCUS object is ".concat(locusObjectStateAfterUpdates, ", all updates: ").concat((0, _stringify.default)(data.updatedObjects.map(function (o) {
+              return {
+                type: o.htMeta.elementId.type,
+                id: o.htMeta.elementId.id,
+                hasData: !!o.data
+              };
+            }))));
+            // now apply all the updates from the hash tree onto the locus
+            data.updatedObjects.forEach(function (object) {
+              locus = _this5.updateLocusFromHashTreeObject(object, locus);
+            });
+
+            // update our locus info with the new locus
+            this.onDeltaLocus(locus);
+            break;
+          }
+        case _hashTreeParser.LocusInfoUpdateType.MEETING_ENDED:
+          {
+            _loggerProxy.default.logger.info("Locus-info:index#updateFromHashTree --> received signal that meeting ended, destroying meeting ".concat(this.meetingId));
+            var meeting = this.webex.meetings.meetingCollection.get(this.meetingId);
+            this.webex.meetings.destroy(meeting, _constants.MEETING_REMOVED_REASON.SELF_REMOVED);
+          }
+      }
     }
 
     /**
@@ -342,37 +731,44 @@ var LocusInfo = exports.default = /*#__PURE__*/function (_EventsScope) {
   }, {
     key: "parse",
     value: function parse(meeting, data) {
-      // eslint-disable-next-line @typescript-eslint/no-shadow
-      var eventType = data.eventType;
-      var locus = this.getTheLocusToUpdate(data.locus);
-      _loggerProxy.default.logger.info("Locus-info:index#parse --> received locus data: ".concat(eventType));
-      locus.jsSdkMeta = {
-        removedParticipantIds: []
-      };
-      switch (eventType) {
-        case _constants.LOCUSEVENT.PARTICIPANT_JOIN:
-        case _constants.LOCUSEVENT.PARTICIPANT_LEFT:
-        case _constants.LOCUSEVENT.CONTROLS_UPDATED:
-        case _constants.LOCUSEVENT.PARTICIPANT_AUDIO_MUTED:
-        case _constants.LOCUSEVENT.PARTICIPANT_AUDIO_UNMUTED:
-        case _constants.LOCUSEVENT.PARTICIPANT_VIDEO_MUTED:
-        case _constants.LOCUSEVENT.PARTICIPANT_VIDEO_UNMUTED:
-        case _constants.LOCUSEVENT.SELF_CHANGED:
-        case _constants.LOCUSEVENT.PARTICIPANT_UPDATED:
-        case _constants.LOCUSEVENT.PARTICIPANT_CONTROLS_UPDATED:
-        case _constants.LOCUSEVENT.PARTICIPANT_ROLES_UPDATED:
-        case _constants.LOCUSEVENT.PARTICIPANT_DECLINED:
-        case _constants.LOCUSEVENT.FLOOR_GRANTED:
-        case _constants.LOCUSEVENT.FLOOR_RELEASED:
-          this.onFullLocus(locus, eventType);
-          break;
-        case _constants.LOCUSEVENT.DIFFERENCE:
-          this.handleLocusDelta(locus, meeting);
-          break;
-        default:
-          // Why will there be a event with no eventType ????
-          // we may not need this, we can get full locus
-          this.handleLocusDelta(locus, meeting);
+      if (this.hashTreeParser) {
+        this.handleHashTreeMessage(meeting, data.eventType, data.stateElementsMessage);
+      } else {
+        // eslint-disable-next-line @typescript-eslint/no-shadow
+        var eventType = data.eventType;
+        var locus = this.getTheLocusToUpdate(data.locus);
+        _loggerProxy.default.logger.info("Locus-info:index#parse --> received locus data: ".concat(eventType));
+        locus.jsSdkMeta = {
+          removedParticipantIds: []
+        };
+        switch (eventType) {
+          case _constants.LOCUSEVENT.PARTICIPANT_JOIN:
+          case _constants.LOCUSEVENT.PARTICIPANT_LEFT:
+          case _constants.LOCUSEVENT.CONTROLS_UPDATED:
+          case _constants.LOCUSEVENT.PARTICIPANT_AUDIO_MUTED:
+          case _constants.LOCUSEVENT.PARTICIPANT_AUDIO_UNMUTED:
+          case _constants.LOCUSEVENT.PARTICIPANT_VIDEO_MUTED:
+          case _constants.LOCUSEVENT.PARTICIPANT_VIDEO_UNMUTED:
+          case _constants.LOCUSEVENT.SELF_CHANGED:
+          case _constants.LOCUSEVENT.PARTICIPANT_UPDATED:
+          case _constants.LOCUSEVENT.PARTICIPANT_CONTROLS_UPDATED:
+          case _constants.LOCUSEVENT.PARTICIPANT_ROLES_UPDATED:
+          case _constants.LOCUSEVENT.PARTICIPANT_DECLINED:
+          case _constants.LOCUSEVENT.FLOOR_GRANTED:
+          case _constants.LOCUSEVENT.FLOOR_RELEASED:
+            this.onFullLocus(locus, eventType);
+            break;
+          case _constants.LOCUSEVENT.DIFFERENCE:
+            this.handleLocusDelta(locus, meeting);
+            break;
+          case _constants.LOCUSEVENT.HASH_TREE_DATA_UPDATED:
+            this.sendClassicVsHashTreeMismatchMetric(meeting, "got ".concat(eventType, ", expected classic events"));
+            break;
+          default:
+            // Why will there be a event with no eventType ????
+            // we may not need this, we can get full locus
+            this.handleLocusDelta(locus, meeting);
+        }
       }
     }
 
@@ -389,26 +785,99 @@ var LocusInfo = exports.default = /*#__PURE__*/function (_EventsScope) {
       return this.emit(scope, eventName, args);
     }
 
+    /**
+     * Function for handling full locus when it's using hash trees (so not the "classic" one).
+     *
+     * @param {object} locus locus object
+     * @param {string} eventType locus event
+     * @param {DataSet[]} dataSets
+     * @returns {void}
+     */
+  }, {
+    key: "onFullLocusWithHashTrees",
+    value: function onFullLocusWithHashTrees(locus, eventType, dataSets) {
+      if (!this.hashTreeParser) {
+        _loggerProxy.default.logger.info("Locus-info:index#onFullLocus --> creating hash tree parser");
+        _loggerProxy.default.logger.info('Locus-info:index#onFullLocus --> dataSets:', dataSets, ' and locus:', locus);
+        this.hashTreeParser = this.createHashTreeParser({
+          initialLocus: {
+            locus: locus,
+            dataSets: dataSets
+          }
+        });
+        this.onFullLocusCommon(locus, eventType);
+      } else {
+        // in this case the Locus we're getting is not necessarily the full one
+        // so treat it like if we just got it in any api response
+
+        _loggerProxy.default.logger.info('Locus-info:index#onFullLocus --> hash tree parser already exists, handling it like a normal API response');
+        this.handleLocusAPIResponse(undefined, {
+          dataSets: dataSets,
+          locus: locus
+        });
+      }
+    }
+
+    /**
+     * Function for handling full locus when it's the "classic" one (not hash trees)
+     *
+     * @param {object} locus locus object
+     * @param {string} eventType locus event
+     * @returns {void}
+     */
+  }, {
+    key: "onFullLocusClassic",
+    value: function onFullLocusClassic(locus, eventType) {
+      if (!this.locusParser.isNewFullLocus(locus)) {
+        _loggerProxy.default.logger.info("Locus-info:index#onFullLocus --> ignoring old full locus DTO, eventType=".concat(eventType));
+        return;
+      }
+      this.onFullLocusCommon(locus, eventType);
+    }
+
     /**
      * updates the locus with full locus object
      * @param {object} locus locus object
-     * @param {string} eventType particulat locus event
+     * @param {string} eventType locus event
+     * @param {DataSet[]} dataSets
      * @returns {object} null
      * @memberof LocusInfo
      */
   }, {
     key: "onFullLocus",
-    value: function onFullLocus(locus, eventType) {
-      var _locus$jsSdkMeta;
+    value: function onFullLocus(locus, eventType, dataSets) {
       if (!locus) {
         _loggerProxy.default.logger.error('Locus-info:index#onFullLocus --> object passed as argument was invalid, continuing.');
       }
-      if (!this.locusParser.isNewFullLocus(locus)) {
-        _loggerProxy.default.logger.info("Locus-info:index#onFullLocus --> ignoring old full locus DTO, eventType=".concat(eventType));
-        return;
+      if (dataSets) {
+        // this is the new hashmap Locus DTO format (only applicable to webinars for now)
+        this.onFullLocusWithHashTrees(locus, eventType, dataSets);
+      } else {
+        this.onFullLocusClassic(locus, eventType);
       }
+    }
+
+    /**
+     * Common part of handling full locus, used by both classic and hash tree based locus handling
+     * @param {object} locus locus object
+     * @param {string} eventType locus event
+     * @returns {void}
+     */
+  }, {
+    key: "onFullLocusCommon",
+    value: function onFullLocusCommon(locus, eventType) {
+      var _this$participants,
+        _this6 = this,
+        _locus$jsSdkMeta;
       this.scheduledMeeting = locus.meeting || null;
       this.participants = locus.participants;
+      (_this$participants = this.participants) === null || _this$participants === void 0 ? void 0 : _this$participants.forEach(function (participant) {
+        var _participant$htMeta;
+        // participant.htMeta is set only for hash tree based locus
+        if ((_participant$htMeta = participant.htMeta) !== null && _participant$htMeta !== void 0 && _participant$htMeta.elementId.id) {
+          _this6.hashTreeObjectId2ParticipantId.set(participant.htMeta.elementId.id, participant.id);
+        }
+      });
       var isReplaceMembers = _controlsUtils.default.isNeedReplaceMembers(this.controls, locus.controls);
       this.updateLocusInfo(locus);
       this.updateParticipants(locus.participants, (_locus$jsSdkMeta = locus.jsSdkMeta) === null || _locus$jsSdkMeta === void 0 ? void 0 : _locus$jsSdkMeta.removedParticipantIds, isReplaceMembers);
@@ -479,7 +948,7 @@ var LocusInfo = exports.default = /*#__PURE__*/function (_EventsScope) {
   }, {
     key: "updateLocusInfo",
     value: function updateLocusInfo(locus) {
-      var _locus$self, _locus$self2, _locus$links3, _locus$links4;
+      var _locus$self, _locus$self2;
       if (((_locus$self = locus.self) === null || _locus$self === void 0 ? void 0 : _locus$self.reason) === 'MOVED' && ((_locus$self2 = locus.self) === null || _locus$self2 === void 0 ? void 0 : _locus$self2.state) === 'LEFT') {
         // When moved to a breakout session locus sends a message for the previous locus
         // indicating that we have been moved. It isn't helpful to continue parsing this
@@ -494,17 +963,13 @@ var LocusInfo = exports.default = /*#__PURE__*/function (_EventsScope) {
       this.updateLocusUrl(locus.url, _controlsUtils.default.isMainSessionDTO(locus));
       this.updateMeetingInfo(locus.info, locus.self);
       this.updateMediaShares(locus.mediaShares);
-      this.updateParticipantsUrl(locus.participantsUrl);
-      this.updateReplace(locus.replace);
+      this.updateReplaces(locus.replaces);
       this.updateSelf(locus.self);
       this.updateAclUrl(locus.aclUrl);
       this.updateBasequence(locus.baseSequence);
       this.updateSequence(locus.sequence);
-      this.updateMemberShip(locus.membership);
-      this.updateIdentifiers(locus.identities);
       this.updateEmbeddedApps(locus.embeddedApps);
-      this.updateServices((_locus$links3 = locus.links) === null || _locus$links3 === void 0 ? void 0 : _locus$links3.services);
-      this.updateResources((_locus$links4 = locus.links) === null || _locus$links4 === void 0 ? void 0 : _locus$links4.resources);
+      this.updateLinks(locus.links);
       this.compareAndUpdate();
       // update which required to compare different objects from locus
     }
@@ -1053,41 +1518,35 @@ var LocusInfo = exports.default = /*#__PURE__*/function (_EventsScope) {
     }
 
     /**
-     * @param {Object} services
+     * Updates links and emits appropriate events if services or resources have changed
+     * @param {Object} links
      * @returns {undefined}
      * @memberof LocusInfo
      */
   }, {
-    key: "updateServices",
-    value: function updateServices(services) {
-      if (services && !(0, _lodash.isEqual)(this.services, services)) {
-        this.services = services;
+    key: "updateLinks",
+    value: function updateLinks(links) {
+      var _this$links, _this$links2;
+      var _ref2 = links || {},
+        services = _ref2.services,
+        resources = _ref2.resources;
+      if (services && !(0, _lodash.isEqual)((_this$links = this.links) === null || _this$links === void 0 ? void 0 : _this$links.services, services)) {
         this.emitScoped({
           file: 'locus-info',
-          function: 'updateServices'
+          function: 'updateLinks'
         }, _constants.LOCUSINFO.EVENTS.LINKS_SERVICES, {
           services: services
         });
       }
-    }
-
-    /**
-     * @param {Object} resources
-     * @returns {undefined}
-     * @memberof LocusInfo
-     */
-  }, {
-    key: "updateResources",
-    value: function updateResources(resources) {
-      if (resources && !(0, _lodash.isEqual)(this.resources, resources)) {
-        this.resources = resources;
+      if (resources && !(0, _lodash.isEqual)((_this$links2 = this.links) === null || _this$links2 === void 0 ? void 0 : _this$links2.resources, resources)) {
         this.emitScoped({
           file: 'locus-info',
-          function: 'updateResources'
+          function: 'updateLinks'
         }, _constants.LOCUSINFO.EVENTS.LINKS_RESOURCES, {
           resources: resources
         });
       }
+      this.links = links;
     }
 
     /**
@@ -1245,28 +1704,15 @@ var LocusInfo = exports.default = /*#__PURE__*/function (_EventsScope) {
     }
 
     /**
-     * @param {String} participantsUrl
+     * @param {Object} replaces
      * @returns {undefined}
      * @memberof LocusInfo
      */
   }, {
-    key: "updateParticipantsUrl",
-    value: function updateParticipantsUrl(participantsUrl) {
-      if (participantsUrl && !(0, _lodash.isEqual)(this.participantsUrl, participantsUrl)) {
-        this.participantsUrl = participantsUrl;
-      }
-    }
-
-    /**
-     * @param {Object} replace
-     * @returns {undefined}
-     * @memberof LocusInfo
-     */
-  }, {
-    key: "updateReplace",
-    value: function updateReplace(replace) {
-      if (replace && !(0, _lodash.isEqual)(this.replace, replace)) {
-        this.replace = replace;
+    key: "updateReplaces",
+    value: function updateReplaces(replaces) {
+      if (replaces && !(0, _lodash.isEqual)(this.replaces, replaces)) {
+        this.replaces = replaces;
       }
     }
 
@@ -1525,32 +1971,6 @@ var LocusInfo = exports.default = /*#__PURE__*/function (_EventsScope) {
       }
     }
 
-    /**
-     * @param {Object} membership
-     * @returns {undefined}
-     * @memberof LocusInfo
-     */
-  }, {
-    key: "updateMemberShip",
-    value: function updateMemberShip(membership) {
-      if (membership && !(0, _lodash.isEqual)(this.membership, membership)) {
-        this.membership = membership;
-      }
-    }
-
-    /**
-     * @param {Array} identities
-     * @returns {undefined}
-     * @memberof LocusInfo
-     */
-  }, {
-    key: "updateIdentifiers",
-    value: function updateIdentifiers(identities) {
-      if (identities && !(0, _lodash.isEqual)(this.identities, identities)) {
-        this.identities = identities;
-      }
-    }
-
     /**
      * check the locus is main session's one or not, if is main session's, update main session cache
      * @param {Object} locus
@@ -1628,7 +2048,7 @@ var LocusInfo = exports.default = /*#__PURE__*/function (_EventsScope) {
   }, {
     key: "updateMainSessionLocusCache",
     value: function updateMainSessionLocusCache(mainLocus) {
-      var _this4 = this;
+      var _this7 = this;
       if (!mainLocus) {
         return;
       }
@@ -1637,7 +2057,7 @@ var LocusInfo = exports.default = /*#__PURE__*/function (_EventsScope) {
         // shallow merge and do special merge for participants
         (0, _lodash.assignWith)(this.mainSessionLocusCache, locusClone, function (objValue, srcValue, key) {
           if (key === 'participants') {
-            return _this4.mergeParticipants(objValue, srcValue);
+            return _this7.mergeParticipants(objValue, srcValue);
           }
           return srcValue || objValue;
         });