@webex/plugin-meetings 3.12.0-next.9 → 3.12.0-task-refactor.1

package/dist/hashTree/hashTreeParser.js

@@ -1,31 +1,14 @@
 "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$keys4 = 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.MeetingEndedError = exports.LocusInfoUpdateType = void 0;
+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"));
@@ -34,18 +17,7 @@ var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime
 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$keys4(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 = {
@@ -56,7 +28,7 @@ var LocusInfoUpdateType = exports.LocusInfoUpdateType = {
  * 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 = exports.MeetingEndedError = /*#__PURE__*/function (_Error) {
+var MeetingEndedError = /*#__PURE__*/function (_Error) {
   function MeetingEndedError() {
     (0, _classCallCheck2.default)(this, MeetingEndedError);
     return _callSuper(this, MeetingEndedError, arguments);
@@ -64,11 +36,14 @@ var MeetingEndedError = exports.MeetingEndedError = /*#__PURE__*/function (_Erro
   (0, _inherits2.default)(MeetingEndedError, _Error);
   return (0, _createClass2.default)(MeetingEndedError);
 }(/*#__PURE__*/(0, _wrapNativeSuper2.default)(Error));
-/* Currently Locus always sends Metadata objects only in the "self" dataset.
- * If this ever changes, update all the code that relies on this constant.
+/**
+ * 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
  */
-var MetadataDataSetName = _constants2.DataSetNames.SELF;
-var PossibleSentinelMessageDataSetNames = [_constants2.DataSetNames.MAIN, _constants2.DataSetNames.SELF, _constants2.DataSetNames.UNJOINED];
+function isSelf(object) {
+  return object.htMeta.elementId.type.toLowerCase() === _types.ObjectType.self;
+}
 
 /**
  * Parses hash tree eventing locus data
@@ -80,7 +55,7 @@ var HashTreeParser = /*#__PURE__*/function () {
    * @param {Object} options.initialLocus The initial locus data containing the hash tree information
    */
   function HashTreeParser(options) {
-    var _locus$links, _locus$links$resource, _locus$links$resource2, _options$metadata, _options$metadata2, _options$metadata2$vi;
+    var _locus$self;
     (0, _classCallCheck2.default)(this, HashTreeParser);
     (0, _defineProperty2.default)(this, "dataSets", {});
     (0, _defineProperty2.default)(this, "visibleDataSetsUrl", void 0);
@@ -89,234 +64,30 @@ var HashTreeParser = /*#__PURE__*/function () {
     (0, _defineProperty2.default)(this, "locusInfoUpdateCallback", void 0);
     (0, _defineProperty2.default)(this, "visibleDataSets", void 0);
     (0, _defineProperty2.default)(this, "debugId", void 0);
-    (0, _defineProperty2.default)(this, "heartbeatIntervalMs", void 0);
-    (0, _defineProperty2.default)(this, "excludedDataSets", void 0);
-    (0, _defineProperty2.default)(this, "state", void 0);
-    var _options$initialLocus = options.initialLocus,
-      dataSets = _options$initialLocus.dataSets,
-      locus = _options$initialLocus.locus; // extract dataSets from initialLocus
-
+    var locus = options.initialLocus.locus;
     this.debugId = options.debugId;
     this.webexRequest = options.webexRequest;
     this.locusInfoUpdateCallback = options.locusInfoUpdateCallback;
-    this.excludedDataSets = options.excludedDataSets || [];
-    this.visibleDataSetsUrl = locus === null || locus === void 0 ? void 0 : (_locus$links = locus.links) === null || _locus$links === void 0 ? void 0 : (_locus$links$resource = _locus$links.resources) === null || _locus$links$resource === void 0 ? void 0 : (_locus$links$resource2 = _locus$links$resource.visibleDataSets) === null || _locus$links$resource2 === void 0 ? void 0 : _locus$links$resource2.url;
-    this.setVisibleDataSets(((_options$metadata = options.metadata) === null || _options$metadata === void 0 ? void 0 : _options$metadata.visibleDataSets) || [], dataSets);
-    this.state = 'active';
-    if (((_options$metadata2 = options.metadata) === null || _options$metadata2 === void 0 ? void 0 : (_options$metadata2$vi = _options$metadata2.visibleDataSets) === null || _options$metadata2$vi === void 0 ? void 0 : _options$metadata2$vi.length) === 0) {
-      _loggerProxy.default.logger.warn("HashTreeParser#constructor --> ".concat(this.debugId, " No visibleDataSets found in Metadata"));
-    }
-    // object mapping dataset names to arrays of leaf data
-    var leafData = this.analyzeLocusHtMeta(locus);
-    if (options.metadata) {
-      // add also the metadata that's outside of locus object itself
-      this.analyzeMetadata(leafData, options.metadata);
-    }
-    _loggerProxy.default.logger.info("HashTreeParser#constructor --> ".concat(this.debugId, " creating HashTreeParser for datasets: ").concat((0, _stringify.default)(dataSets.map(function (ds) {
-      return ds.name;
-    })), " with visible datasets: ").concat((0, _stringify.default)(this.visibleDataSets.map(function (vds) {
-      return vds.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.isVisibleDataSet(name) ? new _hashTree.default(leafData[name] || [], leafCount) : undefined
-        });
-      }
-    } catch (err) {
-      _iterator.e(err);
-    } finally {
-      _iterator.f();
-    }
+    this.visibleDataSets = (locus === null || locus === void 0 ? void 0 : (_locus$self = locus.self) === null || _locus$self === void 0 ? void 0 : _locus$self.visibleDataSets) || [];
   }
 
   /**
-   * Sets the visible data sets list for the HashTreeParser. This method should be called only at the start, to initialize
-   * the visible data sets, before any message processsing, so for example from the constructor or when resuming the parser.
+   * Initializes the hash tree parser from a message received from Locus.
    *
-   * @param {Array<VisibleDataSetInfo>} visibleDataSets - The visible data sets to set
-   * @param {Array<DataSet>} dataSets - The "dataSets" list from Locus (yes, Locus sends visibleDataSets and dataSets as separate lists and they can differ)
-   * @returns {void}
+   * @param {HashTreeMessage} message - initial hash tree message received from Locus
+   * @returns {Promise}
    */
   return (0, _createClass2.default)(HashTreeParser, [{
-    key: "setVisibleDataSets",
-    value: function setVisibleDataSets(visibleDataSets, dataSets) {
-      var _this = this;
-      this.visibleDataSets = (0, _lodash.cloneDeep)(visibleDataSets).filter(function (vds) {
-        return (
-          // exclude data sets we will never care about
-          !_this.isExcludedDataSet(vds.name) &&
-          // and make sure that visibleDataSets list is consistent with dataSets list
-          dataSets.some(function (ds) {
-            return ds.name === vds.name;
-          })
-        );
-      });
-    }
-
-    /**
-     * Checks if the given data set name is in the list of visible data sets
-     * @param {string} dataSetName data set name to check
-     * @returns {Boolean} True if the data set is visible, false otherwise
-     */
-  }, {
-    key: "isVisibleDataSet",
-    value: function isVisibleDataSet(dataSetName) {
-      return this.visibleDataSets.some(function (vds) {
-        return vds.name === dataSetName;
-      });
-    }
-
-    /**
-     * Checks if the given data set name is in the excluded list
-     * @param {string} dataSetName data set name to check
-     * @returns {boolean} True if the data set is excluded, false otherwise
-     */
-  }, {
-    key: "isExcludedDataSet",
-    value: function isExcludedDataSet(dataSetName) {
-      return this.excludedDataSets.some(function (name) {
-        return name === dataSetName;
-      });
-    }
-
-    /**
-     * Adds a data set to the visible data sets list, unless it is in the excluded list.
-     * @param {VisibleDataSetInfo} dataSetInfo data set info to add
-     * @returns {boolean} True if the data set was added, false if it was excluded
-     */
-  }, {
-    key: "addToVisibleDataSetsList",
-    value: function addToVisibleDataSetsList(dataSetInfo) {
-      if (this.isExcludedDataSet(dataSetInfo.name)) {
-        _loggerProxy.default.logger.info("HashTreeParser#addToVisibleDataSetsList --> ".concat(this.debugId, " Data set \"").concat(dataSetInfo.name, "\" is in the excluded list, ignoring"));
-        return false;
-      }
-      this.visibleDataSets.push(dataSetInfo);
-      return true;
-    }
-
-    /**
-     * Initializes a new visible data set by creating a hash tree for it, adding it to all the internal structures,
-     * and sending an initial sync request to Locus with empty leaf data - that will trigger Locus to gives us all the data
-     * from that dataset (in the response or via messages).
-     *
-     * @param {VisibleDataSetInfo} visibleDataSetInfo Information about the new visible data set
-     * @param {DataSet} dataSetInfo The new data set to be added
-     * @returns {Promise}
-     */
-  }, {
-    key: "initializeNewVisibleDataSet",
-    value: function initializeNewVisibleDataSet(visibleDataSetInfo, dataSetInfo) {
-      if (this.isVisibleDataSet(dataSetInfo.name)) {
-        _loggerProxy.default.logger.info("HashTreeParser#initializeNewVisibleDataSet --> ".concat(this.debugId, " Data set \"").concat(dataSetInfo.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(dataSetInfo.name, "\""));
-      if (!this.addToVisibleDataSetsList(visibleDataSetInfo)) {
-        return _promise.default.resolve({
-          updateType: LocusInfoUpdateType.OBJECTS_UPDATED,
-          updatedObjects: []
-        });
-      }
-      var hashTree = new _hashTree.default([], dataSetInfo.leafCount);
-      this.dataSets[dataSetInfo.name] = _objectSpread(_objectSpread({}, dataSetInfo), {}, {
-        hashTree: hashTree
-      });
-      return this.sendInitializationSyncRequestToLocus(dataSetInfo.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 _this2 = 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 {
-            updateType: LocusInfoUpdateType.OBJECTS_UPDATED,
-            updatedObjects: _this2.parseMessage(syncResponse, "via empty leaves /sync API call for ".concat(debugText))
-          };
-        }
-        return {
-          updateType: LocusInfoUpdateType.OBJECTS_UPDATED,
-          updatedObjects: []
-        };
-      });
-    }
-
-    /**
-     * Queries Locus for all up-to-date information about all visible data sets
-     *
-     * @returns {Promise}
-     */
-  }, {
-    key: "getAllVisibleDataSetsFromLocus",
-    value: function getAllVisibleDataSetsFromLocus() {
-      var _this3 = this;
-      if (!this.visibleDataSetsUrl) {
-        _loggerProxy.default.logger.warn("HashTreeParser#getAllVisibleDataSetsFromLocus --> ".concat(this.debugId, " No visibleDataSetsUrl, cannot get data sets information"));
-        return _promise.default.resolve([]);
-      }
-      return this.webexRequest({
-        method: _constants.HTTP_VERBS.GET,
-        uri: this.visibleDataSetsUrl
-      }).then(function (response) {
-        return response.body.dataSets;
-      }).catch(function (error) {
-        _this3.checkForSentinelHttpResponse(error);
-        throw error;
-      });
-    }
-
-    /**
-     * 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 visibleDataSets;
         return _regenerator.default.wrap(function (_context) {
           while (1) switch (_context.prev = _context.next) {
             case 0:
-              this.visibleDataSetsUrl = message.visibleDataSetsUrl;
-              _loggerProxy.default.logger.info("HashTreeParser#initializeFromMessage --> ".concat(this.debugId, " visibleDataSetsUrl=").concat(this.visibleDataSetsUrl));
-              _context.next = 1;
-              return this.getAllVisibleDataSetsFromLocus();
-            case 1:
-              visibleDataSets = _context.sent;
-              _context.next = 2;
-              return this.initializeDataSets(visibleDataSets, 'initialization from message');
-            case 2:
             case "end":
               return _context.stop();
           }
-        }, _callee, this);
+        }, _callee);
       }));
       function initializeFromMessage(_x) {
         return _initializeFromMessage.apply(this, arguments);
@@ -337,374 +108,19 @@ var HashTreeParser = /*#__PURE__*/function () {
     key: "initializeFromGetLociResponse",
     value: (function () {
       var _initializeFromGetLociResponse = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee2(locus) {
-        var _locus$links2, _locus$links2$resourc, _locus$links2$resourc2;
-        var visibleDataSets;
         return _regenerator.default.wrap(function (_context2) {
           while (1) switch (_context2.prev = _context2.next) {
             case 0:
-              if (locus !== null && locus !== void 0 && (_locus$links2 = locus.links) !== null && _locus$links2 !== void 0 && (_locus$links2$resourc = _locus$links2.resources) !== null && _locus$links2$resourc !== void 0 && (_locus$links2$resourc2 = _locus$links2$resourc.visibleDataSets) !== null && _locus$links2$resourc2 !== void 0 && _locus$links2$resourc2.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:
-              this.visibleDataSetsUrl = locus.links.resources.visibleDataSets.url;
-              _loggerProxy.default.logger.info("HashTreeParser#initializeFromGetLociResponse --> ".concat(this.debugId, " visibleDataSets url: ").concat(this.visibleDataSetsUrl));
-              _context2.next = 2;
-              return this.getAllVisibleDataSetsFromLocus();
-            case 2:
-              visibleDataSets = _context2.sent;
-              _context2.next = 3;
-              return this.initializeDataSets(visibleDataSets, 'initialization from GET /loci response');
-            case 3:
             case "end":
               return _context2.stop();
           }
-        }, _callee2, this);
+        }, _callee2);
       }));
       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[]} visibleDataSets Array of visible 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(visibleDataSets, debugText) {
-        var updatedObjects, _iterator2, _step2, dataSet, name, leafCount, url, _data, _t;
-        return _regenerator.default.wrap(function (_context3) {
-          while (1) switch (_context3.prev = _context3.next) {
-            case 0:
-              if (!(this.state === 'stopped')) {
-                _context3.next = 1;
-                break;
-              }
-              return _context3.abrupt("return");
-            case 1:
-              updatedObjects = [];
-              _iterator2 = _createForOfIteratorHelper(visibleDataSets);
-              _context3.prev = 2;
-              _iterator2.s();
-            case 3:
-              if ((_step2 = _iterator2.n()).done) {
-                _context3.next = 7;
-                break;
-              }
-              dataSet = _step2.value;
-              name = dataSet.name, leafCount = dataSet.leafCount, url = dataSet.url;
-              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.isVisibleDataSet(name)) {
-                _context3.next = 4;
-                break;
-              }
-              if (this.addToVisibleDataSetsList({
-                name: name,
-                url: url
-              })) {
-                _context3.next = 4;
-                break;
-              }
-              return _context3.abrupt("continue", 6);
-            case 4:
-              if (this.dataSets[name].hashTree) {
-                _context3.next = 6;
-                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 = 5;
-              return this.sendInitializationSyncRequestToLocus(name, debugText);
-            case 5:
-              _data = _context3.sent;
-              if (_data.updateType === LocusInfoUpdateType.OBJECTS_UPDATED) {
-                updatedObjects.push.apply(updatedObjects, (0, _toConsumableArray2.default)(_data.updatedObjects || []));
-              }
-            case 6:
-              _context3.next = 3;
-              break;
-            case 7:
-              _context3.next = 9;
-              break;
-            case 8:
-              _context3.prev = 8;
-              _t = _context3["catch"](2);
-              _iterator2.e(_t);
-            case 9:
-              _context3.prev = 9;
-              _iterator2.f();
-              return _context3.finish(9);
-            case 10:
-              this.callLocusInfoUpdateCallback({
-                updateType: LocusInfoUpdateType.OBJECTS_UPDATED,
-                updatedObjects: updatedObjects
-              });
-            case 11:
-            case "end":
-              return _context3.stop();
-          }
-        }, _callee3, this, [[2, 8, 9, 10]]);
-      }));
-      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, currentLocusPartName) {
-        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) {
-            if (type.toLowerCase() === _types.ObjectType.control) {
-              // control entries require special handling, because they are signalled by Locus
-              // differently when coming in messages vs API responses
-              newLeafInfo.data = (0, _defineProperty2.default)({}, currentLocusPartName, (0, _lodash.cloneDeep)(currentLocusPart));
-            } else {
-              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.entries()),
-            _step4;
-          try {
-            for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
-              var _step4$value = (0, _slicedToArray2.default)(_step4.value, 2),
-                index = _step4$value[0],
-                item = _step4$value[1];
-              _findAndStoreMetaData(item, index.toString());
-            }
-          } 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], key);
-            }
-          }
-        }
-      };
-      _findAndStoreMetaData(locus, 'locus');
-      return leafInfo;
-    }
-
-    /**
-     * Analyzes the Metadata object that is sent outside of Locus object, and appends its data to passed in leafInfo
-     * structure.
-     *
-     * @param {Record<string, LeafInfo[]>} leafInfo the structure to which the Metadata info will be appended
-     * @param {Metadata} metadata Metadata object
-     * @returns {void}
-     */
-  }, {
-    key: "analyzeMetadata",
-    value: function analyzeMetadata(leafInfo, metadata) {
-      var _htMeta$dataSetNames;
-      var htMeta = metadata.htMeta;
-      if ((htMeta === null || htMeta === void 0 ? void 0 : (_htMeta$dataSetNames = htMeta.dataSetNames) === null || _htMeta$dataSetNames === void 0 ? void 0 : _htMeta$dataSetNames.length) === 1 && htMeta.dataSetNames[0].toLowerCase() === MetadataDataSetName) {
-        var _metadata$htMeta$elem = metadata.htMeta.elementId,
-          type = _metadata$htMeta$elem.type,
-          id = _metadata$htMeta$elem.id,
-          version = _metadata$htMeta$elem.version;
-        var dataSetName = htMeta.dataSetNames[0];
-        if (!leafInfo[dataSetName]) {
-          leafInfo[dataSetName] = [];
-        }
-        leafInfo[dataSetName].push({
-          type: type,
-          id: id,
-          version: version
-        });
-      } else {
-        throw new Error("".concat(this.debugId, " Metadata htMeta has unexpected dataSetNames: ").concat(htMeta && htMeta.dataSetNames.join(',')));
-      }
-    }
-
-    /**
-     * 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 _this4 = this;
-      return message.dataSets.some(function (dataSet) {
-        if (dataSet.leafCount === 1 && dataSet.root === _constants2.EMPTY_HASH && (!_this4.dataSets[dataSet.name] || _this4.dataSets[dataSet.name].version < dataSet.version) && PossibleSentinelMessageDataSetNames.includes(dataSet.name.toLowerCase())) {
-          // 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 _this5 = 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) {
-        _this5.updateDataSetInfo(dataSet);
-        _this5.runSyncAlgorithm(dataSet);
-      });
-    }
-
-    /**
-     * Asynchronously initializes new visible data sets
-     *
-     * @param {VisibleDataSetInfo[]} dataSetsRequiringInitialization list of datasets to initialize
-     * @returns {void}
-     */
-  }, {
-    key: "queueInitForNewVisibleDataSets",
-    value: function queueInitForNewVisibleDataSets(dataSetsRequiringInitialization) {
-      var _this6 = this;
-      _loggerProxy.default.logger.info("HashTreeParser#queueInitForNewVisibleDataSets --> ".concat(this.debugId, " queuing initialization of new visible datasets: ").concat(dataSetsRequiringInitialization.map(function (ds) {
-        return ds.name;
-      }).join(', ')));
-      queueMicrotask(function () {
-        _this6.initializeNewVisibleDataSets(dataSetsRequiringInitialization).catch(function (error) {
-          if (error instanceof MeetingEndedError) {
-            _this6.callLocusInfoUpdateCallback({
-              updateType: LocusInfoUpdateType.MEETING_ENDED
-            });
-          } else {
-            _loggerProxy.default.logger.warn("HashTreeParser#queueInitForNewVisibleDataSets --> ".concat(_this6.debugId, " error while initializing new visible datasets: ").concat(dataSetsRequiringInitialization.map(function (ds) {
-              return ds.name;
-            }).join(', '), ": "), error);
-          }
-        });
-      });
-    }
-
-    /**
-     * Handles updates to Metadata object that we receive from Locus via other means than messages. Right now
-     * that means only in the API response alongside locus object.
-     *
-     * @param {Metadata} metadata received in Locus update other than a message (for example in an API response)
-     * @param {HashTreeObject[]} updatedObjects a list of updated hash tree objects to which any updates resulting from new Metadata will be added
-     * @returns {void}
-     */
-  }, {
-    key: "handleMetadataUpdate",
-    value: function handleMetadataUpdate(metadata, updatedObjects) {
-      var _this$dataSets$Metada;
-      var dataSetsRequiringInitialization = [];
-
-      // current assumption based on Locus docs is that Metadata object lives always in "self" data set
-      var hashTree = (_this$dataSets$Metada = this.dataSets[MetadataDataSetName]) === null || _this$dataSets$Metada === void 0 ? void 0 : _this$dataSets$Metada.hashTree;
-      if (!hashTree) {
-        _loggerProxy.default.logger.warn("HashTreeParser#handleLocusUpdate --> ".concat(this.debugId, " received Metadata object but no hash tree for \"").concat(MetadataDataSetName, "\" data set exists"));
-      } else {
-        var metadataUpdated = hashTree.putItem(metadata.htMeta.elementId);
-        if (metadataUpdated) {
-          // metadata in Locus API response is in a slightly different format than the objects in messages, so need to adapt it
-          var metadataObject = {
-            htMeta: metadata.htMeta,
-            data: metadata
-          };
-          updatedObjects.push(metadataObject);
-          var _this$checkForVisible = this.checkForVisibleDataSetChanges([metadataObject]),
-            changeDetected = _this$checkForVisible.changeDetected,
-            removedDataSets = _this$checkForVisible.removedDataSets,
-            addedDataSets = _this$checkForVisible.addedDataSets;
-          if (changeDetected) {
-            dataSetsRequiringInitialization = this.processVisibleDataSetChanges(removedDataSets, addedDataSets, updatedObjects);
-          }
-          if (dataSetsRequiringInitialization.length > 0) {
-            // there are some data sets that we need to initialize asynchronously
-            this.queueInitForNewVisibleDataSets(dataSetsRequiringInitialization);
-          }
-        }
-      }
-    }
-
     /**
      * 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
@@ -712,477 +128,11 @@ var HashTreeParser = /*#__PURE__*/function () {
      * @param {Object} update - The locus update containing data sets and locus information
      * @returns {void}
      */
+    )
   }, {
     key: "handleLocusUpdate",
     value: function handleLocusUpdate(update) {
-      var _this7 = this;
-      if (this.state === 'stopped') {
-        return;
-      }
-      var dataSets = update.dataSets,
-        locus = update.locus,
-        metadata = update.metadata;
-      if (!dataSets) {
-        _loggerProxy.default.logger.info("HashTreeParser#handleLocusUpdate --> ".concat(this.debugId, " received hash tree update without dataSets"));
-      } else {
-        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
-      });
-
-      // if we got metadata, process it (currently that means only potential visible data set list changes)
-      if (metadata) {
-        this.handleMetadataUpdate(metadata, updatedObjects);
-      }
-
-      // 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 (_this7.dataSets[dataSetName]) {
-          if (_this7.dataSets[dataSetName].hashTree) {
-            var appliedChangesList = _this7.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(_this7.debugId, " received leaf data for data set \"").concat(dataSetName, "\" that has no hash tree created, ignoring"));
-          }
-        } else {
-          _loggerProxy.default.logger.info("HashTreeParser#handleLocusUpdate --> ".concat(_this7.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
-        });
-      }
-    }
-
-    /**
-     * 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#updateDataSetInfo --> ".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#updateDataSetInfo --> ".concat(this.debugId, " updated \"").concat(receivedDataSet.name, "\" dataset 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 _this8 = this;
-      var removedDataSets = [];
-      var addedDataSets = [];
-
-      // visibleDataSets can only be changed by Metadata object updates
-      updatedObjects.forEach(function (object) {
-        var _object$data;
-        if ((0, _utils.isMetadata)(object) && (_object$data = object.data) !== null && _object$data !== void 0 && _object$data.visibleDataSets) {
-          var newVisibleDataSets = object.data.visibleDataSets.filter(function (vds) {
-            return !_this8.isExcludedDataSet(vds.name);
-          });
-          removedDataSets = _this8.visibleDataSets.filter(function (ds) {
-            return !newVisibleDataSets.some(function (nvs) {
-              return nvs.name === ds.name;
-            });
-          });
-          addedDataSets = newVisibleDataSets.filter(function (nvs) {
-            return _this8.visibleDataSets.every(function (ds) {
-              return ds.name !== nvs.name;
-            });
-          });
-          if (removedDataSets.length > 0 || addedDataSets.length > 0) {
-            _loggerProxy.default.logger.info("HashTreeParser#checkForVisibleDataSetChanges --> ".concat(_this8.debugId, " visible data sets change: removed: ").concat(removedDataSets.map(function (ds) {
-              return ds.name;
-            }).join(', '), ", added: ").concat(addedDataSets.map(function (ds) {
-              return ds.name;
-            }).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 timers as there is no hash tree anymore to sync
-      if (this.dataSets[dataSetName].timer) {
-        clearTimeout(this.dataSets[dataSetName].timer);
-        this.dataSets[dataSetName].timer = undefined;
-      }
-      if (this.dataSets[dataSetName].heartbeatWatchdogTimer) {
-        clearTimeout(this.dataSets[dataSetName].heartbeatWatchdogTimer);
-        this.dataSets[dataSetName].heartbeatWatchdogTimer = 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 {VisibleDataSetInfo[]} removedDataSets - The list of removed data sets.
-     * @param {VisibleDataSetInfo[]} addedDataSets - The list of added data sets.
-     * @param {HashTreeObject[]} updatedObjects - The list of updated hash tree objects to which changes will be added.
-     * @returns {VisibleDataSetInfo[]} list of data sets that couldn't be initialized synchronously
-     */
-  }, {
-    key: "processVisibleDataSetChanges",
-    value: function processVisibleDataSetChanges(removedDataSets, addedDataSets, updatedObjects) {
-      var _this9 = 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 _this9$dataSets$ds$na;
-        if ((_this9$dataSets$ds$na = _this9.dataSets[ds.name]) !== null && _this9$dataSets$ds$na !== void 0 && _this9$dataSets$ds$na.hashTree) {
-          for (var i = 0; i < _this9.dataSets[ds.name].hashTree.numLeaves; i += 1) {
-            removedObjects.push.apply(removedObjects, (0, _toConsumableArray2.default)(_this9.dataSets[ds.name].hashTree.getLeafData(i).map(function (elementId) {
-              return {
-                htMeta: {
-                  elementId: elementId,
-                  dataSetNames: [ds.name]
-                },
-                data: null
-              };
-            })));
-          }
-          _this9.deleteHashTree(ds.name);
-        }
-      });
-      this.visibleDataSets = this.visibleDataSets.filter(function (vds) {
-        return !removedDataSets.some(function (rds) {
-          return rds.name === vds.name;
-        });
-      });
-      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.name];
-          if (dataSetInfo) {
-            if (this.isVisibleDataSet(dataSetInfo.name)) {
-              _loggerProxy.default.logger.info("HashTreeParser#processVisibleDataSetChanges --> ".concat(this.debugId, " Data set \"").concat(ds.name, "\" 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.name, "\""));
-            if (!this.addToVisibleDataSetsList(ds)) {
-              // eslint-disable-next-line no-continue
-              continue;
-            }
-            var hashTree = new _hashTree.default([], dataSetInfo.leafCount);
-            this.dataSets[dataSetInfo.name] = _objectSpread(_objectSpread({}, dataSetInfo), {}, {
-              hashTree: hashTree
-            });
-
-            // this call is needed here for the edge case where we receive a message with new visible data sets
-            // and there are no objects belonging to these data sets in the message but we already have the info about them in this.dataSets
-            this.runSyncAlgorithm(this.dataSets[dataSetInfo.name]);
-          } else {
-            _loggerProxy.default.logger.info("HashTreeParser#processVisibleDataSetChanges --> ".concat(this.debugId, " visible data set \"").concat(ds.name, "\" 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 {VisibleDataSetInfo[]} 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(addedDataSets) {
-        var _this0 = this;
-        var allDataSets, _iterator7, _step7, _loop, _t2;
-        return _regenerator.default.wrap(function (_context5) {
-          while (1) switch (_context5.prev = _context5.next) {
-            case 0:
-              if (!(this.state === 'stopped')) {
-                _context5.next = 1;
-                break;
-              }
-              return _context5.abrupt("return");
-            case 1:
-              _context5.next = 2;
-              return this.getAllVisibleDataSetsFromLocus();
-            case 2:
-              allDataSets = _context5.sent;
-              _iterator7 = _createForOfIteratorHelper(addedDataSets);
-              _context5.prev = 3;
-              _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.name;
-                      });
-                      _loggerProxy.default.logger.info("HashTreeParser#initializeNewVisibleDataSets --> ".concat(_this0.debugId, " initializing data set \"").concat(ds.name, "\""));
-                      if (dataSetInfo) {
-                        _context4.next = 1;
-                        break;
-                      }
-                      _loggerProxy.default.logger.warn("HashTreeParser#initializeNewVisibleDataSets --> ".concat(_this0.debugId, " missing info about data set \"").concat(ds.name, "\" in Locus response from visibleDataSetsUrl"));
-                      _context4.next = 3;
-                      break;
-                    case 1:
-                      _context4.next = 2;
-                      return _this0.initializeNewVisibleDataSet(ds, dataSetInfo);
-                    case 2:
-                      updates = _context4.sent;
-                      _this0.callLocusInfoUpdateCallback(updates);
-                    case 3:
-                    case "end":
-                      return _context4.stop();
-                  }
-                }, _loop);
-              });
-              _iterator7.s();
-            case 4:
-              if ((_step7 = _iterator7.n()).done) {
-                _context5.next = 6;
-                break;
-              }
-              return _context5.delegateYield(_loop(), "t0", 5);
-            case 5:
-              _context5.next = 4;
-              break;
-            case 6:
-              _context5.next = 8;
-              break;
-            case 7:
-              _context5.prev = 7;
-              _t2 = _context5["catch"](3);
-              _iterator7.e(_t2);
-            case 8:
-              _context5.prev = 8;
-              _iterator7.f();
-              return _context5.finish(8);
-            case 9:
-            case "end":
-              return _context5.stop();
-          }
-        }, _callee4, this, [[3, 7, 8, 9]]);
-      }));
-      function initializeNewVisibleDataSets(_x5) {
-        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 {HashTreeObject[]} list of hash tree objects that were updated as a result of processing the message
-     */
-    )
-  }, {
-    key: "parseMessage",
-    value: function parseMessage(message, debugText) {
-      var _message$locusStateEl,
-        _this1 = this,
-        _message$locusStateEl2;
-      if (this.state === 'stopped') {
-        return [];
-      }
-      var 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 _this1.updateDataSetInfo(dataSet);
-      });
-      var 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
-      var dataSetsRequiringInitialization = [];
-
-      // first find out if there are any visible data set changes - they're signalled in Metadata object updates
-      var metadataUpdates = (message.locusStateElements || []).filter(function (object) {
-        return (0, _utils.isMetadata)(object);
-      });
-      if (metadataUpdates.length > 0) {
-        var updatedMetadataObjects = [];
-        metadataUpdates.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 _this1$dataSets$dataS;
-              var dataSetName = _step8.value;
-              var hashTree = (_this1$dataSets$dataS = _this1.dataSets[dataSetName]) === null || _this1$dataSets$dataS === void 0 ? void 0 : _this1$dataSets$dataS.hashTree;
-              if (hashTree && object.data) {
-                if (hashTree.putItem(object.htMeta.elementId)) {
-                  updatedMetadataObjects.push(object);
-                }
-              }
-            }
-          } catch (err) {
-            _iterator8.e(err);
-          } finally {
-            _iterator8.f();
-          }
-        });
-        updatedObjects.push.apply(updatedObjects, updatedMetadataObjects);
-        var _this$checkForVisible2 = this.checkForVisibleDataSetChanges(updatedMetadataObjects),
-          changeDetected = _this$checkForVisible2.changeDetected,
-          removedDataSets = _this$checkForVisible2.removedDataSets,
-          addedDataSets = _this$checkForVisible2.addedDataSets;
-        if (changeDetected) {
-          dataSetsRequiringInitialization = this.processVisibleDataSetChanges(removedDataSets, addedDataSets, updatedObjects);
-        }
-      }
-      if (((_message$locusStateEl2 = message.locusStateElements) === null || _message$locusStateEl2 === void 0 ? void 0 : _message$locusStateEl2.length) > 0) {
-        // 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 (_this1.dataSets[dataSet.name]) {
-            var hashTree = _this1.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) {
-                  // 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(_this1.debugId, " unexpected (not visible) dataSet ").concat(dataSet.name, " received in hash tree message"));
-            }
-          }
-          _this1.runSyncAlgorithm(dataSet);
-        });
-      }
-      if (dataSetsRequiringInitialization.length > 0) {
-        // there are some data sets that we need to initialize asynchronously
-        this.queueInitForNewVisibleDataSets(dataSetsRequiringInitialization);
-      }
-      if (updatedObjects.length === 0) {
-        _loggerProxy.default.logger.info("HashTreeParser#parseMessage --> ".concat(this.debugId, " No objects updated as a result of received message"));
-      }
-      return updatedObjects;
+      // todo
     }
 
     /**
@@ -1194,505 +144,21 @@ var HashTreeParser = /*#__PURE__*/function () {
      */
   }, {
     key: "handleMessage",
-    value: function handleMessage(message, debugText) {
-      if (this.state === 'stopped') {
-        return;
-      }
-      if (message.heartbeatIntervalMs) {
-        this.heartbeatIntervalMs = message.heartbeatIntervalMs;
-      }
-      if (this.isEndMessage(message)) {
-        _loggerProxy.default.logger.info("HashTreeParser#handleMessage --> ".concat(this.debugId, " received sentinel END MEETING message"));
-        this.stopAllTimers();
-        this.callLocusInfoUpdateCallback({
-          updateType: LocusInfoUpdateType.MEETING_ENDED
-        });
-      } else if (message.locusStateElements === undefined) {
-        this.handleRootHashHeartBeatMessage(message);
-        this.resetHeartbeatWatchdogs(message.dataSets);
-      } else {
-        var updatedObjects = this.parseMessage(message, debugText);
-        this.resetHeartbeatWatchdogs(message.dataSets);
-        this.callLocusInfoUpdateCallback({
-          updateType: LocusInfoUpdateType.OBJECTS_UPDATED,
-          updatedObjects: updatedObjects
-        });
-      }
-    }
-
-    /**
-     * 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 _this10 = this;
-      if (this.state === 'stopped') {
-        return;
-      }
-      var updateType = updates.updateType,
-        updatedObjects = updates.updatedObjects;
-      if (updateType === LocusInfoUpdateType.OBJECTS_UPDATED && (updatedObjects === null || updatedObjects === void 0 ? void 0 : updatedObjects.length) > 0) {
-        // Filter out updates for objects that already have a higher version in their datasets,
-        // or removals for objects that still exist in any of their datasets
-        var filteredUpdates = updatedObjects.filter(function (object) {
-          var elementId = object.htMeta.elementId;
-          var type = elementId.type,
-            id = elementId.id,
-            version = elementId.version;
-
-          // Check all datasets
-          for (var _i2 = 0, _Object$keys3 = (0, _keys.default)(_this10.dataSets); _i2 < _Object$keys3.length; _i2++) {
-            var dataSetName = _Object$keys3[_i2];
-            var dataSet = _this10.dataSets[dataSetName];
-
-            // only visible datasets have hash trees set
-            if (dataSet !== null && dataSet !== void 0 && dataSet.hashTree) {
-              var existingVersion = dataSet.hashTree.getItemVersion(id, type);
-              if (existingVersion !== undefined) {
-                if (object.data) {
-                  // For updates: filter out if any dataset has a higher version
-                  if (existingVersion > version) {
-                    _loggerProxy.default.logger.info("HashTreeParser#callLocusInfoUpdateCallback --> ".concat(_this10.debugId, " Filtering out update for ").concat(type, ":").concat(id, " v").concat(version, " because dataset \"").concat(dataSetName, "\" has v").concat(existingVersion));
-                    return false;
-                  }
-                } else if (existingVersion >= version) {
-                  // For removals: filter out if the object still exists in any dataset
-                  _loggerProxy.default.logger.info("HashTreeParser#callLocusInfoUpdateCallback --> ".concat(_this10.debugId, " Filtering out removal for ").concat(type, ":").concat(id, " v").concat(version, " because dataset \"").concat(dataSetName, "\" still has v").concat(existingVersion));
-                  return false;
-                }
-              }
-            }
-          }
-          return true;
-        });
-        if (filteredUpdates.length > 0) {
-          this.locusInfoUpdateCallback(updateType, {
-            updatedObjects: filteredUpdates
-          });
-        }
-      } else if (updateType !== LocusInfoUpdateType.OBJECTS_UPDATED) {
-        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);
-    }
-
-    /**
-     * Performs a sync for the given data set.
-     *
-     * @param {InternalDataSet} dataSet - The data set to sync
-     * @param {string} rootHash - Our current root hash for this data set
-     * @param {string} reason - The reason for the sync (used for logging)
-     * @returns {Promise<void>}
-     */
-  }, {
-    key: "performSync",
     value: (function () {
-      var _performSync = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee5(dataSet, rootHash, reason) {
-        var mismatchedLeavesData, receivedHashes, _yield$this$getHashes, hashes, latestDataSetInfo, mismatchedLeaveIndexes, syncResponse, _t3, _t4;
-        return _regenerator.default.wrap(function (_context6) {
-          while (1) switch (_context6.prev = _context6.next) {
+      var _handleMessage = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee3(message, debugText) {
+        return _regenerator.default.wrap(function (_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
             case 0:
-              if (dataSet.hashTree) {
-                _context6.next = 1;
-                break;
-              }
-              return _context6.abrupt("return");
-            case 1:
-              _context6.prev = 1;
-              _loggerProxy.default.logger.info("HashTreeParser#performSync --> ".concat(this.debugId, " ").concat(reason, ", syncing data set \"").concat(dataSet.name, "\""));
-              mismatchedLeavesData = {};
-              if (!(dataSet.leafCount !== 1)) {
-                _context6.next = 7;
-                break;
-              }
-              _context6.prev = 2;
-              _context6.next = 3;
-              return this.getHashesFromLocus(dataSet.name, rootHash);
-            case 3:
-              _yield$this$getHashes = _context6.sent;
-              hashes = _yield$this$getHashes.hashes;
-              latestDataSetInfo = _yield$this$getHashes.dataSet;
-              receivedHashes = hashes;
-              dataSet.hashTree.resize(latestDataSetInfo.leafCount);
-              _context6.next = 6;
-              break;
-            case 4:
-              _context6.prev = 4;
-              _t3 = _context6["catch"](2);
-              if (!(_t3.statusCode === 409)) {
-                _context6.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(this.debugId, " Got 409 when fetching hashes for data set \"").concat(dataSet.name, "\": ").concat(_t3.message));
-              return _context6.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);
-              });
-              _context6.next = 8;
-              break;
-            case 7:
-              mismatchedLeavesData[0] = dataSet.hashTree.getLeafData(0);
-            case 8:
-              if (!((0, _keys.default)(mismatchedLeavesData).length > 0)) {
-                _context6.next = 10;
-                break;
-              }
-              _context6.next = 9;
-              return this.sendSyncRequestToLocus(dataSet, mismatchedLeavesData);
-            case 9:
-              syncResponse = _context6.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) {
-                this.handleMessage(syncResponse, 'via sync API');
-              }
-            case 10:
-              _context6.next = 12;
-              break;
-            case 11:
-              _context6.prev = 11;
-              _t4 = _context6["catch"](1);
-              if (_t4 instanceof MeetingEndedError) {
-                this.callLocusInfoUpdateCallback({
-                  updateType: LocusInfoUpdateType.MEETING_ENDED
-                });
-              } else {
-                _loggerProxy.default.logger.warn("HashTreeParser#performSync --> ".concat(this.debugId, " error during sync for data set \"").concat(dataSet.name, "\":"), _t4);
-              }
-            case 12:
             case "end":
-              return _context6.stop();
+              return _context3.stop();
           }
-        }, _callee5, this, [[1, 11], [2, 4]]);
+        }, _callee3);
       }));
