@webex/plugin-meetings 3.11.0-next.34 → 3.11.0-next.36

package/dist/aiEnableRequest/index.js

@@ -178,7 +178,7 @@ var AIEnableRequest = _webexCore.WebexPlugin.extend({
       method: _constants.HTTP_VERBS.PUT
     });
   },
-  version: "3.11.0-next.34"
+  version: "3.11.0-next.36"
 });
 var _default = exports.default = AIEnableRequest;
 //# sourceMappingURL=index.js.map

package/dist/breakouts/breakout.js

@@ -209,7 +209,7 @@ var Breakout = _webexCore.WebexPlugin.extend({
       sessionId: this.sessionId
     });
   },
-  version: "3.11.0-next.34"
+  version: "3.11.0-next.36"
 });
 var _default = exports.default = Breakout;
 //# sourceMappingURL=breakout.js.map

package/dist/breakouts/index.js

@@ -1109,7 +1109,7 @@ var Breakouts = _webexCore.WebexPlugin.extend({
       this.trigger(_constants.BREAKOUTS.EVENTS.ASK_RETURN_TO_MAIN);
     }
   },
-  version: "3.11.0-next.34"
+  version: "3.11.0-next.36"
 });
 var _default = exports.default = Breakouts;
 //# sourceMappingURL=index.js.map

package/dist/hashTree/hashTreeParser.js

@@ -233,7 +233,10 @@ var HashTreeParser = /*#__PURE__*/function () {
       _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 _this2.parseMessage(syncResponse, "via empty leaves /sync API call for ".concat(debugText));
+          return {
+            updateType: LocusInfoUpdateType.OBJECTS_UPDATED,
+            updatedObjects: _this2.parseMessage(syncResponse, "via empty leaves /sync API call for ".concat(debugText))
+          };
         }
         return {
           updateType: LocusInfoUpdateType.OBJECTS_UPDATED,
@@ -366,7 +369,7 @@ var HashTreeParser = /*#__PURE__*/function () {
               _iterator2.s();
             case 2:
               if ((_step2 = _iterator2.n()).done) {
-                _context3.next = 7;
+                _context3.next = 6;
                 break;
               }
               dataSet = _step2.value;
@@ -388,10 +391,10 @@ var HashTreeParser = /*#__PURE__*/function () {
                 _context3.next = 3;
                 break;
               }
-              return _context3.abrupt("continue", 6);
+              return _context3.abrupt("continue", 5);
             case 3:
               if (this.dataSets[name].hashTree) {
-                _context3.next = 6;
+                _context3.next = 5;
                 break;
               }
               _loggerProxy.default.logger.info("HashTreeParser#initializeDataSets --> ".concat(this.debugId, " creating hash tree for visible dataset \"").concat(name, "\" (").concat(debugText, ")"));
@@ -402,42 +405,33 @@ var HashTreeParser = /*#__PURE__*/function () {
               return this.sendInitializationSyncRequestToLocus(name, debugText);
             case 4:
               _data = _context3.sent;
-              if (!(_data.updateType === LocusInfoUpdateType.MEETING_ENDED)) {
-                _context3.next = 5;
-                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 5:
               if (_data.updateType === LocusInfoUpdateType.OBJECTS_UPDATED) {
                 updatedObjects.push.apply(updatedObjects, (0, _toConsumableArray2.default)(_data.updatedObjects || []));
               }
-            case 6:
+            case 5:
               _context3.next = 2;
               break;
-            case 7:
-              _context3.next = 9;
+            case 6:
+              _context3.next = 8;
               break;
-            case 8:
-              _context3.prev = 8;
+            case 7:
+              _context3.prev = 7;
               _t = _context3["catch"](1);
               _iterator2.e(_t);
-            case 9:
-              _context3.prev = 9;
+            case 8:
+              _context3.prev = 8;
               _iterator2.f();
-              return _context3.finish(9);
-            case 10:
+              return _context3.finish(8);
+            case 9:
               this.callLocusInfoUpdateCallback({
                 updateType: LocusInfoUpdateType.OBJECTS_UPDATED,
                 updatedObjects: updatedObjects
               });
-            case 11:
+            case 10:
             case "end":
               return _context3.stop();
           }
-        }, _callee3, this, [[1, 8, 9, 10]]);
+        }, _callee3, this, [[1, 7, 8, 9]]);
       }));
       function initializeDataSets(_x3, _x4) {
         return _initializeDataSets.apply(this, arguments);
@@ -1027,143 +1021,116 @@ var HashTreeParser = /*#__PURE__*/function () {
      *
      * @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}
+     * @returns {HashTreeObject[]} list of hash tree objects that were updated as a result of processing the message
      */
     )
   }, {
     key: "parseMessage",
-    value: (function () {
-      var _parseMessage = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee5(message, debugText) {
-        var _message$locusStateEl,
-          _this1 = this,
-          _message$locusStateEl2;
-        var dataSets, visibleDataSetsUrl, isRosterDropped, updatedObjects, dataSetsRequiringInitialization, metadataUpdates, updatedMetadataObjects, _this$checkForVisible2, 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
-              }
+    value: function parseMessage(message, debugText) {
+      var _message$locusStateEl,
+        _this1 = this,
+        _message$locusStateEl2;
+      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);
-              });
-              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 Metadata object updates
-              metadataUpdates = (message.locusStateElements || []).filter(function (object) {
-                return (0, _utils.isMetadata)(object);
-              });
-              if (metadataUpdates.length > 0) {
-                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);
-                _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);
+      // 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);
                 }
               }
