@webex/plugin-meetings 3.10.0-next.8 → 3.10.0-webex-services-ready.1

package/dist/hashTree/hashTreeParser.js

@@ -0,0 +1,1266 @@
+"use strict";
+
+var _Reflect$construct = require("@babel/runtime-corejs2/core-js/reflect/construct");
+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$keys3 = 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 _interopRequireDefault = require("@babel/runtime-corejs2/helpers/interopRequireDefault");
+_Object$defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.LocusInfoUpdateType = void 0;
+exports.isSelf = isSelf;
+var _regenerator = _interopRequireDefault(require("@babel/runtime-corejs2/regenerator"));
+var _stringify = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/json/stringify"));
+var _promise = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/promise"));
+var _isArray = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/array/is-array"));
+var _keys = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/object/keys"));
+var _values = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/object/values"));
+var _parseInt2 = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/parse-int"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/slicedToArray"));
+var _typeof2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/typeof"));
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/toConsumableArray"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/asyncToGenerator"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/defineProperty"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/createClass"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/classCallCheck"));
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/possibleConstructorReturn"));
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/getPrototypeOf"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/inherits"));
+var _wrapNativeSuper2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/wrapNativeSuper"));
+var _lodash = require("lodash");
+var _hashTree = _interopRequireDefault(require("./hashTree"));
+var _loggerProxy = _interopRequireDefault(require("../common/logs/logger-proxy"));
+var _constants = require("../constants");
+var _constants2 = require("./constants");
+var _types = require("./types");
+var _utils = require("./utils");
+function ownKeys(e, r) { var t = _Object$keys3(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 _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 _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; })(); }
+var LocusInfoUpdateType = exports.LocusInfoUpdateType = {
+  OBJECTS_UPDATED: 'OBJECTS_UPDATED',
+  MEETING_ENDED: 'MEETING_ENDED'
+};
+/**
+ * This error is thrown if we receive information that the meeting has ended while we're processing some hash messages.
+ * It's handled internally by HashTreeParser and results in MEETING_ENDED being sent up.
+ */
+var MeetingEndedError = /*#__PURE__*/function (_Error) {
+  function MeetingEndedError() {
+    (0, _classCallCheck2.default)(this, MeetingEndedError);
+    return _callSuper(this, MeetingEndedError, arguments);
+  }
+  (0, _inherits2.default)(MeetingEndedError, _Error);
+  return (0, _createClass2.default)(MeetingEndedError);
+}(/*#__PURE__*/(0, _wrapNativeSuper2.default)(Error));
+/**
+ * Checks if the given hash tree object is of type "self"
+ * @param {HashTreeObject} object object to check
+ * @returns {boolean} True if the object is of type "self", false otherwise
+ */
+function isSelf(object) {
+  return object.htMeta.elementId.type.toLowerCase() === _types.ObjectType.self;
+}
+
+/**
+ * Parses hash tree eventing locus data
+ */
+var HashTreeParser = /*#__PURE__*/function () {
+  /**
+   * Constructor for HashTreeParser
+   * @param {Object} options
+   * @param {Object} options.initialLocus The initial locus data containing the hash tree information
+   */
+  function HashTreeParser(options) {
+    var _locus$self;
+    (0, _classCallCheck2.default)(this, HashTreeParser);
+    (0, _defineProperty2.default)(this, "dataSets", {});
+    (0, _defineProperty2.default)(this, "visibleDataSetsUrl", void 0);
+    // url from which we can get info about all data sets
+    (0, _defineProperty2.default)(this, "webexRequest", void 0);
+    (0, _defineProperty2.default)(this, "locusInfoUpdateCallback", void 0);
+    (0, _defineProperty2.default)(this, "visibleDataSets", void 0);
+    (0, _defineProperty2.default)(this, "debugId", void 0);
+    var _options$initialLocus = options.initialLocus,
+      dataSets = _options$initialLocus.dataSets,
+      locus = _options$initialLocus.locus; // extract dataSets from initialLocus
+
+    this.debugId = options.debugId;
+    this.webexRequest = options.webexRequest;
+    this.locusInfoUpdateCallback = options.locusInfoUpdateCallback;
+    this.visibleDataSets = (locus === null || locus === void 0 ? void 0 : (_locus$self = locus.self) === null || _locus$self === void 0 ? void 0 : _locus$self.visibleDataSets) || [];
+    if (this.visibleDataSets.length === 0) {
+      _loggerProxy.default.logger.warn("HashTreeParser#constructor --> ".concat(this.debugId, " No visibleDataSets found in locus.self"));
+    }
+    // object mapping dataset names to arrays of leaf data
+    var leafData = this.analyzeLocusHtMeta(locus);
+    _loggerProxy.default.logger.info("HashTreeParser#constructor --> creating HashTreeParser for datasets: ".concat((0, _stringify.default)(dataSets.map(function (ds) {
+      return ds.name;
+    }))));
+    var _iterator = _createForOfIteratorHelper(dataSets),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var dataSet = _step.value;
+        var name = dataSet.name,
+          leafCount = dataSet.leafCount;
+        this.dataSets[name] = _objectSpread(_objectSpread({}, dataSet), {}, {
+          hashTree: this.visibleDataSets.includes(name) ? new _hashTree.default(leafData[name] || [], leafCount) : undefined
+        });
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+  }
+
+  /**
+   * 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}
+   */
+  return (0, _createClass2.default)(HashTreeParser, [{
+    key: "initializeNewVisibleDataSet",
+    value: function initializeNewVisibleDataSet(dataSet) {
+      if (this.visibleDataSets.includes(dataSet.name)) {
+        _loggerProxy.default.logger.info("HashTreeParser#initializeNewVisibleDataSet --> ".concat(this.debugId, " Data set \"").concat(dataSet.name, "\" already exists, skipping init"));
+        return _promise.default.resolve({
+          updateType: LocusInfoUpdateType.OBJECTS_UPDATED,
+          updatedObjects: []
+        });
+      }
+      _loggerProxy.default.logger.info("HashTreeParser#initializeNewVisibleDataSet --> ".concat(this.debugId, " Adding visible data set \"").concat(dataSet.name, "\""));
+      this.visibleDataSets.push(dataSet.name);
+      var hashTree = new _hashTree.default([], dataSet.leafCount);
+      this.dataSets[dataSet.name] = _objectSpread(_objectSpread({}, dataSet), {}, {
+        hashTree: hashTree
+      });
+      return this.sendInitializationSyncRequestToLocus(dataSet.name, 'new visible data set');
+    }
+
+    /**
+     * 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}
+     */
+  }, {
+    key: "sendInitializationSyncRequestToLocus",
+    value: function sendInitializationSyncRequestToLocus(datasetName, debugText) {
+      var _this = this;
+      var dataset = this.dataSets[datasetName];
+      if (!dataset) {
+        _loggerProxy.default.logger.warn("HashTreeParser#sendInitializationSyncRequestToLocus --> ".concat(this.debugId, " No data set found for ").concat(datasetName, ", cannot send the request for leaf data"));
+        return _promise.default.resolve(null);
+      }
+      var emptyLeavesData = new Array(dataset.leafCount).fill([]);
+      _loggerProxy.default.logger.info("HashTreeParser#sendInitializationSyncRequestToLocus --> ".concat(this.debugId, " Sending initial sync request to Locus for data set \"").concat(datasetName, "\" with empty leaf data"));
+      return this.sendSyncRequestToLocus(this.dataSets[datasetName], emptyLeavesData).then(function (syncResponse) {
+        if (syncResponse) {
+          return _this.parseMessage(syncResponse, "via empty leaves /sync API call for ".concat(debugText));
+        }
+        return {
+          updateType: LocusInfoUpdateType.OBJECTS_UPDATED,
+          updatedObjects: []
+        };
+      });
+    }
+
+    /**
+     * 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}
+     */
+  }, {
+    key: "getAllDataSetsMetadata",
+    value: function getAllDataSetsMetadata(url) {
+      return this.webexRequest({
+        method: _constants.HTTP_VERBS.GET,
+        uri: url
+      }).then(function (response) {
+        return response.body.dataSets;
+      });
+    }
+
+    /**
+     * Initializes the hash tree parser from a message received from Locus.
+     *
+     * @param {HashTreeMessage} message - initial hash tree message received from Locus
+     * @returns {Promise}
+     */
+  }, {
+    key: "initializeFromMessage",
+    value: (function () {
+      var _initializeFromMessage = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee(message) {
+        var dataSets;
+        return _regenerator.default.wrap(function (_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              _loggerProxy.default.logger.info("HashTreeParser#initializeFromMessage --> ".concat(this.debugId, " visibleDataSetsUrl=").concat(message.visibleDataSetsUrl));
+              _context.next = 1;
+              return this.getAllDataSetsMetadata(message.visibleDataSetsUrl);
+            case 1:
+              dataSets = _context.sent;
+              _context.next = 2;
+              return this.initializeDataSets(dataSets, 'initialization from message');
+            case 2:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this);
+      }));
+      function initializeFromMessage(_x) {
+        return _initializeFromMessage.apply(this, arguments);
+      }
+      return initializeFromMessage;
+    }()
+    /**
+     * Initializes the hash tree parser from GET /loci API response by fetching all data sets metadata
+     * first and then doing an initialization sync on each data set
+     *
+     * This function requires that this.visibleDataSets have been already populated correctly by the constructor.
+     *
+     * @param {LocusDTO} locus - locus object received from GET /loci
+     * @returns {Promise}
+     */
+    )
+  }, {
+    key: "initializeFromGetLociResponse",
+    value: (function () {
+      var _initializeFromGetLociResponse = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee2(locus) {
+        var _locus$links, _locus$links$resource, _locus$links$resource2;
+        var dataSets;
+        return _regenerator.default.wrap(function (_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              if (locus !== null && locus !== void 0 && (_locus$links = locus.links) !== null && _locus$links !== void 0 && (_locus$links$resource = _locus$links.resources) !== null && _locus$links$resource !== void 0 && (_locus$links$resource2 = _locus$links$resource.visibleDataSets) !== null && _locus$links$resource2 !== void 0 && _locus$links$resource2.url) {
+                _context2.next = 1;
+                break;
+              }
+              _loggerProxy.default.logger.warn("HashTreeParser#initializeFromGetLociResponse --> ".concat(this.debugId, " missing visibleDataSets url in GET Loci response, cannot initialize hash trees"));
+              return _context2.abrupt("return");
+            case 1:
+              _loggerProxy.default.logger.info("HashTreeParser#initializeFromGetLociResponse --> ".concat(this.debugId, " visibleDataSets url: ").concat(locus.links.resources.visibleDataSets.url));
+              _context2.next = 2;
+              return this.getAllDataSetsMetadata(locus.links.resources.visibleDataSets.url);
+            case 2:
+              dataSets = _context2.sent;
+              _context2.next = 3;
+              return this.initializeDataSets(dataSets, 'initialization from GET /loci response');
+            case 3:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, this);
+      }));
+      function initializeFromGetLociResponse(_x2) {
+        return _initializeFromGetLociResponse.apply(this, arguments);
+      }
+      return initializeFromGetLociResponse;
+    }()
+    /**
+     * 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}
+     */
+    )
+  }, {
+    key: "initializeDataSets",
+    value: (function () {
+      var _initializeDataSets = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee3(dataSets, debugText) {
+        var updatedObjects, _iterator2, _step2, dataSet, name, leafCount, _data, _t;
+        return _regenerator.default.wrap(function (_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              updatedObjects = [];
+              _iterator2 = _createForOfIteratorHelper(dataSets);
+              _context3.prev = 1;
+              _iterator2.s();
+            case 2:
+              if ((_step2 = _iterator2.n()).done) {
+                _context3.next = 6;
+                break;
+              }
+              dataSet = _step2.value;
+              name = dataSet.name, leafCount = dataSet.leafCount;
+              if (!this.dataSets[name]) {
+                _loggerProxy.default.logger.info("HashTreeParser#initializeDataSets --> ".concat(this.debugId, " initializing dataset \"").concat(name, "\" (").concat(debugText, ")"));
+                this.dataSets[name] = _objectSpread({}, dataSet);
+              } else {
+                _loggerProxy.default.logger.info("HashTreeParser#initializeDataSets --> ".concat(this.debugId, " dataset \"").concat(name, "\" already exists (").concat(debugText, ")"));
+              }
+              if (!(this.visibleDataSets.includes(name) && !this.dataSets[name].hashTree)) {
+                _context3.next = 5;
+                break;
+              }
+              _loggerProxy.default.logger.info("HashTreeParser#initializeDataSets --> ".concat(this.debugId, " creating hash tree for visible dataset \"").concat(name, "\" (").concat(debugText, ")"));
+              this.dataSets[name].hashTree = new _hashTree.default([], leafCount);
+
+              // eslint-disable-next-line no-await-in-loop
+              _context3.next = 3;
+              return this.sendInitializationSyncRequestToLocus(name, debugText);
+            case 3:
+              _data = _context3.sent;
+              if (!(_data.updateType === LocusInfoUpdateType.MEETING_ENDED)) {
+                _context3.next = 4;
+                break;
+              }
+              _loggerProxy.default.logger.warn("HashTreeParser#initializeDataSets --> ".concat(this.debugId, " meeting ended while initializing new visible data set \"").concat(name, "\""));
+
+              // throw an error, it will be caught higher up and the meeting will be destroyed
+              throw new MeetingEndedError();
+            case 4:
+              if (_data.updateType === LocusInfoUpdateType.OBJECTS_UPDATED) {
+                updatedObjects.push.apply(updatedObjects, (0, _toConsumableArray2.default)(_data.updatedObjects || []));
+              }
+            case 5:
+              _context3.next = 2;
+              break;
+            case 6:
+              _context3.next = 8;
+              break;
+            case 7:
+              _context3.prev = 7;
+              _t = _context3["catch"](1);
+              _iterator2.e(_t);
+            case 8:
+              _context3.prev = 8;
+              _iterator2.f();
+              return _context3.finish(8);
+            case 9:
+              this.callLocusInfoUpdateCallback({
+                updateType: LocusInfoUpdateType.OBJECTS_UPDATED,
+                updatedObjects: updatedObjects
+              });
+            case 10:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3, this, [[1, 7, 8, 9]]);
+      }));
+      function initializeDataSets(_x3, _x4) {
+        return _initializeDataSets.apply(this, arguments);
+      }
+      return 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
+     */
+    )
+  }, {
+    key: "analyzeLocusHtMeta",
+    value: function analyzeLocusHtMeta(locus, options) {
+      var _ref = options || {},
+        _ref$copyData = _ref.copyData,
+        copyData = _ref$copyData === void 0 ? false : _ref$copyData;
+      // object mapping dataset names to arrays of leaf data
+      var leafInfo = {};
+      var _findAndStoreMetaData = function findAndStoreMetaData(currentLocusPart) {
+        if ((0, _typeof2.default)(currentLocusPart) !== 'object' || currentLocusPart === null) {
+          return;
+        }
+        if (currentLocusPart.htMeta && currentLocusPart.htMeta.dataSetNames) {
+          var _currentLocusPart$htM = currentLocusPart.htMeta.elementId,
+            type = _currentLocusPart$htM.type,
+            id = _currentLocusPart$htM.id,
+            version = _currentLocusPart$htM.version;
+          var dataSetNames = currentLocusPart.htMeta.dataSetNames;
+          var newLeafInfo = {
+            type: type,
+            id: id,
+            version: version
+          };
+          if (copyData) {
+            newLeafInfo.data = (0, _lodash.cloneDeep)(currentLocusPart);
+
+            // remove any nested other objects that have their own htMeta
+            (0, _utils.deleteNestedObjectsWithHtMeta)(newLeafInfo.data);
+          }
+          var _iterator3 = _createForOfIteratorHelper(dataSetNames),
+            _step3;
+          try {
+            for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+              var dataSetName = _step3.value;
+              if (!leafInfo[dataSetName]) {
+                leafInfo[dataSetName] = [];
+              }
+              leafInfo[dataSetName].push(newLeafInfo);
+            }
+          } catch (err) {
+            _iterator3.e(err);
+          } finally {
+            _iterator3.f();
+          }
+        }
+        if ((0, _isArray.default)(currentLocusPart)) {
+          var _iterator4 = _createForOfIteratorHelper(currentLocusPart),
+            _step4;
+          try {
+            for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+              var item = _step4.value;
+              _findAndStoreMetaData(item);
+            }
+          } catch (err) {
+            _iterator4.e(err);
+          } finally {
+            _iterator4.f();
+          }
+        } else {
+          for (var _i = 0, _Object$keys = (0, _keys.default)(currentLocusPart); _i < _Object$keys.length; _i++) {
+            var key = _Object$keys[_i];
+            if (Object.prototype.hasOwnProperty.call(currentLocusPart, key)) {
+              _findAndStoreMetaData(currentLocusPart[key]);
+            }
+          }
+        }
+      };
+      _findAndStoreMetaData(locus);
+      return leafInfo;
+    }
+
+    /**
+     * 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
+     */
+  }, {
+    key: "isEndMessage",
+    value: function isEndMessage(message) {
+      var mainDataSet = message.dataSets.find(function (dataSet) {
+        return dataSet.name.toLowerCase() === _constants2.DataSetNames.MAIN;
+      });
+      if (mainDataSet && mainDataSet.leafCount === 1 && mainDataSet.root === _constants2.EMPTY_HASH && this.dataSets[_constants2.DataSetNames.MAIN].version < mainDataSet.version) {
+        // this is a special way for Locus to indicate that this meeting has ended
+        return true;
+      }
+      return false;
+    }
+
+    /**
+     * Handles the root hash heartbeat message
+     *
+     * @param {RootHashMessage} message - The root hash heartbeat message
+     * @returns {void}
+     */
+  }, {
+    key: "handleRootHashHeartBeatMessage",
+    value: function handleRootHashHeartBeatMessage(message) {
+      var _this2 = this;
+      var dataSets = message.dataSets;
+      _loggerProxy.default.logger.info("HashTreeParser#handleRootHashMessage --> ".concat(this.debugId, " Received heartbeat root hash message with data sets: ").concat((0, _stringify.default)(dataSets.map(function (_ref2) {
+        var name = _ref2.name,
+          root = _ref2.root,
+          leafCount = _ref2.leafCount,
+          version = _ref2.version;
+        return {
+          name: name,
+          root: root,
+          leafCount: leafCount,
+          version: version
+        };
+      }))));
+      dataSets.forEach(function (dataSet) {
+        _this2.updateDataSetInfo(dataSet);
+        _this2.runSyncAlgorithm(dataSet);
+      });
+    }
+
+    /**
+     * 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
+     *
+     * @param {Object} update - The locus update containing data sets and locus information
+     * @returns {void}
+     */
+  }, {
+    key: "handleLocusUpdate",
+    value: function handleLocusUpdate(update) {
+      var _this3 = this;
+      var dataSets = update.dataSets,
+        locus = update.locus;
+      if (!dataSets) {
+        _loggerProxy.default.logger.warn("HashTreeParser#handleLocusUpdate --> ".concat(this.debugId, " received hash tree update without dataSets"));
+      }
+      var _iterator5 = _createForOfIteratorHelper(dataSets),
+        _step5;
+      try {
+        for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+          var dataSet = _step5.value;
+          this.updateDataSetInfo(dataSet);
+        }
+      } catch (err) {
+        _iterator5.e(err);
+      } finally {
+        _iterator5.f();
+      }
+      var updatedObjects = [];
+
+      // first, analyze the locus object to extract the hash tree objects' htMeta and data from it
+      var leafInfo = this.analyzeLocusHtMeta(locus, {
+        copyData: true
+      });
+
+      // then process the data in hash trees, if it is a new version, then add it to updatedObjects
+      (0, _keys.default)(leafInfo).forEach(function (dataSetName) {
+        if (_this3.dataSets[dataSetName]) {
+          if (_this3.dataSets[dataSetName].hashTree) {
+            var appliedChangesList = _this3.dataSets[dataSetName].hashTree.putItems(leafInfo[dataSetName].map(function (leaf) {
+              return {
+                id: leaf.id,
+                type: leaf.type,
+                version: leaf.version
+              };
+            }));
+            (0, _lodash.zip)(appliedChangesList, leafInfo[dataSetName]).forEach(function (_ref3) {
+              var _ref4 = (0, _slicedToArray2.default)(_ref3, 2),
+                changeApplied = _ref4[0],
+                leaf = _ref4[1];
+              if (changeApplied) {
+                updatedObjects.push({
+                  htMeta: {
+                    elementId: {
+                      type: leaf.type,
+                      id: leaf.id,
+                      version: leaf.version
+                    },
+                    dataSetNames: [dataSetName]
+                  },
+                  data: leaf.data
+                });
+              }
+            });
+          } else {
+            // no hash tree means that the data set is not visible
+            _loggerProxy.default.logger.warn("HashTreeParser#handleLocusUpdate --> ".concat(_this3.debugId, " received leaf data for data set \"").concat(dataSetName, "\" that has no hash tree created, ignoring"));
+          }
+        } else {
+          _loggerProxy.default.logger.warn("HashTreeParser#handleLocusUpdate --> ".concat(_this3.debugId, " received leaf data for unknown data set \"").concat(dataSetName, "\", ignoring"));
+        }
+      });
+      if (updatedObjects.length === 0) {
+        _loggerProxy.default.logger.info("HashTreeParser#handleLocusUpdate --> ".concat(this.debugId, " No objects updated as a result of received API response"));
+      } else {
+        this.callLocusInfoUpdateCallback({
+          updateType: LocusInfoUpdateType.OBJECTS_UPDATED,
+          updatedObjects: updatedObjects
+        });
+      }
+
+      // todo: once Locus design on how visible data sets will be communicated in subsequent API responses is confirmed,
+      // we'll need to check here if visible data sets have changed and update this.visibleDataSets, remove/create hash trees etc
+    }
+
+    /**
+     * 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}
+     */
+  }, {
+    key: "updateDataSetInfo",
+    value: function updateDataSetInfo(receivedDataSet) {
+      if (!this.dataSets[receivedDataSet.name]) {
+        this.dataSets[receivedDataSet.name] = _objectSpread({}, receivedDataSet);
+        _loggerProxy.default.logger.info("HashTreeParser#handleMessage --> ".concat(this.debugId, " created entry for \"").concat(receivedDataSet.name, "\" dataset: version=").concat(receivedDataSet.version, ", root=").concat(receivedDataSet.root));
+        return;
+      }
+      // update our version of the dataSet
+      if (this.dataSets[receivedDataSet.name].version < receivedDataSet.version) {
+        this.dataSets[receivedDataSet.name].version = receivedDataSet.version;
+        this.dataSets[receivedDataSet.name].root = receivedDataSet.root;
+        this.dataSets[receivedDataSet.name].idleMs = receivedDataSet.idleMs;
+        this.dataSets[receivedDataSet.name].backoff = {
+          maxMs: receivedDataSet.backoff.maxMs,
+          exponent: receivedDataSet.backoff.exponent
+        };
+        _loggerProxy.default.logger.info("HashTreeParser#handleMessage --> ".concat(this.debugId, " updated \"").concat(receivedDataSet.name, "\" to version=").concat(receivedDataSet.version, ", root=").concat(receivedDataSet.root));
+      }
+    }
+
+    /**
+     * 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.
+     */
+  }, {
+    key: "checkForVisibleDataSetChanges",
+    value: function checkForVisibleDataSetChanges(updatedObjects) {
+      var _this4 = this;
+      var removedDataSets = [];
+      var addedDataSets = [];
+
+      // visibleDataSets can only be changed by self object updates
+      updatedObjects.forEach(function (object) {
+        var _object$data;
+        // todo: in the future visibleDataSets will be in "Metadata" object, not in "self"
+        if (isSelf(object) && (_object$data = object.data) !== null && _object$data !== void 0 && _object$data.visibleDataSets) {
+          var newVisibleDataSets = object.data.visibleDataSets;
+          removedDataSets = _this4.visibleDataSets.filter(function (ds) {
+            return !newVisibleDataSets.includes(ds);
+          });
+          addedDataSets = newVisibleDataSets.filter(function (ds) {
+            return !_this4.visibleDataSets.includes(ds);
+          });
+          if (removedDataSets.length > 0 || addedDataSets.length > 0) {
+            _loggerProxy.default.logger.info("HashTreeParser#checkForVisibleDataSetChanges --> ".concat(_this4.debugId, " visible data sets change: removed: ").concat(removedDataSets.join(', '), ", added: ").concat(addedDataSets.join(', ')));
+          }
+        }
+      });
+      return {
+        changeDetected: removedDataSets.length > 0 || addedDataSets.length > 0,
+        removedDataSets: removedDataSets,
+        addedDataSets: addedDataSets
+      };
+    }
+
+    /**
+     * Deletes the hash tree for the specified data set.
+     *
+     * @param {string} dataSetName name of the data set to delete
+     * @returns {void}
+     */
+  }, {
+    key: "deleteHashTree",
+    value: function deleteHashTree(dataSetName) {
+      this.dataSets[dataSetName].hashTree = undefined;
+
+      // we also need to stop the timer as there is no hash tree anymore to sync
+      if (this.dataSets[dataSetName].timer) {
+        clearTimeout(this.dataSets[dataSetName].timer);
+        this.dataSets[dataSetName].timer = undefined;
+      }
+    }
+
+    /**
+     * 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
+     */
+  }, {
+    key: "processVisibleDataSetChanges",
+    value: function processVisibleDataSetChanges(removedDataSets, addedDataSets, updatedObjects) {
+      var _this5 = this;
+      var dataSetsRequiringInitialization = [];
+
+      // if a visible data set was removed, we need to tell our client that all objects from it are removed
+      var removedObjects = [];
+      removedDataSets.forEach(function (ds) {
+        var _this5$dataSets$ds;
+        if ((_this5$dataSets$ds = _this5.dataSets[ds]) !== null && _this5$dataSets$ds !== void 0 && _this5$dataSets$ds.hashTree) {
+          for (var i = 0; i < _this5.dataSets[ds].hashTree.numLeaves; i += 1) {
+            removedObjects.push.apply(removedObjects, (0, _toConsumableArray2.default)(_this5.dataSets[ds].hashTree.getLeafData(i).map(function (elementId) {
+              return {
+                htMeta: {
+                  elementId: elementId,
+                  dataSetNames: [ds]
+                },
+                data: null
+              };
+            })));
+          }
+          _this5.deleteHashTree(ds);
+        }
+      });
+      this.visibleDataSets = this.visibleDataSets.filter(function (vds) {
+        return !removedDataSets.includes(vds);
+      });
+      updatedObjects.push.apply(updatedObjects, removedObjects);
+
+      // now setup the new visible data sets
+      var _iterator6 = _createForOfIteratorHelper(addedDataSets),
+        _step6;
+      try {
+        for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+          var ds = _step6.value;
+          var dataSetInfo = this.dataSets[ds];
+          if (dataSetInfo) {
+            if (this.visibleDataSets.includes(dataSetInfo.name)) {
+              _loggerProxy.default.logger.info("HashTreeParser#processVisibleDataSetChanges --> ".concat(this.debugId, " Data set \"").concat(ds, "\" is already visible, skipping"));
+
+              // eslint-disable-next-line no-continue
+              continue;
+            }
+            _loggerProxy.default.logger.info("HashTreeParser#processVisibleDataSetChanges --> ".concat(this.debugId, " Adding visible data set \"").concat(ds, "\""));
+            this.visibleDataSets.push(ds);
+            var hashTree = new _hashTree.default([], dataSetInfo.leafCount);
+            this.dataSets[dataSetInfo.name] = _objectSpread(_objectSpread({}, dataSetInfo), {}, {
+              hashTree: hashTree
+            });
+          } else {
+            _loggerProxy.default.logger.info("HashTreeParser#processVisibleDataSetChanges --> ".concat(this.debugId, " visible data set \"").concat(ds, "\" added but no info about it in our dataSets structures"));
+            // todo: add a metric here
+            dataSetsRequiringInitialization.push(ds);
+          }
+        }
+      } catch (err) {
+        _iterator6.e(err);
+      } finally {
+        _iterator6.f();
+      }
+      return dataSetsRequiringInitialization;
+    }
+
+    /**
+     * 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>}
+     */
+  }, {
+    key: "initializeNewVisibleDataSets",
+    value: (function () {
+      var _initializeNewVisibleDataSets = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee4(message, addedDataSets) {
+        var _this6 = this;
+        var allDataSets, _iterator7, _step7, _loop, _t2;
+        return _regenerator.default.wrap(function (_context5) {
+          while (1) switch (_context5.prev = _context5.next) {
+            case 0:
+              _context5.next = 1;
+              return this.getAllDataSetsMetadata(message.visibleDataSetsUrl);
+            case 1:
+              allDataSets = _context5.sent;
+              _iterator7 = _createForOfIteratorHelper(addedDataSets);
+              _context5.prev = 2;
+              _loop = /*#__PURE__*/_regenerator.default.mark(function _loop() {
+                var ds, dataSetInfo, updates;
+                return _regenerator.default.wrap(function (_context4) {
+                  while (1) switch (_context4.prev = _context4.next) {
+                    case 0:
+                      ds = _step7.value;
+                      dataSetInfo = allDataSets.find(function (d) {
+                        return d.name === ds;
+                      });
+                      _loggerProxy.default.logger.info("HashTreeParser#initializeNewVisibleDataSets --> ".concat(_this6.debugId, " initializing data set \"").concat(ds, "\""));
+                      if (dataSetInfo) {
+                        _context4.next = 1;
+                        break;
+                      }
+                      _loggerProxy.default.logger.warn("HashTreeParser#handleHashTreeMessage --> ".concat(_this6.debugId, " missing info about data set \"").concat(ds, "\" in Locus response from visibleDataSetsUrl"));
+                      _context4.next = 3;
+                      break;
+                    case 1:
+                      _context4.next = 2;
+                      return _this6.initializeNewVisibleDataSet(dataSetInfo);
+                    case 2:
+                      updates = _context4.sent;
+                      _this6.callLocusInfoUpdateCallback(updates);
+                    case 3:
+                    case "end":
+                      return _context4.stop();
+                  }
+                }, _loop);
+              });
+              _iterator7.s();
+            case 3:
+              if ((_step7 = _iterator7.n()).done) {
+                _context5.next = 5;
+                break;
+              }
+              return _context5.delegateYield(_loop(), "t0", 4);
+            case 4:
+              _context5.next = 3;
+              break;
+            case 5:
+              _context5.next = 7;
+              break;
+            case 6:
+              _context5.prev = 6;
+              _t2 = _context5["catch"](2);
+              _iterator7.e(_t2);
+            case 7:
+              _context5.prev = 7;
+              _iterator7.f();
+              return _context5.finish(7);
+            case 8:
+            case "end":
+              return _context5.stop();
+          }
+        }, _callee4, this, [[2, 6, 7, 8]]);
+      }));
+      function initializeNewVisibleDataSets(_x5, _x6) {
+        return _initializeNewVisibleDataSets.apply(this, arguments);
+      }
+      return 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}
+     */
+    )
+  }, {
+    key: "parseMessage",
+    value: (function () {
+      var _parseMessage = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee5(message, debugText) {
+        var _message$locusStateEl,
+          _this7 = this;
+        var dataSets, visibleDataSetsUrl, isRosterDropped, updatedObjects, dataSetsRequiringInitialization, selfUpdates, updatedSelfObjects, _this$checkForVisible, changeDetected, removedDataSets, addedDataSets;
+        return _regenerator.default.wrap(function (_context6) {
+          while (1) switch (_context6.prev = _context6.next) {
+            case 0:
+              dataSets = message.dataSets, visibleDataSetsUrl = message.visibleDataSetsUrl;
+              _loggerProxy.default.logger.info("HashTreeParser#parseMessage --> ".concat(this.debugId, " received message ").concat(debugText || '', ":"), message);
+              if (((_message$locusStateEl = message.locusStateElements) === null || _message$locusStateEl === void 0 ? void 0 : _message$locusStateEl.length) === 0) {
+                _loggerProxy.default.logger.warn("HashTreeParser#parseMessage --> ".concat(this.debugId, " got empty locusStateElements!!!"));
+                // todo: send a metric
+              }
+
+              // first, update our metadata about the datasets with info from the message
+              this.visibleDataSetsUrl = visibleDataSetsUrl;
+              dataSets.forEach(function (dataSet) {
+                return _this7.updateDataSetInfo(dataSet);
+              });
+              if (!this.isEndMessage(message)) {
+                _context6.next = 1;
+                break;
+              }
+              _loggerProxy.default.logger.info("HashTreeParser#parseMessage --> ".concat(this.debugId, " received END message"));
+              this.stopAllTimers();
+              return _context6.abrupt("return", {
+                updateType: LocusInfoUpdateType.MEETING_ENDED
+              });
+            case 1:
+              isRosterDropped = false;
+              updatedObjects = []; // when we detect new visible datasets, it may be that the metadata about them is not
+              // available in the message, they will require separate async initialization
+              dataSetsRequiringInitialization = []; // first find out if there are any visible data set changes - they're signalled in SELF object updates
+              selfUpdates = (message.locusStateElements || []).filter(function (object) {
+                return (
+                  // todo: SPARK-744859 once Locus supports it, we will filter for "Metadata" type here instead of "self"
+                  isSelf(object)
+                );
+              });
+              if (selfUpdates.length > 0) {
+                updatedSelfObjects = [];
+                selfUpdates.forEach(function (object) {
+                  // todo: once Locus supports it, we will use the "view" field here instead of dataSetNames
+                  var _iterator8 = _createForOfIteratorHelper(object.htMeta.dataSetNames),
+                    _step8;
+                  try {
+                    for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
+                      var _this7$dataSets$dataS;
+                      var dataSetName = _step8.value;
+                      var hashTree = (_this7$dataSets$dataS = _this7.dataSets[dataSetName]) === null || _this7$dataSets$dataS === void 0 ? void 0 : _this7$dataSets$dataS.hashTree;
+                      if (hashTree && object.data) {
+                        if (hashTree.putItem(object.htMeta.elementId)) {
+                          updatedSelfObjects.push(object);
+                        }
+                      }
+                    }
+                  } catch (err) {
+                    _iterator8.e(err);
+                  } finally {
+                    _iterator8.f();
+                  }
+                });
+                updatedObjects.push.apply(updatedObjects, updatedSelfObjects);
+                _this$checkForVisible = this.checkForVisibleDataSetChanges(updatedSelfObjects), changeDetected = _this$checkForVisible.changeDetected, removedDataSets = _this$checkForVisible.removedDataSets, addedDataSets = _this$checkForVisible.addedDataSets;
+                if (changeDetected) {
+                  dataSetsRequiringInitialization = this.processVisibleDataSetChanges(removedDataSets, addedDataSets, updatedObjects);
+                }
+              }
+
+              // by this point we now have this.dataSets setup for data sets from this message
+              // and hash trees created for the new visible data sets,
+              // so we can now process all the updates from the message
+              dataSets.forEach(function (dataSet) {
+                if (_this7.dataSets[dataSet.name]) {
+                  var hashTree = _this7.dataSets[dataSet.name].hashTree;
+                  if (hashTree) {
+                    var locusStateElementsForThisSet = message.locusStateElements.filter(function (object) {
+                      return object.htMeta.dataSetNames.includes(dataSet.name);
+                    });
+                    var appliedChangesList = hashTree.updateItems(locusStateElementsForThisSet.map(function (object) {
+                      return object.data ? {
+                        operation: 'update',
+                        item: object.htMeta.elementId
+                      } : {
+                        operation: 'remove',
+                        item: object.htMeta.elementId
+                      };
+                    }));
+                    (0, _lodash.zip)(appliedChangesList, locusStateElementsForThisSet).forEach(function (_ref5) {
+                      var _ref6 = (0, _slicedToArray2.default)(_ref5, 2),
+                        changeApplied = _ref6[0],
+                        object = _ref6[1];
+                      if (changeApplied) {
+                        if (isSelf(object) && !object.data) {
+                          isRosterDropped = true;
+                        }
+                        // add to updatedObjects so that our locus DTO will get updated with the new object
+                        updatedObjects.push(object);
+                      }
+                    });
+                  } else {
+                    _loggerProxy.default.logger.info("Locus-info:index#parseMessage --> ".concat(_this7.debugId, " unexpected (not visible) dataSet ").concat(dataSet.name, " received in hash tree message"));
+                  }
+                }
+                if (!isRosterDropped) {
+                  _this7.runSyncAlgorithm(dataSet);
+                }
+              });
+              if (!isRosterDropped) {
+                _context6.next = 2;
+                break;
+              }
+              _loggerProxy.default.logger.info("HashTreeParser#parseMessage --> ".concat(this.debugId, " detected roster drop"));
+              this.stopAllTimers();
+
+              // in case of roster drop we don't care about other updates
+              return _context6.abrupt("return", {
+                updateType: LocusInfoUpdateType.MEETING_ENDED
+              });
+            case 2:
+              if (dataSetsRequiringInitialization.length > 0) {
+                // there are some data sets that we need to initialize asynchronously
+                queueMicrotask(function () {
+                  _this7.initializeNewVisibleDataSets(message, dataSetsRequiringInitialization);
+                });
+              }
+              if (updatedObjects.length === 0) {
+                _loggerProxy.default.logger.info("HashTreeParser#parseMessage --> ".concat(this.debugId, " No objects updated as a result of received message"));
+              }
+              return _context6.abrupt("return", {
+                updateType: LocusInfoUpdateType.OBJECTS_UPDATED,
+                updatedObjects: updatedObjects
+              });
+            case 3:
+            case "end":
+              return _context6.stop();
+          }
+        }, _callee5, this);
+      }));
+      function parseMessage(_x7, _x8) {
+        return _parseMessage.apply(this, arguments);
+      }
+      return parseMessage;
+    }()
+    /**
+     * Handles incoming hash tree messages, updates the hash trees and calls locusInfoUpdateCallback
+     *
+     * @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 {void}
+     */
+    )
+  }, {
+    key: "handleMessage",
+    value: (function () {
+      var _handleMessage = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee6(message, debugText) {
+        var updates;
+        return _regenerator.default.wrap(function (_context7) {
+          while (1) switch (_context7.prev = _context7.next) {
+            case 0:
+              if (!(message.locusStateElements === undefined)) {
+                _context7.next = 1;
+                break;
+              }
+              this.handleRootHashHeartBeatMessage(message);
+              _context7.next = 3;
+              break;
+            case 1:
+              _context7.next = 2;
+              return this.parseMessage(message, debugText);
+            case 2:
+              updates = _context7.sent;
+              this.callLocusInfoUpdateCallback(updates);
+            case 3:
+            case "end":
+              return _context7.stop();
+          }
+        }, _callee6, this);
+      }));
+      function handleMessage(_x9, _x0) {
+        return _handleMessage.apply(this, arguments);
+      }
+      return handleMessage;
+    }()
+    /**
+     * Calls the updateInfo callback if there are any updates to report
+     *
+     * @param {Object} updates parsed from a Locus message
+     * @returns {void}
+     */
+    )
+  }, {
+    key: "callLocusInfoUpdateCallback",
+    value: function callLocusInfoUpdateCallback(updates) {
+      var updateType = updates.updateType,
+        updatedObjects = updates.updatedObjects;
+      if (updateType !== LocusInfoUpdateType.OBJECTS_UPDATED || (updatedObjects === null || updatedObjects === void 0 ? void 0 : updatedObjects.length) > 0) {
+        this.locusInfoUpdateCallback(updateType, {
+          updatedObjects: updatedObjects
+        });
+      }
+    }
+
+    /**
+     * 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
+     */
+  }, {
+    key: "getWeightedBackoffTime",
+    value: function getWeightedBackoffTime(backoff) {
+      var maxMs = backoff.maxMs,
+        exponent = backoff.exponent;
+      var randomValue = Math.random();
+      return Math.round(Math.pow(randomValue, exponent) * maxMs);
+    }
+
+    /**
+     * Runs the sync algorithm for the given data set.
+     *
+     * @param {DataSet} receivedDataSet - The data set to run the sync algorithm for.
+     * @returns {void}
+     */
+  }, {
+    key: "runSyncAlgorithm",
+    value: function runSyncAlgorithm(receivedDataSet) {
+      var _this8 = this;
+      var dataSet = this.dataSets[receivedDataSet.name];
+      if (!dataSet) {
+        _loggerProxy.default.logger.warn("HashTreeParser#runSyncAlgorithm --> ".concat(this.debugId, " No data set found for ").concat(receivedDataSet.name, ", skipping sync algorithm"));
+        return;
+      }
+      if (!dataSet.hashTree) {
+        _loggerProxy.default.logger.info("HashTreeParser#runSyncAlgorithm --> ".concat(this.debugId, " Data set \"").concat(dataSet.name, "\" has no hash tree, skipping sync algorithm"));
+        return;
+      }
+      dataSet.hashTree.resize(receivedDataSet.leafCount);
+
+      // temporary log for the workshop // todo: remove
+      var ourCurrentRootHash = dataSet.hashTree.getRootHash();
+      _loggerProxy.default.logger.info("HashTreeParser#runSyncAlgorithm --> ".concat(this.debugId, " dataSet=\"").concat(dataSet.name, "\" version=").concat(dataSet.version, " hashes before starting timer: ours=").concat(ourCurrentRootHash, " Locus=").concat(dataSet.root));
+      var delay = dataSet.idleMs + this.getWeightedBackoffTime(dataSet.backoff);
+      if (delay > 0) {
+        if (dataSet.timer) {
+          clearTimeout(dataSet.timer);
+        }
+        _loggerProxy.default.logger.info("HashTreeParser#runSyncAlgorithm --> ".concat(this.debugId, " setting \"").concat(dataSet.name, "\" sync timer for ").concat(delay));
+        dataSet.timer = setTimeout(/*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee7() {
+          var rootHash, mismatchedLeavesData, receivedHashes, _yield$_this8$getHash, hashes, latestDataSetInfo, mismatchedLeaveIndexes, syncResponse, _t3;
+          return _regenerator.default.wrap(function (_context8) {
+            while (1) switch (_context8.prev = _context8.next) {
+              case 0:
+                dataSet.timer = undefined;
+                if (dataSet.hashTree) {
+                  _context8.next = 1;
+                  break;
+                }
+                _loggerProxy.default.logger.warn("HashTreeParser#runSyncAlgorithm --> ".concat(_this8.debugId, " Data set \"").concat(dataSet.name, "\" no longer has a hash tree, cannot run sync algorithm"));
+                return _context8.abrupt("return");
+              case 1:
+                rootHash = dataSet.hashTree.getRootHash();
+                if (!(dataSet.root !== rootHash)) {
+                  _context8.next = 11;
+                  break;
+                }
+                _loggerProxy.default.logger.info("HashTreeParser#runSyncAlgorithm --> ".concat(_this8.debugId, " Root hash mismatch: received=").concat(dataSet.root, ", ours=").concat(rootHash, ", syncing data set \"").concat(dataSet.name, "\""));
+                mismatchedLeavesData = {};
+                if (!(dataSet.leafCount !== 1)) {
+                  _context8.next = 7;
+                  break;
+                }
+                _context8.prev = 2;
+                _context8.next = 3;
+                return _this8.getHashesFromLocus(dataSet.name);
+              case 3:
+                _yield$_this8$getHash = _context8.sent;
+                hashes = _yield$_this8$getHash.hashes;
+                latestDataSetInfo = _yield$_this8$getHash.dataSet;
+                receivedHashes = hashes;
+                dataSet.hashTree.resize(latestDataSetInfo.leafCount);
+                _context8.next = 6;
+                break;
+              case 4:
+                _context8.prev = 4;
+                _t3 = _context8["catch"](2);
+                if (!(_t3.statusCode === 409)) {
+                  _context8.next = 5;
+                  break;
+                }
+                // this is a leaf count mismatch, we should do nothing, just wait for another heartbeat message from Locus
+                _loggerProxy.default.logger.info("HashTreeParser#getHashesFromLocus --> ".concat(_this8.debugId, " Got 409 when fetching hashes for data set \"").concat(dataSet.name, "\": ").concat(_t3.message));
+                return _context8.abrupt("return");
+              case 5:
+                throw _t3;
+              case 6:
+                // identify mismatched leaves
+                mismatchedLeaveIndexes = dataSet.hashTree.diffHashes(receivedHashes);
+                mismatchedLeaveIndexes.forEach(function (index) {
+                  mismatchedLeavesData[index] = dataSet.hashTree.getLeafData(index);
+                });
+                _context8.next = 8;
+                break;
+              case 7:
+                mismatchedLeavesData[0] = dataSet.hashTree.getLeafData(0);
+              case 8:
+                if (!((0, _keys.default)(mismatchedLeavesData).length > 0)) {
+                  _context8.next = 10;
+                  break;
+                }
+                _context8.next = 9;
+                return _this8.sendSyncRequestToLocus(dataSet, mismatchedLeavesData);
+              case 9:
+                syncResponse = _context8.sent;
+                // sync API may return nothing (in that case data will arrive via messages)
+                // or it may return a response in the same format as messages
+                if (syncResponse) {
+                  _this8.handleMessage(syncResponse, 'via sync API');
+                }
+              case 10:
+                _context8.next = 12;
+                break;
+              case 11:
+                _loggerProxy.default.logger.info("HashTreeParser#runSyncAlgorithm --> ".concat(_this8.debugId, " \"").concat(dataSet.name, "\" root hash matching: ").concat(rootHash, ", version=").concat(dataSet.version));
+              case 12:
+              case "end":
+                return _context8.stop();
+            }
+          }, _callee7, null, [[2, 4]]);
+        })), delay);
+      } else {
+        _loggerProxy.default.logger.info("HashTreeParser#runSyncAlgorithm --> ".concat(this.debugId, " No delay for \"").concat(dataSet.name, "\" data set, skipping sync timer reset/setup"));
+      }
+    }
+
+    /**
+     * Stops all timers for the data sets to prevent any further sync attempts.
+     * @returns {void}
+     */
+  }, {
+    key: "stopAllTimers",
+    value: function stopAllTimers() {
+      (0, _values.default)(this.dataSets).forEach(function (dataSet) {
+        if (dataSet.timer) {
+          clearTimeout(dataSet.timer);
+          dataSet.timer = undefined;
+        }
+      });
+    }
+
+    /**
+     * Gets the current hashes from the locus for a specific data set.
+     * @param {string} dataSetName
+     * @returns {string[]}
+     */
+  }, {
+    key: "getHashesFromLocus",
+    value: function getHashesFromLocus(dataSetName) {
+      var _this9 = this;
+      _loggerProxy.default.logger.info("HashTreeParser#getHashesFromLocus --> ".concat(this.debugId, " Requesting hashes for data set \"").concat(dataSetName, "\""));
+      var dataSet = this.dataSets[dataSetName];
+      var url = "".concat(dataSet.url, "/hashtree");
+      return this.webexRequest({
+        method: _constants.HTTP_VERBS.GET,
+        uri: url
+      }).then(function (response) {
+        var _response$body, _response$body2;
+        var hashes = (_response$body = response.body) === null || _response$body === void 0 ? void 0 : _response$body.hashes;
+        var dataSetFromResponse = (_response$body2 = response.body) === null || _response$body2 === void 0 ? void 0 : _response$body2.dataSet;
+        if (!hashes || !(0, _isArray.default)(hashes)) {
+          _loggerProxy.default.logger.warn("HashTreeParser#getHashesFromLocus --> ".concat(_this9.debugId, " Locus returned invalid hashes, response body="), response.body);
+          throw new Error("Locus returned invalid hashes: ".concat(hashes));
+        }
+        _loggerProxy.default.logger.info("HashTreeParser#getHashesFromLocus --> ".concat(_this9.debugId, " Received hashes for data set \"").concat(dataSetName, "\": ").concat((0, _stringify.default)(hashes)));
+        return {
+          hashes: hashes,
+          dataSet: dataSetFromResponse
+        };
+      }).catch(function (error) {
+        _loggerProxy.default.logger.error("HashTreeParser#getHashesFromLocus --> ".concat(_this9.debugId, " Error ").concat(error.statusCode, " fetching hashes for data set \"").concat(dataSetName, "\":"), error);
+        throw error;
+      });
+    }
+
+    /**
+     * 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>}
+     */
+  }, {
+    key: "sendSyncRequestToLocus",
+    value: function sendSyncRequestToLocus(dataSet, mismatchedLeavesData) {
+      var _dataSet$hashTree,
+        _this0 = this;
+      _loggerProxy.default.logger.info("HashTreeParser#sendSyncRequestToLocus --> ".concat(this.debugId, " Sending sync request for data set \"").concat(dataSet.name, "\""));
+      var url = "".concat(dataSet.url, "/sync");
+      var body = {
+        dataSet: {
+          name: dataSet.name,
+          leafCount: dataSet.leafCount,
+          root: (_dataSet$hashTree = dataSet.hashTree) === null || _dataSet$hashTree === void 0 ? void 0 : _dataSet$hashTree.getRootHash()
+        },
+        leafDataEntries: []
+      };
+      (0, _keys.default)(mismatchedLeavesData).forEach(function (index) {
+        body.leafDataEntries.push({
+          leafIndex: (0, _parseInt2.default)(index, 10),
+          elementIds: mismatchedLeavesData[index]
+        });
+      });
+      return this.webexRequest({
+        method: _constants.HTTP_VERBS.POST,
+        uri: url,
+        body: body
+      }).then(function (resp) {
+        _loggerProxy.default.logger.info("HashTreeParser#sendSyncRequestToLocus --> ".concat(_this0.debugId, " Sync request succeeded for \"").concat(dataSet.name, "\""));
+        if (!resp.body || (0, _lodash.isEmpty)(resp.body)) {
+          _loggerProxy.default.logger.info("HashTreeParser#sendSyncRequestToLocus --> ".concat(_this0.debugId, " Got ").concat(resp.statusCode, " with empty body for sync request for data set \"").concat(dataSet.name, "\", data should arrive via messages"));
+          return null;
+        }
+        return resp.body;
+      }).catch(function (error) {
+        _loggerProxy.default.logger.error("HashTreeParser#sendSyncRequestToLocus --> ".concat(_this0.debugId, " Error ").concat(error.statusCode, " sending sync request for data set \"").concat(dataSet.name, "\":"), error);
+        throw error;
+      });
+    }
+  }]);
+}();
+var _default = exports.default = HashTreeParser;
+//# sourceMappingURL=hashTreeParser.js.map