-      function performSync(_x6, _x7, _x8) {
-        return _performSync.apply(this, arguments);
-      }
-      return performSync;
-    }()
-    /**
-     * 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 _this11 = 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 _callee6() {
-          var rootHash;
-          return _regenerator.default.wrap(function (_context7) {
-            while (1) switch (_context7.prev = _context7.next) {
-              case 0:
-                dataSet.timer = undefined;
-                if (dataSet.hashTree) {
-                  _context7.next = 1;
-                  break;
-                }
-                _loggerProxy.default.logger.warn("HashTreeParser#runSyncAlgorithm --> ".concat(_this11.debugId, " Data set \"").concat(dataSet.name, "\" no longer has a hash tree, cannot run sync algorithm"));
-                return _context7.abrupt("return");
-              case 1:
-                rootHash = dataSet.hashTree.getRootHash();
-                if (!(dataSet.root !== rootHash)) {
-                  _context7.next = 3;
-                  break;
-                }
-                _context7.next = 2;
-                return _this11.performSync(dataSet, rootHash, "Root hash mismatch: received=".concat(dataSet.root, ", ours=").concat(rootHash));
-              case 2:
-                _context7.next = 4;
-                break;
-              case 3:
-                _loggerProxy.default.logger.info("HashTreeParser#runSyncAlgorithm --> ".concat(_this11.debugId, " \"").concat(dataSet.name, "\" root hash matching: ").concat(rootHash, ", version=").concat(dataSet.version));
-              case 4:
-              case "end":
-                return _context7.stop();
-            }
-          }, _callee6);
-        })), delay);
-      } else {
-        _loggerProxy.default.logger.info("HashTreeParser#runSyncAlgorithm --> ".concat(this.debugId, " No delay for \"").concat(dataSet.name, "\" data set, skipping sync timer reset/setup"));
-      }
-    }
-
-    /**
-     * Resets the heartbeat watchdog timers for the specified data sets. Each data set has its own
-     * watchdog timer that monitors whether heartbeats are being received within the expected interval.
-     * If a heartbeat is not received for a specific data set within heartbeatIntervalMs plus
-     * a backoff-calculated time, the sync algorithm is initiated for that data set
-     *
-     * @param {Array<DataSet>} receivedDataSets - The data sets from the received message for which watchdog timers should be reset
-     * @returns {void}
-     */
-  }, {
-    key: "resetHeartbeatWatchdogs",
-    value: function resetHeartbeatWatchdogs(receivedDataSets) {
-      var _this12 = this;
-      if (!this.heartbeatIntervalMs) {
-        return;
-      }
-      var _iterator9 = _createForOfIteratorHelper(receivedDataSets),
-        _step9;
-      try {
-        var _loop2 = function _loop2() {
-          var receivedDataSet = _step9.value;
-          var dataSet = _this12.dataSets[receivedDataSet.name];
-          if (!(dataSet !== null && dataSet !== void 0 && dataSet.hashTree)) {
-            // eslint-disable-next-line no-continue
-            return 1; // continue
-          }
-          if (dataSet.heartbeatWatchdogTimer) {
-            clearTimeout(dataSet.heartbeatWatchdogTimer);
-            dataSet.heartbeatWatchdogTimer = undefined;
-          }
-          var backoffTime = _this12.getWeightedBackoffTime(dataSet.backoff);
-          var delay = _this12.heartbeatIntervalMs + backoffTime;
-          dataSet.heartbeatWatchdogTimer = setTimeout(/*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee7() {
-            return _regenerator.default.wrap(function (_context8) {
-              while (1) switch (_context8.prev = _context8.next) {
-                case 0:
-                  dataSet.heartbeatWatchdogTimer = undefined;
-                  _loggerProxy.default.logger.warn("HashTreeParser#resetHeartbeatWatchdogs --> ".concat(_this12.debugId, " Heartbeat watchdog fired for data set \"").concat(dataSet.name, "\" - no heartbeat received within expected interval, initiating sync"));
-                  _context8.next = 1;
-                  return _this12.performSync(dataSet, dataSet.hashTree.getRootHash(), "heartbeat watchdog expired");
-                case 1:
-                case "end":
-                  return _context8.stop();
-              }
-            }, _callee7);
-          })), delay);
-        };
-        for (_iterator9.s(); !(_step9 = _iterator9.n()).done;) {
-          if (_loop2()) continue;
-        }
-      } catch (err) {
-        _iterator9.e(err);
-      } finally {
-        _iterator9.f();
-      }
-    }
-
-    /**
-     * 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;
-        }
-        if (dataSet.heartbeatWatchdogTimer) {
-          clearTimeout(dataSet.heartbeatWatchdogTimer);
-          dataSet.heartbeatWatchdogTimer = undefined;
-        }
-      });
-    }
-
-    /**
-     * Stops the HashTreeParser, preventing it from processing any further messages and clearing all timers.
-     * It also clears all the hash trees, so if the parser is resumed later, it will need to do a sync
-     * to be up-to-date.
-     * @returns {void}
-     */
-  }, {
-    key: "stop",
-    value: function stop() {
-      _loggerProxy.default.logger.info("HashTreeParser#stop --> ".concat(this.debugId, " Stopping HashTreeParser, clearing timers and hash trees"));
-      this.stopAllTimers();
-      (0, _values.default)(this.dataSets).forEach(function (dataSet) {
-        dataSet.hashTree = undefined;
-      });
-      this.visibleDataSets = [];
-      this.state = 'stopped';
-    }
-
-    /**
-     * Resumes the HashTreeParser that was previously stopped.
-     * @param {HashTreeMessage} message - The message to resume with, it must contain metadata with visible data sets info
-     * @returns {void}
-     */
-  }, {
-    key: "resume",
-    value: function resume(message) {
-      var _message$locusStateEl3, _metadataObject$data;
-      // check that message contains metadata with visible data sets - this is essential to be able to resume
-      var metadataObject = (_message$locusStateEl3 = message.locusStateElements) === null || _message$locusStateEl3 === void 0 ? void 0 : _message$locusStateEl3.find(function (el) {
-        return (0, _utils.isMetadata)(el);
-      });
-      if (!(metadataObject !== null && metadataObject !== void 0 && (_metadataObject$data = metadataObject.data) !== null && _metadataObject$data !== void 0 && _metadataObject$data.visibleDataSets)) {
-        _loggerProxy.default.logger.warn("HashTreeParser#resume --> ".concat(this.debugId, " Cannot resume HashTreeParser because the message is missing metadata with visible data sets info"));
-        return;
-      }
-      this.setVisibleDataSets(metadataObject.data.visibleDataSets, message.dataSets);
-      this.dataSets = {};
-      var _iterator0 = _createForOfIteratorHelper(message.dataSets),
-        _step0;
-      try {
-        for (_iterator0.s(); !(_step0 = _iterator0.n()).done;) {
-          var dataSet = _step0.value;
-          var name = dataSet.name,
-            leafCount = dataSet.leafCount;
-          this.dataSets[name] = _objectSpread(_objectSpread({}, dataSet), {}, {
-            hashTree: this.isVisibleDataSet(name) ? new _hashTree.default([], leafCount) : undefined
-          });
-        }
-      } catch (err) {
-        _iterator0.e(err);
-      } finally {
-        _iterator0.f();
+      function handleMessage(_x3, _x4) {
+        return _handleMessage.apply(this, arguments);
       }
-      _loggerProxy.default.logger.info("HashTreeParser#resume --> ".concat(this.debugId, " Resuming HashTreeParser with data sets: ").concat((0, _keys.default)(this.dataSets).join(', '), ", visible data sets: ").concat(this.visibleDataSets.map(function (ds) {
-        return ds.name;
-      }).join(', ')));
-      this.state = 'active';
-      this.handleMessage(message, 'on resume');
-    }
-  }, {
-    key: "checkForSentinelHttpResponse",
-    value: function checkForSentinelHttpResponse(error, dataSetName) {
-      var _error$body;
-      var isValidDataSetForSentinel = dataSetName === undefined || PossibleSentinelMessageDataSetNames.includes(dataSetName.toLowerCase());
-      if ((error.statusCode === 409 && ((_error$body = error.body) === null || _error$body === void 0 ? void 0 : _error$body.errorCode) === 2403004 || error.statusCode === 404) && isValidDataSetForSentinel) {
-        _loggerProxy.default.logger.info("HashTreeParser#checkForSentinelHttpResponse --> ".concat(this.debugId, " Received ").concat(error.statusCode, " for data set \"").concat(dataSetName, "\", indicating that the meeting has ended"));
-        this.stopAllTimers();
-        throw new MeetingEndedError();
-      }
-    }
-
-    /**
-     * Gets the current hashes from the locus for a specific data set.
-     * @param {string} dataSetName
-     * @param {string} currentRootHash
-     * @returns {string[]}
-     */
-  }, {
-    key: "getHashesFromLocus",
-    value: function getHashesFromLocus(dataSetName, currentRootHash) {
-      var _this13 = 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,
-        qs: {
-          rootHash: currentRootHash
-        }
-      }).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(_this13.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(_this13.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(_this13.debugId, " Error ").concat(error.statusCode, " fetching hashes for data set \"").concat(dataSetName, "\":"), error);
-        _this13.checkForSentinelHttpResponse(error, dataSet.name);
-        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 _this14 = 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 = {
-        leafCount: dataSet.leafCount,
-        leafDataEntries: []
-      };
-      (0, _keys.default)(mismatchedLeavesData).forEach(function (index) {
-        body.leafDataEntries.push({
-          leafIndex: (0, _parseInt2.default)(index, 10),
-          elementIds: mismatchedLeavesData[index]
-        });
-      });
-      var ourCurrentRootHash = dataSet.hashTree ? dataSet.hashTree.getRootHash() : _constants2.EMPTY_HASH;
-      return this.webexRequest({
-        method: _constants.HTTP_VERBS.POST,
-        uri: url,
-        qs: {
-          rootHash: ourCurrentRootHash
-        },
-        body: body
-      }).then(function (resp) {
-        _loggerProxy.default.logger.info("HashTreeParser#sendSyncRequestToLocus --> ".concat(_this14.debugId, " Sync request succeeded for \"").concat(dataSet.name, "\""));
-        if (!resp.body || (0, _lodash.isEmpty)(resp.body)) {
-          _loggerProxy.default.logger.info("HashTreeParser#sendSyncRequestToLocus --> ".concat(_this14.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(_this14.debugId, " Error ").concat(error.statusCode, " sending sync request for data set \"").concat(dataSet.name, "\":"), error);
-        _this14.checkForSentinelHttpResponse(error, dataSet.name);
-        throw error;
-      });
-    }
+      return handleMessage;
+    }())
   }]);
 }();
 var _default = exports.default = HashTreeParser;