-              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) {
-                          if ((0, _utils.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(_this1.debugId, " unexpected (not visible) dataSet ").concat(dataSet.name, " received in hash tree message"));
-                    }
-                  }
-                  if (!isRosterDropped) {
-                    _this1.runSyncAlgorithm(dataSet);
-                  }
-                });
-              }
-              if (!isRosterDropped) {
-                _context6.next = 1;
-                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
+            }
+          } 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);
               });
-            case 1:
-              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 _context6.abrupt("return", {
-                updateType: LocusInfoUpdateType.OBJECTS_UPDATED,
-                updatedObjects: updatedObjects
+              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);
+                }
               });
-            case 2:
-            case "end":
-              return _context6.stop();
+            } else {
+              _loggerProxy.default.logger.info("Locus-info:index#parseMessage --> ".concat(_this1.debugId, " unexpected (not visible) dataSet ").concat(dataSet.name, " received in hash tree message"));
+            }
           }
-        }, _callee5, this);
-      }));
-      function parseMessage(_x6, _x7) {
-        return _parseMessage.apply(this, arguments);
+          _this1.runSyncAlgorithm(dataSet);
+        });
       }
-      return parseMessage;
-    }()
+      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;
+    }
+
     /**
      * Handles incoming hash tree messages, updates the hash trees and calls locusInfoUpdateCallback
      *
@@ -1171,66 +1138,37 @@ var HashTreeParser = /*#__PURE__*/function () {
      * @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.heartbeatIntervalMs) {
-                this.heartbeatIntervalMs = message.heartbeatIntervalMs;
-              }
-              if (!this.isEndMessage(message)) {
-                _context7.next = 1;
-                break;
-              }
-              _loggerProxy.default.logger.info("HashTreeParser#parseMessage --> ".concat(this.debugId, " received sentinel END MEETING message"));
-              this.stopAllTimers();
-              this.callLocusInfoUpdateCallback({
-                updateType: LocusInfoUpdateType.MEETING_ENDED
-              });
-              _context7.next = 4;
-              break;
-            case 1:
-              if (!(message.locusStateElements === undefined)) {
-                _context7.next = 2;
-                break;
-              }
-              this.handleRootHashHeartBeatMessage(message);
-              this.resetHeartbeatWatchdogs(message.dataSets);
-              _context7.next = 4;
-              break;
-            case 2:
-              _context7.next = 3;
-              return this.parseMessage(message, debugText);
-            case 3:
-              updates = _context7.sent;
-              // Only reset watchdogs if the meeting hasn't ended
-              if (updates.updateType !== LocusInfoUpdateType.MEETING_ENDED) {
-                this.resetHeartbeatWatchdogs(message.dataSets);
-              }
-              this.callLocusInfoUpdateCallback(updates);
-            case 4:
-            case "end":
-              return _context7.stop();
-          }
-        }, _callee6, this);
-      }));
-      function handleMessage(_x8, _x9) {
-        return _handleMessage.apply(this, arguments);
+    value: function handleMessage(message, debugText) {
+      if (message.heartbeatIntervalMs) {
+        this.heartbeatIntervalMs = message.heartbeatIntervalMs;
       }
-      return handleMessage;
-    }()
+      if (this.isEndMessage(message)) {
+        _loggerProxy.default.logger.info("HashTreeParser#parseMessage --> ".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) {
@@ -1309,45 +1247,45 @@ var HashTreeParser = /*#__PURE__*/function () {
   }, {
     key: "performSync",
     value: (function () {
-      var _performSync = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee7(dataSet, rootHash, reason) {
+      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 (_context8) {
-          while (1) switch (_context8.prev = _context8.next) {
+        return _regenerator.default.wrap(function (_context6) {
+          while (1) switch (_context6.prev = _context6.next) {
             case 0:
               if (dataSet.hashTree) {
-                _context8.next = 1;
+                _context6.next = 1;
                 break;
               }
-              return _context8.abrupt("return");
+              return _context6.abrupt("return");
             case 1:
-              _context8.prev = 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)) {
-                _context8.next = 7;
+                _context6.next = 7;
                 break;
               }
-              _context8.prev = 2;
-              _context8.next = 3;
+              _context6.prev = 2;
+              _context6.next = 3;
               return this.getHashesFromLocus(dataSet.name, rootHash);
             case 3:
-              _yield$this$getHashes = _context8.sent;
+              _yield$this$getHashes = _context6.sent;
               hashes = _yield$this$getHashes.hashes;
               latestDataSetInfo = _yield$this$getHashes.dataSet;
               receivedHashes = hashes;
               dataSet.hashTree.resize(latestDataSetInfo.leafCount);
-              _context8.next = 6;
+              _context6.next = 6;
               break;
             case 4:
-              _context8.prev = 4;
-              _t3 = _context8["catch"](2);
+              _context6.prev = 4;
+              _t3 = _context6["catch"](2);
               if (!(_t3.statusCode === 409)) {
-                _context8.next = 5;
+                _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 _context8.abrupt("return");
+              return _context6.abrupt("return");
             case 5:
               throw _t3;
             case 6:
@@ -1356,30 +1294,30 @@ var HashTreeParser = /*#__PURE__*/function () {
               mismatchedLeaveIndexes.forEach(function (index) {
                 mismatchedLeavesData[index] = dataSet.hashTree.getLeafData(index);
               });
-              _context8.next = 8;
+              _context6.next = 8;
               break;
             case 7:
               mismatchedLeavesData[0] = dataSet.hashTree.getLeafData(0);
             case 8:
               if (!((0, _keys.default)(mismatchedLeavesData).length > 0)) {
-                _context8.next = 10;
+                _context6.next = 10;
                 break;
               }
-              _context8.next = 9;
+              _context6.next = 9;
               return this.sendSyncRequestToLocus(dataSet, mismatchedLeavesData);
             case 9:
-              syncResponse = _context8.sent;
+              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:
-              _context8.next = 12;
+              _context6.next = 12;
               break;
             case 11:
-              _context8.prev = 11;
-              _t4 = _context8["catch"](1);
+              _context6.prev = 11;
+              _t4 = _context6["catch"](1);
               if (_t4 instanceof MeetingEndedError) {
                 this.callLocusInfoUpdateCallback({
                   updateType: LocusInfoUpdateType.MEETING_ENDED
@@ -1389,11 +1327,11 @@ var HashTreeParser = /*#__PURE__*/function () {
               }
             case 12:
             case "end":
-              return _context8.stop();
+              return _context6.stop();
           }
-        }, _callee7, this, [[1, 11], [2, 4]]);
+        }, _callee5, this, [[1, 11], [2, 4]]);
       }));
-      function performSync(_x0, _x1, _x10) {
+      function performSync(_x6, _x7, _x8) {
         return _performSync.apply(this, arguments);
       }
       return performSync;
@@ -1429,36 +1367,36 @@ var HashTreeParser = /*#__PURE__*/function () {
           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 _callee8() {
+        dataSet.timer = setTimeout(/*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee6() {
           var rootHash;
-          return _regenerator.default.wrap(function (_context9) {
-            while (1) switch (_context9.prev = _context9.next) {
+          return _regenerator.default.wrap(function (_context7) {
+            while (1) switch (_context7.prev = _context7.next) {
               case 0:
                 dataSet.timer = undefined;
                 if (dataSet.hashTree) {
-                  _context9.next = 1;
+                  _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 _context9.abrupt("return");
+                return _context7.abrupt("return");
               case 1:
                 rootHash = dataSet.hashTree.getRootHash();
                 if (!(dataSet.root !== rootHash)) {
-                  _context9.next = 3;
+                  _context7.next = 3;
                   break;
                 }
-                _context9.next = 2;
+                _context7.next = 2;
                 return _this11.performSync(dataSet, rootHash, "Root hash mismatch: received=".concat(dataSet.root, ", ours=").concat(rootHash));
               case 2:
-                _context9.next = 4;
+                _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 _context9.stop();
+                return _context7.stop();
             }
-          }, _callee8);
+          }, _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"));
@@ -1497,19 +1435,19 @@ var HashTreeParser = /*#__PURE__*/function () {
           }
           var backoffTime = _this12.getWeightedBackoffTime(dataSet.backoff);
           var delay = _this12.heartbeatIntervalMs + backoffTime;
-          dataSet.heartbeatWatchdogTimer = setTimeout(/*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee9() {
-            return _regenerator.default.wrap(function (_context0) {
-              while (1) switch (_context0.prev = _context0.next) {
+          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"));
-                  _context0.next = 1;
+                  _context8.next = 1;
                   return _this12.performSync(dataSet, dataSet.hashTree.getRootHash(), "heartbeat watchdog expired");
                 case 1:
                 case "end":
-                  return _context0.stop();
+                  return _context8.stop();
               }
-            }, _callee9);
+            }, _callee7);
           })), delay);
         };
         for (_iterator9.s(); !(_step9 = _iterator9.n()).done;) {