@webex/plugin-meetings 3.0.0-beta.2 → 3.0.0-beta.200

package/dist/locus-info/parser.js

@@ -1,31 +1,22 @@
 "use strict";
 
 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 = void 0;
-
 var _taggedTemplateLiteral2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/taggedTemplateLiteral"));
-
 var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/classCallCheck"));
-
 var _createClass2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/createClass"));
-
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/defineProperty"));
-
 var _difference2 = _interopRequireDefault(require("lodash/difference"));
-
 var _queue = _interopRequireDefault(require("../common/queue"));
-
 var _loggerProxy = _interopRequireDefault(require("../common/logs/logger-proxy"));
-
 var _templateObject, _templateObject2, _templateObject3, _templateObject4, _templateObject5, _templateObject6, _templateObject7, _templateObject8, _templateObject9, _templateObject10;
-
+var MAX_OOO_DELTA_COUNT = 5; // when we receive an out-of-order delta and the queue builds up to MAX_OOO_DELTA_COUNT, we do a sync with Locus
+var OOO_DELTA_WAIT_TIME = 10000; // [ms] minimum wait time before we do a sync if we get out-of-order deltas
+var OOO_DELTA_WAIT_TIME_RANDOM_DELAY = 5000; // [ms] max random delay added to OOO_DELTA_WAIT_TIME
 /**
  * Locus Delta Parser
  * @private
@@ -33,6 +24,9 @@ var _templateObject, _templateObject2, _templateObject3, _templateObject4, _temp
  */
 var Parser = /*#__PURE__*/function () {
   // processing status
+
+  // received an out-of-order delta, so waiting for the missing one
+
   // loci comparison states
 
   /**
@@ -40,22 +34,72 @@ var Parser = /*#__PURE__*/function () {
    */
   function Parser() {
     (0, _classCallCheck2.default)(this, Parser);
-    this.queue = new _queue.default();
-    this.status = Parser.status.IDLE;
+    (0, _defineProperty2.default)(this, "status", void 0);
+    (0, _defineProperty2.default)(this, "queue", void 0);
+    (0, _defineProperty2.default)(this, "workingCopy", void 0);
+    (0, _defineProperty2.default)(this, "syncTimer", void 0);
+    var deltaCompareFunc = function deltaCompareFunc(left, right) {
+      var _Parser$loci = Parser.loci,
+        LT = _Parser$loci.LT,
+        GT = _Parser$loci.GT;
+      var extract = Parser.extractComparisonState;
+      if (Parser.isSequenceEmpty(left)) {
+        return -1;
+      }
+      if (Parser.isSequenceEmpty(right)) {
+        return 1;
+      }
+      var result = extract(Parser.compareSequence(left.baseSequence, right.baseSequence));
+      if (result === LT) {
+        return -1;
+      }
+      if (result === GT) {
+        return 1;
+      }
+      return 0;
+    };
+    this.queue = new _queue.default(deltaCompareFunc);
+    this.status = 'IDLE';
     this.onDeltaAction = null;
     this.workingCopy = null;
+    this.syncTimer = null;
   }
+
   /**
-   * Checks if two sequences overlap in time,
-   * the sequence with the higher minimum value is greater.
-   * Chooses sequence with most recent data.
-   * @param {Types~Locus} current
-   * @param {Types~Locus} incoming
-   * @returns {string} loci comparison state
+   * Returns a debug string representing a locus delta - useful for logging
+   *
+   * @param {LocusDeltaDto} locus Locus delta
+   * @returns {string}
    */
-
-
   (0, _createClass2.default)(Parser, [{
+    key: "isNewFullLocus",
+    value:
+    /**
+     * Returns true if the incoming full locus DTO is newer than the current working copy
+     *
+     * @param {Types~Locus} incomingFullDto New Full Locus DTO
+     * @returns {string} either Parser.loci.USE_INCOMING or Parser.loci.USE_CURRENT
+     */
+    function isNewFullLocus(incomingFullDto) {
+      if (!Parser.isLoci(incomingFullDto)) {
+        _loggerProxy.default.logger.info('Locus-info:parser#isNewFullLocus --> Ignoring non-locus object.');
+        return false;
+      }
+      if (!this.workingCopy) {
+        // we don't have a working copy yet, so any full locus is better than nothing
+        return true;
+      }
+      var comparisonResult = Parser.compareFullDtoSequence(this.workingCopy, incomingFullDto);
+      return comparisonResult === Parser.loci.USE_INCOMING;
+    }
+
+    /**
+     * Compares Locus sequences
+     * @param {Types~Locus} current Current working copy
+     * @param {Types~Locus} incoming New Locus delta
+     * @returns {string}
+     */
+  }, {
     key: "isValidLocus",
     value:
     /**
@@ -64,33 +108,23 @@ var Parser = /*#__PURE__*/function () {
      * @returns {boolean}
      */
     function isValidLocus(newLoci) {
-      var _this = this;
-
       var isValid = false;
-      var IDLE = Parser.status.IDLE;
       var isLoci = Parser.isLoci;
 
-      var setStatus = function setStatus(status) {
-        _this.status = status;
-      }; // one or both objects are not locus delta events
-
-
+      // one or both objects are not locus delta events
       if (!isLoci(this.workingCopy) || !isLoci(newLoci)) {
-        setStatus(IDLE);
-
         _loggerProxy.default.logger.info('Locus-info:parser#processDeltaEvent --> Ignoring non-locus object. workingCopy:', this.workingCopy, 'newLoci:', newLoci);
       } else {
         isValid = true;
       }
-
       return isValid;
     }
+
     /**
      * Determines if a paricular locus's sequence is empty
      * @param {Types~Locus} locus
      * @returns {bool}
      */
-
   }, {
     key: "nextEvent",
     value:
@@ -100,19 +134,23 @@ var Parser = /*#__PURE__*/function () {
      * @returns {undefined}
      */
     function nextEvent() {
-      if (this.status === Parser.status.PAUSED) {
+      if (this.status === 'PAUSED') {
         _loggerProxy.default.logger.info('Locus-info:parser#nextEvent --> Locus parser paused.');
-
         return;
-      } // continue processing until queue is empty
-
+      }
+      if (this.status === 'BLOCKED') {
+        _loggerProxy.default.logger.info('Locus-info:parser#nextEvent --> Locus parser blocked by out-of-order delta.');
+        return;
+      }
 
+      // continue processing until queue is empty
       if (this.queue.size() > 0) {
         this.processDeltaEvent();
       } else {
-        this.status = Parser.status.IDLE;
+        this.status = 'IDLE';
       }
     }
+
     /**
      * Function handler for delta actions,
      * is set by instance callee.
@@ -120,37 +158,42 @@ var Parser = /*#__PURE__*/function () {
      * @param {Types~Locus} locus Locus delta
      * @returns {undefined}
      */
-    // eslint-disable-next-line no-unused-vars
-
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
   }, {
     key: "onDeltaAction",
     value: function onDeltaAction(action, locus) {}
+
     /**
      * Event handler for locus delta events
      * @param {Types~Locus} loci Locus Delta
      * @returns {undefined}
      */
-
   }, {
     key: "onDeltaEvent",
     value: function onDeltaEvent(loci) {
       // enqueue the new loci
-      this.queue.enqueue(loci); // start processing events in the queue if idle
-      // and a function handler is defined
-
-      if (this.status === Parser.status.IDLE && this.onDeltaAction) {
-        // Update status, ensure we only process one event at a time.
-        this.status = Parser.status.WORKING;
-        this.processDeltaEvent();
+      this.queue.enqueue(loci);
+      if (this.onDeltaAction) {
+        if (this.status === 'BLOCKED') {
+          if (this.queue.size() > MAX_OOO_DELTA_COUNT) {
+            this.triggerSync('queue too big, blocked on out-of-order delta');
+          } else {
+            this.processDeltaEvent();
+          }
+        } else if (this.status === 'IDLE') {
+          // Update status, ensure we only process one event at a time.
+          this.status = 'WORKING';
+          this.processDeltaEvent();
+        }
       }
     }
+
     /**
      * Appends new data onto a string of existing data.
      * @param {string} newData
      * @param {string} oldData
      * @returns {string}
      */
-
   }, {
     key: "pause",
     value:
@@ -159,36 +202,87 @@ var Parser = /*#__PURE__*/function () {
      * @returns {undefined}
      */
     function pause() {
-      this.status = Parser.status.PAUSED;
-
+      this.status = 'PAUSED';
       _loggerProxy.default.logger.info('Locus-info:parser#pause --> Locus parser paused.');
     }
+
+    /**
+     * Triggers a sync with Locus
+     *
+     * @param {string} reason used just for logging
+     * @returns {undefined}
+     */
+  }, {
+    key: "triggerSync",
+    value: function triggerSync(reason) {
+      _loggerProxy.default.logger.info("Locus-info:parser#triggerSync --> doing sync, reason: ".concat(reason));
+      this.stopSyncTimer();
+      this.pause();
+      this.onDeltaAction(Parser.loci.DESYNC, this.workingCopy);
+    }
+
+    /**
+     * Starts a timer with a random delay. When that timer expires we will do a sync.
+     *
+     * The main purpose of this timer is to handle a case when we get some out-of-order deltas,
+     * so we start waiting to receive the missing delta. If that delta never arrives, this timer
+     * will trigger a sync with Locus.
+     *
+     * @returns {undefined}
+     */
+  }, {
+    key: "startSyncTimer",
+    value: function startSyncTimer() {
+      var _this = this;
+      if (this.syncTimer === null) {
+        var timeout = OOO_DELTA_WAIT_TIME + Math.random() * OOO_DELTA_WAIT_TIME_RANDOM_DELAY;
+        this.syncTimer = setTimeout(function () {
+          _this.syncTimer = null;
+          _this.triggerSync('timer expired, blocked on out-of-order delta');
+        }, timeout);
+      }
+    }
+
+    /**
+     * Stops the timer for triggering a sync
+     *
+     * @returns {undefined}
+     */
+  }, {
+    key: "stopSyncTimer",
+    value: function stopSyncTimer() {
+      if (this.syncTimer !== null) {
+        clearTimeout(this.syncTimer);
+        this.syncTimer = null;
+      }
+    }
+
     /**
      * Processes next locus delta in the queue,
      * continues until the queue is empty
      * or cleared.
      * @returns {undefined}
      */
-
   }, {
     key: "processDeltaEvent",
     value: function processDeltaEvent() {
-      var _Parser$loci = Parser.loci,
-          DESYNC = _Parser$loci.DESYNC,
-          USE_INCOMING = _Parser$loci.USE_INCOMING;
+      var _Parser$loci2 = Parser.loci,
+        DESYNC = _Parser$loci2.DESYNC,
+        USE_INCOMING = _Parser$loci2.USE_INCOMING,
+        WAIT = _Parser$loci2.WAIT;
       var extract = Parser.extractComparisonState;
       var newLoci = this.queue.dequeue();
-
       if (!this.isValidLocus(newLoci)) {
+        this.nextEvent();
         return;
       }
-
       var result = Parser.compare(this.workingCopy, newLoci);
-      var lociComparison = extract(result); // limited debugging, use chrome extension
-      // for full debugging.
+      var lociComparison = extract(result);
 
+      // limited debugging, use chrome extension
+      // for full debugging.
       _loggerProxy.default.logger.debug("Locus-info:parser#processDeltaEvent --> Locus Debug: ".concat(result));
-
+      var needToWait = false;
       if (lociComparison === DESYNC) {
         // wait for desync response
         this.pause();
@@ -197,53 +291,86 @@ var Parser = /*#__PURE__*/function () {
         // Note: The working copy of parser gets updated in .onFullLocus()
         // and here when USE_INCOMING locus.
         this.workingCopy = newLoci;
+      } else if (lociComparison === WAIT) {
+        // we've taken newLoci from the front of the queue, so put it back there as we have to wait
+        // for the one that should be in front of it, before we can process it
+        this.queue.enqueue(newLoci);
+        needToWait = true;
+      }
+      if (needToWait) {
+        this.status = 'BLOCKED';
+        this.startSyncTimer();
+      } else {
+        this.stopSyncTimer();
+        if (this.status === 'BLOCKED') {
+          // we are not blocked anymore
+          this.status = 'WORKING';
+          _loggerProxy.default.logger.info("Locus-info:parser#processDeltaEvent --> received delta that we were waiting for ".concat(Parser.locus2string(newLoci), ", not blocked anymore"));
+        }
       }
-
       if (this.onDeltaAction) {
-        _loggerProxy.default.logger.info("Locus-info:parser#processDeltaEvent --> Locus Delta Action: ".concat(lociComparison));
-
-        this.onDeltaAction.call(this, lociComparison, newLoci);
+        _loggerProxy.default.logger.info("Locus-info:parser#processDeltaEvent --> Locus Delta ".concat(Parser.locus2string(newLoci), ", Action: ").concat(lociComparison));
+        this.onDeltaAction(lociComparison, newLoci);
       }
-
       this.nextEvent();
     }
+
     /**
      * Resume from a paused state
      * @returns {undefined}
      */
-
   }, {
     key: "resume",
     value: function resume() {
       _loggerProxy.default.logger.info('Locus-info:parser#resume --> Locus parser resumed.');
-
-      this.status = Parser.status.WORKING;
+      this.status = 'WORKING';
       this.nextEvent();
     }
+
     /**
      * Gets related debug info for given error code
      * @param {string} debugCode Debug code
      * @param {string} comparison Locus comparison string
      * @returns {object} Debug message
      */
-
   }], [{
+    key: "locus2string",
+    value: function locus2string(locus) {
+      var _locus$sequence;
+      if (!((_locus$sequence = locus.sequence) !== null && _locus$sequence !== void 0 && _locus$sequence.entries)) {
+        return 'invalid';
+      }
+      return locus.sequence.entries.length ? "seq=".concat(locus.sequence.entries.at(-1)) : 'empty';
+    }
+
+    /**
+     * Checks if two sequences overlap in time,
+     * the sequence with the higher minimum value is greater.
+     * Chooses sequence with most recent data.
+     * @param {Types~Locus} current
+     * @param {Types~Locus} incoming
+     * @returns {string} loci comparison state
+     */
+  }, {
     key: "checkSequenceOverlap",
     value: function checkSequenceOverlap(current, incoming) {
-      var comparison = null; // if earliest working copy sequence is more recent than last incoming sequence
+      var comparison = null;
 
+      // if earliest working copy sequence is more recent than last incoming sequence
       if (current.min > incoming.max) {
         // choose left side (current)
         comparison = "".concat(Parser.loci.GT, ":SO001");
-      } // if last working copy sequence is before the earliest incoming sequence
+      }
+      // if last working copy sequence is before the earliest incoming sequence
       else if (current.max < incoming.min) {
         // choose right side (incoming)
         comparison = "".concat(Parser.loci.LT, ":SO002");
-      } // if no match above, defaults to null
-
+      }
 
+      // if no match above, defaults to null
       return comparison;
     }
+
     /**
      * Checks if two sequences have unequal ranges.
      * Chooses sequence with most larger range.
@@ -251,7 +378,6 @@ var Parser = /*#__PURE__*/function () {
      * @param {Types~Locus} incoming
      * @returns {object} loci comparison
      */
-
   }, {
     key: "checkUnequalRanges",
     value: function checkUnequalRanges(current, incoming) {
@@ -259,14 +385,16 @@ var Parser = /*#__PURE__*/function () {
       var currentIsNotUnique = current.unique.length === 0;
       var incomingIsNotUnique = incoming.unique.length === 0;
       var currentTotalRange = current.end - current.min;
-      var incomingTotalRange = incoming.end - incoming.min; // no unique values for both loci
+      var incomingTotalRange = incoming.end - incoming.min;
 
+      // no unique values for both loci
       if (currentIsNotUnique && incomingIsNotUnique) {
         // current working copy loci has a larger range
         if (currentTotalRange > incomingTotalRange) {
           // choose left side (current)
           comparison = "".concat(Parser.loci.GT, ":UR001");
-        } // incoming delta loci has a larger range
+        }
+        // incoming delta loci has a larger range
         else if (currentTotalRange < incomingTotalRange) {
           // choose right side (incoming)
           comparison = "".concat(Parser.loci.LT, ":UR002");
@@ -276,9 +404,9 @@ var Parser = /*#__PURE__*/function () {
           comparison = "".concat(Parser.loci.EQ, ":UR003");
         }
       }
-
       return comparison;
     }
+
     /**
      * Checks if either sequences has unique entries.
      * Entries are considered unique if they do not overlap
@@ -288,25 +416,26 @@ var Parser = /*#__PURE__*/function () {
      * @param {Types~Locus} incoming
      * @returns {string} loci comparison state
      */
-
   }, {
     key: "checkForUniqueEntries",
     value: function checkForUniqueEntries(current, incoming) {
       var comparison = null;
       var currentIsUnique = current.unique.length > 0;
-      var incomingIsUnique = incoming.unique.length > 0; // current has unique entries and incoming does not
+      var incomingIsUnique = incoming.unique.length > 0;
 
+      // current has unique entries and incoming does not
       if (currentIsUnique && !incomingIsUnique) {
         // choose left side (current)
         comparison = "".concat(Parser.loci.GT, ":UE001");
-      } // current has no unique entries but incoming does
+      }
+      // current has no unique entries but incoming does
       else if (!currentIsUnique && incomingIsUnique) {
         // choose right side (incoming)
         comparison = "".concat(Parser.loci.LT, ":UE002");
       }
-
       return comparison;
     }
+
     /**
      * Checks both Locus Delta objects to see if they are
      * out of sync with one another. If so sends a DESYNC
@@ -315,7 +444,6 @@ var Parser = /*#__PURE__*/function () {
      * @param {Types~Locus} incoming
      * @returns {string} loci comparison state
      */
-
   }, {
     key: "checkIfOutOfSync",
     value: function checkIfOutOfSync(current, incoming) {
@@ -325,22 +453,20 @@ var Parser = /*#__PURE__*/function () {
       var currentHasNoRange = !current.start && !current.end;
       var incomingHasNoRange = !incoming.start && !incoming.end;
       var neitherSeqHasRange = currentHasNoRange && incomingHasNoRange;
-
       var hasUniqOverlap = function hasUniqOverlap(list, min, max) {
         return list.some(function (seq) {
           return min < seq && seq < max;
         });
-      }; // current unique entries overlap the total range of incoming
-
-
-      var currentUniqOverlap = hasUniqOverlap(current.unique, incoming.min, incoming.max); // vice-versa, incoming unique entries overlap the total range of current
-
+      };
+      // current unique entries overlap the total range of incoming
+      var currentUniqOverlap = hasUniqOverlap(current.unique, incoming.min, incoming.max);
+      // vice-versa, incoming unique entries overlap the total range of current
       var incomingUniqOverlap = hasUniqOverlap(incoming.unique, current.min, current.max);
-
       if (neitherSeqHasRange || currentUniqOverlap || incomingUniqOverlap) {
         // outputs string indicating which condition occurred. ex: 0,1,0
-        var debugInfo = "".concat(+neitherSeqHasRange, ",").concat(+currentUniqOverlap, ",").concat(+incomingUniqOverlap); // send DESYNC to server
+        var debugInfo = "".concat(+neitherSeqHasRange, ",").concat(+currentUniqOverlap, ",").concat(+incomingUniqOverlap);
 
+        // send DESYNC to server
         comparison = "".concat(Parser.loci.DESYNC, ":OOS001:").concat(debugInfo);
       } else if (currentUniqueMin > incomingUniqueMin) {
         // choose left side (current)
@@ -349,9 +475,9 @@ var Parser = /*#__PURE__*/function () {
         // choose right side (incoming)
         comparison = "".concat(Parser.loci.LT, ":OOS003");
       }
-
       return comparison;
     }
+
     /**
      * Compares two loci to determine which one contains the most recent state
      * @instance
@@ -360,26 +486,23 @@ var Parser = /*#__PURE__*/function () {
      * @param {Types~Locus} incoming
      * @returns {string} loci comparison state
      */
-
   }, {
     key: "compare",
     value: function compare(current, incoming) {
       var isSequenceEmpty = Parser.isSequenceEmpty;
       var extract = Parser.extractComparisonState;
       var pack = Parser.packComparisonResult;
-
       if (isSequenceEmpty(current) || isSequenceEmpty(incoming)) {
         return pack(Parser.loci.USE_INCOMING, 'C001');
       }
-
       if (incoming.baseSequence) {
         return pack(Parser.compareDelta(current, incoming), 'C002');
       }
-
       var result = Parser.compareSequence(current.sequence, incoming.sequence);
       var action = Parser.compareToAction(extract(result));
       return pack(action, result);
     }
+
     /**
      * Compares two loci sequences (with delta params) and indicates what action
      * to take.
@@ -390,127 +513,142 @@ var Parser = /*#__PURE__*/function () {
      * @private
      * @returns {string} loci comparison state
      */
-
   }, {
     key: "compareDelta",
     value: function compareDelta(current, incoming) {
-      var _Parser$loci2 = Parser.loci,
-          LT = _Parser$loci2.LT,
-          GT = _Parser$loci2.GT,
-          EQ = _Parser$loci2.EQ,
-          DESYNC = _Parser$loci2.DESYNC,
-          USE_INCOMING = _Parser$loci2.USE_INCOMING;
+      var _Parser$loci3 = Parser.loci,
+        LT = _Parser$loci3.LT,
+        GT = _Parser$loci3.GT,
+        EQ = _Parser$loci3.EQ,
+        DESYNC = _Parser$loci3.DESYNC,
+        USE_INCOMING = _Parser$loci3.USE_INCOMING,
+        WAIT = _Parser$loci3.WAIT;
       var extract = Parser.extractComparisonState;
       var pack = Parser.packComparisonResult;
       var result = Parser.compareSequence(current.sequence, incoming.sequence);
       var comparison = extract(result);
-
       if (comparison !== LT) {
         return pack(Parser.compareToAction(comparison), result);
       }
-
       comparison = Parser.compareSequence(current.sequence, incoming.baseSequence);
-
       switch (extract(comparison)) {
         case GT:
         case EQ:
           comparison = USE_INCOMING;
           break;
-
+        case LT:
+          if (extract(Parser.compareSequence(incoming.baseSequence, incoming.sequence)) === EQ) {
+            // special case where Locus sends a delta with baseSequence === sequence to trigger a sync,
+            // because the delta event is too large to be sent over mercury connection
+            comparison = DESYNC;
+          } else {
+            // the incoming locus has baseSequence from the future, so it is out-of-order,
+            // we are missing 1 or more locus that should be in front of it, we need to wait for it
+            comparison = WAIT;
+          }
+          break;
         default:
           comparison = DESYNC;
       }
-
       return pack(comparison, result);
     }
+
     /**
-     * Compares Locus sequences
+     * Compares Locus sequences - it should be called only for full Locus DTOs, not deltas
+     *
      * @param {Types~Locus} current Current working copy
-     * @param {Types~Locus} incoming New Locus delta
-     * @returns {string}
+     * @param {Types~Locus} incomingFullDto New Full Locus DTO
+     * @returns {string} either Parser.loci.USE_INCOMING or Parser.loci.USE_CURRENT
      */
+  }, {
+    key: "compareFullDtoSequence",
+    value: function compareFullDtoSequence(current, incomingFullDto) {
+      if (Parser.isSequenceEmpty(current) || Parser.isSequenceEmpty(incomingFullDto)) {
+        return Parser.loci.USE_INCOMING;
+      }
 
+      // the sequence.entries list will always contain at least 1 entry
+      // https://sqbu-github.cisco.com/WebExSquared/cloud-apps/wiki/Locus-Sequence-Comparison-Algorithm
+
+      return incomingFullDto.sequence.entries.slice(-1)[0] > current.sequence.entries.slice(-1)[0] ? Parser.loci.USE_INCOMING : Parser.loci.USE_CURRENT;
+    }
   }, {
     key: "compareSequence",
     value: function compareSequence(current, incoming) {
       // Locus sequence comparison rules in order of priority.
       // https://sqbu-github.cisco.com/WebExSquared/cloud-apps/wiki/Locus-Sequence-Comparison-Algorithm
+
       var local = Parser.getMetaData(current);
-      var delta = Parser.getMetaData(incoming); // update loci metadata
+      var delta = Parser.getMetaData(incoming);
 
+      // update loci metadata
       local.unique = Parser.getUniqueSequences(local, delta);
-      delta.unique = Parser.getUniqueSequences(delta, local); // Locus sequence comparison rules
-      // order matters
+      delta.unique = Parser.getUniqueSequences(delta, local);
 
+      // Locus sequence comparison rules
+      // order matters
       var rules = [Parser.checkSequenceOverlap, Parser.checkUnequalRanges, Parser.checkForUniqueEntries, Parser.checkIfOutOfSync];
-
       for (var _i = 0, _rules = rules; _i < _rules.length; _i++) {
         var rule = _rules[_i];
         // Rule only returns a value if the rule applies,
         // otherwise returns null.
         var result = rule(local, delta);
-
         if (result) {
           return result;
         }
-      } // error, none of rules above applied
+      }
+
+      // error, none of rules above applied
       // should never get here as last rule
       // should be catch all.
-
-
       return Parser.loci.ERROR;
     }
+
     /**
      * Transates the result of a sequence comparison into an intended behavior
      * @param {string} result
      * @returns {string} Locus comparison action
      */
-
   }, {
     key: "compareToAction",
     value: function compareToAction(result) {
-      var _Parser$loci3 = Parser.loci,
-          DESYNC = _Parser$loci3.DESYNC,
-          EQ = _Parser$loci3.EQ,
-          ERROR = _Parser$loci3.ERROR,
-          GT = _Parser$loci3.GT,
-          LT = _Parser$loci3.LT,
-          USE_CURRENT = _Parser$loci3.USE_CURRENT,
-          USE_INCOMING = _Parser$loci3.USE_INCOMING;
+      var _Parser$loci4 = Parser.loci,
+        DESYNC = _Parser$loci4.DESYNC,
+        EQ = _Parser$loci4.EQ,
+        ERROR = _Parser$loci4.ERROR,
+        GT = _Parser$loci4.GT,
+        LT = _Parser$loci4.LT,
+        USE_CURRENT = _Parser$loci4.USE_CURRENT,
+        USE_INCOMING = _Parser$loci4.USE_INCOMING;
       var action = ERROR;
-
       switch (result) {
         case EQ:
         case GT:
           action = USE_CURRENT;
           break;
-
         case LT:
           action = USE_INCOMING;
           break;
-
         case DESYNC:
           action = DESYNC;
           break;
-
         default:
           _loggerProxy.default.logger.info("Locus-info:parser#compareToAction --> Error: ".concat(result, " is not a recognized sequence comparison result."));
-
       }
-
       return action;
     }
+
     /**
      * Extracts a loci comparison from a string of data.
      * @param {string} lociComparisonResult Comparison result with extra data
      * @returns {string} Comparison of EQ, LT, GT, or DESYNC.
      */
-
   }, {
     key: "extractComparisonState",
     value: function extractComparisonState(lociComparisonResult) {
       return lociComparisonResult.split(':')[0];
     }
+
     /**
      * @typedef {object} LociMetadata
      * @property {number} start - Starting sequence number
@@ -527,17 +665,18 @@ var Parser = /*#__PURE__*/function () {
      * @param {Array.<number>} sequence Locus delta sequence
      * @returns {LociMetadata} Locus Delta Metadata
      */
-
   }, {
     key: "getMetaData",
     value: function getMetaData(sequence) {
       var entries = sequence.entries;
       var first = entries[0];
-      var last = entries.slice(-1)[0]; // rangeStart or rangeEnd is 0 if a range doesn't exist
+      var last = entries.slice(-1)[0];
 
+      // rangeStart or rangeEnd is 0 if a range doesn't exist
       var start = sequence.rangeStart;
-      var end = sequence.rangeEnd; // sequence data
+      var end = sequence.rangeEnd;
 
+      // sequence data
       return {
         start: start,
         end: end,
@@ -551,6 +690,7 @@ var Parser = /*#__PURE__*/function () {
         entries: entries
       };
     }
+
     /**
      * Compares two Locus delta objects and notes unique
      * values contained within baseLoci.
@@ -558,15 +698,15 @@ var Parser = /*#__PURE__*/function () {
      * @param {LociMetadata} otherLoci
      * @returns {Array.<number>} List of unique sequences
      */
-
   }, {
     key: "getUniqueSequences",
     value: function getUniqueSequences(baseLoci, otherLoci) {
       var diff = (0, _difference2.default)(baseLoci.entries, otherLoci.entries);
       var start = otherLoci.start,
-          end = otherLoci.end;
+        end = otherLoci.end;
       return Parser.getNumbersOutOfRange(diff, start, end);
     }
+
     /**
      * Returns an array of numbers outside of a given range.
      * @param {Array.<number>} list Array to filter
@@ -574,15 +714,15 @@ var Parser = /*#__PURE__*/function () {
      * @param {number} rangeEnd End of range
      * @returns {Array.<number>} Array of numbers sorted ASC
      */
-
   }, {
     key: "getNumbersOutOfRange",
     value: function getNumbersOutOfRange(list, rangeStart, rangeEnd) {
       // Collect all numbers if number is outside of specified range
       var output = list.filter(function (num) {
         return num < rangeStart || num > rangeEnd;
-      }); // sort ascending
+      });
 
+      // sort ascending
       return output.sort(function (a, b) {
         return a - b;
       });
@@ -591,34 +731,30 @@ var Parser = /*#__PURE__*/function () {
     key: "isSequenceEmpty",
     value: function isSequenceEmpty(locus) {
       var _sequence$entries;
-
       var sequence = locus.sequence;
       var hasEmptyEntries = !((_sequence$entries = sequence.entries) !== null && _sequence$entries !== void 0 && _sequence$entries.length);
       var hasEmptyRange = sequence.rangeStart === 0 && sequence.rangeEnd === 0;
       return hasEmptyEntries && hasEmptyRange;
     }
+
     /**
      * Determines if an object has basic
      * structure of a locus object.
      * @param {Types~Locus} loci
      * @returns {boolean}
      */
-
   }, {
     key: "isLoci",
     value: function isLoci(loci) {
       if (!loci || !loci.sequence) {
         return false;
       }
-
       var hasProp = function hasProp(prop) {
         return Object.prototype.hasOwnProperty.call(loci.sequence, prop);
       };
-
       if (hasProp('rangeStart') && hasProp('rangeEnd')) {
         return true;
       }
-
       return false;
     }
   }, {
@@ -633,7 +769,6 @@ var Parser = /*#__PURE__*/function () {
       var mStr = function mStr(strings) {
         return strings.join('').replace(/\s{2,}/g, ' ');
       };
-
       var resolutionMap = {
         EQ: "".concat(Parser.loci.LT, ": is equal (current == incoming)."),
         LT: "".concat(Parser.loci.LT, ": choose right side (incoming)."),
@@ -699,13 +834,7 @@ var Parser = /*#__PURE__*/function () {
   }]);
   return Parser;
 }();
-
 exports.default = Parser;
-(0, _defineProperty2.default)(Parser, "status", {
-  IDLE: 'IDLE',
-  PAUSED: 'PAUSED',
-  WORKING: 'WORKING'
-});
 (0, _defineProperty2.default)(Parser, "loci", {
   EQ: 'EQUAL',
   GT: 'GREATER_THAN',
@@ -713,6 +842,7 @@ exports.default = Parser;
   DESYNC: 'DESYNC',
   USE_INCOMING: 'USE_INCOMING',
   USE_CURRENT: 'USE_CURRENT',
+  WAIT: 'WAIT',
   ERROR: 'ERROR'
 });
 //# sourceMappingURL=parser.js.map